@tianmucreations/jeeves 0.3.1 → 0.3.2

package/dist/ink/mouse.js

@@ -1,10 +1,12 @@
 import { session } from '../state/session.js';
+import { pointAt, copySelection } from './selection.js';
 // SGR mouse tracking (modes 1000 + 1002 + 1006), enabled for the whole session by
 // the AlternateScreen takeover and disabled on every exit path. Claude Code's
 // approach: in the alternate screen the terminal has no scrollback, so wheel
 // events are captured and translated into transcript scrolling. The trade-off is
-// native click-drag selection; Shift (or Option in Terminal.app) bypasses mouse
-// capture for copying - the help screen says so.
+// the terminal's own click-drag selection, so selection is done here instead
+// (selection.ts): drag to select, copied on release. Fn in Terminal.app still
+// bypasses capture for the terminal's own selection.
 export const ENABLE_MOUSE_TRACKING = '\x1b[?1000h\x1b[?1002h\x1b[?1006h';
 export const DISABLE_MOUSE_TRACKING = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
 // Ink's input parser hands over complete CSI sequences but strips the leading ESC
@@ -35,14 +37,45 @@ export function parseMouseSequence(input) {
     if (rawButton <= 6) {
         return { kind: 'press', button: rawButton, col, row };
     }
+    // Mode 1002 reports movement with a button held as the button code plus 32.
+    if (rawButton >= 32 && rawButton <= 34) {
+        return { kind: 'drag', button: rawButton - 32, col, row };
+    }
     return null;
 }
 // Wheel up scrolls the transcript up 3 rows, wheel down 3 rows back; the session
-// clamps at the newest (0) and the Transcript clamps at the oldest. Non-wheel
-// events are consumed silently - clicks must never leak into text inputs.
+// clamps at the newest (0) and the Transcript clamps at the oldest. A left-button
+// press in the conversation starts a selection, dragging extends it, and releasing
+// copies it. Nothing here ever reaches the text being typed.
 export function handleMouseInput(input) {
     const event = parseMouseSequence(input);
-    if (event === null || event.kind !== 'wheel')
+    if (event === null)
+        return;
+    if (event.kind === 'wheel') {
+        session.scrollTranscript(event.button === 0 ? 3 : -3);
+        return;
+    }
+    if (event.button !== 0)
         return;
-    session.scrollTranscript(event.button === 0 ? 3 : -3);
+    if (event.kind === 'press') {
+        const point = pointAt(event.col, event.row);
+        session.setSelection(point ? { anchor: point, focus: point } : null);
+        // Outside the conversation: a click in the typing box places the cursor.
+        if (!point)
+            session.inputClick?.(event.col, event.row);
+        return;
+    }
+    const current = session.selection;
+    if (!current)
+        return;
+    const point = pointAt(event.col, event.row, true);
+    if (point)
+        session.setSelection({ anchor: current.anchor, focus: point });
+    if (event.kind === 'release') {
+        const moved = point && (point.line !== current.anchor.line || point.ch !== current.anchor.ch);
+        if (moved)
+            void copySelection();
+        else
+            session.setSelection(null);
+    }
 }

package/dist/ink/quit.js

@@ -0,0 +1,21 @@
+import { session } from '../state/session.js';
+// Quitting takes Ctrl+C twice within two seconds (Claude Code's rule), so a stray
+// Ctrl+C - the copy key on Windows and Linux - never closes Jeeves and loses the
+// conversation. The first press says so in the info bar.
+const WINDOW_MS = 2000;
+let firstPress = 0;
+let noteTimer = null;
+export function pressCtrlCToQuit(now = Date.now()) {
+    if (now - firstPress <= WINDOW_MS) {
+        session.requestExit();
+        return;
+    }
+    firstPress = now;
+    session.setBusyNote('press Ctrl+C again to quit');
+    if (noteTimer)
+        clearTimeout(noteTimer);
+    noteTimer = setTimeout(() => {
+        if (session.busyNote === 'press Ctrl+C again to quit')
+            session.setBusyNote(null);
+    }, WINDOW_MS);
+}

package/dist/ink/selection.js

