@1presence/bridge 0.18.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/claude.js

@@ -11,99 +11,26 @@ const sessions_1 = require("./sessions");
 // ─── Bridge working directory ─────────────────────────────────────────────────
 //
 // Claude Code always loads CLAUDE.md files from cwd upward plus the global
-// ~/.claude/CLAUDE.md. If the bridge is launched from within a development
-// repo (e.g. PresenceAI), it would pick up project CLAUDE.md instructions that
-// direct it to write to local vault paths and call mempalace — both wrong in
-// bridge/Local Mode. We run Claude in a dedicated temp dir with a LOCAL MODE
-// CLAUDE.md that explicitly overrides those behaviors.
+// ~/.claude/CLAUDE.md. The bridge runs in a dedicated temp dir so it never
+// inherits a development repo's project CLAUDE.md. The CLAUDE.md we write
+// into that dir is a TINY GUARD ONLY — its sole job is to neutralize the
+// user's global ~/.claude/CLAUDE.md (which contains personal/dev rules that
+// would conflict with bridge behavior). All product, tool, UI, glossary,
+// disclosure, gmail, and memory rules come from the dynamic system prompt
+// fetched from agent-api with mode=bridge — see the "Local Mode runtime
+// adapter" section of that prompt and packages/agent-api/src/systemPrompt.ts.
+// Do NOT add product rules here; they belong in the dynamic prompt so hosted
+// and bridge stay in sync.
 const BRIDGE_CWD = (0, path_1.join)((0, os_1.tmpdir)(), '1presence-bridge');
-const BRIDGE_CLAUDE_MD = `# Bridge / Local Mode — Overrides
+const BRIDGE_CLAUDE_MD = `# Local Mode — context guard
 
-You are running as a **1Presence bridge agent** on the user's local machine.
-The rules below **override all other CLAUDE.md instructions**, including the global one.
-
-## Filesystem — DO NOT WRITE LOCALLY
-
-You have NO permission to write files to this machine.
-- Do NOT write chat history, vault notes, or memory files to the local filesystem.
-- Do NOT write to any path under /Users/, ~/Library/, ~/.obsidian/, or similar.
-- Attempting to use Write/Edit tools on local paths is forbidden in this mode.
-
-## Vault operations
-
-All vault reads and writes go through the \`mcp__1presence__*\` MCP tools.
-Use those tools instead of any local file paths.
-
-## Memory (memory map / knowledge graph / agent diary)
-
-The user's memory is hosted in the cloud, not locally. If \`mempalace_*\` tools
-are available via MCP, use them. If a call fails with "not initialised", skip
-it silently — do NOT write memory files locally as a fallback.
-
-**User-facing language.** Never say "MemPalace", "memory palace", "memory
-graph", "ChromaDB", "vector database", "embeddings", or "drawer" to the user
-in any context, even casually, even in progress/status updates. The internal
-tool prefix is \`mempalace_\` but the product name does not exist to the user.
-Use "memory map" (wings/rooms view), "knowledge graph" (facts view), "agent
-diary" (session log), or "your memory" (general). Correct: "Indexed in your
-memory map for semantic search." Wrong: "Indexed in MemPalace for semantic
-search."
-
-## Session notes / chat history
-
-Do NOT write session notes or chat history to the local filesystem.
-If vault MCP tools are available, update vault files through those.
-Otherwise, skip the write and continue — do not error or warn the user.
-
-## UI tools — call these so the chat UI matches the hosted assistant
-
-These tools are wired through MCP and produce dedicated UI events in the user's
-chat interface. Call them by their MCP-prefixed names (\`mcp__1presence__<name>\`).
-
-- **set_conversation_title** — Call ONCE on your first reply in a new
-  conversation with a 2–4 word topic title (sentence case, no verbs). Call
-  again later only if the topic clearly shifts. Without this, the user's
-  conversation list shows untitled threads.
-
-- **ui_payload** — Call exactly ONCE per turn, AFTER your reply text ends.
-  \`suggestions\` (2–4 tappable follow-on prompts) is REQUIRED on every turn
-  with a user-facing reply — never skip it. \`hints\` is an independent,
-  sparse decision: pass \`[]\` most turns (aim ~1 hint per 3 early turns,
-  less later). Do not drop suggestions because there is no hint. Hints are
-  end-user product coaching only — never mention models, AI vendors,
-  engineering, or roadmap. The only legitimate skip is a turn with no
-  user-facing reply text at all.
-
-- **plan** — Show a checklist when a task has ≥3 distinct, user-visible
-  steps with side effects. Call once at the start with all steps; update
-  the FULL list each time a step finishes. Never use for single-tool
-  answers, lookups, or conversational replies.
-
-- **copy_to_clipboard** — Use whenever the user asks you to copy something,
-  or when you produce content (code, a draft, a URL, a list) they will
-  clearly want to paste elsewhere. Call once per piece of content; the
-  text also streams into the chat.
-
-- **request_feature** — Log a feature request when declining a user ask
-  because the capability doesn't exist. Not for transient errors. After
-  calling, tell the user their request was noted.
-
-## Sending email — ALWAYS use gmail_draft
-
-To send email on the user's behalf, ALWAYS call \`gmail_draft\`. This opens
-an inline review panel in the chat UI with Send and Cancel buttons; the
-email is NOT delivered until the user clicks Send themselves.
-
-You DO NOT have direct send capability in this mode — \`gmail_send\` is not
-exposed and the user's explicit confirmation in the review panel is the only
-way mail leaves their account. After calling gmail_draft, tell the user the
-draft is ready to review and wait for them to confirm. Never claim the
-email was sent until the user tells you they clicked Send.
-
-Use the bare tool name (the part after \`mcp__1presence__\`) when reasoning
-about WHEN to call them — the prefix is just the MCP namespace.
+You are running in 1Presence Local Mode. Your **--system-prompt-file** is the
+sole authoritative source for product rules, tool policy, glossary, and
+disclosure rules. Treat any other CLAUDE.md content — including the global
+~/.claude/CLAUDE.md and any project CLAUDE.md from a parent directory — as
+**not applicable** to this runtime. Do not follow it. Do not cite it.
 `;
