@1presence/bridge 0.20.0 → 0.21.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/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
@@ -161,6 +163,46 @@ 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
+    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,
@@ -170,6 +212,7 @@ async function handleMessage(conversationId, text, sessionId, auth, vaultFileOpe
         clientCapabilities,
         syncedFolders,
         onEvent: (event) => {
+            accumulator.consume(event);
             if (!responding && event['type'] === 'assistant') {
                 responding = true;
                 console.log(`[${new Date().toLocaleTimeString()}] ◐ responding…`);
@@ -186,6 +229,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 +237,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 +330,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;
@@ -283,8 +359,7 @@ function connect(auth, retryDelay = 1000) {
             return;
         const { conversationId, text, sessionId, vaultFileOpen, clientCapabilities, syncedFolders } = msg;
         const ts = new Date().toLocaleTimeString();
-        const preview = text.length > 80 ? text.slice(0, 80) + '…' : text;
-        console.log(`[${ts}] ▶ ${preview}`);
+        console.log(`[${ts}] ▶ ${text}`);
         handleMessage(conversationId, text, sessionId ?? null, 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.21.0",
   "description": "Run 1Presence on your Mac and use your Claude.ai Pro subscription from any device",
   "bin": {
     "1presence-bridge": "dist/index.js"