@@ -0,0 +1,128 @@
+import { spawn } from 'node:child_process';
+import { session } from '../state/session.js';
+// A screen position (1-based column and row, as the mouse reports them) as a line
+// and character of the drawn conversation. Outside the conversation area: null,
+// unless clamp is set, when it is pinned to the nearest edge (for dragging past it).
+export function pointAt(col, row, clamp = false) {
+    const view = session.transcriptView;
+    if (!view)
+        return null;
+    let r = row - view.top;
+    if (r < 0 || r >= view.height) {
+        if (!clamp)
+            return null;
+        r = Math.max(0, Math.min(view.height - 1, r));
+    }
+    // The newest line sits on the bottom row; scrolling up moves older lines in.
+    const line = view.lines.length - view.scrollTop - view.height + r;
+    if (line < 0 || line >= view.lines.length) {
+        if (!clamp)
+            return null;
+        return { line: Math.max(0, Math.min(view.lines.length - 1, line)), ch: line < 0 ? 0 : Number.MAX_SAFE_INTEGER };
+    }
+    return { line, ch: Math.max(0, col - view.left) };
+}
+// Start and end in reading order.
+export function ordered(a, b) {
+    return a.line < b.line || (a.line === b.line && a.ch <= b.ch) ? [a, b] : [b, a];
+}
+// The selected characters of one drawn line, as [from, to), or null.
+export function selectedRange(lineIndex, length) {
+    const sel = session.selection;
+    if (!sel)
+        return null;
+    const [start, end] = ordered(sel.anchor, sel.focus);
+    if (lineIndex < start.line || lineIndex > end.line)
+        return null;
+    const from = lineIndex === start.line ? Math.min(start.ch, length) : 0;
+    const to = lineIndex === end.line ? Math.min(end.ch + 1, length) : length;
+    return to > from ? [from, to] : null;
+}
+// The selected text: each line's selected part without the padding the display adds.
+export function selectedText(lines) {
+    const sel = session.selection;
+    if (!sel)
+        return '';
+    const [start, end] = ordered(sel.anchor, sel.focus);
+    const out = [];
+    for (let i = start.line; i <= end.line && i < lines.length; i++) {
+        const range = selectedRange(i, lines[i].length);
+        out.push(range ? lines[i].slice(range[0], range[1]).replace(/\s+$/, '') : '');
+    }
+    return out.join('\n').replace(/^\n+|\n+$/g, '');
+}
+// As Claude Code (ink/termio/osc.ts setClipboard): the terminal's clipboard escape
+// (OSC 52) always, and - on this computer, not over SSH - its own clipboard
+// program too, because OSC 52 depends on terminal settings (several Linux terminals
+// ignore it): pbcopy on a Mac, clip on Windows, and on Linux the first of wl-copy
+// (Wayland), xclip or xsel (X11) that exists, remembered after the first copy.
+let linuxCopy;
+function runCopy(program, args, text) {
+    return new Promise((resolve) => {
+        try {
+            const child = spawn(program, args, { stdio: ['pipe', 'ignore', 'ignore'] });
+            const timer = setTimeout(() => child.kill(), 2000);
+            child.on('error', () => {
+                clearTimeout(timer);
+                resolve(false);
+            });
+            child.on('close', (code) => {
+                clearTimeout(timer);
+                resolve(code === 0);
+            });
+            child.stdin.on('error', () => { });
+            child.stdin.end(text);
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}
+export async function copyNative(text) {
+    if (process.platform === 'darwin')
+        return runCopy('pbcopy', [], text);
+    if (process.platform === 'win32')
+        return runCopy('clip', [], text);
+    if (linuxCopy === null)
+        return false;
+    if (linuxCopy)
+        return runCopy(linuxCopy[0], linuxCopy[1], text);
+    const candidates = [['wl-copy', []], ['xclip', ['-selection', 'clipboard']], ['xsel', ['--clipboard', '--input']]];
+    for (const candidate of candidates) {
+        if (await runCopy(candidate[0], candidate[1], text)) {
+            linuxCopy = candidate;
+            return true;
+        }
+    }
+    linuxCopy = null;
+    return false;
+}
+export async function copyToClipboard(text) {
+    let sent = false;
+    try {
+        process.stdout.write(`\x1b]52;c;${Buffer.from(text, 'utf8').toString('base64')}\x07`);
+        sent = true;
+    }
+    catch {
+        // A closed stream: the clipboard program below may still work.
+    }
+    if (process.env.SSH_CONNECTION)
+        return sent;
+    return (await copyNative(text)) || sent;
+}
+let noteTimer = null;
+// Copies the selection and says so in the info bar for two seconds.
+export async function copySelection() {
+    const view = session.transcriptView;
+    const text = view ? selectedText(view.lines) : '';
+    if (!text)
+        return;
+    const copied = await copyToClipboard(text);
+    session.setBusyNote(copied ? 'copied' : "couldn't copy");
+    if (noteTimer)
+        clearTimeout(noteTimer);
+    noteTimer = setTimeout(() => {
+        if (session.busyNote === 'copied' || session.busyNote === "couldn't copy")
+            session.setBusyNote(null);
+    }, 2000);
+}

package/dist/keys/store.js

@@ -1,13 +1,83 @@
+// API keys live in the operating system's own credential store (the macOS Keychain),
+// never in plain files. The library loads lazily so a missing native module degrades
+// gracefully instead of crashing the app.
+//
+// On a Mac, Jeeves uses Apple's own `security` program, as Claude Code does
+// (src/utils/secureStorage/macOsKeychainStorage.ts): no add-on to break. keytar is
+// archived (unmaintained since Dec 2022) and inside the desktop app it crashed on
+// quit whenever a keychain read was still running - 10 of 10 times (19 Sept). The
+// Keychain items are the same ones keytar made (service "jeeves", account = the
+// service id), so nobody re-enters a key: checked 19 Sept - an item keytar created
+// was updated, read, listed and deleted by `security` with no permission box.
+// Windows and Linux stay on keytar until the same check is done there.
+import { execFile } from 'node:child_process';
 // JEEVES_KEYCHAIN_SERVICE lets a test run use its own keychain entries, never the real ones.
 const SERVICE = process.env.JEEVES_KEYCHAIN_SERVICE || 'jeeves';
 let cached = null;
+function runSecurity(args, input) {
+    return new Promise((resolve) => {
+        const child = execFile('/usr/bin/security', args, { timeout: 10_000, maxBuffer: 16 * 1024 * 1024 }, (error, stdout) => {
+            const code = error ? (typeof error.code === 'number' ? error.code : 1) : 0;
+            resolve({ code, stdout: String(stdout) });
+        });
+        if (input !== undefined)
+            child.stdin?.end(input);
+    });
+}
+// Quotes a value for one line of `security -i`: the ids are plain words, but never trust that.
+const quoted = (value) => `"${value.replace(/["\\]/g, '')}"`;
+const macKeychain = {
+    async setPassword(service, account, password) {
+        // The key goes in as hex on standard input, so it never appears in the list of
+        // running programs (Claude Code's reason: process monitors see only "security -i").
+        const hex = Buffer.from(password, 'utf8').toString('hex');
+        const { code } = await runSecurity(['-i'], `add-generic-password -U -s ${quoted(service)} -a ${quoted(account)} -X "${hex}"\n`);
+        if (code !== 0)
+            throw new Error('The Mac keychain did not save the key.');
+    },
+    async getPassword(service, account) {
+        // Exit 44 is "no such item" - a real "no key". Any other failure (a timeout, a
+        // busy keychain) is asked once more rather than taken as "no key" (Claude Code
+        // treats a timed-out read as "may have a key" for the same reason).
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const { code, stdout } = await runSecurity(['find-generic-password', '-s', service, '-a', account, '-w']);
+            if (code === 0)
+                return stdout.replace(/\n$/, '') || null;
+            if (code === 44)
+                return null;
+        }
+        return null;
+    },
+    async deletePassword(service, account) {
+        const { code } = await runSecurity(['delete-generic-password', '-s', service, '-a', account]);
+        return code === 0;
+    },
+    // Names only: dump-keychain without -d lists what is saved, never the keys themselves.
+    async findCredentials(service) {
+        const { stdout } = await runSecurity(['dump-keychain']);
+        const accounts = [];
+        for (const block of stdout.split('keychain: ')) {
+            if (!block.includes(`"svce"<blob>="${service}"`))
+                continue;
+            const account = /"acct"<blob>="([^"]*)"/.exec(block)?.[1];
+            if (account)
+                accounts.push({ account, password: '' });
+        }
+        return accounts;
+    },
+};
 async function load() {
     // Escape hatch for automated tests so they never touch the real credential store.
     if (process.env.JEEVES_SKIP_KEYCHAIN === '1')
         return null;
     if (cached === null) {
-        const mod = await import('keytar');
-        cached = (mod.default ?? mod);
+        if (process.platform === 'darwin') {
+            cached = macKeychain;
+        }
+        else {
+            const mod = await import('keytar');
+            cached = (mod.default ?? mod);
+        }
     }
     return cached;
 }

