xonecas.io
64875
Mc

mini-coder / commit d2fa578

feat: add OAuth login for Anthropic Claude Pro/Max subscriptions

Allow users to authenticate with their Claude Pro/Max subscription via
`/login anthropic`, using OAuth Authorization Code + PKCE flow against
claude.ai. Tokens are stored in SQLite and auto-refreshed on expiry.

- OAuth module (src/oauth/): PKCE generation, Anthropic provider, token storage
- /login and /logout CLI commands with browser-based auth flow
- Provider integration: resolveModel uses OAuth tokens transparently
- Model list fetching works with OAuth tokens (no ANTHROPIC_API_KEY needed)
- Auto-discovery detects OAuth login for default model selection
- 5-minute login timeout, smart token cleanup on auth vs network errors

xonecas2026-03-16 d2fa57880179c2465965be6be21aeaafcb0c9b7f parent b1ed99a

13 files changed

src/agent/session-runner.ts+1−1
@@ -209,7 +209,7 @@ export class SessionRunner {
209209 saveMessages(this.session.id, [userMsg], thisTurn);
210210 this.coreHistory.push(userMsg);
211211
212- const llm = resolveModel(this.currentModel);
212+ const llm = await resolveModel(this.currentModel);
213213 if (!this._systemPrompt) {
214214 this.rebuildSystemPrompt();
215215 }
src/cli/commands-help.ts+2−0
@@ -37,6 +37,8 @@ export function renderHelpCommand(
3737 ["/mcp list", "list MCP servers"],
3838 ["/mcp add <n> <t> [u]", "add an MCP server"],
3939 ["/mcp remove <name>", "remove an MCP server"],
40+ ["/login [provider]", "login via OAuth (e.g. anthropic)"],
41+ ["/logout <provider>", "clear OAuth tokens"],
4042 ["/help", "show this help"],
4143 ]);
4244
src/cli/commands-login.ts+132−0
@@ -0,0 +1,132 @@
1+import * as c from "yoctocolors";
2+import {
3+ getAccessToken,
4+ getOAuthProvider,
5+ getOAuthProviders,
6+ isLoggedIn,
7+ listLoggedInProviders,
8+ login,
9+ logout,
10+} from "../oauth/auth-storage.ts";
11+import { PREFIX, writeln } from "./output.ts";
12+import type { CommandContext } from "./types.ts";
13+
14+function renderLoginHelp(): void {
15+ writeln();
16+ writeln(` ${c.dim("usage:")}`);
17+ writeln(` /login ${c.dim("show login status")}`);
18+ writeln(` /login <provider> ${c.dim("login via OAuth")}`);
19+ writeln(` /logout <provider> ${c.dim("clear saved tokens")}`);
20+ writeln();
21+ writeln(` ${c.dim("providers:")}`);
22+ for (const p of getOAuthProviders()) {
23+ const status = isLoggedIn(p.id)
24+ ? c.green("logged in")
25+ : c.dim("not logged in");
26+ writeln(` ${c.cyan(p.id.padEnd(20))} ${p.name} ${c.dim("·")} ${status}`);
27+ }
28+ writeln();
29+}
30+
31+function renderStatus(): void {
32+ const loggedIn = listLoggedInProviders();
33+ if (loggedIn.length === 0) {
34+ writeln(
35+ `${PREFIX.info} ${c.dim("no OAuth logins — use")} /login <provider>`,
36+ );
37+ return;
38+ }
39+ for (const id of loggedIn) {
40+ const provider = getOAuthProvider(id);
41+ const name = provider?.name ?? id;
42+ writeln(`${PREFIX.success} ${c.cyan(id)} ${c.dim(name)}`);
43+ }
44+}
45+
46+export async function handleLoginCommand(
47+ ctx: CommandContext,
48+ args: string,
49+): Promise<void> {
50+ const providerId = args.trim().toLowerCase();
51+
52+ if (!providerId) {
53+ renderStatus();
54+ return;
55+ }
56+
57+ if (providerId === "help" || providerId === "--help") {
58+ renderLoginHelp();
59+ return;
60+ }
61+
62+ const provider = getOAuthProvider(providerId);
63+ if (!provider) {
64+ writeln(
65+ `${PREFIX.error} unknown provider "${providerId}" — available: ${getOAuthProviders()
66+ .map((p) => p.id)
67+ .join(", ")}`,
68+ );
69+ return;
70+ }
71+
72+ if (isLoggedIn(providerId)) {
73+ // Verify the token is still refreshable
74+ const token = await getAccessToken(providerId);
75+ if (token) {
76+ writeln(
77+ `${PREFIX.success} already logged in to ${c.cyan(provider.name)}`,
78+ );
79+ return;
80+ }
81+ // Token expired and couldn't refresh — proceed with fresh login
82+ }
83+
84+ ctx.startSpinner("waiting for browser login");
85+ try {
86+ await login(providerId, {
87+ onOpenUrl: (url, instructions) => {
88+ ctx.stopSpinner();
89+ writeln(`${PREFIX.info} ${instructions}`);
90+ writeln();
91+ writeln(` ${c.cyan(url)}`);
92+ writeln();
93+ // Try to open the browser
94+ const open =
95+ process.platform === "darwin"
96+ ? "open"
97+ : process.platform === "win32"
98+ ? "start"
99+ : "xdg-open";
100+ Bun.spawn([open, url], { stdout: "ignore", stderr: "ignore" });
101+ ctx.startSpinner("waiting for browser callback");
102+ },
103+ onProgress: (msg) => {
104+ ctx.stopSpinner();
105+ writeln(`${PREFIX.info} ${c.dim(msg)}`);
106+ ctx.startSpinner("exchanging tokens");
107+ },
108+ });
109+ ctx.stopSpinner();
110+ writeln(`${PREFIX.success} logged in to ${c.cyan(provider.name)}`);
111+ } catch (err) {
112+ ctx.stopSpinner();
113+ writeln(`${PREFIX.error} login failed: ${(err as Error).message}`);
114+ }
115+}
116+
117+export function handleLogoutCommand(_ctx: CommandContext, args: string): void {
118+ const providerId = args.trim().toLowerCase();
119+
120+ if (!providerId) {
121+ writeln(`${PREFIX.error} usage: /logout <provider>`);
122+ return;
123+ }
124+
125+ if (!isLoggedIn(providerId)) {
126+ writeln(`${PREFIX.info} ${c.dim("not logged in to")} ${providerId}`);
127+ return;
128+ }
129+
130+ logout(providerId);
131+ writeln(`${PREFIX.success} logged out of ${c.cyan(providerId)}`);
132+}
src/cli/commands.ts+9−0
@@ -8,6 +8,7 @@ import {
88 handleVerboseCommand,
99 } from "./commands-config.ts";
1010 import { renderHelpCommand } from "./commands-help.ts";
11+import { handleLoginCommand, handleLogoutCommand } from "./commands-login.ts";
1112 import { handleMcpCommand } from "./commands-mcp.ts";
1213 import { handleModelCommand } from "./commands-model.ts";
1314 import {
@@ -155,6 +156,14 @@ export async function handleCommand(
155156 await handleMcpCommand(ctx, args);
156157 return { type: "handled" };
157158
159+ case "login":
160+ await handleLoginCommand(ctx, args);
161+ return { type: "handled" };
162+
163+ case "logout":
164+ handleLogoutCommand(ctx, args);
165+ return { type: "handled" };
166+
158167 case "new":
159168 handleNew(ctx);
160169 return { type: "handled" };
src/llm-api/model-info-fetch.ts+19−8
@@ -1,3 +1,5 @@
1+import { getAccessToken, isLoggedIn } from "../oauth/auth-storage.ts";
2+
13 const ZEN_BASE = "https://opencode.ai/zen/v1";
24 const OPENAI_BASE = "https://api.openai.com";
35 const ANTHROPIC_BASE = "https://api.anthropic.com";
@@ -146,19 +148,28 @@ async function fetchOpenAIModels(): Promise<ProviderModelCandidate[] | null> {
146148 );
147149 }
148150
151+async function getAnthropicOAuthToken(): Promise<string | null> {
152+ if (!isLoggedIn("anthropic")) return null;
153+ return getAccessToken("anthropic");
154+}
155+
149156 async function fetchAnthropicModels(): Promise<
150157 ProviderModelCandidate[] | null
151158 > {
152- const key = process.env.ANTHROPIC_API_KEY;
153- if (!key) return null;
159+ const envKey = process.env.ANTHROPIC_API_KEY;
160+ const oauthToken = !envKey ? await getAnthropicOAuthToken() : null;
161+ if (!envKey && !oauthToken) return null;
162+
163+ const headers: Record<string, string> = {
164+ "anthropic-version": "2023-06-01",
165+ ...(oauthToken
166+ ? { Authorization: `Bearer ${oauthToken}` }
167+ : { "x-api-key": envKey as string }),
168+ };
169+
154170 const payload = await fetchJson(
155171 `${ANTHROPIC_BASE}/v1/models`,
156- {
157- headers: {
158- "x-api-key": key,
159- "anthropic-version": "2023-06-01",
160- },
161- },
172+ { headers },
162173 6_000,
163174 );
164175 return processModelsList(payload, "data", "id", (item, modelId) => {
src/llm-api/providers-resolve.test.ts+4−4
@@ -25,14 +25,14 @@ afterEach(() => {
2525 });
2626
2727 describe("resolveModel", () => {
28- test("rejects model strings without provider prefix", () => {
29- expect(() => resolveModel("gpt-4o")).toThrow(
28+ test("rejects model strings without provider prefix", async () => {
29+ await expect(resolveModel("gpt-4o")).rejects.toThrow(
3030 'Invalid model string "gpt-4o". Expected format: "<provider>/<model-id>"',
3131 );
3232 });
3333
34- test("rejects unsupported providers", () => {
35- expect(() => resolveModel("foo/bar")).toThrow(
34+ test("rejects unsupported providers", async () => {
35+ await expect(resolveModel("foo/bar")).rejects.toThrow(
3636 'Unknown provider "foo". Supported: zen, anthropic, openai, google, ollama',
3737 );
3838 });
src/llm-api/providers.ts+43−10
@@ -4,6 +4,7 @@ import { createOpenAI } from "@ai-sdk/openai";
44 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
55 import type { LanguageModel } from "ai";
66
7+import { getAccessToken, isLoggedIn } from "../oauth/auth-storage.ts";
78 import { logApiEvent } from "./api-log.ts";
89 import {
910 type AvailableModelsSnapshot,
@@ -169,20 +170,52 @@ function resolveOpenAIModel(modelId: string): LanguageModel {
169170 : directProviders.openai()(modelId);
170171 }
171172
172-const PROVIDER_MODEL_RESOLVERS: Readonly<Record<ProviderName, ModelResolver>> =
173- {
174- zen: resolveZenModel,
175- anthropic: (modelId) => directProviders.anthropic()(modelId),
176- openai: resolveOpenAIModel,
177- google: (modelId) => directProviders.google()(modelId),
178- ollama: (modelId) => directProviders.ollama().chatModel(modelId),
179- };
173+type AsyncModelResolver = (
174+ modelId: string,
175+) => LanguageModel | Promise<LanguageModel>;
176+
177+/** Cache the OAuth-backed Anthropic provider keyed by access token. */
178+let oauthAnthropicCache: { token: string; provider: AnthropicProvider } | null =
179+ null;
180+
181+async function resolveAnthropicModel(modelId: string): Promise<LanguageModel> {
182+ // OAuth token takes priority over env var
183+ if (isLoggedIn("anthropic")) {
184+ const token = await getAccessToken("anthropic");
185+ if (token) {
186+ if (!oauthAnthropicCache || oauthAnthropicCache.token !== token) {
187+ oauthAnthropicCache = {
188+ token,
189+ provider: createAnthropic({
190+ fetch: fetchWithLogging,
191+ authToken: token,
192+ }),
193+ };
194+ }
195+ return oauthAnthropicCache.provider(modelId);
196+ }
197+ }
198+ // Fallback to ANTHROPIC_API_KEY env var
199+ return directProviders.anthropic()(modelId);
200+}
201+
202+const PROVIDER_MODEL_RESOLVERS: Readonly<
203+ Record<ProviderName, AsyncModelResolver>
204+> = {
205+ zen: resolveZenModel,
206+ anthropic: resolveAnthropicModel,
207+ openai: resolveOpenAIModel,
208+ google: (modelId) => directProviders.google()(modelId),
209+ ollama: (modelId) => directProviders.ollama().chatModel(modelId),
210+};
180211
181212 function isProviderName(provider: string): provider is ProviderName {
182213 return SUPPORTED_PROVIDERS.includes(provider as ProviderName);
183214 }
184215
185-export function resolveModel(modelString: string): LanguageModel {
216+export async function resolveModel(
217+ modelString: string,
218+): Promise<LanguageModel> {
186219 const slashIdx = modelString.indexOf("/");
187220 if (slashIdx === -1) {
188221 throw new Error(
@@ -204,7 +237,7 @@ export function resolveModel(modelString: string): LanguageModel {
204237
205238 export function autoDiscoverModel(): string {
206239 if (process.env.OPENCODE_API_KEY) return "zen/claude-sonnet-4-6";
207- if (process.env.ANTHROPIC_API_KEY)
240+ if (process.env.ANTHROPIC_API_KEY || isLoggedIn("anthropic"))
208241 return "anthropic/claude-sonnet-4-5-20250929";
209242 if (process.env.OPENAI_API_KEY) return "openai/gpt-4o";
210243 if (process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY)
src/oauth/anthropic.ts+182−0
@@ -0,0 +1,182 @@
1+/**
2+ * Anthropic OAuth flow (Claude Pro/Max subscription).
3+ *
4+ * Uses Authorization Code + PKCE against claude.ai/platform.claude.com.
5+ * Starts a local HTTP callback server for the redirect.
6+ */
7+
8+import { createServer, type Server } from "node:http";
9+import { generatePKCE } from "./pkce.ts";
10+import type {
11+ OAuthCredentials,
12+ OAuthLoginCallbacks,
13+ OAuthProviderConfig,
14+} from "./types.ts";
15+
16+const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
17+const AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
18+const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
19+const CALLBACK_HOST = "127.0.0.1";
20+const CALLBACK_PORT = 53692;
21+const CALLBACK_PATH = "/callback";
22+const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
23+const SCOPES =
24+ "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
25+
26+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
27+
28+const SUCCESS_HTML = `<!doctype html>
29+<html lang="en"><head><meta charset="utf-8"><title>Authenticated</title></head>
30+<body><p>Authentication successful. Return to your terminal.</p></body></html>`;
31+
32+function startCallbackServer(expectedState: string): Promise<{
33+ server: Server;
34+ waitForCode: () => Promise<{ code: string; state: string } | null>;
35+ cancel: () => void;
36+}> {
37+ return new Promise((resolve, reject) => {
38+ let result: { code: string; state: string } | null = null;
39+ let cancelled = false;
40+
41+ const server = createServer((req, res) => {
42+ const url = new URL(req.url ?? "", "http://localhost");
43+ if (url.pathname !== CALLBACK_PATH) {
44+ res.writeHead(404).end("Not found");
45+ return;
46+ }
47+
48+ const code = url.searchParams.get("code");
49+ const state = url.searchParams.get("state");
50+ const error = url.searchParams.get("error");
51+
52+ if (error || !code || !state || state !== expectedState) {
53+ res.writeHead(400).end("Authentication failed.");
54+ return;
55+ }
56+
57+ res.writeHead(200, { "Content-Type": "text/html" }).end(SUCCESS_HTML);
58+ result = { code, state };
59+ });
60+
61+ server.on("error", reject);
62+ server.listen(CALLBACK_PORT, CALLBACK_HOST, () => {
63+ resolve({
64+ server,
65+ cancel: () => {
66+ cancelled = true;
67+ },
68+ waitForCode: async () => {
69+ const deadline = Date.now() + LOGIN_TIMEOUT_MS;
70+ while (!result && !cancelled && Date.now() < deadline) {
71+ await new Promise((r) => setTimeout(r, 100));
72+ }
73+ return result;
74+ },
75+ });
76+ });
77+ });
78+}
79+
80+async function postTokenRequest(
81+ body: Record<string, string>,
82+ label: string,
83+): Promise<OAuthCredentials> {
84+ const res = await fetch(TOKEN_URL, {
85+ method: "POST",
86+ headers: {
87+ "Content-Type": "application/json",
88+ Accept: "application/json",
89+ },
90+ body: JSON.stringify(body),
91+ signal: AbortSignal.timeout(30_000),
92+ });
93+
94+ if (!res.ok) {
95+ const text = await res.text();
96+ throw new Error(`${label} failed (${res.status}): ${text}`);
97+ }
98+
99+ const data = (await res.json()) as {
100+ access_token: string;
101+ refresh_token: string;
102+ expires_in: number;
103+ };
104+
105+ return {
106+ access: data.access_token,
107+ refresh: data.refresh_token,
108+ // Expire 5 minutes early to avoid edge cases
109+ expires: Date.now() + data.expires_in * 1000 - 5 * 60 * 1000,
110+ };
111+}
112+
113+function exchangeCode(
114+ code: string,
115+ state: string,
116+ verifier: string,
117+): Promise<OAuthCredentials> {
118+ return postTokenRequest(
119+ {
120+ grant_type: "authorization_code",
121+ client_id: CLIENT_ID,
122+ code,
123+ state,
124+ redirect_uri: REDIRECT_URI,
125+ code_verifier: verifier,
126+ },
127+ "Token exchange",
128+ );
129+}
130+
131+function refreshAnthropicToken(
132+ refreshToken: string,
133+): Promise<OAuthCredentials> {
134+ return postTokenRequest(
135+ {
136+ grant_type: "refresh_token",
137+ client_id: CLIENT_ID,
138+ refresh_token: refreshToken,
139+ },
140+ "Token refresh",
141+ );
142+}
143+
144+async function loginAnthropic(
145+ callbacks: OAuthLoginCallbacks,
146+): Promise<OAuthCredentials> {
147+ const { verifier, challenge } = await generatePKCE();
148+ const cb = await startCallbackServer(verifier);
149+
150+ try {
151+ const params = new URLSearchParams({
152+ code: "true",
153+ client_id: CLIENT_ID,
154+ response_type: "code",
155+ redirect_uri: REDIRECT_URI,
156+ scope: SCOPES,
157+ code_challenge: challenge,
158+ code_challenge_method: "S256",
159+ state: verifier,
160+ });
161+
162+ callbacks.onOpenUrl(
163+ `${AUTHORIZE_URL}?${params}`,
164+ "Complete login in your browser.",
165+ );
166+
167+ const result = await cb.waitForCode();
168+ if (!result) throw new Error("Login cancelled or no code received");
169+
170+ callbacks.onProgress("Exchanging authorization code for tokens…");
171+ return exchangeCode(result.code, result.state, verifier);
172+ } finally {
173+ cb.server.close();
174+ }
175+}
176+
177+export const anthropicOAuth: OAuthProviderConfig = {
178+ id: "anthropic",
179+ name: "Anthropic (Claude Pro/Max)",
180+ login: loginAnthropic,
181+ refreshToken: refreshAnthropicToken,
182+};
src/oauth/auth-storage.ts+130−0
@@ -0,0 +1,130 @@
1+/**
2+ * SQLite-backed OAuth token storage.
3+ *
4+ * Tokens are stored in the oauth_tokens table and auto-refreshed when expired.
5+ */
6+
7+import { getDb } from "../session/db/connection.ts";
8+import { anthropicOAuth } from "./anthropic.ts";
9+import type {
10+ OAuthCredentials,
11+ OAuthLoginCallbacks,
12+ OAuthProviderConfig,
13+} from "./types.ts";
14+
15+interface OAuthTokenRow {
16+ provider: string;
17+ access_token: string;
18+ refresh_token: string;
19+ expires_at: number;
20+ updated_at: number;
21+}
22+
23+const PROVIDERS: ReadonlyMap<string, OAuthProviderConfig> = new Map([
24+ [anthropicOAuth.id, anthropicOAuth],
25+]);
26+
27+export function getOAuthProviders(): OAuthProviderConfig[] {
28+ return [...PROVIDERS.values()];
29+}
30+
31+export function getOAuthProvider(id: string): OAuthProviderConfig | undefined {
32+ return PROVIDERS.get(id);
33+}
34+
35+// ─── Persistence ──────────────────────────────────────────────────────────────
36+
37+function getStoredToken(provider: string): OAuthTokenRow | null {
38+ return (
39+ getDb()
40+ .query<OAuthTokenRow, [string]>(
41+ "SELECT provider, access_token, refresh_token, expires_at, updated_at FROM oauth_tokens WHERE provider = ?",
42+ )
43+ .get(provider) ?? null
44+ );
45+}
46+
47+function upsertToken(provider: string, creds: OAuthCredentials): void {
48+ getDb().run(
49+ `INSERT INTO oauth_tokens (provider, access_token, refresh_token, expires_at, updated_at)
50+ VALUES (?, ?, ?, ?, ?)
51+ ON CONFLICT(provider) DO UPDATE SET
52+ access_token = excluded.access_token,
53+ refresh_token = excluded.refresh_token,
54+ expires_at = excluded.expires_at,
55+ updated_at = excluded.updated_at`,
56+ [provider, creds.access, creds.refresh, creds.expires, Date.now()],
57+ );
58+}
59+
60+function deleteToken(provider: string): void {
61+ getDb().run("DELETE FROM oauth_tokens WHERE provider = ?", [provider]);
62+}
63+
64+/** True for HTTP 401/403 — the refresh token is definitively rejected. */
65+function isAuthError(err: unknown): boolean {
66+ if (!(err instanceof Error)) return false;
67+ return /\b(401|403)\b/.test(err.message);
68+}
69+
70+// ─── Public API ───────────────────────────────────────────────────────────────
71+
72+export function isLoggedIn(provider: string): boolean {
73+ return getStoredToken(provider) !== null;
74+}
75+
76+export function listLoggedInProviders(): string[] {
77+ return getDb()
78+ .query<{ provider: string }, []>(
79+ "SELECT provider FROM oauth_tokens ORDER BY provider",
80+ )
81+ .all()
82+ .map((r) => r.provider);
83+}
84+
85+export async function login(
86+ providerId: string,
87+ callbacks: OAuthLoginCallbacks,
88+): Promise<void> {
89+ const provider = PROVIDERS.get(providerId);
90+ if (!provider) throw new Error(`Unknown OAuth provider: ${providerId}`);
91+
92+ const creds = await provider.login(callbacks);
93+ upsertToken(providerId, creds);
94+}
95+
96+export function logout(providerId: string): void {
97+ deleteToken(providerId);
98+}
99+
100+/**
101+ * Get a valid access token for the provider.
102+ * Automatically refreshes if expired. Returns null if not logged in.
103+ */
104+export async function getAccessToken(
105+ providerId: string,
106+): Promise<string | null> {
107+ const row = getStoredToken(providerId);
108+ if (!row) return null;
109+
110+ // Token still valid
111+ if (Date.now() < row.expires_at) {
112+ return row.access_token;
113+ }
114+
115+ // Attempt refresh
116+ const provider = PROVIDERS.get(providerId);
117+ if (!provider) return null;
118+
119+ try {
120+ const refreshed = await provider.refreshToken(row.refresh_token);
121+ upsertToken(providerId, refreshed);
122+ return refreshed.access;
123+ } catch (err) {
124+ // Only clear tokens on definitive auth failures, not transient network errors
125+ if (isAuthError(err)) {
126+ deleteToken(providerId);
127+ }
128+ return null;
129+ }
130+}
src/oauth/pkce.test.ts+26−0
@@ -0,0 +1,26 @@
1+import { describe, expect, test } from "bun:test";
2+import { generatePKCE } from "./pkce.ts";
3+
4+const BASE64URL_RE = /^[A-Za-z0-9_-]+$/;
5+
6+describe("generatePKCE", () => {
7+ test("produces base64url verifier and challenge", async () => {
8+ const { verifier, challenge } = await generatePKCE();
9+
10+ expect(verifier).toMatch(BASE64URL_RE);
11+ expect(challenge).toMatch(BASE64URL_RE);
12+ expect(verifier.length).toBeGreaterThan(0);
13+ expect(challenge.length).toBeGreaterThan(0);
14+ });
15+
16+ test("challenge differs from verifier", async () => {
17+ const { verifier, challenge } = await generatePKCE();
18+ expect(challenge).not.toBe(verifier);
19+ });
20+
21+ test("produces unique verifiers", async () => {
22+ const a = await generatePKCE();
23+ const b = await generatePKCE();
24+ expect(a.verifier).not.toBe(b.verifier);
25+ });
26+});
src/oauth/pkce.ts+22−0
@@ -0,0 +1,22 @@
1+function base64urlEncode(bytes: Uint8Array): string {
2+ let binary = "";
3+ for (const byte of bytes) {
4+ binary += String.fromCharCode(byte);
5+ }
6+ return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
7+}
8+
9+export async function generatePKCE(): Promise<{
10+ verifier: string;
11+ challenge: string;
12+}> {
13+ const verifierBytes = new Uint8Array(32);
14+ crypto.getRandomValues(verifierBytes);
15+ const verifier = base64urlEncode(verifierBytes);
16+
17+ const data = new TextEncoder().encode(verifier);
18+ const hashBuffer = await crypto.subtle.digest("SHA-256", data);
19+ const challenge = base64urlEncode(new Uint8Array(hashBuffer));
20+
21+ return { verifier, challenge };
22+}
src/oauth/types.ts+18−0
@@ -0,0 +1,18 @@
1+export interface OAuthCredentials {
2+ access: string;
3+ refresh: string;
4+ expires: number; // epoch ms
5+}
6+
7+export interface OAuthProviderConfig {
8+ readonly id: string;
9+ readonly name: string;
10+
11+ login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials>;
12+ refreshToken(refreshToken: string): Promise<OAuthCredentials>;
13+}
14+
15+export interface OAuthLoginCallbacks {
16+ onOpenUrl: (url: string, instructions: string) => void;
17+ onProgress: (message: string) => void;
18+}
src/session/db/connection.ts+9−1
@@ -13,7 +13,7 @@ function getDbPath(): string {
1313 return join(dir, "sessions.db");
1414 }
1515
16-const DB_VERSION = 3;
16+const DB_VERSION = 4;
1717
1818 const SCHEMA = `
1919 CREATE TABLE IF NOT EXISTS sessions (
@@ -92,6 +92,14 @@ const SCHEMA = `
9292 key TEXT PRIMARY KEY,
9393 value TEXT NOT NULL
9494 );
95+
96+ CREATE TABLE IF NOT EXISTS oauth_tokens (
97+ provider TEXT PRIMARY KEY,
98+ access_token TEXT NOT NULL,
99+ refresh_token TEXT NOT NULL,
100+ expires_at INTEGER NOT NULL,
101+ updated_at INTEGER NOT NULL
102+ );
95103 `;
96104
97105 let _db: Database | null = null;