@1presence/bridge 0.6.0 → 0.9.0

package/dist/claude.js

@@ -125,6 +125,12 @@ function spawnClaude(params) {
     const { conversationId, presenceSessionId, text, uid, vaultFileOpen, clientCapabilities, syncedFolders, onEvent, onDone, onError } = params;
     const systemPromptPath = (0, path_1.join)((0, os_1.tmpdir)(), `agent-${uid}.md`);
     const mcpConfigPath = (0, path_1.join)((0, os_1.tmpdir)(), `mcp-${uid}.json`);
+    if (verbose) {
+        process.stderr.write(`[bridge:verbose] cwd:           ${BRIDGE_CWD}\n`);
+        process.stderr.write(`[bridge:verbose] override md:   ${(0, path_1.join)(BRIDGE_CWD, 'CLAUDE.md')}\n`);
+        process.stderr.write(`[bridge:verbose] system prompt: ${systemPromptPath}\n`);
+        process.stderr.write(`[bridge:verbose] mcp config:    ${mcpConfigPath}\n`);
+    }
     // If a prior process is still running for this conversation (user sent a
     // follow-up before the previous turn finished), supersede it. The latest
     // user intent wins; the orphan would otherwise keep streaming events.

package/dist/config.js

@@ -6,6 +6,7 @@ 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 ──────────────────────────────────────────────────────────────────
 //
 // `~/.1presence/config.json` holds bridge-wide preferences that should persist
@@ -30,41 +31,157 @@ function persist(c) {
     cached = c;
 }
 // ─── Model choice ─────────────────────────────────────────────────────────────
-function promptForModel() {
+/**
+ * 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
+ * process before any model call completes. Returns null on timeout or if the
+ * CLI isn't installed — we never want this auxiliary lookup to block startup.
+ */
+function detectClaudeDefaultModel() {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (v) => { if (!settled) {
+            settled = true;
+            resolve(v);
+        } };
+        let proc;
+        try {
+            proc = (0, child_process_1.spawn)('claude', [
+                '-p',
+                '--input-format', 'stream-json',
+                '--output-format', 'stream-json',
+                '--verbose',
+                '--tools', '',
+                '--setting-sources', '',
+            ], { stdio: ['pipe', 'pipe', 'ignore'] });
+        }
+        catch {
+            finish(null);
+            return;
+        }
+        const timer = setTimeout(() => { try {
+            proc.kill('SIGKILL');
+        }
+        catch { } ; finish(null); }, 5000);
+        proc.on('error', () => { clearTimeout(timer); finish(null); });
+        proc.on('close', () => { clearTimeout(timer); finish(null); });
+        let buf = '';
+        proc.stdout?.on('data', (chunk) => {
+            buf += chunk.toString('utf-8');
+            const lines = buf.split('\n');
+            buf = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const ev = JSON.parse(trimmed);
+                    if (ev['type'] === 'system' && ev['subtype'] === 'init') {
+                        const model = ev['model'];
+                        clearTimeout(timer);
+                        try {
+                            proc.kill('SIGKILL');
+                        }
+                        catch { }
+                        finish(typeof model === 'string' ? model : null);
+                        return;
+                    }
+                }
+                catch { /* ignore non-JSON lines */ }
+            }
+        });
+        // Send one empty user message so claude proceeds past startup and emits
+        // the init event. We kill before any assistant turn runs, so no tokens
+        // are billed.
+        proc.stdin?.end('{"type":"user","message":{"role":"user","content":""}}\n');
+    });
+}
+// The fixed menu — keep the option count small so the timeout default is easy
+// to glance at. Option 1's `model: null` means "let Claude Code pick" (no
+// `--model` flag passed to the subprocess).
+const MODEL_OPTIONS = [
+    { num: 1, model: null, label: 'Use Claude Code default' },
+    { num: 2, model: 'claude-opus-4-7', label: 'claude-opus-4-7' },
+    { num: 3, model: 'claude-sonnet-4-6', label: 'claude-sonnet-4-6' },
+    { 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) {
     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');
-        process.stdout.write('  Leave blank to use your local Claude Code default (recommended).\n');
-        process.stdout.write('  Or enter a model id (e.g. claude-sonnet-4-5, claude-opus-4-7, claude-haiku-4-5).\n');
-        rl.question('  model: ', (answer) => {
+        for (const opt of MODEL_OPTIONS) {
+            const isDefault = opt.num === defaultNum;
+            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`);
+        let settled = false;
+        const finish = (model) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
             rl.close();
+            resolve(model);
+        };
+        const timer = setTimeout(() => {
+            const def = MODEL_OPTIONS.find((o) => o.num === defaultNum);
+            process.stdout.write(`\n(timed out — using option ${defaultNum})\n`);
+            finish(def.model);
+        }, PROMPT_TIMEOUT_MS);
+        rl.question('  choice: ', (answer) => {
             const trimmed = answer.trim();
-            resolve(trimmed || null);
+            if (!trimmed) {
+                const def = MODEL_OPTIONS.find((o) => o.num === defaultNum);
+                finish(def.model);
+                return;
+            }
+            const n = Number(trimmed);
+            const opt = MODEL_OPTIONS.find((o) => o.num === n);
+            if (opt) {
+                finish(opt.model);
+                return;
+            }
+            // Fall back to treating the input as a raw model id for power users.
+            finish(trimmed);
         });
     });
 }
 /**
- * Ensures the user has picked a model preference. On first interactive run,
- * prompts and persists. Subsequent runs return the saved value without asking.
- * In a non-TTY environment (background process, CI) the prompt is skipped and
- * we record an explicit "no override" so we don't keep trying.
+ * 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.
  */
 async function ensureModelChoice() {
     const c = load();
-    if ('model' in c)
-        return; // already configured (string or explicit null)
     if (!process.stdin.isTTY) {
-        persist({ ...c, model: null });
+        if (!('model' in c))
+            persist({ ...c, model: null });
         return;
     }
-    const chosen = await promptForModel();
+    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`);
     }
     else {
-        console.log(`\nUsing your Claude Code default.`);
+        console.log(`\nUsing your Claude Code default${defaultModel ? ` (${defaultModel})` : ''}.`);
         console.log(`(Edit ~/.1presence/config.json to pin a model later.)\n`);
     }
 }

package/dist/index.js

@@ -249,6 +249,10 @@ function connect(auth, retryDelay = 1000) {
             (0, auth_1.clearAuth)();
             process.exit(1);
         }
+        if (code === 4003) {
+            console.error('Local Claude Code is not enabled for your account. To request access, email hello@1presence.com.');
+            process.exit(1);
+        }
         const delay = Math.min(retryDelay, 30_000);
         console.log(`Bridge disconnected (${code}). Reconnecting in ${delay / 1000}s…`);
         setTimeout(async () => {

package/package.json

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