@1presence/bridge 0.21.0 → 0.23.0

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,23 @@ 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 <uuid>` must be a fresh UUID per spawn: the CLI treats
+    //   this flag as a "claim a new session ID" operation and rejects the
+    //   second spawn with "Session ID X is already in use" if we reuse one
+    //   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.
     const args = [
-        '-p', promptText,
+        '--print',
+        '--input-format', 'stream-json',
         '--output-format', 'stream-json',
         '--verbose',
         '--tools', '',
@@ -100,23 +114,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 +177,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

@@ -119,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 {
@@ -166,6 +171,14 @@ async function handleMessage(conversationId, text, sessionId, auth, vaultFileOpe
     const accumulator = (0, accumulator_1.makeBridgeAccumulator)();
     const startedAt = Date.now();
     const turnSessionId = sessionId ?? conversationId; // gateway always supplies one; defensive fallback
+    // The CLI's `--session-id` is treated as a "claim this new session ID"
+    // operation — passing the same UUID across turns of one chat (which is
+    // what the presence sessionId is) makes turn 2 fail with "Session ID X
+    // is already in use", even with --no-session-persistence. Use the
+    // per-spawn conversationId instead — continuity comes from history
+    // replay via --input-format stream-json, not from CLI session tracking.
+    // turnSessionId is still kept for spool records / log correlation.
+    const claudePinnedSessionId = isUuid(conversationId) ? conversationId : crypto.randomUUID();
     function buildSpoolRecord(usage, model) {
         const s = accumulator.state();
         return {
@@ -205,9 +218,10 @@ async function handleMessage(conversationId, text, sessionId, auth, vaultFileOpe
     }
     (0, claude_1.spawnClaude)({
         conversationId,
-        presenceSessionId: sessionId,
+        presenceSessionId: claudePinnedSessionId,
         text,
         uid: activeAuth.uid,
+        history,
         vaultFileOpen,
         clientCapabilities,
         syncedFolders,
@@ -357,10 +371,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();
-        console.log(`[${ts}] ▶ ${text}`);
-        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1presence/bridge",
-  "version": "0.21.0",
+  "version": "0.23.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);
-}