@1presence/bridge 0.20.0 → 0.22.0

package/dist/accumulator.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBridgeAccumulator = makeBridgeAccumulator;
+exports.postSaveTurn = postSaveTurn;
+function makeBridgeAccumulator() {
+    const state = {
+        assistantText: '',
+        toolCalls: [],
+        toolResults: {},
+    };
+    let textEmitted = false;
+    let turnTextEmitted = false;
+    function appendText(text) {
+        if (textEmitted && !turnTextEmitted)
+            state.assistantText += '\n\n';
+        state.assistantText += text;
+        turnTextEmitted = true;
+        textEmitted = true;
+    }
+    return {
+        consume(event) {
+            const type = event['type'];
+            if (type === 'text') {
+                const t = event['text'];
+                if (t)
+                    appendText(t);
+                return;
+            }
+            if (type === 'assistant') {
+                // New API turn — reset the per-turn flag so the next text emission
+                // gets a `\n\n` separator iff text was already emitted in a prior turn.
+                turnTextEmitted = false;
+                const msg = event['message'];
+                const content = msg?.['content'];
+                if (!Array.isArray(content))
+                    return;
+                for (const block of content) {
+                    if (block['type'] === 'text') {
+                        const t = block['text'];
+                        if (t)
+                            appendText(t);
+                    }
+                    else if (block['type'] === 'tool_use') {
+                        const id = block['id'];
+                        const name = block['name'];
+                        const input = block['input'] ?? {};
+                        if (!id || !name)
+                            continue;
+                        const bareName = name.replace(/^mcp__1presence__/, '');
+                        state.toolCalls.push({ id, name: bareName, input });
+                        if (bareName === 'set_conversation_title') {
+                            const raw = String(input['title'] ?? '').trim();
+                            if (raw)
+                                state.title = raw.charAt(0).toUpperCase() + raw.slice(1);
+                        }
+                    }
+                }
+                return;
+            }
+            if (type === 'user') {
+                const msg = event['message'];
+                const content = msg?.['content'];
+                if (!Array.isArray(content))
+                    return;
+                for (const block of content) {
+                    if (block['type'] !== 'tool_result')
+                        continue;
+                    const id = block['tool_use_id'];
+                    const result = block['content'];
+                    if (!id)
+                        continue;
+                    state.toolResults[id] = typeof result === 'string' ? result : JSON.stringify(result);
+                }
+                return;
+            }
+        },
+        state() {
+            return state;
+        },
+    };
+}
+async function postSaveTurn(gatewayHttp, token, record) {
+    let res;
+    try {
+        res = await fetch(`${gatewayHttp}/bridge/save-turn`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+                sessionId: record.sessionId,
+                conversationId: record.conversationId,
+                userMessage: record.userMessage,
+                assistantText: record.assistantText,
+                toolCalls: record.toolCalls,
+                toolResults: record.toolResults,
+                ...(record.title ? { title: record.title } : {}),
+                ...(record.usage ? { usage: record.usage } : {}),
+            }),
+        });
+    }
+    catch (err) {
+        return { ok: false, finalized: false, status: 0, error: err.message };
+    }
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        return { ok: false, finalized: false, status: res.status, error: body.slice(0, 200) };
+    }
+    const data = await res.json().catch(() => ({}));
+    return { ok: true, finalized: data.finalized === true, status: res.status };
+}

package/dist/claude.js

@@ -7,7 +7,6 @@ const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
-const sessions_1 = require("./sessions");
 // ─── Bridge working directory ─────────────────────────────────────────────────
 //
 // Claude Code always loads CLAUDE.md files from cwd upward plus the global
