@1presence/bridge 0.14.0 → 0.16.0

package/dist/claude.js

@@ -227,7 +227,7 @@ function spawnClaude(params) {
                     // First conversation since bridge started — announce prominently
                     // so the user can confirm which model and credential is in use.
                     const source = keySource === 'none' || !keySource ? 'claude.ai subscription' : keySource;
-                    const pin = (0, config_1.getBridgeModel)() ? '  (pinned via 1presence config)' : '';
+                    const pin = (0, config_1.getBridgeModel)() ? '  (selected at startup)' : '';
                     process.stdout.write(`\n  model: ${model ?? 'unknown'}${pin}\n  auth:  ${source}\n\n`);
                     modelAnnounced = true;
                 }

package/dist/config.js

@@ -2,35 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureModelChoice = ensureModelChoice;
 exports.getBridgeModel = getBridgeModel;
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
 const readline_1 = require("readline");
 const child_process_1 = require("child_process");
-// ─── Storage ──────────────────────────────────────────────────────────────────
+// ─── In-memory model choice ───────────────────────────────────────────────────
 //
-// `~/.1presence/config.json` holds bridge-wide preferences that should persist
-// across runs but aren't sensitive (unlike auth.json). Today: model choice.
-const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), '.1presence');
-const CONFIG_FILE = (0, path_1.join)(CONFIG_DIR, 'config.json');
-let cached = null;
-function load() {
-    if (cached)
-        return cached;
-    try {
-        cached = JSON.parse((0, fs_1.readFileSync)(CONFIG_FILE, 'utf-8'));
-    }
-    catch {
-        cached = {};
-    }
-    return cached;
-}
-function persist(c) {
-    (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
-    (0, fs_1.writeFileSync)(CONFIG_FILE, JSON.stringify(c, null, 2), 'utf-8');
-    cached = c;
-}
-// ─── Model choice ─────────────────────────────────────────────────────────────
+// The bridge prompts for a model on every interactive startup. The choice is
+// kept in memory for the life of the process — nothing is written to disk.
+// In a non-TTY environment the prompt is skipped and Claude Code's own default
+// is used.
+let selectedModel = null;
+// ─── Default-model probe ──────────────────────────────────────────────────────
 /**
  * Asks the local `claude` CLI which model it would pick by default, by reading
  * the `model` field of the `system/init` stream-json event and killing the
@@ -106,27 +87,18 @@ const MODEL_OPTIONS = [
     { num: 4, model: 'claude-haiku-4-5', label: 'claude-haiku-4-5' },
 ];
 const PROMPT_TIMEOUT_MS = 10_000;
-function defaultOptionNum(previous) {
-    if (typeof previous === 'string') {
-        const match = MODEL_OPTIONS.find((o) => o.model === previous);
-        if (match)
-            return match.num;
-    }
-    // Either never asked (undefined) or explicit no-override (null) → option 1.
-    return 1;
-}
-function promptForModel(defaultModel, previousChoice) {
+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 defaultNum = defaultOptionNum(previousChoice);
         process.stdout.write('\nWhich Claude model should the bridge use?\n');
         for (const opt of MODEL_OPTIONS) {
-            const isDefault = opt.num === defaultNum;
+            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(`  (* = current; auto-selected in ${PROMPT_TIMEOUT_MS / 1000}s if nothing pressed)\n`);
+        process.stdout.write(`  (* = default; auto-selected in ${PROMPT_TIMEOUT_MS / 1000}s if nothing pressed)\n`);
         let settled = false;
         const finish = (model) => {
             if (settled)
@@ -137,14 +109,14 @@ function promptForModel(defaultModel, previousChoice) {
             resolve(model);
         };
         const timer = setTimeout(() => {
-            const def = MODEL_OPTIONS.find((o) => o.num === defaultNum);
-            process.stdout.write(`\n(timed out — using option ${defaultNum})\n`);
+            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 === defaultNum);
+                const def = MODEL_OPTIONS.find((o) => o.num === DEFAULT_OPTION_NUM);
                 finish(def.model);
                 return;
             }
@@ -160,32 +132,25 @@ function promptForModel(defaultModel, previousChoice) {
     });
 }
 /**
- * Asks the user which model to pin every time the bridge starts interactively.
- * The current pick (or option 1 on first run) is the timeout default — wait
- * 10 seconds and the previous choice carries over. In a non-TTY environment
- * the prompt is skipped: an existing pin is kept, and a first non-TTY start
- * records "no override" so we don't keep trying.
+ * Asks the user which model to use for this bridge session. The choice lives
+ * in memory only — every startup re-prompts. In a non-TTY environment the
+ * prompt is skipped and Claude Code's own default is used.
  */
 async function ensureModelChoice() {
-    const c = load();
     if (!process.stdin.isTTY) {
-        if (!('model' in c))
-            persist({ ...c, model: null });
+        selectedModel = null;
         return;
     }
     const defaultModel = await detectClaudeDefaultModel();
-    const chosen = await promptForModel(defaultModel, c.model);
-    persist({ ...c, model: chosen });
-    if (chosen) {
-        console.log(`\nPinned model: ${chosen}`);
-        console.log(`(Edit or delete ~/.1presence/config.json to change.)\n`);
+    selectedModel = await promptForModel(defaultModel);
+    if (selectedModel) {
+        console.log(`\nUsing model: ${selectedModel} (this session only)\n`);
     }
     else {
-        console.log(`\nUsing your Claude Code default${defaultModel ? ` (${defaultModel})` : ''}.`);
-        console.log(`(Edit ~/.1presence/config.json to pin a model later.)\n`);
+        console.log(`\nUsing your Claude Code default${defaultModel ? ` (${defaultModel})` : ''}.\n`);
     }
 }
-/** Returns the pinned model id, or null to defer to Claude Code's own default. */
+/** Returns the model id chosen for this session, or null to defer to Claude Code's own default. */
 function getBridgeModel() {
-    return load().model ?? null;
+    return selectedModel;
 }

package/dist/index.js

@@ -38,61 +38,63 @@ 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) {
     return (0, path_1.join)((0, os_1.tmpdir)(), name);
 }
-async function writeSetupFiles(auth) {
+// Fetch the system prompt and write it to /tmp/agent-${uid}.md. The hosted
+// 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. Throws on failure; caller must handle.
+async function writeSystemPrompt(auth) {
     const { uid, token } = auth;
-    // Prefer the fully-built hosted system prompt so the bridge runtime behaves
-    // identically to the cloud agent (tool-use policy, ui_payload sparsity,
-    // plan thresholds, Gmail safety, connector pivots, personal AGENT.md, etc.).
-    // If the pod isn't reachable yet, fall back to the user's AGENT.md alone —
-    // Claude will still run, just without the platform policy layer.
-    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 ───────────────────────');
         console.log(systemPrompt);
         console.log('[bridge:verbose] ─── end system prompt ───────────────────\n');
     }
-    // MCP config pointing at gateway's /mcp endpoint (proxied to agent-api)
+}
+function writeMcpConfig(auth) {
+    const { uid, token } = auth;
     const mcpConfig = {
         mcpServers: {
             '1presence': {
@@ -104,6 +106,10 @@ async function writeSetupFiles(auth) {
     };
     writeRestricted(tmpFile(`mcp-${uid}.json`), JSON.stringify(mcpConfig, null, 2));
 }
+async function writeSetupFiles(auth) {
+    await writeSystemPrompt(auth);
+    writeMcpConfig(auth);
+}
 // The MCP config embeds a Bearer JWT and the system prompt may contain vault
 // state. writeFileSync's mode only takes effect on file creation — chmodSync
 // covers the overwrite case so a legacy 0644 file gets tightened on next run.
@@ -136,6 +142,24 @@ async function handleMessage(conversationId, text, sessionId, auth, vaultFileOpe
         }
         console.warn(`[bridge] token refresh failed (proceeding with current token): ${err.message}`);
     }
+    // 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). 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) {
+        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)({
         conversationId,
@@ -242,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
@@ -277,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;
 }
@@ -309,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);
@@ -323,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) {
@@ -331,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.14.0",
+  "version": "0.16.0",
   "description": "Run 1Presence on your Mac and use your Claude.ai Pro subscription from any device",
   "bin": {
     "1presence-bridge": "dist/index.js"