cc-viewer 1.9.14 → 1.9.16

package/dist/index.html

@@ -21,7 +21,7 @@
     // 整体显示大小已弃用 CSS zoom：Electron 改用 webFrame.setZoomFactor（首屏抢占见
     // electron/tab-content-preload.js），纯浏览器交由用户用浏览器自带快捷键缩放，故此处不再设 zoom。
   </script>
-  <script type="module" crossorigin src="./assets/index-CU0gt6m1.js"></script>
+  <script type="module" crossorigin src="./assets/index-sgW8MlD3.js"></script>
   <link rel="modulepreload" crossorigin href="./assets/vendor-antd-I6I2F7Rv.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-codemirror-Zkm6UHQg.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-mdxeditor-CC09MDyZ.js">

package/node_modules/@ccv/core/src/contentFilter.js

@@ -312,6 +312,9 @@ function stripSystemTags(text) {
   // Same kind as the protocol JSON in a <teammate-message> wrapper; after stripping, the
   // second pass recovers only the user-appended body (empty if none)
   out = extractProtocolNotifications(out).rest;
+  // An interrupt marker may share a text block with the user's next prompt.
+  // Strip only its complete leading form; later quoted markers stay verbatim.
+  out = out.replace(/^\s*\[Request interrupted[^\]\n]*\]\s*/i, '');
   return out.trim();
 }
 

package/node_modules/@ccv/core/src/queued-prompt.js