@@ -52,7 +51,7 @@ function formatPayload(value) {
 const active = new Map();
 // ─── Spawn ────────────────────────────────────────────────────────────────────
 function spawnClaude(params) {
-    const { conversationId, presenceSessionId, text, uid, vaultFileOpen, clientCapabilities, syncedFolders, onEvent, onDone, onError } = params;
+    const { conversationId, presenceSessionId, text, uid, history, 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) {
@@ -60,6 +59,7 @@ function spawnClaude(params) {
         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] history turns: ${history.length}\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
@@ -70,7 +70,6 @@ function spawnClaude(params) {
         existing.kill('SIGTERM');
         active.delete(conversationId);
     }
-    const claudeSessionId = presenceSessionId ? (0, sessions_1.getClaudeSession)(presenceSessionId) : undefined;
     const ctxParts = [];
     if (vaultFileOpen)
         ctxParts.push(`vault_file_open: ${vaultFileOpen}`);
@@ -78,7 +77,7 @@ function spawnClaude(params) {
         ctxParts.push(`client_capabilities: ${clientCapabilities.join(', ')}`);
     if (syncedFolders?.length)
         ctxParts.push(`synced_folders: ${syncedFolders.join(', ')}`);
-    const promptText = ctxParts.length > 0 ? `[${ctxParts.join(' | ')}]\n\n${text}` : text;
+    const userMessageText = ctxParts.length > 0 ? `[${ctxParts.join(' | ')}]\n\n${text}` : text;
     // Lockdown rationale:
     // - `--tools ""` disables ALL built-in tools (Bash/Read/Write/Edit/Glob/Grep/
     //   WebFetch/etc.). MCP tools are not "built-in" so the 1Presence MCP surface
@@ -90,8 +89,19 @@ function spawnClaude(params) {
     // - `--strict-mcp-config` keeps the MCP surface to exactly what we wire in
     //   via --mcp-config. Together these guarantee the bridge can only call
     //   `mcp__1presence__*` — no filesystem, no shell, no arbitrary network.
+    //
+    // Session continuity rationale:
+    // - `--input-format stream-json` accepts structured user/assistant messages
+    //   on stdin. We replay prior turns (loaded by the gateway from Firestore)
+    //   followed by the new user turn — this is how the bridge sees history.
+    // - `--no-session-persistence` keeps no jsonl on disk. The bridge has zero
+    //   local filesystem dependency for continuity; Firestore is the only
+    //   source of truth.
+    // - `--session-id <presenceSessionId>` pins the CLI session UUID to the
+    //   presence sessionId so logs across bridge/gateway are easy to correlate.
     const args = [
-        '-p', promptText,
+        '--print',
+        '--input-format', 'stream-json',
         '--output-format', 'stream-json',
         '--verbose',
         '--tools', '',
@@ -100,23 +110,46 @@ function spawnClaude(params) {
         '--system-prompt-file', systemPromptPath,
         '--mcp-config', mcpConfigPath,
         '--strict-mcp-config',
+        '--no-session-persistence',
+        '--session-id', presenceSessionId,
     ];
     const pinnedModel = (0, config_1.getBridgeModel)();
     if (pinnedModel) {
         args.push('--model', pinnedModel);
     }
-    if (claudeSessionId) {
-        args.push('--resume', claudeSessionId);
-    }
     // Strip API key so Claude Code uses the user's claude.ai Pro subscription
     // (OAuth credentials), not an API key that would bill to a separate account.
     const { ANTHROPIC_API_KEY: _stripped, ...safeEnv } = process.env;
     const proc = (0, child_process_1.spawn)('claude', args, {
         cwd: BRIDGE_CWD,
         env: safeEnv,
-        stdio: ['ignore', 'pipe', 'pipe'],
+        stdio: ['pipe', 'pipe', 'pipe'],
     });
     active.set(conversationId, proc);
+    // Feed prior turns + the new user message via stdin as stream-json.
+    // Each line is a JSON object: `{ type, message: { role, content } }`.
+    // Sanitisation (orphan tool_use stripping, displayOnly filtering) already
+    // happened on the gateway via @presence/shared.toModelMessages — replay
+    // the history verbatim and append the fresh user turn.
+    try {
+        const stdin = proc.stdin;
+        if (!stdin) {
+            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 } };
+            stdin.write(JSON.stringify(wrapped) + '\n');
+        }
+        const newTurn = { type: 'user', message: { role: 'user', content: userMessageText } };
+        stdin.write(JSON.stringify(newTurn) + '\n');
+        stdin.end();
+    }
+    catch (err) {
+        process.stderr.write(`[bridge] failed to write stdin: ${err.message}\n`);
+        proc.kill('SIGTERM');
+        onError(`stdin write failed: ${err.message}`, null, null);
+        return;
+    }
     let sessionIdExtracted = false;
     let messageCount = 0;
     let costUsd = 0;
@@ -140,12 +173,10 @@ function spawnClaude(params) {
                 continue;
             }
             const type = event['type'];
-            // Extract claude session ID from the first system/init event
+            // 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.
             if (!sessionIdExtracted && type === 'system' && event['subtype'] === 'init') {
-                const sid = event['session_id'];
-                if (sid && presenceSessionId) {
-                    (0, sessions_1.saveClaudeSession)(presenceSessionId, sid);
-                }
                 const keySource = event['apiKeySource'];
                 const model = event['model'];
                 if (model)

package/dist/index.js

@@ -12,6 +12,8 @@ const auth_1 = require("./auth");
 const claude_1 = require("./claude");
 const config_1 = require("./config");
 const update_1 = require("./update");
+const accumulator_1 = require("./accumulator");
+const outbox_1 = require("./outbox");
 const package_json_1 = require("../package.json");
 // Published tarballs don't ship src/, so this fires only when running the
 // dist build from a live workspace checkout. Catches the trap where editing
@@ -117,8 +119,13 @@ function writeRestricted(path, data) {
     (0, fs_1.writeFileSync)(path, data, { mode: 0o600 });
     (0, fs_1.chmodSync)(path, 0o600);
 }
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(value) {
+    return UUID_RE.test(value);
+}
 // ─── Handle a single incoming message (token refresh + spawn) ─────────────────
-async function handleMessage(conversationId, text, sessionId, auth, vaultFileOpen, clientCapabilities, syncedFolders) {
+async function handleMessage(conversationId, text, sessionId, history, auth, vaultFileOpen, clientCapabilities, syncedFolders) {
     // Refresh JWT if <10 min remaining before spawning Claude
     let activeAuth = auth;
     try {
@@ -161,15 +168,61 @@ async function handleMessage(conversationId, text, sessionId, auth, vaultFileOpe
         return;
     }
     let responding = false;
+    const accumulator = (0, accumulator_1.makeBridgeAccumulator)();
+    const startedAt = Date.now();
+    const turnSessionId = sessionId ?? conversationId; // gateway always supplies one; defensive fallback
+    // --session-id requires a UUID; turnSessionId is always one in practice
+    // (gateway generates via crypto.randomUUID). Defensive: if a non-UUID slips
+    // through, fall back to conversationId which is also crypto.randomUUID.
+    const claudePinnedSessionId = isUuid(turnSessionId) ? turnSessionId : conversationId;
+    function buildSpoolRecord(usage, model) {
+        const s = accumulator.state();
+        return {
+            sessionId: turnSessionId,
+            conversationId,
+            userMessage: text,
+            assistantText: s.assistantText,
+            toolCalls: s.toolCalls,
+            toolResults: s.toolResults,
+            ...(s.title ? { title: s.title } : {}),
+            usage: usage
+                ? { ...usage, ...(model ? { model } : {}) }
+                : null,
+            startedAt,
+            finalizedAt: Date.now(),
+        };
+    }
+    async function finalizeAndPost(record) {
+        // Spool BEFORE the network call so a crash between here and the POST
+        // ack is recoverable by drain-on-startup. The gateway dedupes on
+        // conversationId, so a replay is idempotent.
+        try {
+            (0, outbox_1.writeSpool)(record);
+        }
+        catch (err) {
+            console.warn(`[bridge] spool write failed: ${err.message}`);
+        }
+        const result = await (0, accumulator_1.postSaveTurn)(GATEWAY_HTTP, activeAuth.token, record);
+        if (result.ok) {
+            (0, outbox_1.deleteSpool)(record.conversationId);
+        }
+        else {
+            // Leave the spool file in place — next startup or next successful
+            // POST opportunity will retry. Quietly log so users aren't alarmed.
+            console.warn(`[bridge] save-turn POST failed (${result.status}): ${result.error ?? 'unknown'} — kept on disk for retry`);
+        }
+    }
     (0, claude_1.spawnClaude)({
         conversationId,
-        presenceSessionId: sessionId,
+        presenceSessionId: claudePinnedSessionId,
         text,
         uid: activeAuth.uid,
+        history,
         vaultFileOpen,
         clientCapabilities,
         syncedFolders,
         onEvent: (event) => {
+            accumulator.consume(event);
             if (!responding && event['type'] === 'assistant') {
                 responding = true;
                 console.log(`[${new Date().toLocaleTimeString()}] ◐ responding…`);
@@ -186,6 +239,7 @@ async function handleMessage(conversationId, text, sessionId, auth, vaultFileOpe
             parts.push(costStr);
             const suffix = parts.length ? `  ${parts.join('  ')}` : '';
             console.log(`[${new Date().toLocaleTimeString()}] ✓ done${suffix}`);
+            const mapped = toBridgeUsage(usage);
             if (currentWs?.readyState === ws_1.default.OPEN) {
                 currentWs.send(JSON.stringify({
                     type: 'done',
@@ -193,34 +247,60 @@ async function handleMessage(conversationId, text, sessionId, auth, vaultFileOpe
                     messageCount,
                     costUsd,
                     model,
-                    usage: usage ? {
-                        inputTokens: usage.input_tokens,
-                        outputTokens: usage.output_tokens,
-                        cacheReadTokens: usage.cache_read_input_tokens,
-                        cacheCreationTokens: usage.cache_creation_input_tokens,
-                    } : null,
+                    usage: mapped,
                 }));
             }
+            // HTTP fallback runs unconditionally — gateway dedupes against WS path.
+            void finalizeAndPost(buildSpoolRecord(mapped, model));
         },
         onError: (message, usage, model) => {
             console.error(`[${new Date().toLocaleTimeString()}] ✗ ${message}`);
+            const mapped = toBridgeUsage(usage);
             if (currentWs?.readyState === ws_1.default.OPEN) {
                 currentWs.send(JSON.stringify({
                     type: 'error',
                     conversationId,
                     message,
                     model,
-                    usage: usage ? {
-                        inputTokens: usage.input_tokens,
-                        outputTokens: usage.output_tokens,
-                        cacheReadTokens: usage.cache_read_input_tokens,
-                        cacheCreationTokens: usage.cache_creation_input_tokens,
-                    } : null,
+                    usage: mapped,
                 }));
             }
+            void finalizeAndPost(buildSpoolRecord(mapped, model));
         },
     });
 }
+// ─── Usage shape adapter ──────────────────────────────────────────────────────
+function toBridgeUsage(usage) {
+    if (!usage)
+        return null;
+    return {
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        cacheReadTokens: usage.cache_read_input_tokens,
+        cacheCreationTokens: usage.cache_creation_input_tokens,
+    };
+}
+// ─── Outbox drain ─────────────────────────────────────────────────────────────
+//
+// On bridge startup and on every successful reconnect, replay any spool
+// records that didn't get a successful POST ack last time. The gateway
+// dedupes on conversationId — if it already saved via the WS path, the
+// reply is finalized=false and we still delete the spool.
+async function drainOutbox(auth) {
+    const records = (0, outbox_1.listSpool)();
+    if (records.length === 0)
+        return;
+    console.log(`[bridge] draining ${records.length} pending save record${records.length === 1 ? '' : 's'}…`);
+    for (const record of records) {
+        const result = await (0, accumulator_1.postSaveTurn)(GATEWAY_HTTP, auth.token, record);
+        if (result.ok) {
+            (0, outbox_1.deleteSpool)(record.conversationId);
+        }
+        else {
+            console.warn(`[bridge] drain POST failed (${result.status}): ${result.error ?? 'unknown'} — leaving on disk`);
+        }
+    }
+}
 // ─── WebSocket connection ─────────────────────────────────────────────────────
 // Application-level heartbeat — avoids relying on WebSocket control frames (ping/pong),
 // which some proxies (GKE LB) may not forward reliably.
@@ -260,6 +340,12 @@ function connect(auth, retryDelay = 1000) {
         retryDelay = 1000;
         console.log('✓ Bridge connected. Local Mode active on all your devices.\n');
         startPing();
+        // Drain any save records left behind by an earlier crashed/dropped session.
+        // Fire-and-forget — the network is up, the gateway is reachable, and we
+        // don't want to block message handling on this.
+        if (currentAuth) {
+            drainOutbox(currentAuth).catch(err => console.warn(`[bridge] drain failed: ${err.message}`));
+        }
     });
     ws.on('message', (raw) => {
         let msg;
@@ -281,11 +367,11 @@ function connect(auth, retryDelay = 1000) {
         }
         if (msg.type !== 'message' || !msg.conversationId || !msg.text)
             return;
-        const { conversationId, text, sessionId, vaultFileOpen, clientCapabilities, syncedFolders } = msg;
+        const { conversationId, text, sessionId, history, vaultFileOpen, clientCapabilities, syncedFolders } = msg;
         const ts = new Date().toLocaleTimeString();
-        const preview = text.length > 80 ? text.slice(0, 80) + '…' : text;
-        console.log(`[${ts}] ▶ ${preview}`);
-        handleMessage(conversationId, text, sessionId ?? null, auth, vaultFileOpen, clientCapabilities, syncedFolders).catch((err) => {
+        const hist = Array.isArray(history) ? history : [];
+        console.log(`[${ts}] ▶ ${text}${hist.length ? `  (history: ${hist.length} turn${hist.length === 1 ? '' : 's'})` : ''}`);
+        handleMessage(conversationId, text, sessionId ?? null, hist, auth, vaultFileOpen, clientCapabilities, syncedFolders).catch((err) => {
             console.error(`[bridge] handleMessage error: ${err.message}`);
         });
     });

package/dist/outbox.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeSpool = writeSpool;
+exports.deleteSpool = deleteSpool;
+exports.listSpool = listSpool;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+// ─── On-disk turn spool ───────────────────────────────────────────────────────
+//
+// Each in-flight bridge turn writes a record to ~/.1presence/outbox/. The file
+// exists from the moment the turn starts until the gateway acks the save-turn
+// POST. If the bridge is killed (Ctrl+C, terminal closed, crash) between
+// Claude finishing and the ack landing, the next startup drains the directory
+// — covering the failure mode the WS+HTTP path alone can't.
+//
+// Records are keyed by conversationId, which the gateway also dedupes on, so
+// a drained replay is idempotent: if it already saved via WS, the POST is a
+// 200 no-op and the spool file is deleted.
+//
+// Payload mode 0600 — the file contains the user's assistant transcript and
+// tool inputs. Tightened on every write to handle legacy world-readable files.
+const OUTBOX_DIR = (0, path_1.join)((0, os_1.homedir)(), '.1presence', 'outbox');
+function ensureDir() {
+    (0, fs_1.mkdirSync)(OUTBOX_DIR, { recursive: true });
+}
+function pathFor(conversationId) {
+    return (0, path_1.join)(OUTBOX_DIR, `${conversationId}.json`);
+}
+function writeSpool(record) {
+    ensureDir();
+    (0, fs_1.writeFileSync)(pathFor(record.conversationId), JSON.stringify(record), { mode: 0o600 });
+}
+function deleteSpool(conversationId) {
+    try {
+        (0, fs_1.unlinkSync)(pathFor(conversationId));
+    }
+    catch { /* already gone — fine */ }
+}
+function listSpool() {
+    ensureDir();
+    const out = [];
+    for (const file of (0, fs_1.readdirSync)(OUTBOX_DIR)) {
+        if (!file.endsWith('.json'))
+            continue;
+        try {
+            const raw = (0, fs_1.readFileSync)((0, path_1.join)(OUTBOX_DIR, file), 'utf-8');
+            out.push(JSON.parse(raw));
+        }
+        catch {
+            // Malformed file — leave it alone so a human can inspect.
+        }
+    }
+    return out;
+}

package/package.json

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

package/dist/sessions.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getClaudeSession = getClaudeSession;
-exports.saveClaudeSession = saveClaudeSession;
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-// ─── Storage ──────────────────────────────────────────────────────────────────
-const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), '.1presence');
-const SESSIONS_FILE = (0, path_1.join)(CONFIG_DIR, 'sessions.json');
-let cache = null;
-function getMap() {
-    if (cache)
-        return cache;
-    try {
-        const raw = (0, fs_1.readFileSync)(SESSIONS_FILE, 'utf-8');
-        cache = JSON.parse(raw);
-    }
-    catch {
-        cache = {};
-    }
-    return cache;
-}
-function persist(map) {
-    (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
-    (0, fs_1.writeFileSync)(SESSIONS_FILE, JSON.stringify(map, null, 2), 'utf-8');
-}
-// ─── Public API ───────────────────────────────────────────────────────────────
-function getClaudeSession(presenceSessionId) {
-    return getMap()[presenceSessionId];
-}
-function saveClaudeSession(presenceSessionId, claudeSessionId) {
-    const map = getMap();
-    map[presenceSessionId] = claudeSessionId;
-    persist(map);
-}