claude-bridge-cli 2.0.7 → 2.0.8

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"]);
@@ -451,12 +494,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 +519,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,
     };
   }
@@ -630,6 +712,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.8",
   "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": {