@1presence/bridge 0.27.0 → 0.29.0

package/README.md

@@ -15,6 +15,11 @@ npx @1presence/bridge
 
 On first run, a browser window will open to sign in to your 1Presence account. Your credentials are cached in `~/.1presence/auth.json` so subsequent runs start immediately.
 
+### Flags
+
+- `--debug` (`-d`) — print a clean per-turn transcript: the user prompt, the assistant's text, and every tool call's input and output. This mirrors what an admin sees in the chat's debug view. Use this when you want to follow the conversation and inspect tool calls.
+- `--verbose` (`-v`) — log tool inputs/outputs plus the full system prompt and setup paths on every turn. Use this when debugging the prompt itself; for following messages and tool calls without the prompt dump, prefer `--debug`.
+
 Once connected, your 1Presence app on any device automatically routes to your local Claude Code session. When you stop the bridge, 1Presence falls back to platform mode.
 
 ## How it works

package/dist/claude.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setVerbose = setVerbose;
+exports.setDebug = setDebug;
 exports.spawnClaude = spawnClaude;
 exports.killAll = killAll;
 const child_process_1 = require("child_process");
@@ -36,9 +37,17 @@ const config_1 = require("./config");
 // Track whether we've already announced the model this process — printing it
 // per-spawn is noisy; once on startup is what the user actually wants to see.
 let modelAnnounced = false;
-// Verbose flag — when set via --verbose, log full tool inputs and outputs.
+// Verbose flag — when set via --verbose, log full tool inputs and outputs
+// PLUS the entire system prompt. Great for prompt debugging, noisy for
+// message debugging (the prompt dump buries the conversation).
 let verbose = false;
 function setVerbose(v) { verbose = v; }
