@1presence/bridge 0.60.0 → 0.62.0

package/dist/claude.js

@@ -195,6 +195,35 @@ function joinErrorDetail(...parts) {
 // Lines the SDK/CLI writes to its own stderr that look like a failure — surfaced
 // even outside verbose mode so a turn that dies upstream leaves a trail.
 const SDK_STDERR_ERROR_RE = /\b(error|exception|fail(?:ed|ure)?|invalid|unauthor|forbidden|refus|denied|40[0-9]|429|5\d\d|overloaded|rate.?limit)\b/i;
+// The remote 1Presence MCP server's key (matches index.ts writeMcpConfig +
+// the `mcp__1presence__*` allowlist). reconnectMcpServer() takes this name.
+const REMOTE_MCP_SERVER_NAME = '1presence';
+// Signature of a dropped remote MCP session. The pod binds each MCP session to a
+// single long-lived SSE `GET /mcp` stream held in its memory; if that stream
+// drops mid-run (transient network blip on a long workflow stage), the pod
+// deletes the session and every later `POST /mcp/message?sessionId=…` returns
+// HTTP 404 "session not found or expired". The SDK does NOT auto-retry an
+// expired MCP session (sdk.d.ts: "Session expiry is not retried automatically;
+// callers can mcp_reconnect and retry") — it surfaces the 404 as a tool_result
+// error to the model, which then dead-loops calling tools against the same dead
+// session for the rest of the turn. Detecting this lets us reconnect the server
+// so the model's next attempt re-handshakes a fresh session and recovers.
+const MCP_SESSION_EXPIRED_RE = /session not found or expired|Error POSTing to endpoint \(HTTP 404\)/i;
+// Pull every text fragment out of a tool_result `content` (string OR the MCP
+// block-array shape `[{type:'text',text:'…'}]`) so we can scan it for the
+// session-expiry signature above.
+function toolResultText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((b) => (b && typeof b === 'object' && typeof b.text === 'string'
+            ? b.text
+            : ''))
+            .join(' ');
+    }
+    return '';
+}
 /**
  * Copy for an actionable rate-limit notice. The SDK emits `rate_limit_event`
  * whenever rate-limit info CHANGES — including the routine `allowed` case on
@@ -649,8 +678,28 @@ export function spawnClaude(params) {
             ...(pinnedModel ? { model: pinnedModel } : {}),
         };
         const promptMessages = buildPromptMessages(history);
+        // Throttle remote-MCP reconnects: a single dropped session produces a burst
+        // of 404 tool_results (the model keeps trying), so reconnect at most once per
+        // window to avoid a reconnect storm. A reconnect is in-flight guard too.
+        let lastMcpReconnectAt = 0;
+        let mcpReconnecting = false;
+        const MCP_RECONNECT_THROTTLE_MS = 10_000;
+        const maybeReconnectRemoteMcp = (q) => {
+            const now = Date.now();
+            if (mcpReconnecting || now - lastMcpReconnectAt < MCP_RECONNECT_THROTTLE_MS)
+                return;
+            mcpReconnecting = true;
+            lastMcpReconnectAt = now;
+            process.stderr.write(paint(SECTION_COLORS.result, '[bridge] remote MCP session expired — reconnecting and retrying') + '\n');
+            onNotice?.('Reconnecting to 1Presence tools…');
+            void q.reconnectMcpServer(REMOTE_MCP_SERVER_NAME)
+                .then(() => process.stderr.write(paint(SECTION_COLORS.result, '[bridge] remote MCP reconnected') + '\n'))
+                .catch((err) => process.stderr.write(paint(SECTION_COLORS.result, `[bridge] remote MCP reconnect failed: ${err.message}`) + '\n'))
+                .finally(() => { mcpReconnecting = false; });
+        };
         try {
-            for await (const m of query({ prompt: promptStream(promptMessages), options })) {
+            const q = query({ prompt: promptStream(promptMessages), options });
+            for await (const m of q) {
                 // Skip echoed input replays — they would double-count in the accumulator
                 // and re-stream prior turns to the PWA.
                 if (m.isReplay)
@@ -716,6 +765,19 @@ export function spawnClaude(params) {
                     }
                     case 'user': {
                         const um = m;
+                        // Detect a dropped remote-MCP session in any tool_result and re-handshake
+                        // so the model's next tool call lands on a live session instead of
+                        // 404-looping for the rest of the turn (the SDK won't auto-retry it).
+                        const content = um.message?.['content'];
+                        if (Array.isArray(content)) {
+                            for (const block of content) {
+                                if (block && typeof block === 'object' && block['type'] === 'tool_result'
+                                    && MCP_SESSION_EXPIRED_RE.test(toolResultText(block['content']))) {
+                                    maybeReconnectRemoteMcp(q);
+                                    break;
+                                }
+                            }
+                        }
                         const event = { type: 'user', message: um.message };
                         if (handleEvent(event))
                             onEvent(event);

package/dist/claudeAuth.js

@@ -0,0 +1,130 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+/**
+ * Parse the stdout of `claude auth status --json`. Extracts the first JSON object
+ * (defensive against any banner/log noise around it). Returns null when there is
+ * no parseable object or no boolean `loggedIn` field — i.e. an output shape we
+ * don't recognise, which the caller treats as "unknown, don't block".
+ * Exported for unit testing.
+ */
+export function parseAuthStatus(stdout) {
+    const start = stdout.indexOf('{');
+    const end = stdout.lastIndexOf('}');
+    if (start === -1 || end === -1 || end < start)
+        return null;
+    try {
+        const j = JSON.parse(stdout.slice(start, end + 1));
+        if (typeof j['loggedIn'] !== 'boolean')
+            return null;
+        return {
+            loggedIn: j['loggedIn'],
+            email: typeof j['email'] === 'string' ? j['email'] : undefined,
+            authMethod: typeof j['authMethod'] === 'string' ? j['authMethod'] : undefined,
+            subscriptionType: typeof j['subscriptionType'] === 'string' ? j['subscriptionType'] : undefined,
+            orgName: typeof j['orgName'] === 'string' ? j['orgName'] : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Ask the local `claude` CLI whether it's signed in via `claude auth status
+ * --json`. Zero-cost — no model turn runs. Resolves the parsed status, or null
+ * when we can't determine it (CLI not installed, too old for `auth status`,
+ * errored, or timed out). null means "unknown": a probe we can't trust must
+ * never gate startup — the first turn's error path still guides the user if auth
+ * is genuinely broken.
+ */
+export function probeClaudeAuth(timeoutMs = 8000) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (v) => { if (!settled) {
+            settled = true;
+            resolve(v);
+        } };
+        let proc;
+        try {
+            proc = spawn('claude', ['auth', 'status', '--json'], { stdio: ['ignore', 'pipe', 'ignore'] });
+        }
+        catch {
+            finish(null);
+            return;
+        }
+        const timer = setTimeout(() => { try {
+            proc.kill('SIGKILL');
+        }
+        catch { /* already gone */ } finish(null); }, timeoutMs);
+        let out = '';
+        proc.stdout?.on('data', (c) => { out += c.toString('utf-8'); });
+        proc.on('error', () => { clearTimeout(timer); finish(null); });
+        proc.on('close', () => { clearTimeout(timer); finish(parseAuthStatus(out)); });
+    });
+}
+/**
+ * Launch the local Claude Code subscription sign-in (`claude auth login
+ * --claudeai`) with inherited stdio, so the user completes the browser / paste
+ * flow right here. Resolves true when the child exits (any exit code — the caller
+ * re-probes to learn the outcome), or false if it can't be spawned at all (CLI
+ * missing / too old for `auth login`), in which case the poll below still carries
+ * a sign-in the user does in another terminal.
+ */
+export function launchClaudeLogin() {
+    return new Promise((resolve) => {
+        let proc;
+        try {
+            proc = spawn('claude', ['auth', 'login', '--claudeai'], { stdio: 'inherit' });
+        }
+        catch {
+            resolve(false);
+            return;
+        }
+        proc.on('error', () => resolve(false));
+        proc.on('close', () => resolve(true));
+    });
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Poll `claude auth status` until it reports signed-in, or the timeout elapses.
+ * This is also what catches a sign-in the user completes in ANOTHER terminal
+ * window: on macOS the credential lives in the Keychain, which no process can
+ * watch, so polling is the only cross-platform detector. The Agent SDK re-reads
+ * credentials on every query(), so once this returns true the very next turn
+ * works with no bridge restart. `onWaiting` fires once, the first time we find
+ * the user still isn't signed in (so the caller can print a waiting line without
+ * spamming it). Returns true if signed in, false on timeout.
+ */
+export async function waitForClaudeLogin(opts = {}) {
+    const intervalMs = opts.intervalMs ?? 3000;
+    const timeoutMs = opts.timeoutMs ?? 5 * 60 * 1000;
+    const deadline = Date.now() + timeoutMs;
+    let announced = false;
+    for (;;) {
+        const status = await probeClaudeAuth();
+        if (status?.loggedIn)
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        if (!announced) {
+            opts.onWaiting?.();
+            announced = true;
+        }
+        await sleep(intervalMs);
+    }
+}
+/**
+ * Minimal Y/n prompt. Returns the boolean answer; empty input returns `def`.
+ * Caller is responsible for only invoking this when stdin is a TTY.
+ */
+export function promptYesNo(question, def) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(question, (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            if (a === '')
+                return resolve(def);
+            resolve(a === 'y' || a === 'yes');
+        });
+    });
+}

package/dist/index.js

@@ -9,6 +9,7 @@ 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 } from './claude.js';
 import { ensureModelChoice } from './config.js';
+import { probeClaudeAuth, launchClaudeLogin, waitForClaudeLogin, promptYesNo } from './claudeAuth.js';
 import { checkAndUpdate } from './update.js';
 import { makeBridgeAccumulator, postSaveTurn } from './accumulator.js';
 import { writeSpool, deleteSpool, listSpool } from './outbox.js';
@@ -759,6 +760,54 @@ function scheduleReconnect(closeCode, retryDelay) {
     }, delay);
 }
 // ─── Main ─────────────────────────────────────────────────────────────────────
+// Check the LOCAL Claude Code sign-in (the user's own claude.ai subscription
+// OAuth, distinct from the 1Presence gateway login above) before connecting.
+// Local Mode drives Claude Code through the Agent SDK, so if Claude Code isn't
+// signed in every turn fails with the `local_auth` code (and pages ops). Catch
+// it up front: probe, and if signed out, offer to sign in here — polling also
+// picks up a sign-in the user does in another terminal, and the SDK re-reads
+// credentials each turn, so no restart is needed once signed in. Any uncertainty
+// (old CLI without `auth status`, probe error) is treated as "don't block".
+async function ensureClaudeCodeLogin() {
+    const status = await probeClaudeAuth();
+    if (status === null)
+        return; // unknown — don't gate startup on a probe we can't trust
+    if (status.loggedIn) {
+        const who = status.email ? ` as ${status.email}` : '';
+        const plan = status.subscriptionType ? ` (${status.subscriptionType})` : '';
+        console.log(paint(SECTION_COLORS.assistant, `✓ Claude Code signed in${who}${plan}`));
+        return;
+    }
+    console.log(paint(SECTION_COLORS.result, '\n⚠ Your local Claude Code isn’t signed in.'));
+    console.log('  Local Mode runs on your own Claude subscription — Claude Code has to be signed in on this machine, or every message will fail.');
+    if (!process.stdin.isTTY) {
+        console.log('  Not an interactive terminal, so I can’t prompt. Sign in with `claude auth login`, then start the bridge again.\n');
+        return;
+    }
+    const yes = await promptYesNo('  Log in to Claude now? (Y/n) ', true);
+    if (!yes) {
+        console.log('  Skipping sign-in. Messages will fail until you run `claude auth login` — sign in any time and resend.\n');
+        return;
+    }
+    // Best-effort: open the sign-in right here. If the CLI is too old for
+    // `auth login`, this returns false and the poll still catches a sign-in the
+    // user does in another terminal.
+    const launched = await launchClaudeLogin();
+    if (!launched) {
+        console.log('  Couldn’t open sign-in automatically. In another terminal run:  claude auth login');
+    }
+    const ok = await waitForClaudeLogin({
+        onWaiting: () => console.log(paint('90', '  Waiting for sign-in… finish it in the browser (or run `claude auth login` in any terminal). Ctrl+C to abort.')),
+    });
+    if (ok) {
+        const s = await probeClaudeAuth();
+        const who = s?.email ? ` as ${s.email}` : '';
+        console.log(paint(SECTION_COLORS.assistant, `✓ Signed in${who} — continuing.\n`));
+    }
+    else {
+        console.log(paint(SECTION_COLORS.result, '  Still not signed in — starting anyway. Sign in any time and resend your message.\n'));
+    }
+}
 async function main() {
     console.log(`1Presence Bridge v${version}\n`);
     if (VERBOSE) {
@@ -778,6 +827,9 @@ 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 ensureModelChoice();
+    // Local Claude Code sign-in check (see fn comment). Runs before setup/connect
+    // so a signed-out user is guided in up front rather than hitting a failed turn.
+    await ensureClaudeCodeLogin();
     // 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1presence/bridge",
-  "version": "0.60.0",
+  "version": "0.62.0",
   "description": "Run 1Presence on your Mac and use your Claude.ai Pro subscription from any device",
   "type": "module",
   "bin": {