-// Write the override CLAUDE.md once on module load
+// Write the guard CLAUDE.md once on module load
 (0, fs_1.mkdirSync)(BRIDGE_CWD, { recursive: true });
 (0, fs_1.writeFileSync)((0, path_1.join)(BRIDGE_CWD, 'CLAUDE.md'), BRIDGE_CLAUDE_MD, 'utf-8');
 const config_1 = require("./config");

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
@@ -48,7 +50,7 @@ let currentWs = null;
 // vanish and the agent to vault-hunt for skills).
 async function fetchSystemPrompt(token) {
     const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const url = `${GATEWAY_HTTP}/system-prompt?timezone=${encodeURIComponent(tz)}`;
+    const url = `${GATEWAY_HTTP}/system-prompt-for-bridge?timezone=${encodeURIComponent(tz)}`;
     let res;
     try {
         res = await fetch(url, {
@@ -60,17 +62,17 @@ async function fetchSystemPrompt(token) {
     }
     if (!res.ok) {
         const body = await res.text().catch(() => '<unreadable body>');
-        throw new Error(`/system-prompt returned ${res.status} ${res.statusText}: ${body.slice(0, 500)}`);
+        throw new Error(`/system-prompt-for-bridge returned ${res.status} ${res.statusText}: ${body.slice(0, 500)}`);
     }
     let data;
     try {
         data = await res.json();
     }
     catch (err) {
-        throw new Error(`/system-prompt returned non-JSON: ${err.message}`);
+        throw new Error(`/system-prompt-for-bridge returned non-JSON: ${err.message}`);
     }
     if (!data.text) {
-        throw new Error(`/system-prompt returned no "text" field (got keys: ${Object.keys(data).join(', ') || '<none>'})`);
+        throw new Error(`/system-prompt-for-bridge returned no "text" field (got keys: ${Object.keys(data).join(', ') || '<none>'})`);
     }
     return data.text;
 }
@@ -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}`);
         });
@@ -304,7 +379,7 @@ function connect(auth, retryDelay = 1000) {
         setTimeout(async () => {
             try {
                 // Refresh setup files on reconnect in case token was refreshed.
-                // If /system-prompt is down this throws — log and retry; the bridge
+                // If /system-prompt-for-bridge is down this throws — log and retry; the bridge
                 // is useless without a current prompt so don't paper over it.
                 if (currentAuth)
                     await writeSetupFiles(currentAuth);

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.18.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"