+// Debug flag — when set via --debug, render a clean, sectioned transcript of
+// the live turn: user prompt, assistant text, every tool input, every tool
+// result. This is the bridge equivalent of the chat's admin debug view. It
+// deliberately does NOT print the system prompt — that's what --verbose is for.
+let debug = false;
+function setDebug(v) { debug = v; }
 function formatPayload(value) {
     try {
         return JSON.stringify(value, null, 2);
@@ -47,6 +56,26 @@ function formatPayload(value) {
         return String(value);
     }
 }
+// ─── Debug transcript rendering ─────────────────────────────────────────────
+//
+// A clean, scannable block per event — coloured header rule + body. Matches
+// the shape of the chat's admin debug bubbles (user / assistant / tool input /
+// tool result) so what you see locally mirrors what an admin sees in the app.
+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 = {
+    user: '34', // blue
+    assistant: '32', // green
+    input: '36', // cyan
+    result: '33', // yellow
+};
+function debugBlock(label, colorCode, body) {
+    const rule = `── ${label} `.padEnd(64, '─');
+    process.stderr.write(`\n${paint(colorCode, rule)}\n${body.trimEnd()}\n`);
+}
 // ─── Active processes ─────────────────────────────────────────────────────────
 const active = new Map();
 // ─── Spawn ────────────────────────────────────────────────────────────────────
@@ -61,6 +90,16 @@ function spawnClaude(params) {
         process.stderr.write(`[bridge:verbose] mcp config:    ${mcpConfigPath}\n`);
         process.stderr.write(`[bridge:verbose] history turns: ${history.length}\n`);
     }
+    // Debug transcript: lead with the user prompt for this turn (the clean
+    // message, before the gateway's ephemeral-context prefix), plus a hint at
+    // how much prior context is being replayed.
+    if (debug) {
+        const histNote = history.length ? `  (replaying ${history.length} prior turn${history.length === 1 ? '' : 's'})` : '';
+        debugBlock(`user${histNote}`, DEBUG_COLORS.user, text);
+    }
+    // tool_use_id → tool name, so a tool_result block (which only carries the id)
+    // can be labelled with the tool it answers in the debug transcript.
+    const toolNames = new Map();
     // 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.
@@ -147,7 +186,16 @@ function spawnClaude(params) {
             throw new Error('claude stdin is null — spawn must use stdio[0]="pipe"');
         }
         for (const msg of history) {
-            const wrapped = { type: msg.role, message: { role: msg.role, content: msg.content } };
+            // Normalise to array-of-blocks: Claude Code's stream-json input parser
+            // iterates `content` directly. A string slips into a `"tool_use_id" in
+            // <char>` check inside the CLI and aborts the process with `W is not an
+            // Object` (JSC) / exit 1 mid-turn. The gateway also normalises before
+            // sending, so a current gateway + any bridge version is safe; this guard
+            // covers older gateways and ad-hoc local replay tests.
+            const content = Array.isArray(msg.content)
+                ? msg.content
+                : [{ type: 'text', text: typeof msg.content === 'string' ? msg.content : '' }];
+            const wrapped = { type: msg.role, message: { role: msg.role, content } };
             stdin.write(JSON.stringify(wrapped) + '\n');
         }
         stdin.end();
@@ -221,16 +269,25 @@ function spawnClaude(params) {
                     let wroteText = false;
                     for (const block of content) {
                         if (block['type'] === 'tool_use') {
-                            if (wroteText) {
-                                process.stderr.write('\n');
-                                wroteText = false;
-                            }
                             const toolName = block['name'];
-                            const prefix = toolName.startsWith('mcp__') ? '[mcp]' : '[tool]';
-                            process.stderr.write(`[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`);
+                            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']));
+                            }
+                            else {
+                                if (wroteText) {
+                                    process.stderr.write('\n');
+                                    wroteText = false;
+                                }
+                                const prefix = toolName.startsWith('mcp__') ? '[mcp]' : '[tool]';
+                                process.stderr.write(`[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`);
+                                }
                             }
                             // Defense-in-depth: CLI flags (--tools "", --allowedTools, --strict-mcp-config,
                             // --setting-sources "") are supposed to make this unreachable. If we see a
@@ -260,8 +317,14 @@ function spawnClaude(params) {
                         else if (block['type'] === 'text') {
                             const text = block['text'];
                             if (text) {
-                                process.stderr.write(text.replace(/\n+/g, ' '));
-                                wroteText = true;
+                                if (debug) {
+                                    // Full text, newlines intact — the readable transcript.
+                                    debugBlock('assistant', DEBUG_COLORS.assistant, text);
+                                }
+                                else {
+                                    process.stderr.write(text.replace(/\n+/g, ' '));
+                                    wroteText = true;
+                                }
                             }
                         }
                     }
@@ -270,7 +333,7 @@ function spawnClaude(params) {
                 }
             }
             // Tool results stream back as `user` events with tool_result blocks.
-            if (verbose && type === 'user') {
+            if ((verbose || debug) && type === 'user') {
                 const msg = event['message'];
                 const content = msg?.['content'];
                 if (Array.isArray(content)) {
@@ -278,7 +341,14 @@ function spawnClaude(params) {
                         if (block['type'] === 'tool_result') {
                             const id = block['tool_use_id'] ?? '';
                             const out = block['content'];
-                            process.stderr.write(`[bridge:verbose] ─── output ${id} ───\n${formatPayload(out)}\n[bridge:verbose] ─── end output ───\n`);
+                            if (debug) {
+                                const name = toolNames.get(id) ?? id ?? 'result';
+                                const errFlag = block['is_error'] ? '  [error]' : '';
+                                debugBlock(`result ← ${name}${errFlag}`, DEBUG_COLORS.result, formatPayload(out));
+                            }
+                            else {
+                                process.stderr.write(`[bridge:verbose] ─── output ${id} ───\n${formatPayload(out)}\n[bridge:verbose] ─── end output ───\n`);
+                            }
                         }
                     }
                 }

package/dist/index.js

@@ -31,6 +31,10 @@ if (__dirname.endsWith('dist')) {
 }
 // ─── CLI args ─────────────────────────────────────────────────────────────────
 const VERBOSE = process.argv.includes('--verbose') || process.argv.includes('-v');
+// --debug renders a clean per-turn transcript (user prompt, assistant text,
+// tool inputs, tool outputs) — the bridge equivalent of the chat's admin
+// debug view. Unlike --verbose it does NOT dump the system prompt.
+const DEBUG = process.argv.includes('--debug') || process.argv.includes('-d');
 // ─── Config ───────────────────────────────────────────────────────────────────
 const GATEWAY_URL = process.env.BRIDGE_GATEWAY_URL ?? 'https://api.1presence.com';
 const GATEWAY_WS = GATEWAY_URL.replace(/^https?:/, 'wss:').replace(/\/$/, '') + '/bridge';
@@ -424,6 +428,10 @@ async function main() {
         (0, claude_1.setVerbose)(true);
         console.log('[bridge:verbose] verbose logging enabled — system prompts, tool inputs, and tool outputs will be printed.\n');
     }
+    if (DEBUG) {
+        (0, claude_1.setDebug)(true);
+        console.log('[bridge:debug] debug transcript enabled — user prompts, assistant text, tool inputs, and tool outputs will be printed (system prompt omitted; use --verbose for that).\n');
+    }
     if (await (0, update_1.checkAndUpdate)())
         return;
     // Auth

package/package.json

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