cc-viewer 1.9.14 → 1.9.16

package/server/lib/v2/conversation-store.js

@@ -35,13 +35,13 @@ export class ConversationStore {
   /**
    * @param {object} paths - sessionPaths() object
    * @param {{appendTo: Function}} queue - AsyncWriteQueue (explicit-path API)
-   * @param {{exactFps?: boolean}} [opts] - exact mode: judgement fingerprints
-   *   additionally hash the FULL message JSON. The offline converter needs
-   *   byte-grade faithfulness (its golden gate replays byte-identical wire);
-   *   fingerprintMsg's 80-char first-block snip cannot distinguish wires that
-   *   share a long prefix (real data 2026-07-14: sub prompts identical in the
-   *   first 80 chars, differing later, judged "unchanged" → replay stuck on
-   *   the first wire). The live request path keeps the cheap default.
+   * @param {{exactFps?: boolean|'main'}} [opts] - exact mode: judgement
+   *   fingerprints additionally hash the FULL normalized message JSON. Default
+   *   'main' covers the user-facing conversation; sub/misc retain cheap fps.
+   *   The offline converter passes true for byte-grade faithfulness across all
+   *   conversations. fingerprintMsg's 80-char first-block snip cannot see an
+   *   appended prompt in a later content block, which would otherwise be
+   *   judged "unchanged" and vanish from the replayed main conversation.
    */
   constructor(paths, queue, opts = {}) {
     this._paths = paths;
@@ -54,9 +54,12 @@ export class ConversationStore {
     // per request on affected conversations (real-data storm, ~62% of corpus
     // bytes). Storage still records the wire verbatim; only the judgement
     // compares modulo cache_control/form.
-    this._fpOf = opts.exactFps
-      ? (m) => { const n = normalizeMsgForEquality(m); return `${fingerprintMsg(n)}:${fnv1a(JSON.stringify(n))}`; }
-      : fingerprintMsg;
+    this._exactFps = opts.exactFps === undefined ? 'main' : opts.exactFps;
+    this._exactFpOf = (m) => {
+      const n = normalizeMsgForEquality(m);
+      return `${fingerprintMsg(n)}:${fnv1a(JSON.stringify(n))}`;
+    };
+    this._fpOf = this._exactFps === true ? this._exactFpOf : fingerprintMsg;
   }
 
   _state(convKey) {
@@ -123,7 +126,8 @@ export class ConversationStore {
     // exactly like v1's Plan C does, or the two dual-write sides legitimately
     // diverge in a way the verify digest (built on messageFingerprint) is
     // structurally blind to (review P2).
-    const fpsIn = msgs.map(this._fpOf);
+    const fpOf = this._exactFps === 'main' && convKey === 'main' ? this._exactFpOf : this._fpOf;
+    const fpsIn = msgs.map(fpOf);
     const prev = st.count;
     const prevFps = st.fps;
 

package/server/lib/v2/v2-writer.js

@@ -73,7 +73,7 @@ export class V2Writer {
     // writers pass none of these.
     this._sessionsDirName = opts.sessionsDirName || 'sessions';
     this._metaExtra = opts.metaExtra || null;
-    this._exactConvFps = !!opts.exactConvFps;
+    this._exactConvFps = opts.exactConvFps;
     // S6b live feed: called with the session dir after every ingest so the
     // in-process live cursor can read the fresh appends with zero fs-watch
     // latency. Purely a nudge — the feed's data source stays the files.

package/server/lib/view-root.js

@@ -1,7 +1,6 @@
 // View-root resolution (multi-project, 2026-10): map an optional `?project=`
 // name to the REAL filesystem root of that project, so project-scoped READ
-// routes (file tree / git / skills / memory / stats / search) can follow the
-// viewed parallel project instead of always the bound one.
+// routes and boundary-checked file mutations follow the viewed project.
 //
 // Name → path sources (both consulted, in order):
 //   1. workspace-registry (loadWorkspaces) — persistent { path, projectName },
@@ -22,7 +21,8 @@
 //   3. still >1 real candidate → 400, never a silent guess.
 //
 // Pure + dependency-injected (fs/registry/pty seams) so it is directly
-// node-testable. WRITE routes must NOT use this — they stay bound-only.
+// node-testable. File mutation routes use the same resolver as their reads;
+// every target must still pass the resolved root's filesystem boundary checks.
 
 import { realpathSync, existsSync, statSync } from 'node:fs';
 import { projectKeyForCwd } from './system-prompt-snapshots.js';
@@ -192,7 +192,7 @@ export function resolveViewRoot({ projectParam, instanceParam, boundCwd, loadWor
 }
 
 /**
- * HTTP-facing wrapper shared by every project-scoped READ route (multi-project,
+ * HTTP-facing wrapper shared by project-scoped routes (multi-project,
  * 2026-10): resolves `?project=` (or a POST-body override) via resolveViewRoot
  * and, on failure, writes the error response itself. Returns the resolved root
  * to continue with, or null after replying (the caller must return early).

package/server/pty-manager.js

@@ -1290,12 +1290,15 @@ export function resolveInstanceForCwd(cwd) {
  * would make resize/scrollback/getPtyState follow whichever project was last
  * SENT to, a new cross-project bleed (review P1, 2026-10-05).
  */
-function _resolveKeyByAnchor({ sessionId, project, instanceKey } = {}) {
+function _resolveKeyByAnchor({ sessionId, project, instanceKey, strict = false } = {}) {
+  // Explicit strict targets never fall back to the active conversation. Without this,
+  // a dead project/instance could receive a queued prompt meant for another one.
   // Multi-instance: an explicit instanceKey is the strongest anchor — it pins THIS exact
   // process (disambiguating two same-cwd instances that basename routing cannot).
   if (typeof instanceKey === 'string' && /^ccv-[0-9a-f]+$/.test(instanceKey)) {
     const rec = ptys.get(instanceKey);
     if (rec && rec.ptyProcess) return instanceKey;
+    if (strict) return null;
   }
   const projKey = (typeof project === 'string' && project) ? _resolveKey({ project }) : null;
   if (typeof sessionId === 'string' && sessionId) {
@@ -1313,12 +1316,13 @@ function _resolveKeyByAnchor({ sessionId, project, instanceKey } = {}) {
     }
   }
   if (projKey) return projKey;
+  if (strict) return null;
   return activePtyKey != null && ptys.has(activePtyKey) ? activePtyKey : null;
 }
 
 /** writeToPty variant routed by an explicit anchor instead of the global active pointer. */
-export function writeToPtyFor(data, { sessionId, project, instanceKey } = {}) {
-  const key = _resolveKeyByAnchor({ sessionId, project, instanceKey });
+export function writeToPtyFor(data, { sessionId, project, instanceKey, strict = false } = {}) {
+  const key = _resolveKeyByAnchor({ sessionId, project, instanceKey, strict });
   const s = key ? ptys.get(key) : null;
   if (s && s.ptyProcess) {
     s.ptyProcess.write(data);
@@ -1332,11 +1336,7 @@ export function writeToPtyFor(data, { sessionId, project, instanceKey } = {}) {
  * the write fails (onComplete(false)) WITHOUT falling back to the project/active record —
  * scheduled-task injection must never land in the wrong conversation (review P0-2). */
 export function writeToPtySequentialFor(chunks, onComplete, opts = {}, anchor = {}) {
-  let key = _resolveKeyByAnchor(anchor);
-  if (opts && opts.strict && typeof anchor.instanceKey === 'string' && anchor.instanceKey) {
-    const rec = ptys.get(anchor.instanceKey);
-    if (!rec || !rec.ptyProcess) key = null; // strict: a dead explicit instance never falls back
-  }
+  const key = _resolveKeyByAnchor({ ...anchor, strict: opts.strict === true });
   const s = key ? ptys.get(key) : null;
   if (!s || !s.ptyProcess || !chunks || chunks.length === 0) {
     if (onComplete) onComplete(false);

package/server/routes/ask-perm.js

@@ -7,6 +7,8 @@ import { _projectName } from '../interceptor.js';
 import { readPrefsRaw } from '../lib/prefs-store.js';
 import { getCurrentProjectKey, hasFork, resolveScoped } from '../lib/project-prefs.js';
 import { reportSwallowed } from '../lib/error-report.js';
+import { computeAutoApprove, createAutoApproveState } from '../lib/auto-approve.js';
+import { isPublishCommand } from '../lib/approval-policy.js';
 
 function pendingAsks(req, res, parsedUrl, isLocal, deps) {
   try {
@@ -394,7 +396,7 @@ function permHook(req, res, parsedUrl, isLocal, deps) {
       return;
     }
     try {
-      const { toolName, input } = JSON.parse(body);
+      const { toolName, input, cwd } = JSON.parse(body);
       if (!toolName) {
         res.writeHead(400, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Missing toolName' }));
@@ -407,6 +409,7 @@ function permHook(req, res, parsedUrl, isLocal, deps) {
         const oldest = deps.pendingPermHooks.get(oldestId);
         if (oldest) {
           clearTimeout(oldest.timer);
+          if (oldest.auto?.timer) clearTimeout(oldest.auto.timer);
           try { if (!oldest.res.headersSent) { oldest.res.writeHead(429, { 'Content-Type': 'application/json' }); oldest.res.end(JSON.stringify({ error: 'Too many concurrent requests' })); } } catch {}
           deps.pendingPermHooks.delete(oldestId);
         }
@@ -431,6 +434,7 @@ function permHook(req, res, parsedUrl, isLocal, deps) {
       const timer = setTimeout(() => {
         const entry = deps.pendingPermHooks.get(id);
         if (entry) {
+          if (entry.auto?.timer) clearTimeout(entry.auto.timer);
           deps.pendingPermHooks.delete(id);
           try {
             if (!entry.res.headersSent) {
@@ -447,11 +451,33 @@ function permHook(req, res, parsedUrl, isLocal, deps) {
         }
       }, PERM_HOOK_TIMEOUT);
 
-      deps.pendingPermHooks.set(id, { toolName, input, res, timer, createdAt: Date.now() });
+      // Server-side auto-approve countdown (same semantics as the SDK path in
+      // sdk-manager.js): armed from request arrival; the server answers the hook
+      // itself at deadline + 1s buffer when no client did. autoCancelled is set by
+      // the perm-hook-auto-cancel WS handler (the approval then stays pending for
+      // a manual decision) and replayed to fresh clients.
+      // npm publish is a hard safety floor: always wait for a human decision, never
+      // the server-side auto-approve fallback (SDK path parity: sdk-manager.js).
+      const autoMeta = isPublishCommand(toolName, input)
+        ? { enabled: false }
+        : computeAutoApprove('perm', typeof cwd === 'string' && cwd ? cwd : undefined, { file: deps.getPrefsFile?.() });
+
+      const hookEntry = {
+        toolName, input, res, timer, createdAt: Date.now(),
+        autoCancelled: false,
+        auto: null,
+      };
+      deps.pendingPermHooks.set(id, hookEntry);
 
       // Broadcast to all terminal WS clients
       if (deps.terminalWss) {
-        const pmsg = JSON.stringify({ type: 'perm-hook-pending', id, toolName, input });
+        const pmsg = JSON.stringify({
+          type: 'perm-hook-pending', id, toolName, input,
+          // Always stamp autoApproveSeconds (0 = server says OFF) so a client whose
+          // global pref disagrees with the fork-resolved value never re-arms locally.
+          autoApproveSeconds: autoMeta.enabled ? autoMeta.seconds : 0,
+          ...(autoMeta.enabled ? { autoApproveAt: autoMeta.autoApproveAt } : {}),
+        });
         deps.terminalWss.clients.forEach((client) => {
           if (client.readyState === 1) {
             try { client.send(pmsg); } catch {}
@@ -459,11 +485,36 @@ function permHook(req, res, parsedUrl, isLocal, deps) {
         });
       }
 
+      // Arm AFTER the entry is in the map AND the pending frame is out: instant (-1)
+      // fires synchronously and resolves through the entry, so clients observe the
+      // order pending → resolved (never a ghost panel for an already-answered hook).
+      if (autoMeta.enabled) {
+        hookEntry.auto = createAutoApproveState(autoMeta, () => {
+          const entry = deps.pendingPermHooks.get(id);
+          if (!entry || entry.autoCancelled) return;
+          clearTimeout(entry.timer);
+          deps.pendingPermHooks.delete(id);
+          try {
+            if (!entry.res.headersSent) {
+              entry.res.writeHead(200, { 'Content-Type': 'application/json' });
+              entry.res.end(JSON.stringify({ decision: 'allow' }));
+            }
+          } catch {}
+          if (deps.terminalWss) {
+            const rmsg = JSON.stringify({ type: 'perm-hook-resolved', id, reason: 'auto-approved' });
+            deps.terminalWss.clients.forEach((c) => {
+              if (c.readyState === 1) try { c.send(rmsg); } catch {}
+            });
+          }
+        });
+      }
+
       // Handle perm-bridge.js disconnection
       res.on('close', () => {
         const entry = deps.pendingPermHooks.get(id);
         if (entry) {
           clearTimeout(entry.timer);
+          if (entry.auto?.timer) clearTimeout(entry.auto.timer);
           deps.pendingPermHooks.delete(id);
           if (deps.terminalWss) {
             const tmsg = JSON.stringify({ type: 'perm-hook-timeout', id });