@@ -0,0 +1,66 @@
+// CLIENT-SAFE: no node deps. Home: @ccv/core (queued-prompt.js) — consumed by apps/web + packages/app.
+// Display-only recovery of user prompts inserted while Claude Code is working.
+// The original JSONL and model wire roles/content are never changed by these helpers.
+
+import { extractDisplayText } from './contentFilter.js';
+
+const WIRE_PREFIX = 'The user sent a new message while you were working:\n';
+const WIRE_SUFFIX = '\n\nIMPORTANT: After completing your current task, you MUST address the user\'s message above. Do not ignore it.';
+
+/** Extract a prompt from Claude Code's exact mid-conversation-system envelope. */
+export function extractQueuedPromptWireMessage(message) {
+  if (!message || message.role !== 'system') return null;
+  const textBlocks = typeof message.content === 'string'
+    ? [message.content]
+    : Array.isArray(message.content)
+      ? message.content.filter((block) => block?.type === 'text').map((block) => block.text)
+      : [];
+  if (textBlocks.length !== 1 || typeof textBlocks[0] !== 'string') return null;
+  const text = textBlocks[0];
+  if (!text.startsWith(WIRE_PREFIX) || !text.endsWith(WIRE_SUFFIX)) return null;
+  const content = text.slice(WIRE_PREFIX.length, -WIRE_SUFFIX.length);
+  return content ? { content, source: 'wire' } : null;
+}
+
+function hasDisplayText(content) {
+  if (typeof content === 'string') return !!extractDisplayText(content);
+  if (!Array.isArray(content)) return false;
+  return content.some((block) => block?.type === 'text' && !!extractDisplayText(block.text));
+}
+
+/** Render a recovered prompt without changing its transcript/model representation. */
+export function queuedPromptDisplayText(content) {
+  if (typeof content === 'string') return extractDisplayText(content);
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((block) => block?.type === 'text')
+    .map((block) => extractDisplayText(block.text))
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+/**
+ * Convert a confirmed Claude Code transcript queue record to a display input.
+ * An enqueue alone is deliberately insufficient: it may still be pending or cancelled.
+ */
+export function extractQueuedPromptTranscriptLine(line, position = 0) {
+  if (!line || line.isSidechain === true || line.isMeta === true) return null;
+  const attachment = line.type === 'attachment' ? line.attachment : null;
+  if (attachment) {
+    if (attachment.type !== 'queued_command' || attachment.commandMode !== 'prompt') return null;
+    const origin = attachment.origin?.kind;
+    const sdkBlocks = line.entrypoint === 'sdk-ts' && !origin && Array.isArray(attachment.prompt);
+    if (origin !== 'human' && !sdkBlocks) return null;
+    const content = attachment.prompt;
+    if (!hasDisplayText(content)) return null;
+    return {
+      content,
+      source: 'queued_command',
+      sourceId: line.uuid || `queued_command:${position}`,
+      parentUuid: line.parentUuid || null,
+      sessionId: line.sessionId || null,
+      submittedTimestamp: attachment.timestamp || line.timestamp || null,
+    };
+  }
+  return null;
+}

package/node_modules/@ccv/core/src/v2-transcript-normalizer.js

@@ -1,4 +1,5 @@
 // CLIENT-SAFE: no node deps. Home: @ccv/core (v2-transcript-normalizer.js) — consumed by apps/web + packages/app. Do not add fs/process/node: imports.
+import { extractQueuedPromptTranscriptLine } from './queued-prompt.js';
 /**
  * V2 Transcript Normalizer — Claude Code 2.x JSONL → legacy-compatible entry
  *
@@ -35,8 +36,9 @@
  *   same image) is ignored — message.content already carries the standard
  *   base64 data; honoring both would double memory.
  * - Metadata rows (mode / ai-title / last-prompt / file-history-snapshot /
- *   queue-operation) carry no message and are dropped — isRelevantRequest
- *   would otherwise surface them as garbage request rows.
+ *   system frames) carry no message and are dropped. Confirmed queued_command
+ *   attachments are the exception: they become display-only messages, while
+ *   pending enqueue / dequeue / remove / popAll remain non-renderable.
  */
 
 const V2_LINE_TYPES = new Set(['user', 'assistant']);
@@ -59,6 +61,7 @@ const DEDUP_MAX = 1024;
  */
 export function isV2TranscriptLine(entry) {
   if (!entry || typeof entry !== 'object') return false;
+  if (entry.type === 'attachment' || entry.type === 'queue-operation') return false;
   if (!V2_LINE_TYPES.has(entry.type)) return false;
   if (entry.isSidechain === true) return false;
   const msg = entry.message;
@@ -66,6 +69,11 @@ export function isV2TranscriptLine(entry) {
   return V2_LINE_ROLES.has(msg.role);
 }
 
+/** True for a confirmed queue input, not an enqueue that may never be consumed. */
+export function isV2TranscriptDisplayLine(entry) {
+  return isV2TranscriptLine(entry) || !!extractQueuedPromptTranscriptLine(entry);
+}
+
 /**
  * True for a legacy (or already-normalized) renderable request row.
  * Anything that is neither a v2 line nor a legacy request is a metadata row
@@ -86,7 +94,17 @@ function isLegacyRequestLine(entry) {
  */
 export function isMetadataRow(entry) {
   if (!entry || typeof entry !== 'object') return false;
-  return !isV2TranscriptLine(entry) && !isLegacyRequestLine(entry);
+  return !isV2TranscriptDisplayLine(entry) && !isLegacyRequestLine(entry);
+}
+
+function queuedPrompt(line, position = 0) {
+  const prompt = extractQueuedPromptTranscriptLine(line, position);
+  if (!prompt) return null;
+  return {
+    content: prompt.content,
+    _timestamp: prompt.submittedTimestamp,
+    _ccvSourceId: prompt.sourceId,
+  };
 }
 
 function parseTs(ts) {
@@ -116,8 +134,15 @@ function sortLines(lines) {
  */
 function buildSegmentMessages(lines) {
   const messages = [];
+  const queuedPrompts = [];
   const assistantById = new Map(); // message.id → message object
-  for (const line of lines) {
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex];
+    const queued = queuedPrompt(line, lineIndex);
+    if (queued) {
+      queuedPrompts.push({ ...queued, afterIndex: messages.length - 1 });
+      continue;
+    }
     const msg = line.message;
     if (msg.role === 'user') {
       messages.push({
@@ -157,7 +182,7 @@ function buildSegmentMessages(lines) {
     messages.push(m);
     if (mid) assistantById.set(mid, m);
   }
-  return messages;
+  return { messages, queuedPrompts };
 }
 
 /**
@@ -167,9 +192,9 @@ function buildSegmentMessages(lines) {
  * messages[0]._timestamp invariant.
  */
 export function buildSyntheticEntry(lines, sessionId, segIdx) {
-  const messages = buildSegmentMessages(lines);
-  if (messages.length === 0) return null;
-  const entryTs = messages[0]._timestamp;
+  const { messages, queuedPrompts } = buildSegmentMessages(lines);
+  if (messages.length === 0 && queuedPrompts.length === 0) return null;
+  const entryTs = messages.length > 0 ? messages[0]._timestamp : queuedPrompts[0]._timestamp;
   for (const m of messages) m._entryTs = entryTs;
 
   // Last assistant row carries model/usage — expose it as a synthetic
@@ -191,6 +216,7 @@ export function buildSyntheticEntry(lines, sessionId, segIdx) {
     sessionId,
     _seqEpoch: `v2:${sessionId}:${segIdx}`,
     _syntheticV2: true,
+    _ccvQueuedPrompts: queuedPrompts,
     _messageCount: messages.length,
   };
   if (lastModel || lastUsage) {
@@ -240,7 +266,7 @@ export function normalizeV2Entries(rawEntries) {
   let v2Count = 0;
   const kept = [];
   for (const e of rawEntries) {
-    if (isV2TranscriptLine(e)) {
+    if (isV2TranscriptDisplayLine(e)) {
       v2Count++;
     } else if (isLegacyRequestLine(e)) {
       kept.push(e);
@@ -251,7 +277,7 @@ export function normalizeV2Entries(rawEntries) {
 
   const bySession = new Map(); // sessionId → v2 lines
   for (const e of rawEntries) {
-    if (!isV2TranscriptLine(e)) continue;
+    if (!isV2TranscriptDisplayLine(e)) continue;
     const sid = e.sessionId || 'unknown';
     let arr = bySession.get(sid);
     if (!arr) bySession.set(sid, (arr = []));
@@ -260,8 +286,14 @@ export function normalizeV2Entries(rawEntries) {
 
   const synthetics = [];
   for (const [sid, lines] of bySession) {
-    const sorted = sortLines(lines);
-    const segments = splitSegments(sorted);
+    // Queue attachments carry their ENQUEUE timestamp, not the later position at
+    // which Claude consumed them. Keep the whole file sequence when such a row
+    // exists so its tool/assistant neighbours stay faithful to the transcript;
+    // sessions without queue inputs retain historical timestamp repair.
+    const ordered = lines.some((line) => extractQueuedPromptTranscriptLine(line))
+      ? lines
+      : sortLines(lines);
+    const segments = splitSegments(ordered);
     for (let i = 0; i < segments.length; i++) {
       const entry = buildSyntheticEntry(segments[i], sid, i);
       if (entry) synthetics.push(entry);
@@ -291,6 +323,7 @@ export function createV2IncrementalReconstructor() {
                            // primed cold entry's segment epoch, or the merge
                            // boundary check would split the session)
     accumulated: null,     // array of messages (cold snapshot or live-built)
+    queuedPrompts: [],
     shared: false,         // accumulated entries came from prime (copy-on-write)
     assistantById: new Map(),
     // tool_use blocks merged into an already-scanned message by a later split
@@ -300,6 +333,8 @@ export function createV2IncrementalReconstructor() {
     mergedToolUses: [],
     seenUuids: new Set(),
     uuidOrder: [],
+    lastQueuedLine: null,
+    lastQueuedPosition: -1,
     lastAssistant: null,
   };
 
@@ -380,6 +415,7 @@ export function createV2IncrementalReconstructor() {
       sessionId: state.sessionId,
       _seqEpoch: epoch,
       _syntheticV2: true,
+      _ccvQueuedPrompts: state.queuedPrompts.map((prompt) => ({ ...prompt })),
       _messageCount: messages.length,
     };
     if (state.lastAssistant) {
@@ -419,9 +455,12 @@ export function createV2IncrementalReconstructor() {
         ...m,
         content: Array.isArray(m.content) ? [...m.content] : m.content,
       }));
+      state.queuedPrompts = (syntheticEntry._ccvQueuedPrompts || []).map((prompt) => ({ ...prompt }));
+      for (const prompt of state.queuedPrompts) if (prompt._ccvSourceId) state.seenUuids.add(prompt._ccvSourceId);
       state.shared = true;
       state.assistantById.clear();
       for (const m of state.accumulated) {
+        if (m._ccvSourceId) state.seenUuids.add(m._ccvSourceId);
         if (m.role === 'assistant') {
           if (m._mid) state.assistantById.set(m._mid, m);
           state.lastAssistant = m;
@@ -436,7 +475,7 @@ export function createV2IncrementalReconstructor() {
      * isV2TranscriptLine first).
      */
     reconstruct(line) {
-      if (!isV2TranscriptLine(line)) return null;
+      if (!isV2TranscriptDisplayLine(line)) return null;
       // Session switch (workspace switch / another project's file on the same
       // SSE): the old session is already rendered — drop its baseline and
       // start a fresh one so rows never cross sessions.
@@ -445,12 +484,23 @@ export function createV2IncrementalReconstructor() {
         state.entryTs = line.timestamp;
         state.epoch = null;
         state.accumulated = [];
+        state.queuedPrompts = [];
         state.shared = false;
         state.assistantById.clear();
         state.lastAssistant = null;
         state.mergedToolUses = [];
       }
-      const uuid = line.uuid;
+      const position = !line.uuid && line.type === 'attachment' && state.lastQueuedLine === line
+        ? state.lastQueuedPosition : state.queuedPrompts.length;
+      const queued = queuedPrompt(line, position);
+      if (queued && !line.uuid) {
+        state.lastQueuedLine = line;
+        state.lastQueuedPosition = position;
+      } else {
+        state.lastQueuedLine = null;
+        state.lastQueuedPosition = -1;
+      }
+      const uuid = queued?._ccvSourceId || line.uuid;
       if (uuid && state.seenUuids.has(uuid)) return null;
       if (uuid) {
         state.seenUuids.add(uuid);
@@ -465,9 +515,21 @@ export function createV2IncrementalReconstructor() {
         state.entryTs = line.timestamp;
         state.epoch = null;
         state.accumulated = [];
+        state.queuedPrompts = [];
         state.shared = false;
       }
       const msg = line.message;
+      if (queued) {
+        if (state.accumulated === null) {
+          state.sessionId = line.sessionId || 'unknown';
+          state.entryTs = queued._timestamp;
+          state.accumulated = [];
+          state.queuedPrompts = [];
+          state.shared = false;
+        }
+        state.queuedPrompts.push({ ...queued, afterIndex: state.accumulated.length - 1 });
+        return snapshotEntry();
+      }
       if (msg.role === 'user' && isClearRow(line)) {
         // Live /clear: start a new segment (new epoch) so the batch and live
         // paths split sessions identically. The command row itself is dropped.
@@ -478,6 +540,7 @@ export function createV2IncrementalReconstructor() {
         state.epoch = `v2:${state.sessionId}:${(state.epoch?.split(':').pop() ?? 0) + 1}`;
         state.entryTs = null; // first message of the new segment owns the ts
         state.accumulated = [];
+        state.queuedPrompts = [];
         state.shared = false;
         state.assistantById.clear();
         state.lastAssistant = null;
@@ -509,6 +572,7 @@ export function createV2IncrementalReconstructor() {
       state.entryTs = null;
       state.epoch = null;
       state.accumulated = null;
+      state.queuedPrompts = [];
       state.shared = false;
       state.assistantById.clear();
       state.seenUuids.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.9.14",
+  "version": "1.9.16",
   "description": "Claude Code logging, visualization, and management toolkit — launch a web viewer alongside Claude Code with full request/response tracing, proxy, and mobile support",
   "license": "MIT",
   "main": "server.js",

package/server/lib/ask/perm-bridge.js

@@ -164,7 +164,10 @@ const TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 
 function postToViewer() {
   return new Promise((resolve, reject) => {
-    const body = JSON.stringify({ toolName, input: toolInput });
+    // Forward the session cwd so the server can resolve the project-forked
+    // autoApproveSeconds for the right workspace (falls back to the server's
+    // current project key when absent — backward compatible).
+    const body = JSON.stringify({ toolName, input: toolInput, cwd: typeof payload?.cwd === 'string' ? payload.cwd : undefined });
     const req = httpClient.request({
       hostname: '127.0.0.1',
       port: Number(port),

package/server/lib/auto-approve.js

@@ -0,0 +1,160 @@
+// Server-side auto-approve countdown for plan/permission approvals.
+//
+// The auto-approve countdown used to live entirely in the web client: when the
+// browser tab was closed, backgrounded (timer throttling), or disconnected, no
+// approval ever fired and the pending request degraded to the 5-minute deny
+// timeout. This module moves the deadline to the server: the countdown is armed
+// from the moment the approval request arrives (wall-clock), and the server
+// resolves the pending approval itself at deadline + AUTO_APPROVE_BUFFER_MS.
+// The buffer gives a connected client whose own countdown fires at the exact
+// deadline a head start, so a watched approval is still answered by the client
+// and the server timer is only the fallback.
+//
+// Cancellation is durable while the approval is pending: a client cancel marks
+// the entry (autoCancelled) and clears the server timer, the approval stays
+// pending for a manual decision, and the cancelled state is replayed to newly
+// connected clients so they never re-arm a countdown.
+//
+// Semantics of the settings (shared with the client):
+//   plan: prefs.approvalModal.planAutoApproveSeconds (default 0 = off)
+//   perm: prefs.autoApproveSeconds                  (default 3 when unset)
+//   0/off, N>0 = N seconds, -1 = instant (resolve immediately, no buffer).
+// AskUserQuestion approvals are never auto-approved.
+
+import { readPrefsRaw } from './prefs-store.js';
+import { getCurrentProjectKey, hasFork, resolveScoped } from './project-prefs.js';
+import { reportSwallowed } from './error-report.js';
+
+export const AUTO_APPROVE_BUFFER_MS = 1000;
+export const DEFAULT_PERM_AUTO_APPROVE_SECONDS = 3;
+export const AUTO_APPROVE_INSTANT = -1;
+// A hand-edited preferences.json can hold an absurdly large value. Besides being
+// pointless, a value above the 5-minute hard approval timeout would advertise an
+// autoApproveAt the deny timeout always beats (a lying countdown); and beyond
+// 2^31-1 ms Node's setTimeout clamps the delay to 1ms (instant approval). Cap the
+// countdown at the approval timeout so the advertised deadline is always reachable.
+export const MAX_AUTO_APPROVE_SECONDS = 300;
+
+/**
+ * Extract the configured seconds for a kind ('plan' | 'perm') from an effective
+ * prefs object. Returns null when disabled (0 / invalid / negative other than -1 /
+ * absurdly large).
+ */
+export function effectiveAutoApproveSeconds(kind, prefs) {
+  const raw = kind === 'plan'
+    ? prefs?.approvalModal?.planAutoApproveSeconds
+    : (prefs?.autoApproveSeconds ?? DEFAULT_PERM_AUTO_APPROVE_SECONDS);
+  const seconds = Number(raw);
+  if (!Number.isFinite(seconds)) return null;
+  if (seconds === AUTO_APPROVE_INSTANT) return AUTO_APPROVE_INSTANT;
+  if (seconds <= 0) return null;
+  if (seconds > MAX_AUTO_APPROVE_SECONDS) return null;
+  return seconds;
+}
+
+/**
+ * Read prefs (project-fork aware) and compute the auto-approve deadline for a
+ * pending approval. `projectKey` is the session cwd (SDK) or hook-reported cwd
+ * (PTY hook); falls back to the server's current project key.
+ *
+ * Returns:
+ *   { enabled:false }                                      — no auto-approve
+ *   { enabled:true, instant, seconds, autoApproveAt }      — absolute epoch ms deadline
+ */
+export function computeAutoApprove(kind, projectKey, { now = Date.now(), readPrefs = readPrefsRaw, file } = {}) {
+  let prefs = {};
+  try {
+    prefs = readPrefs(file) || {};
+  } catch (err) {
+    reportSwallowed('auto-approve.read-prefs', err);
+    return { enabled: false };
+  }
+  const key = typeof projectKey === 'string' && projectKey ? projectKey : getCurrentProjectKey();
+  const effective = hasFork(prefs, key) ? resolveScoped(prefs, prefs.prefsByProject[key]) : prefs;
+  const seconds = effectiveAutoApproveSeconds(kind, effective);
+  if (seconds === null) return { enabled: false };
+  const instant = seconds === AUTO_APPROVE_INSTANT;
+  return {
+    enabled: true,
+    instant,
+    seconds,
+    autoApproveAt: instant ? now : now + seconds * 1000,
+  };
+}
+
+/**
+ * Delay for the server-side fallback timer: the user-visible deadline plus the
+ * request buffer, never negative. Instant fires on the same tick (0).
+ */
+export function autoApproveFireDelayMs(computed, now = Date.now()) {
+  if (!computed?.enabled) return null;
+  if (computed.instant) return 0;
+  return Math.max(0, computed.autoApproveAt - now) + AUTO_APPROVE_BUFFER_MS;
+}
+
+/**
+ * Arm the server-side fallback timer. Returns the auto state stored on the
+ * pending entry: { autoApproveAt, seconds, cancelled, timer }.
+ * `onFire` is invoked once when the deadline (+buffer) passes; callers must
+ * re-check the entry is still pending and not cancelled inside onFire.
+ * Instant (-1) fires SYNCHRONOUSLY — the caller MUST register the pending entry
+ * (and emit the pending frame) before calling this.
+ */
+export function createAutoApproveState(computed, onFire) {
+  const delay = autoApproveFireDelayMs(computed);
+  if (delay === null) return null; // disabled — never arm
+  const state = {
+    autoApproveAt: computed.autoApproveAt,
+    seconds: computed.seconds,
+    cancelled: false,
+    timer: null,
+  };
+  if (delay === 0) {
+    onFire();
+    return state;
+  }
+  state.timer = setTimeout(onFire, delay);
+  return state;
+}
+
+/**
+ * Cancel an armed auto-approve state: clears the timer and marks it cancelled.
+ * Accepts either the auto state itself or the whole pending entry ({ auto,
+ * autoCancelled }) — the entry form also stamps the durable entry-level flag so
+ * replays never re-arm. Returns true only on the first cancellation (so callers
+ * broadcast once).
+ */
+export function cancelAutoApproveState(autoOrEntry) {
+  if (!autoOrEntry) return false;
+  // Entry form: { auto, autoCancelled }
+  if (Object.prototype.hasOwnProperty.call(autoOrEntry, 'autoCancelled')) {
+    const entry = autoOrEntry;
+    if (entry.autoCancelled) return false;
+    entry.autoCancelled = true;
+    if (entry.auto) {
+      entry.auto.cancelled = true;
+      if (entry.auto.timer) {
+        clearTimeout(entry.auto.timer);
+        entry.auto.timer = null;
+      }
+    }
+    return true;
+  }
+  const auto = autoOrEntry;
+  if (auto.cancelled) return false;
+  auto.cancelled = true;
+  if (auto.timer) {
+    clearTimeout(auto.timer);
+    auto.timer = null;
+  }
+  return true;
+}
+
+/** Fields merged into pending/replay frames for the client countdown UI. */
+export function replayAutoApproveFields(auto, autoCancelled) {
+  return {
+    autoApproveAt: autoCancelled ? null : (auto?.autoApproveAt ?? null),
+    autoApproveSeconds: auto?.seconds ?? null,
+    autoCancelled: autoCancelled === true,
+  };
+}