cosmoremote 2.0.22 → 2.1.1

package/dist/bridge.js

@@ -33,6 +33,10 @@ let promptTicketPublicKeySource = null;
 let workspaceRoot = process.cwd();
 let importableConversations = [];
 let projectFolders = [];
+const MAX_CONCURRENT_CLI_SESSIONS = (() => {
+    const raw = Number(process.env.COSMOREMOTE_MAX_CONCURRENT_CLI_SESSIONS);
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 4;
+})();
 function refreshImportableConversations() {
     try {
         importableConversations = (0, cli_conversations_1.listImportableConversations)(workspaceRoot);
@@ -54,6 +58,58 @@ function refreshProjectFolders() {
 const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), ".cosmoremote");
 const CONFIG_FILE = (0, path_1.join)(CONFIG_DIR, "config.json");
 const SESSION_CONTEXTS_FILE = (0, path_1.join)(CONFIG_DIR, "session-contexts.json");
+function getPackageVersion() {
+    try {
+        const packageJsonPath = (0, path_1.join)(__dirname, "..", "package.json");
+        const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, "utf-8"));
+        return packageJson.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function announceCapabilities() {
+    if (!currentRelayWs || currentRelayWs.readyState !== ws_1.WebSocket.OPEN)
+        return;
+    try {
+        currentRelayWs.send(JSON.stringify({
+            type: "capabilities",
+            bridgeVersion: getPackageVersion(),
+            availableClis: getAvailableCliNames(),
+            folders: projectFolders,
+            conversations: importableConversations,
+            workspaceRoot,
+        }));
+        console.log(`  [relay] announced capabilities clis=${getAvailableCliNames().join(",") || "none"} folders=${projectFolders.length} conversations=${importableConversations.length}`);
+    }
+    catch (err) {
+        console.error(`  [relay] failed to announce capabilities:`, err);
+    }
+}
+function getAvailableCliNames() {
+    const out = [];
+    if (clis?.claude)
+        out.push("CLAUDE");
+    if (clis?.codex)
+        out.push("CODEX");
+    if (clis?.cursor)
+        out.push("CURSOR");
+    return out;
+}
+function normalizedCliName(cli) {
+    const upper = String(cli ?? "").toUpperCase();
+    if (upper === "CODEX" || upper === "CURSOR" || upper === "CLAUDE")
+        return upper;
+    return "CLAUDE";
+}
+function binaryFor(cli) {
+    const binaries = {
+        CODEX: clis.codex,
+        CURSOR: clis.cursor,
+        CLAUDE: clis.claude,
+    };
+    return binaries[String(cli ?? "").toUpperCase()] ?? clis.claude;
+}
 function generatePairingCode() {
     return String(Math.floor(Math.random() * 999999)).padStart(6, "0");
 }
@@ -118,16 +174,26 @@ function loadSessionContexts() {
         const raw = (0, fs_1.readFileSync)(SESSION_CONTEXTS_FILE, "utf-8");
         const parsed = JSON.parse(raw);
         const now = Date.now();
+        let dropped = 0;
         for (const [sessionId, entry] of Object.entries(parsed)) {
             if (!entry || typeof entry.expiresAt !== "number" || entry.expiresAt <= now)
                 continue;
             sessionContexts.set(sessionId, {
                 claudeSessionId: typeof entry.claudeSessionId === "string" ? entry.claudeSessionId : undefined,
                 codexThreadId: typeof entry.codexThreadId === "string" ? entry.codexThreadId : undefined,
+                cursorSessionId: typeof entry.cursorSessionId === "string" ? entry.cursorSessionId : undefined,
                 expiresAt: entry.expiresAt,
             });
         }
-        console.log(`  [context] loaded ${sessionContexts.size} persisted CLI contexts`);
+        // Self-heal: older bridge versions persisted claudeSessionId even when the
+        // turn was killed before Claude wrote its first message. Those entries
+        // point at non-existent .jsonl files and trigger "No conversation found"
+        // on the next prompt. We can't tell from the entry alone whether the file
+        // exists yet (workingDir lives on the session, not the context), so we
+        // defer the check to when the prompt arrives — see handlePromptFromRelay.
+        if (sessionContexts.size > 0) {
+            console.log(`  [context] loaded ${sessionContexts.size} persisted CLI contexts (dropped=${dropped})`);
+        }
     }
     catch (err) {
         console.error("  [context] Failed to read session contexts:", err);
@@ -153,6 +219,7 @@ function upsertSessionContext(sessionId, patch) {
     const entry = {
         claudeSessionId: patch.claudeSessionId ?? existing?.claudeSessionId,
         codexThreadId: patch.codexThreadId ?? existing?.codexThreadId,
+        cursorSessionId: patch.cursorSessionId ?? existing?.cursorSessionId,
         expiresAt: Date.now() + SESSION_CONTEXT_TTL_MS,
     };
     sessionContexts.set(sessionId, entry);
@@ -201,6 +268,53 @@ function getClaudeContext(sessionId) {
 function setClaudeContext(sessionId, claudeId) {
     upsertSessionContext(sessionId, { claudeSessionId: claudeId });
 }
+// Claude Code persists each conversation as a JSONL file under
+// ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl. The "encoded cwd" is the
+// absolute working dir with every "/" replaced by "-" (e.g. /Users/matheus →
+// -Users-matheus). If the file is missing, Claude will refuse to --resume the
+// id, surfacing as "No conversation found with session ID: <uuid>" on stderr.
+//
+// We use this check to gate persistence of claudeSessionId so a turn that was
+// killed before Claude wrote its first turn never poisons session-contexts.json.
+function claudeSessionFileExists(workingDir, claudeSessionId) {
+    if (!workingDir || !claudeSessionId)
+        return false;
+    const encoded = workingDir.replaceAll("/", "-");
+    const path = (0, path_1.join)((0, os_1.homedir)(), ".claude", "projects", encoded, `${claudeSessionId}.jsonl`);
+    return (0, fs_1.existsSync)(path);
+}
+// Guarded variant of setClaudeContext — only persists the mapping if Claude
+// actually wrote conversation history to disk. Without this guard, killed or
+// failed-init sessions left stale entries pointing at non-existent Claude
+// session ids, causing every subsequent prompt to retry with --resume and fail.
+function persistClaudeContextIfValid(sessionId, claudeSessionId, workingDir) {
+    if (claudeSessionFileExists(workingDir, claudeSessionId)) {
+        setClaudeContext(sessionId, claudeSessionId);
+    }
+    else {
+        // Evict any pre-existing entry — it's stale and would trigger --resume
+        // failures on the next prompt.
+        const existing = sessionContexts.get(sessionId);
+        if (existing?.claudeSessionId === claudeSessionId) {
+            clearSessionContext(sessionId);
+            console.log(`  [bridge] dropped stale claude context session=${sessionId.substring(0, 8)} claude=${claudeSessionId.substring(0, 8)} (no jsonl on disk)`);
+        }
+    }
+}
+// Wraps getClaudeContext with on-disk verification. Returns undefined when the
+// persisted claudeSessionId points at a .jsonl that no longer exists — that
+// way fresh CLISession spawns use --session-id (which creates) instead of
+// --resume (which fails). Also self-heals by evicting the bad entry.
+function getValidClaudeContext(sessionId, workingDir) {
+    const claudeSessionId = getClaudeContext(sessionId);
+    if (!claudeSessionId)
+        return undefined;
+    if (claudeSessionFileExists(workingDir, claudeSessionId))
+        return claudeSessionId;
+    clearSessionContext(sessionId);
+    console.log(`  [bridge] evicted stale claude context session=${sessionId.substring(0, 8)} claude=${claudeSessionId.substring(0, 8)} (jsonl missing)`);
+    return undefined;
+}
 function getCodexContext(sessionId) {
     const entry = sessionContexts.get(sessionId);
     if (!entry)
@@ -215,6 +329,66 @@ function getCodexContext(sessionId) {
 function setCodexContext(sessionId, threadId) {
     upsertSessionContext(sessionId, { codexThreadId: threadId });
 }
+function getCursorContext(sessionId) {
+    const entry = sessionContexts.get(sessionId);
+    if (!entry)
+        return undefined;
+    if (Date.now() > entry.expiresAt) {
+        sessionContexts.delete(sessionId);
+        saveSessionContexts();
+        return undefined;
+    }
+    return entry.cursorSessionId;
+}
+function setCursorContext(sessionId, cursorSessionId) {
+    upsertSessionContext(sessionId, { cursorSessionId });
+}
+function cursorSessionFileExists(cursorSessionId) {
+    if (!cursorSessionId)
+        return false;
+    // cursor-agent stores transcripts in TWO shapes:
+    //   global:      ~/.cursor/projects/agent-transcripts/<id>/<id>.jsonl
+    //   per-project: ~/.cursor/projects/<project-slug>/agent-transcripts/<id>/<id>.jsonl
+    // A `cursor-agent --workspace <cwd>` run (what the bridge does) writes to the
+    // per-project path, so checking only the global one evicts every valid resume id.
+    const projectsRoot = (0, path_1.join)((0, os_1.homedir)(), ".cursor", "projects");
+    const rel = (0, path_1.join)("agent-transcripts", cursorSessionId, `${cursorSessionId}.jsonl`);
+    if ((0, fs_1.existsSync)((0, path_1.join)(projectsRoot, rel)))
+        return true;
+    try {
+        for (const entry of (0, fs_1.readdirSync)(projectsRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            if ((0, fs_1.existsSync)((0, path_1.join)(projectsRoot, entry.name, rel)))
+                return true;
+        }
+    }
+    catch {
+        // projects root missing/unreadable — treat as no transcript
+    }
+    return false;
+}
+function persistCursorContextIfValid(sessionId, cursorSessionId) {
+    if (cursorSessionFileExists(cursorSessionId)) {
+        setCursorContext(sessionId, cursorSessionId);
+        return;
+    }
+    const existing = sessionContexts.get(sessionId);
+    if (existing?.cursorSessionId === cursorSessionId) {
+        clearSessionContext(sessionId);
+        console.log(`  [bridge] dropped stale cursor context session=${sessionId.substring(0, 8)} cursor=${cursorSessionId.substring(0, 8)} (no jsonl on disk)`);
+    }
+}
+function getValidCursorContext(sessionId) {
+    const cursorSessionId = getCursorContext(sessionId);
+    if (!cursorSessionId)
+        return undefined;
+    if (cursorSessionFileExists(cursorSessionId))
+        return cursorSessionId;
+    clearSessionContext(sessionId);
+    console.log(`  [bridge] evicted stale cursor context session=${sessionId.substring(0, 8)} cursor=${cursorSessionId.substring(0, 8)} (jsonl missing)`);
+    return undefined;
+}
 function checkLocalLimit(sessionToken) {
     const now = Date.now();
     let entry = localMessageCounts.get(sessionToken);
@@ -264,6 +438,116 @@ function normalizeHttpBaseUrl(rawUrl) {
     const parsed = new URL(normalized);
     return `${parsed.protocol}//${parsed.host}`;
 }
+function resolveAllowedWorkingDir(rawWorkingDir) {
+    const cwd = (0, path_1.resolve)(rawWorkingDir || workspaceRoot);
+    if (!(0, cli_conversations_1.isWithin)(workspaceRoot, cwd)) {
+        return { error: `Working directory is outside the allowed workspace root. cwd=${cwd} workspaceRoot=${workspaceRoot}` };
+    }
+    return { cwd };
+}
+function persistSessionContextsFromSession(sessionId, session) {
+    if (session.claudeSessionId) {
+        persistClaudeContextIfValid(sessionId, session.claudeSessionId, session.workingDir);
+    }
+    if (session.codexThreadId) {
+        setCodexContext(sessionId, session.codexThreadId);
+        console.log(`  [bridge] session=${sessionId.substring(0, 8)} saved codex thread=${session.codexThreadId}`);
+    }
+    if (session.cursorSessionId) {
+        persistCursorContextIfValid(sessionId, session.cursorSessionId);
+    }
+}
+function killSession(sessionId, reason) {
+    const session = sessions.get(sessionId);
+    if (!session)
+        return;
+    console.log(`  [bridge] killing session=${sessionId.substring(0, 8)} reason=${reason}`);
+    persistSessionContextsFromSession(sessionId, session);
+    sessions.delete(sessionId);
+    sessionsCreating.delete(sessionId);
+    session.kill();
+}
+function handlePromptCommon(msg, handlers) {
+    console.log(`  [${handlers.source}] prompt session=${msg.sessionId.substring(0, 8)} cli=${msg.cli || "unknown"} wd=${msg.workingDir || "n/a"}`);
+    const cliName = normalizedCliName(msg.cli);
+    const cliType = cliName.toLowerCase();
+    const binary = binaryFor(msg.cli);
+    console.log(`  [${handlers.source}] session=${msg.sessionId.substring(0, 8)} cliType=${cliType} binary=${binary || "missing"} workingDir=${msg.workingDir}`);
+    handlers.sendStatus(`Bridge received prompt. Preparing ${cliType}...`);
+    if (!binary) {
+        const install = (0, detect_1.installCommandFor)(cliName);
+        handlers.sendError(install
+            ? `${cliType} CLI is not installed on this Mac. Install it with: ${install}`
+            : `${cliType} CLI not found on this machine`);
+        return;
+    }
+    const cwdResult = resolveAllowedWorkingDir(msg.workingDir);
+    if ("error" in cwdResult) {
+        console.log(`  [${handlers.source}] rejecting session=${msg.sessionId.substring(0, 8)} reason=${cwdResult.error}`);
+        handlers.sendError(cwdResult.error);
+        return;
+    }
+    const cwd = cwdResult.cwd;
+    if (sessionsCreating.has(msg.sessionId)) {
+        console.log(`  [${handlers.source}] session=${msg.sessionId.substring(0, 8)} already being created, skipping duplicate`);
+        return;
+    }
+    let session = sessions.get(msg.sessionId);
+    if (!session) {
+        const activeCount = sessions.size + sessionsCreating.size;
+        if (activeCount >= MAX_CONCURRENT_CLI_SESSIONS) {
+            const error = `Bridge is busy: ${activeCount}/${MAX_CONCURRENT_CLI_SESSIONS} CLI sessions are active. Try again after a session finishes.`;
+            console.log(`  [${handlers.source}] rejecting session=${msg.sessionId.substring(0, 8)} reason=${error}`);
+            handlers.sendError(error);
+            return;
+        }
+        sessionsCreating.add(msg.sessionId);
+        try {
+            session = new session_1.CLISession({
+                sessionId: msg.sessionId,
+                cliBinary: binary,
+                workingDir: cwd,
+                initialClaudeSessionId: getValidClaudeContext(msg.sessionId, cwd),
+                initialCodexThreadId: getCodexContext(msg.sessionId),
+                initialCursorSessionId: getValidCursorContext(msg.sessionId),
+            });
+            sessions.set(msg.sessionId, session);
+            handlers.ownerSessionIds?.add(msg.sessionId);
+        }
+        finally {
+            sessionsCreating.delete(msg.sessionId);
+        }
+        console.log(`  [${handlers.source}] session=${msg.sessionId.substring(0, 8)} created mapSize=${sessions.size} resuming=${Boolean(getClaudeContext(msg.sessionId) || getCodexContext(msg.sessionId) || getCursorContext(msg.sessionId))}`);
+        handlers.sendStatus(`Starting ${cliType} in ${cwd}`);
+        session.on("output", (text) => {
+            handlers.sendOutput(text);
+        });
+        session.on("status", (text) => {
+            console.log(`  [${handlers.source}] session=${msg.sessionId.substring(0, 8)} status: ${text}`);
+            handlers.sendStatus(text);
+        });
+        session.on("error", (text) => {
+            console.log(`  [${handlers.source}] session=${msg.sessionId.substring(0, 8)} error: ${text.substring(0, 120)}`);
+            handlers.sendError(text);
+        });
+        session.on("done", (result) => {
+            console.log(`  [${handlers.source}] session=${msg.sessionId.substring(0, 8)} done code=${result.code} outputLen=${result.fullOutput.length}`);
+            const current = sessions.get(msg.sessionId);
+            if (current) {
+                persistSessionContextsFromSession(msg.sessionId, current);
+            }
+            handlers.sendDone(result.fullOutput);
+            if (!current?.hasTurnInFlight && !current?.hasQueuedPrompts) {
+                sessions.delete(msg.sessionId);
+                handlers.ownerSessionIds?.delete(msg.sessionId);
+            }
+        });
+    }
+    else {
+        handlers.ownerSessionIds?.add(msg.sessionId);
+    }
+    session.sendPrompt(msg.content, Array.isArray(msg.attachments) ? msg.attachments : []);
+}
 function sha256Hex(input) {
     return crypto_1.default.createHash("sha256").update(input).digest("hex");
 }
@@ -376,6 +660,7 @@ async function startBridge(opts) {
     setInterval(() => {
         refreshImportableConversations();
         refreshProjectFolders();
+        announceCapabilities();
     }, 60_000);
     loadSessionContexts();
     // Check for updates in background (non-blocking)
@@ -404,12 +689,24 @@ async function startBridge(opts) {
     console.log("  [env] XDG_CACHE_HOME:", process.env.XDG_CACHE_HOME || "unset");
     console.log("  [env] BACKEND_URL:", opts.backendUrl || process.env.BACKEND_URL || "unset");
     console.log("  Available CLIs:");
-    console.log(`    Claude Code: ${clis.claude || "not found"}`);
-    console.log(`    Codex:       ${clis.codex || "not found"}`);
+    const cliLines = [
+        ["Claude Code", "CLAUDE", clis.claude],
+        ["Codex      ", "CODEX", clis.codex],
+        ["Cursor     ", "CURSOR", clis.cursor],
+    ];
+    for (const [label, key, path] of cliLines) {
+        if (path) {
+            console.log(`    ${label}: ${path}`);
+        }
+        else {
+            console.log(`    ${label}: not found`);
+            console.log(`      → install on this Mac with: ${(0, detect_1.installCommandFor)(key)}`);
+        }
+    }
     console.log(`  Workspace:    ${workspaceRoot}`);
     console.log();
-    if (!clis.claude && !clis.codex) {
-        console.error("  ✗ No supported CLIs found. Install Claude Code or Codex first.");
+    if (!clis.claude && !clis.codex && !clis.cursor) {
+        console.error("  ✗ No supported CLIs found. Install Claude Code, Codex, or Cursor Agent first.");
         process.exit(1);
     }
     if (opts.backendUrl) {
@@ -524,7 +821,7 @@ function handleConnection(ws, sessionToken) {
                     const ticket = verifyPromptTicket(msg.promptTicket, msg);
                     console.log(`  [ticket] verified session=${ticket.sessionId.substring(0, 8)} msg=${ticket.messageId.substring(0, 8)} exp=${ticket.expiresAt}`);
                     connectionSessionIds.add(msg.sessionId);
-                    handlePrompt(ws, msg);
+                    handlePrompt(ws, msg, connectionSessionIds);
                 }
                 catch (err) {
                     const error = err instanceof Error ? err.message : "Invalid prompt ticket";
@@ -537,18 +834,8 @@ function handleConnection(ws, sessionToken) {
                 console.log(`  [bridge] incoming kill session=${String(msg.sessionId || "-").substring(0, 8)}`);
                 const session = sessions.get(msg.sessionId);
                 if (session) {
-                    // Save context before killing so we can resume later
-                    if (session.claudeSessionId) {
-                        setClaudeContext(msg.sessionId, session.claudeSessionId);
-                        console.log(`  [bridge] saved claude context before kill=${session.claudeSessionId}`);
-                    }
-                    if (session.codexThreadId) {
-                        setCodexContext(msg.sessionId, session.codexThreadId);
-                        console.log(`  [bridge] saved codex context before kill=${session.codexThreadId}`);
-                    }
-                    sessions.delete(msg.sessionId);
-                    sessionsCreating.delete(msg.sessionId);
-                    session.kill();
+                    killSession(msg.sessionId, "local kill request");
+                    connectionSessionIds.delete(msg.sessionId);
                     ws.send(JSON.stringify({ type: "done", sessionId: msg.sessionId, content: "[killed]" }));
                 }
             }
@@ -563,72 +850,33 @@ function handleConnection(ws, sessionToken) {
         for (const sessionId of connectionSessionIds) {
             const session = sessions.get(sessionId);
             if (session) {
-                console.log(`  [bridge] killing orphaned session=${sessionId.substring(0, 8)} on client disconnect`);
-                session.kill();
-                sessions.delete(sessionId);
-                sessionsCreating.delete(sessionId);
+                killSession(sessionId, "client disconnect");
             }
         }
         connectionSessionIds.clear();
     });
 }
-function handlePrompt(ws, msg) {
-    const cliType = msg.cli?.toUpperCase() === "CODEX" ? "codex" : "claude";
-    const binary = cliType === "codex" ? clis.codex : clis.claude;
-    console.log(`  [bridge] handlePrompt session=${msg.sessionId.substring(0, 8)} cliType=${cliType} binary=${binary || "missing"} workingDir=${msg.workingDir}`);
-    if (!binary) {
-        ws.send(JSON.stringify({ type: "error", sessionId: msg.sessionId, content: `${cliType} CLI not found on this machine` }));
-        return;
-    }
-    // Race condition guard: if another prompt is currently creating this session, skip
-    if (sessionsCreating.has(msg.sessionId)) {
-        console.log(`  [bridge] session=${msg.sessionId.substring(0, 8)} already being created, skipping duplicate`);
-        return;
-    }
-    let session = sessions.get(msg.sessionId);
-    if (!session) {
-        sessionsCreating.add(msg.sessionId);
-        session = new session_1.CLISession({
-            sessionId: msg.sessionId,
-            cliBinary: binary,
-            workingDir: msg.workingDir || workspaceRoot,
-            initialClaudeSessionId: getClaudeContext(msg.sessionId),
-            initialCodexThreadId: getCodexContext(msg.sessionId),
-        });
-        sessions.set(msg.sessionId, session);
-        sessionsCreating.delete(msg.sessionId);
-        console.log(`  [bridge] session=${msg.sessionId.substring(0, 8)} created mapSize=${sessions.size} resuming=${Boolean(getClaudeContext(msg.sessionId) || getCodexContext(msg.sessionId))}`);
-        session.on("output", (text) => {
-            ws.send(JSON.stringify({ type: "output", sessionId: msg.sessionId, content: text }));
-            relaySend({ type: "output", sessionId: msg.sessionId, content: text });
-        });
-        session.on("status", (text) => {
-            console.log(`  [bridge] session=${msg.sessionId.substring(0, 8)} status: ${text}`);
-            ws.send(JSON.stringify({ type: "status", sessionId: msg.sessionId, content: text }));
-            relaySend({ type: "status", sessionId: msg.sessionId, content: text });
-        });
-        session.on("error", (text) => {
-            console.log(`  [bridge] session=${msg.sessionId.substring(0, 8)} error: ${text.substring(0, 120)}`);
-            ws.send(JSON.stringify({ type: "error", sessionId: msg.sessionId, content: text }));
-            relaySend({ type: "error", sessionId: msg.sessionId, content: text });
-        });
-        session.on("done", (result) => {
-            console.log(`  [bridge] session=${msg.sessionId.substring(0, 8)} done code=${result.code} outputLen=${result.fullOutput.length}`);
-            const s = sessions.get(msg.sessionId);
-            if (s?.claudeSessionId) {
-                setClaudeContext(msg.sessionId, s.claudeSessionId);
-                console.log(`  [bridge] session=${msg.sessionId.substring(0, 8)} saved claude context=${s.claudeSessionId}`);
-            }
-            if (s?.codexThreadId) {
-                setCodexContext(msg.sessionId, s.codexThreadId);
-                console.log(`  [bridge] session=${msg.sessionId.substring(0, 8)} saved codex thread=${s.codexThreadId}`);
-            }
-            ws.send(JSON.stringify({ type: "done", sessionId: msg.sessionId, content: result.fullOutput }));
-            relaySend({ type: "done", sessionId: msg.sessionId, content: result.fullOutput });
-            sessions.delete(msg.sessionId);
-        });
-    }
-    session.sendPrompt(msg.content, Array.isArray(msg.attachments) ? msg.attachments : []);
+function handlePrompt(ws, msg, ownerSessionIds) {
+    handlePromptCommon(msg, {
+        source: "bridge",
+        ownerSessionIds,
+        sendOutput: (content) => {
+            ws.send(JSON.stringify({ type: "output", sessionId: msg.sessionId, content }));
+            relaySend({ type: "output", sessionId: msg.sessionId, content });
+        },
+        sendStatus: (content) => {
+            ws.send(JSON.stringify({ type: "status", sessionId: msg.sessionId, content }));
+            relaySend({ type: "status", sessionId: msg.sessionId, content });
+        },
+        sendError: (content) => {
+            ws.send(JSON.stringify({ type: "error", sessionId: msg.sessionId, content }));
+            relaySend({ type: "error", sessionId: msg.sessionId, content });
+        },
+        sendDone: (content) => {
+            ws.send(JSON.stringify({ type: "done", sessionId: msg.sessionId, content }));
+            relaySend({ type: "done", sessionId: msg.sessionId, content });
+        },
+    });
 }
 function connectToBackendRelay(backendUrl) {
     if (backendRelayUrl === backendUrl && currentRelayWs?.readyState === ws_1.WebSocket.OPEN) {
@@ -646,6 +894,7 @@ function connectToBackendRelay(backendUrl) {
         console.log(`  [relay] connecting to ${url}`);
         const ws = new ws_1.WebSocket(url);
         let pingInterval = null;
+        const relaySessionIds = new Set();
         const startAt = Date.now();
         ws.on("open", () => {
             console.log(`  ✓ Connected to backend relay after ${Date.now() - startAt}ms`);
@@ -655,18 +904,7 @@ function connectToBackendRelay(backendUrl) {
             // Announce indexed folders + importable conversations so the iOS folder
             // picker and "Continue ended one" mode have data on first open. The
             // backend caches this in-memory keyed by macId.
-            try {
-                ws.send(JSON.stringify({
-                    type: "capabilities",
-                    folders: projectFolders,
-                    conversations: importableConversations,
-                    workspaceRoot,
-                }));
-                console.log(`  [relay] announced capabilities folders=${projectFolders.length} conversations=${importableConversations.length}`);
-            }
-            catch (err) {
-                console.error(`  [relay] failed to announce capabilities:`, err);
-            }
+            announceCapabilities();
             if (pendingRelayMessages.length > 0) {
                 console.log(`  ↺ Flushing ${pendingRelayMessages.length} queued relay messages`);
                 const toFlush = pendingRelayMessages.splice(0);
@@ -690,22 +928,14 @@ function connectToBackendRelay(backendUrl) {
                     return;
                 if (msg.type === "prompt") {
                     console.log(`  [relay] ← prompt from backend session=${String(msg.sessionId || "-").substring(0, 8)} cli=${msg.cli || "unknown"}`);
-                    handlePromptFromRelay(ws, msg);
+                    handlePromptFromRelay(msg, relaySessionIds);
                 }
                 if (msg.type === "kill") {
                     console.log(`  [relay] ← kill from backend session=${String(msg.sessionId || "-").substring(0, 8)}`);
                     const session = sessions.get(msg.sessionId);
                     if (session) {
-                        // Save context before killing so we can resume later
-                        if (session.claudeSessionId) {
-                            setClaudeContext(msg.sessionId, session.claudeSessionId);
-                        }
-                        if (session.codexThreadId) {
-                            setCodexContext(msg.sessionId, session.codexThreadId);
-                        }
-                        sessions.delete(msg.sessionId);
-                        sessionsCreating.delete(msg.sessionId);
-                        session.kill();
+                        killSession(msg.sessionId, "relay kill request");
+                        relaySessionIds.delete(msg.sessionId);
                     }
                 }
             }
@@ -717,6 +947,13 @@ function connectToBackendRelay(backendUrl) {
         ws.on("close", (code, reason) => {
             if (pingInterval)
                 clearInterval(pingInterval);
+            if (currentRelayWs === ws) {
+                currentRelayWs = null;
+            }
+            for (const sessionId of relaySessionIds) {
+                killSession(sessionId, "relay disconnect");
+            }
+            relaySessionIds.clear();
             const delay = relayRetryDelay;
             console.log(`  Backend relay disconnected after ${Date.now() - startAt}ms code=${code} reason="${reason?.toString() ?? ""}". Reconnecting in ${delay / 1000}s...`);
             backendRelayConnecting = false;
@@ -749,54 +986,14 @@ function relaySend(data) {
         pendingRelayMessages.push(data);
     }
 }
-function handlePromptFromRelay(_relayWs, msg) {
-    console.log(`  → Received prompt for session ${msg.sessionId}: "${msg.content.substring(0, 50)}"`);
-    const cliType = msg.cli?.toUpperCase() === "CODEX" ? "codex" : "claude";
-    const binary = cliType === "codex" ? clis.codex : clis.claude;
-    if (!binary) {
-        relaySend({ type: "error", sessionId: msg.sessionId, content: `${cliType} CLI not found on this machine` });
-        return;
-    }
-    if (sessionsCreating.has(msg.sessionId)) {
-        console.log(`  [relay] session=${msg.sessionId.substring(0, 8)} already being created, skipping duplicate`);
-        return;
-    }
-    let session = sessions.get(msg.sessionId);
-    if (!session) {
-        sessionsCreating.add(msg.sessionId);
-        session = new session_1.CLISession({
-            sessionId: msg.sessionId,
-            cliBinary: binary,
-            workingDir: msg.workingDir || workspaceRoot,
-            initialClaudeSessionId: getClaudeContext(msg.sessionId),
-            initialCodexThreadId: getCodexContext(msg.sessionId),
-        });
-        sessions.set(msg.sessionId, session);
-        sessionsCreating.delete(msg.sessionId);
-        session.on("output", (text) => {
-            relaySend({ type: "output", sessionId: msg.sessionId, content: text });
-        });
-        session.on("status", (text) => {
-            console.log(`  [relay] session=${msg.sessionId.substring(0, 8)} status: ${text}`);
-            relaySend({ type: "status", sessionId: msg.sessionId, content: text });
-        });
-        session.on("error", (text) => {
-            console.log(`  ✗ Session error: ${text.substring(0, 100)}`);
-            relaySend({ type: "error", sessionId: msg.sessionId, content: text });
-        });
-        session.on("done", (result) => {
-            console.log(`  ✓ Session done (exit ${result.code}), output length: ${result.fullOutput.length}`);
-            const s = sessions.get(msg.sessionId);
-            if (s?.claudeSessionId) {
-                setClaudeContext(msg.sessionId, s.claudeSessionId);
-            }
-            if (s?.codexThreadId) {
-                setCodexContext(msg.sessionId, s.codexThreadId);
-            }
-            relaySend({ type: "done", sessionId: msg.sessionId, content: result.fullOutput });
-            sessions.delete(msg.sessionId);
-        });
-    }
-    session.sendPrompt(msg.content, Array.isArray(msg.attachments) ? msg.attachments : []);
+function handlePromptFromRelay(msg, ownerSessionIds) {
+    handlePromptCommon(msg, {
+        source: "relay",
+        ownerSessionIds,
+        sendOutput: (content) => relaySend({ type: "output", sessionId: msg.sessionId, content }),
+        sendStatus: (content) => relaySend({ type: "status", sessionId: msg.sessionId, content }),
+        sendError: (content) => relaySend({ type: "error", sessionId: msg.sessionId, content }),
+        sendDone: (content) => relaySend({ type: "done", sessionId: msg.sessionId, content }),
+    });
 }
 //# sourceMappingURL=bridge.js.map