@1presence/bridge 0.90.0 → 0.92.0

package/README.md

@@ -57,6 +57,8 @@ On startup the bridge makes one request to the public npm registry (`registry.np
 
 **Every start** the bridge asks which Claude model to use — the choice is held in memory for that run only and nothing is written to disk, so restarting always asks again. Pick "Use Claude Code default" to defer to your local Claude Code default, or pin one of the latest models per family: `claude-opus-5`, `claude-fable-5`, `claude-sonnet-5`, `claude-haiku-4-5`. If the prompt times out it auto-selects "Use Claude Code default", which tracks whatever model Claude Code serves for your plan.
 
+**Press `Esc` at any time** to change model without restarting — no signing in again, and nothing in flight is lost. The new model applies to your next message; a reply already being written finishes on the one it started with. `Esc` again closes the menu without changing anything. While the bridge is running it also takes `Ctrl+C` to stop and `Ctrl+Z` to suspend.
+
 Superseded versions (`claude-opus-4-8`, `claude-sonnet-4-6`, …) are deliberately not listed. If you need something other than the latest, use "Use Claude Code default" and set the model in Claude Code itself.
 
 Every reply prints the model, the account it ran for, and your context/cost usage, so you can always see what is running — and if the model that answered isn't the one you pinned, the bridge says so explicitly. Note that only **one bridge per account** serves your turns: start a second one and the older process exits, because otherwise your turns could be answered by a terminal you aren't watching, on the model *it* pinned.

package/dist/claude.js

@@ -17,6 +17,9 @@ mkdirSync(BRIDGE_CWD, { recursive: true });
 writeFileSync(join(BRIDGE_CWD, 'CLAUDE.md'), BRIDGE_CLAUDE_MD, 'utf-8');
 import { getBridgeModel } from './config.js';
 let modelAnnounced = false;
+export function resetModelAnnouncement() {
+    modelAnnounced = false;
+}
 let cliVersion = null;
 export function getCliVersion() { return cliVersion; }
 const rateLimitWindows = new Map();
@@ -311,19 +314,19 @@ export function spawnClaude(params) {
                 extractedModel = model;
             if (ccv)
                 cliVersion = ccv;
-            const pinnedAtStartup = getBridgeModel();
-            const pinHonoured = !!pinnedAtStartup && !!model && model === pinnedAtStartup;
+            const activePin = getBridgeModel();
+            const pinHonoured = !!activePin && !!model && model === activePin;
             if (!modelAnnounced) {
                 const source = keySource === 'none' || !keySource ? 'claude.ai subscription' : keySource;
-                const pin = pinHonoured ? '  (selected at startup)' : '';
+                const pin = pinHonoured ? '  (your selection)' : '';
                 process.stdout.write(`\n  model: ${model ?? 'unknown'}${pin}\n  auth:  ${source}\n\n`);
                 modelAnnounced = true;
             }
             else {
                 process.stderr.write(`[bridge] model: ${model ?? 'unknown'}  apiKeySource: ${keySource ?? 'none'}\n`);
             }
-            if (pinnedAtStartup && model && model !== pinnedAtStartup) {
-                process.stderr.write(`[bridge] WARNING: ${pinnedAtStartup} was selected at startup, but this turn ran on ${model}.\n`);
+            if (activePin && model && model !== activePin) {
+                process.stderr.write(`[bridge] WARNING: ${activePin} is the selected model, but this turn ran on ${model}.\n`);
             }
             sessionIdExtracted = true;
         }

package/dist/config.js

@@ -1,5 +1,5 @@
-import { emitKeypressEvents } from 'readline';
 import { query } from '@anthropic-ai/claude-agent-sdk';
+import { decodeKeys } from './keys.js';
 let selectedModel = null;
 function detectClaudeDefaultModel() {
     return new Promise((resolve) => {
@@ -61,83 +61,103 @@ const MODEL_OPTIONS = [
 ];
 const PROMPT_TIMEOUT_MS = 10_000;
 const DEFAULT_OPTION_NUM = 1;
-function promptForModel(defaultModel) {
+let cachedDefaultModel = null;
+function promptForModel(defaultModel, opts) {
     return new Promise((resolve) => {
-        const initialIdx = Math.max(0, MODEL_OPTIONS.findIndex((o) => o.num === DEFAULT_OPTION_NUM));
-        let idx = initialIdx;
-        process.stdout.write('\nWhich Claude model should the bridge use?\n');
-        process.stdout.write(`  (↑/↓ to move, Enter to select, 1–${MODEL_OPTIONS.length} to jump, auto-selects in ${PROMPT_TIMEOUT_MS / 1000}s)\n`);
+        const currentIdx = MODEL_OPTIONS.findIndex((o) => o.model === opts.current);
+        const fallbackIdx = Math.max(0, MODEL_OPTIONS.findIndex((o) => o.num === DEFAULT_OPTION_NUM));
+        let idx = currentIdx >= 0 ? currentIdx : fallbackIdx;
+        const keys = [
+            '↑/↓ to move',
+            'Enter to select',
+            `1–${MODEL_OPTIONS.length} to jump`,
+            opts.escapeCancels ? 'Esc to cancel' : null,
+            opts.timeoutMs !== null ? `auto-selects in ${opts.timeoutMs / 1000}s` : null,
+        ].filter((s) => s !== null).join(', ');
+        opts.write(`\n${opts.heading}\n`);
+        opts.write(`  (${keys})\n`);
         let rendered = 0;
         const render = () => {
             if (rendered > 0)
-                process.stdout.write(`\x1b[${rendered}A`);
+                opts.write(`\x1b[${rendered}A`);
             rendered = 0;
             for (let i = 0; i < MODEL_OPTIONS.length; i++) {
                 const opt = MODEL_OPTIONS[i];
                 const active = i === idx;
                 const marker = active ? '›' : ' ';
-                const suffix = opt.num === 1 && defaultModel ? ` (${defaultModel})` : '';
-                const text = `  ${marker} ${opt.num}) ${opt.label}${suffix}`;
+                const probed = opt.num === 1 && defaultModel ? ` (${defaultModel})` : '';
+                const inUse = opts.markCurrent && i === currentIdx ? '  ← in use' : '';
+                const text = `  ${marker} ${opt.num}) ${opt.label}${probed}${inUse}`;
                 const line = active ? `\x1b[1;36m${text}\x1b[0m` : text;
-                process.stdout.write(`\x1b[2K${line}\n`);
+                opts.write(`\x1b[2K${line}\n`);
                 rendered++;
             }
         };
         render();
-        emitKeypressEvents(process.stdin);
         const wasRaw = process.stdin.isRaw;
         if (process.stdin.isTTY)
             process.stdin.setRawMode(true);
         process.stdin.resume();
         let settled = false;
         const cleanup = () => {
-            clearTimeout(timer);
-            process.stdin.removeListener('keypress', onKey);
+            if (timer)
+                clearTimeout(timer);
+            process.stdin.removeListener('data', onData);
             if (process.stdin.isTTY)
                 process.stdin.setRawMode(!!wasRaw);
             process.stdin.pause();
         };
-        const finish = (model) => {
+        const finish = (outcome) => {
             if (settled)
                 return;
             settled = true;
             cleanup();
-            resolve(model);
+            resolve(outcome);
         };
-        const onKey = (_str, key) => {
-            if (!key)
-                return;
-            if (key.ctrl && key.name === 'c') {
-                cleanup();
-                process.stdout.write('\n');
-                process.exit(130);
-            }
-            if (key.name === 'up' || key.name === 'k') {
-                idx = (idx - 1 + MODEL_OPTIONS.length) % MODEL_OPTIONS.length;
-                render();
-                return;
-            }
-            if (key.name === 'down' || key.name === 'j') {
-                idx = (idx + 1) % MODEL_OPTIONS.length;
-                render();
-                return;
-            }
-            if (key.name === 'return' || key.name === 'enter') {
-                finish(MODEL_OPTIONS[idx].model);
-                return;
-            }
-            const n = Number(key.sequence ?? '');
-            if (Number.isInteger(n) && n >= 1 && n <= MODEL_OPTIONS.length) {
-                idx = n - 1;
-                render();
-                finish(MODEL_OPTIONS[idx].model);
+        const onData = (chunk) => {
+            for (const key of decodeKeys(chunk)) {
+                if (settled)
+                    return;
+                switch (key.type) {
+                    case 'interrupt':
+                        cleanup();
+                        opts.onInterrupt();
+                        return;
+                    case 'escape':
+                        if (opts.escapeCancels) {
+                            finish({ cancelled: true });
+                            return;
+                        }
+                        break;
+                    case 'up':
+                        idx = (idx - 1 + MODEL_OPTIONS.length) % MODEL_OPTIONS.length;
+                        render();
+                        break;
+                    case 'down':
+                        idx = (idx + 1) % MODEL_OPTIONS.length;
+                        render();
+                        break;
+                    case 'enter':
+                        finish({ cancelled: false, model: MODEL_OPTIONS[idx].model });
+                        return;
+                    case 'digit':
+                        if (key.value <= MODEL_OPTIONS.length) {
+                            idx = key.value - 1;
+                            render();
+                            finish({ cancelled: false, model: MODEL_OPTIONS[idx].model });
+                            return;
+                        }
+                        break;
+                    default:
+                        break;
+                }
             }
         };
-        process.stdin.on('keypress', onKey);
-        const timer = setTimeout(() => {
-            process.stdout.write(`\n(timed out — using option ${MODEL_OPTIONS[idx].num})\n`);
-            finish(MODEL_OPTIONS[idx].model);
-        }, PROMPT_TIMEOUT_MS);
+        process.stdin.on('data', onData);
+        const timer = opts.timeoutMs === null ? null : setTimeout(() => {
+            opts.write(`\n(timed out — using option ${MODEL_OPTIONS[idx].num})\n`);
+            finish({ cancelled: false, model: MODEL_OPTIONS[idx].model });
+        }, opts.timeoutMs);
     });
 }
 export async function ensureModelChoice() {
@@ -145,13 +165,89 @@ export async function ensureModelChoice() {
         selectedModel = null;
         return;
     }
-    const defaultModel = await detectClaudeDefaultModel();
-    selectedModel = await promptForModel(defaultModel);
+    cachedDefaultModel = await detectClaudeDefaultModel();
+    const outcome = await promptForModel(cachedDefaultModel, {
+        heading: 'Which Claude model should the bridge use?',
+        current: null,
+        markCurrent: false,
+        timeoutMs: PROMPT_TIMEOUT_MS,
+        escapeCancels: false,
+        onInterrupt: () => { process.stdout.write('\n'); process.exit(130); },
+        write: (s) => { process.stdout.write(s); },
+    });
+    selectedModel = outcome.cancelled ? null : outcome.model;
     if (selectedModel) {
         console.log(`\nUsing model: ${selectedModel} (this session only)\n`);
     }
     else {
-        console.log(`\nUsing your Claude Code default${defaultModel ? ` (${defaultModel})` : ''}.\n`);
+        console.log(`\nUsing your Claude Code default${cachedDefaultModel ? ` (${cachedDefaultModel})` : ''}.\n`);
+    }
+}
+const HOLD_LIMIT_CHARS = 1_000_000;
+function holdOutput() {
+    const out = process.stdout.write.bind(process.stdout);
+    const err = process.stderr.write.bind(process.stderr);
+    const held = [];
+    let heldChars = 0;
+    let dropped = 0;
+    const capture = (sink) => function (chunk, encoding, cb) {
+        const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf-8');
+        if (heldChars + text.length <= HOLD_LIMIT_CHARS) {
+            held.push([sink, text]);
+            heldChars += text.length;
+        }
+        else {
+            dropped += text.length;
+        }
+        const done = typeof encoding === 'function' ? encoding : cb;
+        if (typeof done === 'function')
+            done();
+        return true;
+    };
+    process.stdout.write = capture(out);
+    process.stderr.write = capture(err);
+    return {
+        passthrough: (s) => { out(s); },
+        release: () => {
+            process.stdout.write = out;
+            process.stderr.write = err;
+            for (const [sink, text] of held)
+                sink(text);
+            held.length = 0;
+            if (dropped > 0) {
+                err(`[bridge] ${dropped} characters of output were dropped while the model picker was open.\n`);
+            }
+        },
+    };
+}
+export async function reopenModelPicker(onInterrupt) {
+    const hold = holdOutput();
+    const previous = selectedModel;
+    try {
+        const outcome = await promptForModel(cachedDefaultModel, {
+            heading: 'Switch model — applies to your next message.',
+            current: previous,
+            markCurrent: true,
+            timeoutMs: null,
+            escapeCancels: true,
+            onInterrupt,
+            write: hold.passthrough,
+        });
+        if (outcome.cancelled) {
+            hold.passthrough('\n\x1b[90m(unchanged)\x1b[0m\n\n');
+            return { changed: false, model: previous };
+        }
+        selectedModel = outcome.model;
+        const name = selectedModel ?? `Claude Code default${cachedDefaultModel ? ` (${cachedDefaultModel})` : ''}`;
+        if (selectedModel === previous) {
+            hold.passthrough(`\n\x1b[90m(unchanged — still ${name})\x1b[0m\n\n`);
+            return { changed: false, model: selectedModel };
+        }
+        hold.passthrough(`\nModel switched to ${name} — applies to your next message.\n\n`);
+        return { changed: true, model: selectedModel };
+    }
+    finally {
+        hold.release();
     }
 }
 export function getBridgeModel() {

package/dist/hotkeys.js

@@ -0,0 +1,78 @@
+import { reopenModelPicker } from './config.js';
+import { decodeKeys } from './keys.js';
+let installed = false;
+let pickerOpen = false;
+function cooked() {
+    try {
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+    }
+    catch {
+    }
+}
+function suspend() {
+    cooked();
+    process.stdin.pause();
+    process.once('SIGCONT', () => {
+        try {
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(true);
+        }
+        catch {
+        }
+        process.stdin.resume();
+    });
+    process.kill(process.pid, 'SIGTSTP');
+}
+async function openPicker(h) {
+    pickerOpen = true;
+    try {
+        const { changed, model } = await reopenModelPicker(() => { cooked(); h.onQuit(); });
+        if (changed)
+            h.onModelChanged?.(model);
+    }
+    catch (err) {
+        process.stderr.write(`[bridge] model picker failed: ${err.message}\n`);
+    }
+    finally {
+        pickerOpen = false;
+        try {
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(true);
+        }
+        catch {
+        }
+        process.stdin.resume();
+    }
+}
+export function installHotkeys(h) {
+    if (installed || !process.stdin.isTTY)
+        return false;
+    installed = true;
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.on('exit', cooked);
+    process.stdin.on('data', (chunk) => {
+        if (pickerOpen)
+            return;
+        for (const key of decodeKeys(chunk)) {
+            if (key.type === 'interrupt') {
+                cooked();
+                h.onQuit();
+                return;
+            }
+            if (key.type === 'suspend') {
+                suspend();
+                return;
+            }
+            if (key.type === 'escape') {
+                void openPicker(h);
+                return;
+            }
+        }
+    });
+    return true;
+}
+export function isPickerOpen() {
+    return pickerOpen;
+}

package/dist/index.js

@@ -7,8 +7,9 @@ import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { getValidAuth, ensureFreshToken, forceRefreshToken, isTokenValid, AuthCancelledError } from './auth.js';
-import { spawnClaude, killAll, cancelConversation, setVerbose, setDebug, paint, SECTION_COLORS, getCliVersion, getRateLimitWindow, REMOTE_MCP_SERVER_NAME as BRIDGE_MCP_SERVER_NAME } from './claude.js';
+import { spawnClaude, killAll, cancelConversation, setVerbose, setDebug, paint, SECTION_COLORS, getCliVersion, getRateLimitWindow, resetModelAnnouncement, REMOTE_MCP_SERVER_NAME as BRIDGE_MCP_SERVER_NAME } from './claude.js';
 import { ensureModelChoice } from './config.js';
+import { installHotkeys } from './hotkeys.js';
 import { probeClaudeAuth, launchClaudeLogin, waitForClaudeLogin, promptYesNo } from './claudeAuth.js';
 import { checkAndUpdate, warnIfRuntimeStale } from './update.js';
 import { makeBridgeAccumulator, postSaveTurn } from './accumulator.js';
@@ -35,6 +36,7 @@ const PWA_URL = process.env.BRIDGE_PWA_URL ?? GATEWAY_HTTP.replace('://api.', ':
 let currentAuth = null;
 let currentWs = null;
 let disconnectedAt = null;
+let hotkeysActive = false;
 let sessionCostUsd = 0;
 let authRejections = 0;
 const MAX_AUTH_REJECTIONS = 3;
@@ -496,7 +498,10 @@ function connect(auth, retryDelay = 1000) {
             console.log(`✓ Bridge reconnected${who} after ${downFor} offline. Local Mode active on all your devices.\n`);
         }
         else {
-            console.log(`✓ Bridge connected${who}. Local Mode active on all your devices.\n`);
+            console.log(`✓ Bridge connected${who}. Local Mode active on all your devices.`);
+            if (hotkeysActive)
+                console.log(paint('90', '  Press Esc to switch model, Ctrl+C to stop.'));
+            console.log('');
         }
         startPing();
         if (currentAuth) {
@@ -702,6 +707,10 @@ async function main() {
     };
     process.on('SIGINT', shutdown);
     process.on('SIGTERM', shutdown);
+    hotkeysActive = installHotkeys({
+        onQuit: shutdown,
+        onModelChanged: () => resetModelAnnouncement(),
+    });
     process.on('uncaughtException', (err) => {
         console.error(paint(SECTION_COLORS.error, `[bridge] uncaughtException: ${err.message}`));
         if (err.stack)

package/dist/keys.js

@@ -0,0 +1,86 @@
+const ESC = 0x1b;
+const isFinal = (b) => b >= 0x40 && b <= 0x7e;
+const isParamOrInter = (b) => b >= 0x20 && b <= 0x3f;
+export function decodeKeys(chunk) {
+    const buf = typeof chunk === 'string' ? Buffer.from(chunk, 'utf-8') : chunk;
+    const keys = [];
+    let i = 0;
+    while (i < buf.length) {
+        const b = buf[i];
+        if (b === ESC) {
+            if (i === buf.length - 1) {
+                keys.push({ type: 'escape' });
+                i++;
+                continue;
+            }
+            const next = buf[i + 1];
+            if (next === 0x5b) {
+                let j = i + 2;
+                while (j < buf.length && isParamOrInter(buf[j]))
+                    j++;
+                if (j < buf.length && isFinal(buf[j])) {
+                    const final = buf[j];
+                    const bare = j === i + 2;
+                    if (bare && final === 0x41)
+                        keys.push({ type: 'up' });
+                    else if (bare && final === 0x42)
+                        keys.push({ type: 'down' });
+                    else
+                        keys.push({ type: 'other' });
+                    i = j + 1;
+                    continue;
+                }
+                keys.push({ type: 'other' });
+                i = buf.length;
+                continue;
+            }
+            if (next === 0x4f && i + 2 < buf.length) {
+                const final = buf[i + 2];
+                if (final === 0x41)
+                    keys.push({ type: 'up' });
+                else if (final === 0x42)
+                    keys.push({ type: 'down' });
+                else
+                    keys.push({ type: 'other' });
+                i += 3;
+                continue;
+            }
+            keys.push({ type: 'other' });
+            i += 2;
+            continue;
+        }
+        if (b === 0x03) {
+            keys.push({ type: 'interrupt' });
+            i++;
+            continue;
+        }
+        if (b === 0x1a) {
+            keys.push({ type: 'suspend' });
+            i++;
+            continue;
+        }
+        if (b === 0x0d || b === 0x0a) {
+            keys.push({ type: 'enter' });
+            i++;
+            continue;
+        }
+        if (b === 0x6b) {
+            keys.push({ type: 'up' });
+            i++;
+            continue;
+        }
+        if (b === 0x6a) {
+            keys.push({ type: 'down' });
+            i++;
+            continue;
+        }
+        if (b >= 0x31 && b <= 0x39) {
+            keys.push({ type: 'digit', value: b - 0x30 });
+            i++;
+            continue;
+        }
+        keys.push({ type: 'other' });
+        i++;
+    }
+    return keys;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1presence/bridge",
-  "version": "0.90.0",
+  "version": "0.92.0",
   "description": "Run 1Presence on your Mac and use your Claude.ai Pro subscription from any device",
   "license": "Apache-2.0",
   "type": "module",
@@ -21,7 +21,7 @@
     "start": "node dist/index.js"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.234",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.257",
     "ws": "^8.20.0",
     "zod": "^4.0.0"
   },