claude-bridge-cli 2.0.7 → 2.0.11

package/lib/bridge.js

@@ -32,6 +32,49 @@ function projectsDir() {
   return path.join(homeDir(), ".claude", "projects");
 }
 
+// ── Persisted turn-completion markers ──────────────────────────────────────
+// A turn is "complete" ONLY when its claude process actually resolved with a
+// parseable result. We persist that fact to disk (keyed by session id) so the
+// completion signal survives a bridge restart. Without it, getSessionMessages
+// falls back to the in-memory `running` set — which is wiped on restart — and
+// then promotes the trailing JSONL assistant line to `final_text`. For a turn
+// orphaned by a restart, that trailing line is often a mid-turn tool-call
+// preamble ("Running the type-check: I'll report once…") which then gets
+// mis-rendered as the final answer. The marker lets us tell genuine completion
+// apart from an interrupted/orphaned turn.
+function completionDir() {
+  const d = path.join(dataDir(), "completions");
+  fs.mkdirSync(d, { recursive: true });
+  return d;
+}
+function completionMarkerPath(sid) {
+  return path.join(completionDir(), encodeURIComponent(sid) + ".json");
+}
+function writeCompletionMarker(sid, finalText) {
+  if (!sid || sid === "pending") return;
+  try {
+    writeJson(completionMarkerPath(sid), {
+      session_id: sid,
+      stop_reason: "end_turn",
+      final_text: typeof finalText === "string" ? finalText : "",
+      completed_at: Date.now(),
+    });
+  } catch {}
+  // Best-effort prune of stale markers (>30d) so the dir can't grow forever.
+  try {
+    const dir = completionDir();
+    const cutoff = Date.now() - 30 * 24 * 3600 * 1000;
+    for (const f of fs.readdirSync(dir)) {
+      const fp = path.join(dir, f);
+      try { if (fs.statSync(fp).mtimeMs < cutoff) fs.unlinkSync(fp); } catch {}
+    }
+  } catch {}
+}
+function readCompletionMarker(sid) {
+  if (!sid) return null;
+  return readJson(completionMarkerPath(sid), null);
+}
+
 // ── Image handling ──
 
 const ALLOWED_IMAGE_EXTS = new Set(["png", "jpg", "jpeg", "gif", "webp"]);
