@1presence/bridge 0.32.0 → 0.34.0

package/dist/claude.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECTION_COLORS = void 0;
 exports.setVerbose = setVerbose;
 exports.setDebug = setDebug;
+exports.paint = paint;
 exports.spawnClaude = spawnClaude;
 exports.killAll = killAll;
 const child_process_1 = require("child_process");
@@ -65,8 +67,12 @@ const USE_COLOR = process.stderr.isTTY === true && !process.env['NO_COLOR'];
 function paint(code, s) {
     return USE_COLOR ? `\x1b[${code}m${s}\x1b[0m` : s;
 }
-// ANSI colour codes per section, mirroring the admin debug palette.
-const DEBUG_COLORS = {
+// ANSI colour codes per section, mirroring the admin debug palette. Shared
+// across all three console modes (debug / verbose / normal) so the same kind
+// of content is always the same colour — system prompts magenta, user prompts
+// blue, assistant text green, tool inputs cyan, tool results yellow.
+exports.SECTION_COLORS = {
+    system: '35', // magenta
     user: '34', // blue
     assistant: '32', // green
     input: '36', // cyan
@@ -97,7 +103,7 @@ function summariseHistoryBlock(block) {
 // can tell user turns from assistant turns at a glance — the missing
 // distinction that made replayed context unreadable in --debug.
 function renderHistoryMessage(msg) {
-    const color = msg.role === 'user' ? DEBUG_COLORS.user : DEBUG_COLORS.assistant;
+    const color = msg.role === 'user' ? exports.SECTION_COLORS.user : exports.SECTION_COLORS.assistant;
     const body = typeof msg.content === 'string'
         ? msg.content
         : msg.content.map(summariseHistoryBlock).join('\n');
@@ -105,25 +111,64 @@ function renderHistoryMessage(msg) {
 }
 // ─── Active processes ─────────────────────────────────────────────────────────
 const active = new Map();
+// Maximum automatic retries when the `claude` CLI exits non-zero BEFORE
+// producing any real output. This covers the known Claude Code print-mode 400
+// regression that surfaces as "API Error: 400 due to tool use concurrency
+// issues" (GitHub anthropics/claude-code#18131, still open) — it is
+// non-deterministic enough that a fresh spawn frequently succeeds. We retry
+// ONLY when the failed attempt produced no real assistant text and no tool
+// calls, so a failure that lands after real work (where retrying could
+// double-execute a side-effectful tool) is surfaced, never silently re-run.
+const MAX_TURN_RETRIES = 1;
+// Map a non-zero CLI exit + any captured "API Error:" line to a concise,
+// user-facing Local Mode message. The raw upstream text stays in operator logs
+// only — we never echo a wall of provider error JSON into the chat. Referring
+// to "Claude Code" here is intentional and consistent with Local Mode's other
+// operational errors (e.g. the "claude CLI not found" message): in Local Mode
+// the user is knowingly running their own Claude Code install.
+//
+// NOTE on the 400 tool-use case: this is an open Claude Code print-mode
+// regression (introduced in 2.1.19, still present in 2.1.146 — the current
+// latest), so upgrading does NOT fix it. We deliberately do not suggest an
+// upgrade; the automatic retry is the real mitigation and resending sometimes
+// gets through.
+function describeCliFailure(code, apiErrorText) {
+    const t = apiErrorText.trim();
+    if (/API Error:\s*400/i.test(t) && /(tool use|concurren|parallel)/i.test(t)) {
+        return 'Local Mode hit a known Claude Code error (a print-mode bug that affects every current version). I retried once automatically — sending the message again sometimes gets through.';
+    }
+    if (/^API Error:/i.test(t)) {
+        return `Local Mode error from Claude Code: ${t.replace(/^API Error:\s*/i, '').trim()}`;
+    }
+    return `Local Mode stopped unexpectedly (claude exited with code ${code ?? 'unknown'}). Please try again.`;
+}
 // ─── Spawn ────────────────────────────────────────────────────────────────────
 function spawnClaude(params) {
     const { conversationId, presenceSessionId, text, uid, history, vaultFileOpen, clientCapabilities, syncedFolders, onEvent, onDone, onError } = params;
+    const attemptIdx = params._attemptIdx ?? 0;
     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`);
-        process.stderr.write(`[bridge:verbose] session id:    ${presenceSessionId}\n`);
-        process.stderr.write(`[bridge:verbose] conversation:  ${conversationId}\n`);
-        process.stderr.write(`[bridge:verbose] history turns: ${history.length}\n`);
+        process.stderr.write(paint('90', `[bridge:verbose] cwd:           ${BRIDGE_CWD}`) + '\n');
+        process.stderr.write(paint('90', `[bridge:verbose] override md:   ${(0, path_1.join)(BRIDGE_CWD, 'CLAUDE.md')}`) + '\n');
+        process.stderr.write(paint('90', `[bridge:verbose] system prompt: ${systemPromptPath}`) + '\n');
+        process.stderr.write(paint('90', `[bridge:verbose] mcp config:    ${mcpConfigPath}`) + '\n');
+        process.stderr.write(paint('90', `[bridge:verbose] session id:    ${presenceSessionId}`) + '\n');
+        process.stderr.write(paint('90', `[bridge:verbose] conversation:  ${conversationId}`) + '\n');
+        process.stderr.write(paint('90', `[bridge:verbose] history turns: ${history.length}`) + '\n');
     }
+    // Surface the user's UID before the session line in every mode — it's the
+    // Firestore doc prefix (`sessions/<uid>_<conversationId>`), so logging it
+    // makes a reported bridge failure correlatable to the stored session without
+    // having to ask which account hit it. The CLI's own `--session-id` is
+    // ephemeral and is NOT the Firestore conversationId, so the uid is the key
+    // join column when debugging.
+    process.stderr.write(`[bridge] user ${uid}\n`);
     // Debug transcript: lead with the user prompt for this turn (the clean
     // message, before the gateway's ephemeral-context prefix), plus the session
     // id (correlates with the chat URL / Firestore session doc) and a hint at
     // how much prior context is being replayed.
-    if (debug) {
+    if (debug || verbose) {
         process.stderr.write(`\n${paint('1', `══ session ${presenceSessionId} ══`)}\n`);
         // `history` already ends with the new user prompt (gateway-appended). Render
         // every PRIOR message with its role colour so what the model saw as context
@@ -137,9 +182,9 @@ function spawnClaude(params) {
             for (const msg of prior)
                 renderHistoryMessage(msg);
         }
-        debugBlock('user · this turn', DEBUG_COLORS.user, text);
+        debugBlock('user · this turn', exports.SECTION_COLORS.user, text);
     }
-    else if (!verbose) {
+    else {
         // Default mode is quiet, but always surface the session id once per turn so
         // it can be matched to the chat URL / Firestore session doc when debugging.
         process.stderr.write(`[bridge] session ${presenceSessionId}\n`);
@@ -192,6 +237,10 @@ function spawnClaude(params) {
     //   across turns of a chat — even with --no-session-persistence. The
     //   bridge passes the per-spawn `conversationId` here; the presence
     //   sessionId is correlated separately via bridge logs and spool records.
+    // The CLI treats --session-id as "claim this new session ID" and rejects a
+    // reused id with "Session ID X is already in use". A retry is a fresh spawn,
+    // so it MUST use a new uuid; the first attempt keeps the correlation id.
+    const spawnSessionId = attemptIdx === 0 ? presenceSessionId : crypto.randomUUID();
     const args = [
         '--print',
         '--input-format', 'stream-json',
@@ -204,7 +253,7 @@ function spawnClaude(params) {
         '--mcp-config', mcpConfigPath,
         '--strict-mcp-config',
         '--no-session-persistence',
-        '--session-id', presenceSessionId,
+        '--session-id', spawnSessionId,
     ];
     const pinnedModel = (0, config_1.getBridgeModel)();
     if (pinnedModel) {
@@ -260,6 +309,15 @@ function spawnClaude(params) {
     let extractedModel = null;
     let buffer = '';
     let killedForViolation = false;
+    // Retry/error-surfacing tracking for this attempt:
+    //  - sawApiError: the CLI emitted an "API Error:" assistant text event (the
+    //    way Claude Code reports an underlying API failure mid-turn).
+    //  - apiErrorText: that text, captured for describeCliFailure().
+    //  - producedRealOutput: any real assistant text or tool_use was emitted, so
+    //    a later failure must NOT be retried (could double-run a side-effect).
+    let sawApiError = false;
+    let apiErrorText = '';
+    let producedRealOutput = false;
     proc.stdout.on('data', (chunk) => {
         buffer += chunk.toString('utf-8');
         const lines = buffer.split('\n');
@@ -276,6 +334,10 @@ function spawnClaude(params) {
                 continue;
             }
             const type = event['type'];
+            // Set when this event is the CLI's "API Error:" turn — we neither forward
+            // it to the PWA nor let it reach the accumulator (it carries no real
+            // content and would poison history / show a raw error mid-stream).
+            let suppressEvent = false;
             // Extract model + key source info from the first system/init event.
             // No session-id persistence — Firestore is the only source of truth
             // now, and we pin --session-id to presenceSessionId on every spawn.
@@ -316,13 +378,14 @@ function spawnClaude(params) {
                     let wroteText = false;
                     for (const block of content) {
                         if (block['type'] === 'tool_use') {
+                            producedRealOutput = true;
                             const toolName = block['name'];
                             const toolId = block['id'];
                             if (toolId)
                                 toolNames.set(toolId, toolName);
                             if (debug) {
                                 // Clean transcript: a single coloured block with the full input.
-                                debugBlock(`tool → ${toolName}`, DEBUG_COLORS.input, formatPayload(block['input']));
+                                debugBlock(`tool → ${toolName}`, exports.SECTION_COLORS.input, formatPayload(block['input']));
                             }
                             else {
                                 if (wroteText) {
@@ -330,10 +393,10 @@ function spawnClaude(params) {
                                     wroteText = false;
                                 }
                                 const prefix = toolName.startsWith('mcp__') ? '[mcp]' : '[tool]';
-                                process.stderr.write(`[bridge] ${prefix} ${toolName}\n`);
+                                process.stderr.write(paint(exports.SECTION_COLORS.input, `[bridge] ${prefix} ${toolName}`) + '\n');
                                 if (verbose) {
                                     const input = block['input'];
-                                    process.stderr.write(`[bridge:verbose] ─── input ${toolName} ───\n${formatPayload(input)}\n[bridge:verbose] ─── end input ───\n`);
+                                    process.stderr.write(paint(exports.SECTION_COLORS.input, `[bridge:verbose] ─── input ${toolName} ───\n${formatPayload(input)}\n[bridge:verbose] ─── end input ───`) + '\n');
                                 }
                             }
                             // Defense-in-depth: CLI flags (--tools "", --allowedTools, --strict-mcp-config,
@@ -364,13 +427,27 @@ function spawnClaude(params) {
                         else if (block['type'] === 'text') {
                             const text = block['text'];
                             if (text) {
-                                if (debug) {
-                                    // Full text, newlines intact — the readable transcript.
-                                    debugBlock('assistant', DEBUG_COLORS.assistant, text);
+                                if (/^API Error:/i.test(text.trimStart())) {
+                                    // The CLI is reporting an underlying API failure as assistant
+                                    // text. Capture it for the user-facing message, and suppress
+                                    // the whole event so the raw error never reaches the PWA or
+                                    // the accumulator (the gateway also blanks it via
+                                    // cleanTurnText — this is the upstream defense).
+                                    sawApiError = true;
+                                    apiErrorText = text.trim();
+                                    suppressEvent = true;
+                                    process.stderr.write(paint(exports.SECTION_COLORS.result, `[bridge] ${text.replace(/\n+/g, ' ')}`) + '\n');
                                 }
                                 else {
-                                    process.stderr.write(text.replace(/\n+/g, ' '));
-                                    wroteText = true;
+                                    producedRealOutput = true;
+                                    if (debug) {
+                                        // Full text, newlines intact — the readable transcript.
+                                        debugBlock('assistant', exports.SECTION_COLORS.assistant, text);
+                                    }
+                                    else {
+                                        process.stderr.write(paint(exports.SECTION_COLORS.assistant, text.replace(/\n+/g, ' ')));
+                                        wroteText = true;
+                                    }
                                 }
                             }
                         }
@@ -391,10 +468,10 @@ function spawnClaude(params) {
                             if (debug) {
                                 const name = toolNames.get(id) ?? id ?? 'result';
                                 const errFlag = block['is_error'] ? '  [error]' : '';
-                                debugBlock(`result ← ${name}${errFlag}`, DEBUG_COLORS.result, formatPayload(out));
+                                debugBlock(`result ← ${name}${errFlag}`, exports.SECTION_COLORS.result, formatPayload(out));
                             }
                             else {
-                                process.stderr.write(`[bridge:verbose] ─── output ${id} ───\n${formatPayload(out)}\n[bridge:verbose] ─── end output ───\n`);
+                                process.stderr.write(paint(exports.SECTION_COLORS.result, `[bridge:verbose] ─── output ${id} ───\n${formatPayload(out)}\n[bridge:verbose] ─── end output ───`) + '\n');
                             }
                         }
                     }
@@ -406,7 +483,8 @@ function spawnClaude(params) {
                 if (typeof c === 'number')
                     costUsd = c;
             }
-            onEvent(event);
+            if (!suppressEvent)
+                onEvent(event);
         }
     });
     proc.stderr.on('data', (chunk) => {
@@ -428,9 +506,19 @@ function spawnClaude(params) {
             catch { /* ignore */ }
         }
         if (code !== 0 && code !== null) {
+            // Auto-retry once when the CLI failed BEFORE producing any real output —
+            // the signature of the known print-mode 400 regression. A fresh spawn
+            // (new --session-id) usually succeeds. We never retry once real text or a
+            // tool call landed, to avoid double-running a side-effectful tool.
+            if (attemptIdx < MAX_TURN_RETRIES && sawApiError && !producedRealOutput) {
+                process.stderr.write(`[bridge] turn failed before output (${apiErrorText.replace(/\n+/g, ' ').slice(0, 120)}) — retrying once\n`);
+                spawnClaude({ ...params, _attemptIdx: attemptIdx + 1 });
+                return;
+            }
             // Pass any partial token usage we observed before the failure so the
-            // PWA and the gateway's bridge usage store can still record it.
-            onError(`claude exited with code ${code}`, usage, extractedModel);
+            // PWA and the gateway's bridge usage store can still record it. Surface a
+            // classified, user-readable message instead of the opaque exit code.
+            onError(describeCliFailure(code, apiErrorText), usage, extractedModel);
         }
         else {
             onDone(messageCount, costUsd, usage, extractedModel);

package/dist/index.js

@@ -98,9 +98,9 @@ async function writeSystemPrompt(auth, agentSlug) {
     const systemPrompt = await fetchSystemPrompt(token, agentSlug);
     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');
+        console.log((0, claude_1.paint)(claude_1.SECTION_COLORS.system, '\n[bridge:verbose] ─── system prompt ───────────────────────'));
+        console.log((0, claude_1.paint)(claude_1.SECTION_COLORS.system, systemPrompt));
+        console.log((0, claude_1.paint)(claude_1.SECTION_COLORS.system, '[bridge:verbose] ─── end system prompt ───────────────────\n'));
     }
 }
 function writeMcpConfig(auth) {
@@ -430,7 +430,7 @@ async function main() {
     console.log(`1Presence Bridge v${package_json_1.version}\n`);
     if (VERBOSE) {
         (0, claude_1.setVerbose)(true);
-        console.log('[bridge:verbose] verbose logging enabled — system prompts, tool inputs, and tool outputs will be printed.\n');
+        console.log('[bridge:verbose] verbose logging enabled — system prompts (magenta), user prompts (blue), assistant text (green), tool inputs (cyan), and tool outputs (yellow) will be printed, colour-coded by kind.\n');
     }
     if (DEBUG) {
         (0, claude_1.setDebug)(true);

package/package.json

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