package/dist/platform/address.js

@@ -0,0 +1,16 @@
+// How Jeeves addresses the person. Asked before anything else, in the terminal and
+// the window alike, so Jeeves never has to guess "Sir" (owner's request, 19 Sept).
+export const ADDRESS_MAX = 30;
+// Morning / afternoon / evening by this computer's own clock.
+export function partOfDay(now = new Date()) {
+    const hour = now.getHours();
+    return hour < 12 ? 'morning' : hour < 18 ? 'afternoon' : 'evening';
+}
+export function timeOfDayGreeting(now = new Date()) {
+    return `Good ${partOfDay(now)}`;
+}
+// The address as saved: trimmed and short; null when nothing usable was given.
+export function cleanAddress(raw) {
+    const value = raw.replace(/\s+/g, ' ').trim().slice(0, ADDRESS_MAX);
+    return value ? value : null;
+}

package/dist/platform/chat-folder.js

@@ -0,0 +1,24 @@
+import { mkdirSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+// "Just chat": no project needed. Jeeves still works in a folder of its own, so
+// anything it is asked to save lands somewhere the person can find, /undo still
+// works, and nothing ever runs loose in the whole home folder (agreed 19 Sept).
+export const CHAT_FOLDER_NAME = 'Jeeves Chats';
+export function chatFolder() {
+    return path.join(os.homedir(), 'Documents', CHAT_FOLDER_NAME);
+}
+// Creates the folder when needed; the location, or null if it could not be made.
+export function ensureChatFolder() {
+    const folder = chatFolder();
+    try {
+        mkdirSync(folder, { recursive: true });
+        return folder;
+    }
+    catch {
+        return null;
+    }
+}
+export function chatNotice(address) {
+    return `Just chatting, ${address} - anything I save for you goes in Documents/${CHAT_FOLDER_NAME}. Type /folder any time to work in a folder instead.`;
+}

package/dist/platform/config.js

@@ -88,6 +88,9 @@ export function getAddress() {
 export function setAddress(address) {
     config.set('address', address);
 }
+export function clearAddress() {
+    config.delete('address');
+}
 // The trimmed models.dev catalogue for direct connections (prices and abilities).
 export function getDirectCatalogue() {
     return config.get('directCatalogue') ?? null;

package/dist/platform/wording.js

@@ -0,0 +1,10 @@
+// Words that depend on the computer Jeeves is running on (owner, 19 Sept: "What
+// if it is on a non-Mac?"). Keys are kept by keytar in Windows Credential Manager
+// and in the system password store on Linux; the copy keys are the terminal's own
+// (Windows Terminal's defaults include Ctrl+Shift+C - learn.microsoft.com, Windows
+// Terminal actions; Linux terminals use the same).
+const platform = process.platform;
+export const KEY_STORE = platform === 'darwin' ? 'your Mac keychain' : platform === 'win32' ? 'Windows Credential Manager' : "your computer's password store";
+export const KEY_STORE_SUBJECT = platform === 'darwin' ? 'The Mac keychain' : platform === 'win32' ? 'Windows Credential Manager' : "Your computer's password store";
+export const COPY_KEYS = platform === 'darwin' ? 'Cmd+C' : 'Ctrl+Shift+C';
+export const WORD_JUMP_KEYS = platform === 'darwin' ? 'Option+← →' : 'Ctrl+← →';

package/dist/providers/direct.js

@@ -6,6 +6,7 @@ import { createXai } from '@ai-sdk/xai';
 import { createMistral } from '@ai-sdk/mistral';
 import { createGroq } from '@ai-sdk/groq';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { silenceGuard } from './silence.js';
 import { prepareStepFor } from './step-control.js';
 import { directService, serviceNameFor, CUSTOM_SERVICE_ID } from './direct-services.js';
 import { estimateCost, priceOf } from './catalogue.js';
@@ -68,10 +69,13 @@ function streamWith(id, name, modelFor, costOf, caching) {
             const stepCostOf = (step) => costOf(step.model?.modelId ?? modelId, step.usage ?? {});
             const prepare = prepareStepFor(beforeStep, modelFor, stepCostOf);
             const system = caching && instructions ? { role: 'system', content: instructions, providerOptions: ANTHROPIC_CACHE } : instructions;
+            const guard = silenceGuard(abortSignal);
             const result = streamText({
                 instructions: system,
                 // The same limits on silence as the other services (see openrouter.ts).
-                timeout: { firstChunkMs: 120_000, chunkMs: 90_000, stepMs: 600_000 },
+                // Silence while the model answers is watched by silenceGuard (it pauses while a
+                // command runs or waits for the person); the first piece still has 2 minutes.
+                timeout: { firstChunkMs: 120_000 },
                 model: modelFor(modelId),
                 messages: caching ? markForCaching(messages) : messages,
                 tools,
@@ -85,13 +89,14 @@ function streamWith(id, name, modelFor, costOf, caching) {
                         return { ...control, messages: markForCaching(control.messages ?? step.messages) };
                     }
                     : undefined,
-                abortSignal,
+                abortSignal: guard.signal,
                 // The library prints every failure to the screen by default, over Jeeves's
                 // window; the failure still arrives below and is explained in plain English.
                 onError: () => { },
             });
             let streamedError = null;
             for await (const part of result.stream) {
+                guard.onPart(part);
                 if (part.type === 'text-delta') {
                     onToken(part.text);
                 }
@@ -105,6 +110,7 @@ function streamWith(id, name, modelFor, costOf, caching) {
                     streamedError = part.error;
                 }
             }
+            guard.stop();
             // The real stream error (a rejected key, a missing model) must win over the
             // SDK's generic no-output error, which would otherwise mask the cause.
             if (streamedError !== null) {

package/dist/providers/index.js

@@ -13,6 +13,7 @@ import { getKey, setKey, deleteKey, listProviders } from '../keys/store.js';
 import { existsSync, readFileSync, rmSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { KEY_STORE, KEY_STORE_SUBJECT } from '../platform/wording.js';
 let active = null;
 let resolvedKey = null;
 let zaiKey = null;
@@ -23,6 +24,10 @@ const serviceKeys = new Map();
 export function getOpenRouterKey() {
     return resolvedKey;
 }
+// The GLM Coding Plan key, for research on the plan (Z.ai's web search and reading).
+export function getZaiKey() {
+    return zaiKey;
+}
 // The calm provider list shared by the model picker and the key screens.
 export const PROVIDER_ROWS = [
     { id: 'openrouter', label: 'OpenRouter', description: 'one key unlocks 400+ models - recommended' },
@@ -107,7 +112,20 @@ export function hasCredentials() {
 // Startup key resolution: the Keychain wins; a .env file is a development fallback
 // that gets migrated into the Keychain on first launch. The first access may pop a
 // macOS permission dialog - that is expected and allowed once.
-export async function initKeys() {
+// Reading the keychain takes a moment; anything that decides "is there a key?" waits
+// for it first (Claude Code's keychainPrefetch pattern). Choosing a folder within
+// about 0.8 s of opening used to decide before the read finished and asked for a key
+// the person already had (measured 19 Sept).
+let keysLoading = null;
+export function initKeys() {
+    keysLoading ??= readKeys();
+    return keysLoading;
+}
+// Resolves once the saved keys have been read (starting the read if needed).
+export function keysRead() {
+    return initKeys();
+}
+async function readKeys() {
     // Read together, so startup is not held up by one keychain read after another.
     const ids = [...DIRECT_SERVICES.map((service) => service.id), CUSTOM_SERVICE_ID];
     const serviceStored = await Promise.all(ids.map((id) => getKey(id)));
@@ -131,10 +149,10 @@ export async function initKeys() {
         const moved = await setKey('openrouter', envKey);
         if (moved) {
             removeEnvFile();
-            session.addNotice('Your key was moved from a local file into your Mac keychain, and the file was removed.');
+            session.addNotice(`Your key was moved from a local file into ${KEY_STORE}, and the file was removed.`);
         }
         else {
-            session.addNotice('The Mac keychain was not reachable, so the key is being read from a local file for now. Type /keys to store it securely.');
+            session.addNotice(`${KEY_STORE_SUBJECT} was not reachable, so the key is being read from a local file for now. Type /keys to store it securely.`);
         }
         resolvedKey = envKey;
         keySource = moved ? 'keychain' : 'env';

package/dist/providers/ollama.js

@@ -1,5 +1,6 @@
 import { streamText, stepCountIs } from 'ai';
 import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { silenceGuard } from './silence.js';
 import { prepareStepFor } from './step-control.js';
 const OLLAMA_BASE_URL = 'http://localhost:11434/v1';
 const MAX_TOOL_STEPS = 25;
@@ -14,6 +15,7 @@ export function createOllamaProvider() {
         id: 'ollama',
         name: 'Ollama',
         async stream({ modelId, messages, tools, instructions, onToken, onReasoning, onToolCall, beforeStep, abortSignal }) {
+            const guard = silenceGuard(abortSignal);
             const result = streamText({
                 instructions,
                 // A stalled request must never wedge the app in the working state forever -
@@ -23,19 +25,22 @@ export function createOllamaProvider() {
                 // started, and 10 minutes for any single step, which also covers a request that
                 // never starts answering. (A plain number here limits the entire multi-step
                 // job; a 3-minute one killed healthy jobs mid-way in testing.)
-                timeout: { firstChunkMs: 120_000, chunkMs: 90_000, stepMs: 600_000 },
+                // Silence while the model answers is watched by silenceGuard (it pauses while a
+                // command runs or waits for the person); the first piece still has 2 minutes.
+                timeout: { firstChunkMs: 120_000 },
                 model: client.chat(modelId),
                 messages,
                 tools,
                 stopWhen: stepCountIs(MAX_TOOL_STEPS),
                 prepareStep: prepareStepFor(beforeStep, (id) => client.chat(id)),
-                abortSignal,
+                abortSignal: guard.signal,
                 // The library prints every failure to the screen by default, over Jeeves's
                 // window; the failure still arrives below and is explained in plain English.
                 onError: () => { },
             });
             let streamedError = null;
             for await (const part of result.stream) {
+                guard.onPart(part);
                 if (part.type === 'text-delta') {
                     onToken(part.text);
                 }
@@ -49,6 +54,7 @@ export function createOllamaProvider() {
                     streamedError = part.error;
                 }
             }
+            guard.stop();
             // The real stream error (a rejected key, a missing model) must win over the
             // SDK's generic no-output error, which would otherwise mask the cause.
             if (streamedError !== null) {

package/dist/providers/openrouter-signin.js

@@ -0,0 +1,102 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+// "Sign in with OpenRouter": the person approves Jeeves in their browser and
+// OpenRouter hands back a key on their own account - nothing to copy or paste, the
+// step that stops most non-coders. OpenRouter's OAuth PKCE flow, as documented at
+// openrouter.ai/docs/use-cases/oauth-pkce (checked 18 Sept 2026): open
+// https://openrouter.ai/auth with callback_url, code_challenge (base64url of the
+// SHA-256 of a random verifier) and code_challenge_method=S256; the browser returns
+// to the callback with ?code=; POST {code, code_verifier, code_challenge_method} to
+// /api/v1/auth/keys and read "key". Localhost callbacks on any port are allowed.
+export const AUTH_URL = 'https://openrouter.ai/auth';
+export const EXCHANGE_URL = 'https://openrouter.ai/api/v1/auth/keys';
+export function pkcePair() {
+    const verifier = randomBytes(32).toString('base64url');
+    const challenge = createHash('sha256').update(verifier).digest('base64url');
+    return { verifier, challenge };
+}
+export function authorizeUrl(callbackUrl, challenge) {
+    const params = new URLSearchParams({ callback_url: callbackUrl, code_challenge: challenge, code_challenge_method: 'S256', key_label: 'Jeeves' });
+    return `${AUTH_URL}?${params.toString()}`;
+}
+// The program and arguments that open a web address on each system.
+export function browserCommand(url, platform = process.platform) {
+    // Windows: rundll32, as Claude Code does (utils/browser.ts) - never cmd's "start",
+    // which splits a web address at its & signs (audit, 19 Sept).
+    return platform === 'darwin' ? ['open', [url]] : platform === 'win32' ? ['rundll32', ['url,OpenURL', url]] : ['xdg-open', [url]];
+}
+// Opens the address in the person's own browser, on every operating system.
+export function openInBrowser(url) {
+    const command = browserCommand(url);
+    try {
+        const child = spawn(command[0], command[1], { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+    }
+    catch {
+        // The address is also shown on screen, so the person can open it themselves.
+    }
+}
+const PAGE = (message) => `<!doctype html><meta charset="utf-8"><title>Jeeves</title><body style="font-family:-apple-system,Segoe UI,sans-serif;background:#0b0b0d;color:#e6e6e6;display:grid;place-items:center;height:100vh;margin:0"><div style="text-align:center"><h1 style="font-weight:500">Jeeves</h1><p>${message}</p></div>`;
+export async function signInWithOpenRouter(options) {
+    const { verifier, challenge } = pkcePair();
+    const exchange = options.exchange ?? ((body) => fetch(EXCHANGE_URL, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) }));
+    return new Promise((resolve) => {
+        let settled = false;
+        const server = createServer(async (request, response) => {
+            const url = new URL(request.url ?? '/', 'http://localhost');
+            const code = url.searchParams.get('code');
+            if (url.pathname !== '/callback' || !code) {
+                response.writeHead(404).end();
+                return;
+            }
+            try {
+                const reply = await exchange({ code, code_verifier: verifier, code_challenge_method: 'S256' });
+                const body = (await reply.json().catch(() => ({})));
+                if (!reply.ok || typeof body.key !== 'string')
+                    throw new Error(`exchange ${reply.status}`);
+                response.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' }).end(PAGE('Jeeves is connected to OpenRouter. You can close this tab and go back to Jeeves.'));
+                finish({ ok: true, key: body.key });
+            }
+            catch {
+                response.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' }).end(PAGE("OpenRouter didn't complete the sign-in. Go back to Jeeves and try again."));
+                finish({ ok: false, reason: 'refused' });
+            }
+        });
+        // Fifteen minutes: long enough to make a new OpenRouter account and confirm an email.
+        const timer = setTimeout(() => finish({ ok: false, reason: 'timeout' }), options.timeoutMs ?? 15 * 60_000);
+        const onAbort = () => finish({ ok: false, reason: 'cancelled' });
+        options.signal?.addEventListener('abort', onAbort);
+        if (options.signal?.aborted) {
+            finish({ ok: false, reason: 'cancelled' });
+            return;
+        }
+        function finish(result) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            options.signal?.removeEventListener('abort', onAbort);
+            server.close();
+            resolve(result);
+        }
+        // Only this computer can reach the callback.
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            const url = authorizeUrl(`http://localhost:${port}/callback`, challenge);
+            options.onUrl?.(url);
+            (options.open ?? openInBrowser)(url);
+        });
+    });
+}
+// Said while the browser is open, in the terminal and the window alike. A person
+// who is not logged in lands on OpenRouter's Sign Up page, which carries a return
+// address to this same approval page (measured 19 Sept with a logged-out visit).
+export const WAITING_STEPS = [
+    'Your browser has opened at OpenRouter.',
+    'Log in if it asks, then click Authorize.',
+    'New to OpenRouter? Make an account on the page that opens - it brings you back to Authorize afterwards. If you end up somewhere else, come back here and choose Sign in again.',
+    "I'm waiting here - this moves on by itself once you approve.",
+];