@@ -202,7 +245,7 @@ function looksLikeInternal(text) {
 }
 
 function parseSessionFile(filePath) {
-  let preview = "", aiTitle = "", customTitle = "", msgCount = 0, lastPrompt = "";
+  let preview = "", aiTitle = "", customTitle = "", msgCount = 0, lastPrompt = "", cwd = "";
   try {
     // For listing, read just the first 64KB and the last 64KB.
     // First chunk: get preview + ai_title from early events.
@@ -219,6 +262,11 @@ function parseSessionFile(filePath) {
         if (!line) continue;
         try {
           const obj = JSON.parse(line);
+          // The real working directory is recorded on the session's events;
+          // capture the first one. Far more accurate than decoding the project
+          // dir name (which is lossy — it can't recover ":" or distinguish a
+          // path separator from a literal "-", e.g. Windows "C:\GIT\…").
+          if (!cwd && typeof obj.cwd === "string" && obj.cwd) cwd = obj.cwd;
           if (obj.type === "summary" && obj.summary) preview = preview || obj.summary.slice(0, 200);
           if (obj.type === "user" && obj.message?.content) {
             const text = typeof obj.message.content === "string" ? obj.message.content : JSON.stringify(obj.message.content);
@@ -261,7 +309,7 @@ function parseSessionFile(filePath) {
       fs.closeSync(fd);
     }
   } catch {}
-  return { preview, ai_title: customTitle || aiTitle, message_count: msgCount, last_prompt: lastPrompt };
+  return { preview, ai_title: customTitle || aiTitle, message_count: msgCount, last_prompt: lastPrompt, cwd };
 }
 
 function projectDirToCwd(name) {
@@ -284,7 +332,7 @@ function listSessions(opts = {}) {
     const title = titleOverrides[id] || parsed.ai_title;
     sessions.push({
       id, project,
-      cwd: projectDirToCwd(project),
+      cwd: parsed.cwd || projectDirToCwd(project),
       mtime: stat.mtimeMs / 1000,
       mtime_iso: stat.mtime.toISOString(),
       preview: parsed.preview,
@@ -333,13 +381,14 @@ function searchSessions(query, limit = 30) {
     const snippetEnd = Math.min(content.length, idx + q.length + 80);
     const snippet = content.slice(snippetStart, snippetEnd).replace(/\n/g, " ").trim();
 
-    let aiTitle = "", msgCount = 0;
+    let aiTitle = "", msgCount = 0, realCwd = "";
     try {
       const lines = content.split("\n").filter(Boolean);
       msgCount = lines.length;
       for (const line of lines) {
         try {
           const obj = JSON.parse(line);
+          if (!realCwd && typeof obj.cwd === "string" && obj.cwd) realCwd = obj.cwd;
           if (obj.type === "result" && obj.result?.metadata?.title?.value) {
             aiTitle = obj.result.metadata.title.value;
           }
@@ -351,7 +400,7 @@ function searchSessions(query, limit = 30) {
 
     results.push({
       id, project,
-      cwd: projectDirToCwd(project),
+      cwd: realCwd || projectDirToCwd(project),
       mtime: stat.mtimeMs / 1000,
       mtime_iso: stat.mtime.toISOString(),
       ai_title: titleOverrides[id] || aiTitle,
@@ -451,12 +500,18 @@ function getSessionMessages(sessionId) {
           const parts = Array.isArray(obj.message.content) ? obj.message.content : [obj.message.content];
           const text = parts.map(p => typeof p === "string" ? p : p.text || "").join("");
           if (!text) continue;
-          // Merge consecutive assistant turns into one (tool_use cycles)
+          // Merge consecutive assistant turns into one (tool_use cycles).
+          // Track the trailing event's stop_reason — `end_turn`/`stop_sequence`
+          // means the turn finished; `tool_use` means it stopped on a tool-call
+          // preamble (i.e. mid-action). This is the authoritative, in-transcript
+          // completion signal and works for every session, old or new.
+          const sr = obj.message?.stop_reason || null;
           if (messages.length && messages[messages.length - 1].role === "assistant") {
             messages[messages.length - 1].text = (messages[messages.length - 1].text + "\n" + text).trim();
             messages[messages.length - 1].timestamp = obj.timestamp || messages[messages.length - 1].timestamp;
+            messages[messages.length - 1]._stop_reason = sr;
           } else {
-            messages.push({ role: "assistant", text, timestamp: obj.timestamp });
+            messages.push({ role: "assistant", text, timestamp: obj.timestamp, _stop_reason: sr });
           }
         } else if (obj.type === "result" && obj.result?.assistantMessage) {
           const text = typeof obj.result.assistantMessage === "string" ? obj.result.assistantMessage : "";
@@ -470,18 +525,51 @@ function getSessionMessages(sessionId) {
     // forever even though Claude is done (the stuck-loader bug on this bridge).
     const inProgress = running.has(sessionId);
     const last_event_ts = messages.length ? (messages[messages.length - 1].timestamp || null) : null;
+    let status = inProgress ? "in_progress" : "complete";
+    let interrupted = false;
     if (!inProgress && messages.length) {
       const last = messages[messages.length - 1];
+      // Completion is decided by two independent signals, either of which is
+      // sufficient:
+      //   1. Transcript: the trailing assistant event's stop_reason is
+      //      `end_turn`/`stop_sequence` (claude closed the turn). Authoritative
+      //      and present in every session, so old sessions stay "complete".
+      //   2. Marker: a persisted completion record exists AND was written no
+      //      earlier than the trailing event (nothing newer ran after it).
+      // If NEITHER holds — e.g. the trailing line is a `tool_use` preamble and
+      // no fresh marker exists because the bridge was restarted mid-turn — the
+      // turn was orphaned. We must NOT fabricate an end_turn on that line.
+      const transcriptDone = last._stop_reason === "end_turn" || last._stop_reason === "stop_sequence";
+      const marker = readCompletionMarker(sessionId);
+      const lastTs = last_event_ts ? Date.parse(last_event_ts) : 0;
+      const markerGenuine = marker && (!lastTs || lastTs <= (marker.completed_at + 2000));
+      const genuine = transcriptDone || markerGenuine;
       if (last.role === "assistant" && last.text) {
-        last.stop_reason = "end_turn";
-        last.final_text = last.text;
+        if (genuine) {
+          last.stop_reason = "end_turn";
+          last.final_text = last.text;
+        } else {
+          // Interrupted/orphaned: finalize honestly instead of passing the
+          // trailing preamble off as the answer (and instead of leaving the
+          // client's loader spinning forever with no end marker).
+          status = "interrupted";
+          interrupted = true;
+          last.interrupted = true;
+          last.stop_reason = "interrupted";
+          last.final_text = last.text +
+            "\n\n⚠️ This turn was interrupted before it finished (the bridge was " +
+            "likely restarted mid-turn). The text above may be a partial step, not " +
+            "the final result. Reply \"continue\" to resume.";
+        }
       }
     }
+    for (const m of messages) delete m._stop_reason;  // internal-only signal
     return {
       session_id: sessionId,
       messages,
       in_progress: inProgress,
-      status: inProgress ? "in_progress" : "complete",
+      status,
+      interrupted,
       last_event_ts,
     };
   }
@@ -538,7 +626,22 @@ function renameSession(sessionId, title) {
 
 // ── Run claude -p ──
 
-function askClaude(config, { prompt, session_id, images, cwd, plan_mode, allow_tools, model }) {
+// Injected into every turn (--append-system-prompt) so Claude never ends a turn
+// promising async follow-up it can't keep: a bridge turn is one-shot and atomic —
+// nothing re-invokes Claude after it stops, so "I'll report once the build
+// completes" is a promise that never resolves (it leaves the UI dead-ended).
+const ATOMIC_TURN_PROMPT =
+  "You are running inside a one-shot, non-interactive bridge: THIS TURN IS ATOMIC. " +
+  "It ends the moment you stop producing output, and nothing re-invokes you afterward. " +
+  "You cannot do work in the background, report back later, be re-triggered when an " +
+  "external job (build/CI/deploy/long command) finishes, or continue on your own. " +
+  "Therefore NEVER end a turn by promising future follow-up such as 'I'll report once " +
+  "it completes', 'I'll continue when CI is done', or 'waiting on X to finish'. Instead, " +
+  "run any work to completion within this turn and report the actual result now. If a " +
+  "task genuinely cannot finish in this turn, say so plainly and tell the user the exact " +
+  "command(s) to run or the next message to send to continue — do not imply you will resume.";
+
+function askClaude(config, { prompt, session_id, images, cwd, plan_mode, allow_tools, model, fork }) {
   return new Promise((resolve) => {
     let finalPrompt = prompt;
     if (images && images.length) {
@@ -582,12 +685,18 @@ function askClaude(config, { prompt, session_id, images, cwd, plan_mode, allow_t
     });
     const promptArg = useTempFile ? `@${tmpFile}` : finalPrompt;
     const args = ["-p", promptArg, "--output-format", "json",
-      "--settings", settings, "--permission-mode", "acceptEdits"];
+      "--settings", settings, "--permission-mode", "acceptEdits",
+      "--append-system-prompt", ATOMIC_TURN_PROMPT];
     let resumeCwd = null;
     if (session_id) {
       const existing = scanSessionFiles().find(s => s.id === session_id);
       if (existing) {
         args.push("--resume", session_id);
+        // Fork: replay this session's history into a BRAND-NEW session id instead
+        // of appending to the original. claude returns the new id in the result,
+        // which the client adopts (leaving the original untouched). --fork-session
+        // only works alongside --resume.
+        if (fork) args.push("--fork-session");
         // Scan JSONL for the first event with a cwd field
         try {
           const lines = fs.readFileSync(existing.filePath, "utf8").split("\n");
@@ -630,6 +739,13 @@ function askClaude(config, { prompt, session_id, images, cwd, plan_mode, allow_t
       try {
         const result = JSON.parse(stdout);
         const sid = result.session_id || session_id || crypto.randomUUID();
+        // Persist genuine completion so it survives a bridge restart. This is
+        // the ONLY place a clean end-of-turn is recorded — the error/partial
+        // branch below deliberately writes no marker, so an interrupted turn
+        // stays distinguishable.
+        const finalText = result.result || result.assistantMessage || "";
+        writeCompletionMarker(sid, finalText);
+        if (session_id && session_id !== sid) writeCompletionMarker(session_id, finalText);
         if (images && images.length && session_id === "pending" && sid !== "pending") {
           const oldDir = path.join(dataDir(), "images", "pending");
           const newDir = path.join(dataDir(), "images", sid);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-bridge-cli",
-  "version": "2.0.7",
+  "version": "2.0.11",
   "description": "Use Claude Code from your browser. Runs a local server that connects your browser tools to the Claude CLI.",
   "main": "lib/bridge.js",
   "bin": {