@1presence/bridge 0.15.0 → 0.17.0

package/dist/config.js

@@ -90,45 +90,81 @@ const PROMPT_TIMEOUT_MS = 10_000;
 const DEFAULT_OPTION_NUM = 1;
 function promptForModel(defaultModel) {
     return new Promise((resolve) => {
-        const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+        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');
-        for (const opt of MODEL_OPTIONS) {
-            const isDefault = opt.num === DEFAULT_OPTION_NUM;
-            const marker = isDefault ? '*' : ' ';
-            const suffix = opt.num === 1 && defaultModel ? ` (${defaultModel})` : '';
-            process.stdout.write(`  ${marker} ${opt.num}) ${opt.label}${suffix}\n`);
-        }
-        process.stdout.write(`  (* = default; auto-selected in ${PROMPT_TIMEOUT_MS / 1000}s if nothing pressed)\n`);
+        process.stdout.write(`  (↑/↓ to move, Enter to select, 1–${MODEL_OPTIONS.length} to jump, auto-selects in ${PROMPT_TIMEOUT_MS / 1000}s)\n`);
+        let rendered = 0;
+        const render = () => {
+            if (rendered > 0)
+                process.stdout.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 line = active ? `\x1b[1;36m${text}\x1b[0m` : text;
+                process.stdout.write(`\x1b[2K${line}\n`);
+                rendered++;
+            }
+        };
+        render();
+        (0, readline_1.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 (process.stdin.isTTY)
+                process.stdin.setRawMode(!!wasRaw);
+            process.stdin.pause();
+        };
         const finish = (model) => {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timer);
-            rl.close();
+            cleanup();
             resolve(model);
         };
-        const timer = setTimeout(() => {
-            const def = MODEL_OPTIONS.find((o) => o.num === DEFAULT_OPTION_NUM);
-            process.stdout.write(`\n(timed out — using option ${DEFAULT_OPTION_NUM})\n`);
-            finish(def.model);
-        }, PROMPT_TIMEOUT_MS);
-        rl.question('  choice: ', (answer) => {
-            const trimmed = answer.trim();
-            if (!trimmed) {
-                const def = MODEL_OPTIONS.find((o) => o.num === DEFAULT_OPTION_NUM);
-                finish(def.model);
+        const onKey = (_str, key) => {
+            if (!key)
                 return;
+            if (key.ctrl && key.name === 'c') {
+                cleanup();
+                process.stdout.write('\n');
+                process.exit(130);
             }
-            const n = Number(trimmed);
-            const opt = MODEL_OPTIONS.find((o) => o.num === n);
-            if (opt) {
-                finish(opt.model);
+            if (key.name === 'up' || key.name === 'k') {
+                idx = (idx - 1 + MODEL_OPTIONS.length) % MODEL_OPTIONS.length;
+                render();
                 return;
             }
-            // Fall back to treating the input as a raw model id for power users.
-            finish(trimmed);
-        });
+            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);
+            }
+        };
+        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);
     });
 }
 /**

package/dist/index.js

@@ -38,38 +38,41 @@ const PWA_URL = process.env.BRIDGE_PWA_URL ?? GATEWAY_HTTP.replace('://api.', ':
 // ─── In-memory state ──────────────────────────────────────────────────────────
 let currentAuth = null;
 let currentWs = null;
-// ─── Vault file fetch ─────────────────────────────────────────────────────────
-async function fetchVaultFile(path, token) {
+// ─── System prompt fetch ──────────────────────────────────────────────────────
+// Pulls the fully-built system prompt from agent-api (via gateway proxy).
+// This MUST match the hosted runtime exactly — STATIC_SYSTEM_PROMPT + dynamic
+// context (timezone, connector scopes, vault state, personal AGENT.md, skills,
+// onboarding). There is intentionally NO fallback: if this fails the bridge
+// must surface the error, not silently degrade to a different prompt source
+// (which historically caused the "Skills section authoritative" rule to
+// vanish and the agent to vault-hunt for skills).
+async function fetchSystemPrompt(token) {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const url = `${GATEWAY_HTTP}/system-prompt?timezone=${encodeURIComponent(tz)}`;
+    let res;
     try {
-        const res = await fetch(`${GATEWAY_HTTP}/vault/file?path=${encodeURIComponent(path)}`, {
+        res = await fetch(url, {
             headers: { Authorization: `Bearer ${token}` },
         });
-        if (!res.ok)
-            return null;
-        return res.text();
     }
-    catch {
-        return null;
+    catch (err) {
+        throw new Error(`fetch failed for ${url}: ${err.message}`);
     }
-}
-// Pulls the fully-built system prompt from agent-api (via gateway proxy).
-// This matches the hosted runtime exactly: STATIC_SYSTEM_PROMPT + dynamic
-// context (timezone, connector scopes, vault state, personal AGENT.md, etc.).
-// Falls back to null on failure — caller decides whether to use AGENT.md only.
-async function fetchSystemPrompt(token) {
+    if (!res.ok) {
+        const body = await res.text().catch(() => '<unreadable body>');
+        throw new Error(`/system-prompt returned ${res.status} ${res.statusText}: ${body.slice(0, 500)}`);
+    }
+    let data;
     try {
-        const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-        const res = await fetch(`${GATEWAY_HTTP}/system-prompt?timezone=${encodeURIComponent(tz)}`, {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-        if (!res.ok)
-            return null;
-        const data = await res.json();
-        return data.text ?? null;
+        data = await res.json();
+    }
+    catch (err) {
+        throw new Error(`/system-prompt returned non-JSON: ${err.message}`);
     }
-    catch {
-        return null;
+    if (!data.text) {
+        throw new Error(`/system-prompt returned no "text" field (got keys: ${Object.keys(data).join(', ') || '<none>'})`);
     }
+    return data.text;
 }
 // ─── Setup files ──────────────────────────────────────────────────────────────
 function tmpFile(name) {
@@ -79,13 +82,10 @@ function tmpFile(name) {
 // runtime rebuilds buildSystemBlocks() per turn (dynamic context: vault state,
 // connector status, palace, onboarding phase, skills) — call this per turn in
 // the bridge too, otherwise newly shipped skills and mid-session vault writes
-// never reach a long-running bridge.
+// never reach a long-running bridge. Throws on failure; caller must handle.
 async function writeSystemPrompt(auth) {
     const { uid, token } = auth;
-    const systemPrompt = (await fetchSystemPrompt(token))
-        ?? (await fetchVaultFile('AGENT.md', token))
-        ?? (await fetchVaultFile('CLAUDE.md', token))
-        ?? '';
+    const systemPrompt = await fetchSystemPrompt(token);
     writeRestricted(tmpFile(`agent-${uid}.md`), systemPrompt);
     if (VERBOSE) {
         console.log('\n[bridge:verbose] ─── system prompt ───────────────────────');
@@ -144,13 +144,21 @@ async function handleMessage(conversationId, text, sessionId, auth, vaultFileOpe
     }
     // Refresh the system prompt on every turn — the hosted runtime rebuilds its
     // dynamic context per turn (vault state, connector status, palace, onboarding
-    // phase, newly enabled skills). Without this the bridge holds a frozen
-    // snapshot from process start and misses anything added since.
+    // phase, newly enabled skills). If this fails we abort the turn rather than
+    // silently reuse a stale snapshot — parity with agent-api is the whole point
+    // of bridge mode, and stale prompts have caused user-visible regressions
+    // (e.g. agent vault-hunting for skills because the Skills authoritative
+    // rule was missing from the previous snapshot).
     try {
         await writeSystemPrompt(activeAuth);
     }
     catch (err) {
-        console.warn(`[bridge] system prompt refresh failed (using cached): ${err.message}`);
+        const message = `System prompt refresh failed: ${err.message}`;
+        console.error(`[${new Date().toLocaleTimeString()}] ✗ ${message}`);
+        if (currentWs?.readyState === ws_1.default.OPEN) {
+            currentWs.send(JSON.stringify({ type: 'error', conversationId, message }));
+        }
+        return;
     }
     let responding = false;
     (0, claude_1.spawnClaude)({
@@ -258,7 +266,9 @@ function connect(auth, retryDelay = 1000) {
         try {
             msg = JSON.parse(raw.toString());
         }
-        catch {
+        catch (err) {
+            const preview = raw.toString().slice(0, 200);
+            console.error(`[bridge] failed to parse ws message as JSON: ${err.message} (raw: ${preview})`);
             return;
         }
         // Application-level pong — clear the timeout
@@ -293,19 +303,26 @@ function connect(auth, retryDelay = 1000) {
         console.log(`Bridge disconnected (${code}). Reconnecting in ${delay / 1000}s…`);
         setTimeout(async () => {
             try {
-                // Refresh setup files on reconnect in case token was refreshed
+                // Refresh setup files on reconnect in case token was refreshed.
+                // If /system-prompt is down this throws — log and retry; the bridge
+                // is useless without a current prompt so don't paper over it.
                 if (currentAuth)
                     await writeSetupFiles(currentAuth);
                 connect(currentAuth, Math.min(retryDelay * 2, 30_000));
             }
             catch (err) {
-                console.error('Reconnect failed:', err.message);
+                console.error(`[bridge] reconnect setup failed: ${err.message}`);
+                console.error('[bridge] will retry connection anyway — system prompt may be stale until next refresh');
+                if (currentAuth)
+                    connect(currentAuth, Math.min(retryDelay * 2, 30_000));
             }
         }, delay);
     });
     ws.on('error', (err) => {
         // close event fires after error — reconnect handled there
         console.error(`[bridge] ws error: ${err.message}`);
+        if (VERBOSE && err.stack)
+            console.error(err.stack);
     });
     return ws;
 }
@@ -325,9 +342,19 @@ async function main() {
     // ~/.1presence/config.json). In a non-TTY environment this is a no-op and
     // Claude Code's own default is used.
     await (0, config_1.ensureModelChoice)();
-    // Write system prompt + MCP config
+    // Write system prompt + MCP config. If this fails the bridge is dead in the
+    // water — surface the underlying error rather than letting it bubble up as
+    // a generic "Fatal:" with no context.
     process.stdout.write('Setting up…');
-    await writeSetupFiles(auth);
+    try {
+        await writeSetupFiles(auth);
+    }
+    catch (err) {
+        process.stdout.write(' FAILED.\n');
+        console.error(`[bridge] setup failed: ${err.message}`);
+        console.error('[bridge] cannot start without a system prompt from the gateway. Check network, auth, and that the gateway is reachable.');
+        process.exit(1);
+    }
     process.stdout.write(' done.\n');
     // Connect
     connect(auth);
@@ -339,6 +366,21 @@ async function main() {
     };
     process.on('SIGINT', shutdown);
     process.on('SIGTERM', shutdown);
+    // Surface anything that would otherwise vanish into the void. Without these,
+    // a thrown error inside an async callback (ws handler, child process event,
+    // setTimeout) silently kills the bridge with no diagnostic.
+    process.on('uncaughtException', (err) => {
+        console.error(`[bridge] uncaughtException: ${err.message}`);
+        if (err.stack)
+            console.error(err.stack);
+    });
+    process.on('unhandledRejection', (reason) => {
+        const message = reason instanceof Error ? reason.message : String(reason);
+        const stack = reason instanceof Error ? reason.stack : undefined;
+        console.error(`[bridge] unhandledRejection: ${message}`);
+        if (stack)
+            console.error(stack);
+    });
 }
 main().catch((err) => {
     if (err instanceof auth_1.AuthCancelledError) {
@@ -347,5 +389,7 @@ main().catch((err) => {
         process.exit(0);
     }
     console.error('Fatal:', err.message);
+    if (err.stack)
+        console.error(err.stack);
     process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1presence/bridge",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "Run 1Presence on your Mac and use your Claude.ai Pro subscription from any device",
   "bin": {
     "1presence-bridge": "dist/index.js"