cc-viewer 1.7.23 → 1.8.1

package/server/lib/launch-config.js

@@ -0,0 +1,329 @@
+/**
+ * launch-config.js — Launch-time configuration shared by the PTY and SDK spawns.
+ *
+ * Extracted from pty-manager.js so the SDK link (sdk-manager.js / cli.js runSdkMode)
+ * produces byte-identical system-prompt injection to the PTY link:
+ *   - withDefaultThinkingDisplay: inject `--thinking-display summarized` by default
+ *   - parseResumeArgs: continuation-flag parsing (-c/--continue/-r/--resume/--fork-session)
+ *   - resolveLaunchSystemPrompt: the full system-prompt pipeline — resume pin
+ *     (snapshot replay, never re-render variables) or fresh build (CC_SYSTEM.md /
+ *     CC_APPEND_SYSTEM.md sentinels, model-specific match, ${...} template render),
+ *     plus the pending record consumed by the wire-side binding (v2-writer Bind A).
+ *
+ * Everything here is spawn-shape logic only — no PTY, no SDK. Callers own their
+ * mode-specific concerns (PTY: rejection self-heal sets, spawn notices; SDK: args →
+ * options.extraArgs conversion).
+ */
+
+import { existsSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { LOG_DIR } from '../../findcc.js';
+import { reportSwallowed } from '@ccv/core/error-report';
+import {
+  buildSystemPromptFileArgs, hasArg, isNonEmptyFile,
+  SYSTEM_PROMPT_FILE, APPEND_SYSTEM_PROMPT_FILE,
+} from './system-prompt-files.js';
+import { renderSystemPromptFileArgs, renderedPromptDir } from './system-prompt-render.js';
+import { appendPending, readSnapshot, resolveContinueTargetUuid } from './system-prompt-snapshots.js';
+import { MODEL_PROMPT_DIR, listModelPrompts } from './model-system-prompts.js';
+import { resolveSpawnModel } from './spawn-model-resolver.js';
+
+// Opus 4.7 默认不再返回 thinking；为所有非显式覆写的调用加上 summarized。
+// 纯函数：仅根据 args 决定是否注入；用户已显式传入 `--thinking-display` 时原样返回。
+export function withDefaultThinkingDisplay(args) {
+  if (!Array.isArray(args)) return args;
+  const hasFlag = args.some(a =>
+    a === '--thinking-display' || (typeof a === 'string' && a.startsWith('--thinking-display='))
+  );
+  return hasFlag ? args : [...args, '--thinking-display', 'summarized'];
+}
+
+// Parse continuation flags from claude args: -c/--continue, -r/--resume (value as the
+// next token or in = form), --fork-session. Returns null for non-continuation launches;
+// picker=true means a valueless -r (interactive picker — target unknowable at spawn).
+// Same flag set as cli.js markContinueEnv / routes/workspaces.js.
+export function parseResumeArgs(args) {
+  if (!Array.isArray(args)) return null;
+  let continued = false;
+  let resumeValue = null;
+  let picker = false;
+  let fork = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '-c' || a === '--continue') { continued = true; continue; }
+    if (a === '--fork-session') { fork = true; continue; }
+    if (a === '-r' || a === '--resume') {
+      continued = true;
+      const next = args[i + 1];
+      if (typeof next === 'string' && next && !next.startsWith('-')) { resumeValue = next; i++; }
+      else picker = true;
+      continue;
+    }
+    const m = typeof a === 'string' && a.match(/^(?:-r|--resume)=(.+)$/);
+    if (m) { continued = true; resumeValue = m[1]; }
+  }
+  return continued ? { resumeValue, picker, fork } : null;
+}
+
+// Materialize snapshot entries into temp files. Each spawn gets its own subdirectory
+// under renderedPromptDir (per-process): two sequential spawns pinning DIFFERENT
+// conversations would otherwise overwrite the same basename before claude reads it.
+// Returns the same {args, loaded, entries} shape renderSystemPromptFileArgs produces.
+export function materializePinnedEntries(entries) {
+  const args = [];
+  const loaded = [];
+  const out = [];
+  for (const e of entries) {
+    try {
+      const dir = join(renderedPromptDir(), `pin-${randomBytes(4).toString('hex')}`);
+      mkdirSync(dir, { recursive: true });
+      const target = join(dir, e.basename);
+      writeFileSync(target, e.content, 'utf-8');
+      args.push(e.flag, target);
+      loaded.push(e.basename);
+      out.push({ flag: e.flag, basename: e.basename, content: e.content });
+    } catch (err) {
+      // A dropped entry breaks the byte-identity this feature exists to protect —
+      // warn visibly AND report: silent degradation here is a future cache miss.
+      console.warn(`[CC Viewer] system-prompt pin materialize failed for ${e?.basename}:`, err?.message || err);
+      reportSwallowed('pty-pin.materialize', err);
+    }
+  }
+  return { args, loaded, entries: out };
+}
+
+// Manual-first: a user-passed synonymous flag suppresses the matching pinned entry
+// (same semantics as the fresh buildSystemPromptFileArgs path). All entries
+// suppressed → no injection.
+export function suppressManuallyFlaggedPinned(entries, userArgs) {
+  return entries.filter(e => {
+    const pair = e.flag === '--system-prompt-file'
+      ? ['--system-prompt', '--system-prompt-file']
+      : ['--append-system-prompt', '--append-system-prompt-file'];
+    return !hasArg(userArgs, ...pair);
+  });
+}
+
+// The F2 no-record notice only matters to users who HAVE injection configured right
+// now (sentinel files or a model-prompt dir) — for everyone else a resume silently
+// injecting nothing is exactly the status quo, and the line would be pure noise.
+// Fidelity note (accepted gap): this check does NOT see the built-in preset layer —
+// users whose only injection is a default-effective built-in (no dirs, no sentinels)
+// get no F2 notice on resume either. Deliberate: making built-in hits count would turn
+// the notice into near-constant noise for every built-in user resuming old sessions.
+export function injectionConfigured(spawnDir, logDir = LOG_DIR) {
+  try {
+    return isNonEmptyFile(join(spawnDir, SYSTEM_PROMPT_FILE))
+      || isNonEmptyFile(join(spawnDir, APPEND_SYSTEM_PROMPT_FILE))
+      || existsSync(join(spawnDir, MODEL_PROMPT_DIR))
+      || existsSync(join(logDir, MODEL_PROMPT_DIR));
+  } catch { return false; }
+}
+
+// Default model reader with the NODE_TEST_CONTEXT guard (dev-shell model env vars must
+// not leak into unit tests). pty-manager passes its own test-seam reader instead.
+function _defaultModelReader(spawnDir, env, opts) {
+  return env.NODE_TEST_CONTEXT ? null : resolveSpawnModel(spawnDir, env, opts);
+}
+
+/**
+ * Resolve this launch's system-prompt injection.
+ *
+ * Resume-pin semantics (see pty-manager header / system-prompt-snapshots.js):
+ *   target identified + snapshot record → re-inject the recorded bytes verbatim;
+ *   target identified + no record       → inject NOTHING (F2 — never alter the system
+ *                                         text an existing context already has);
+ *   target unidentifiable (picker/-c with no transcripts) → normal fresh pipeline.
+ *
+ * @param {object} p
+ * @param {string} p.spawnDir — directory claude runs with
+ * @param {string[]} p.extraArgs — final user args (post settings-merge, post thinking-display);
+ *   used for synonymous-flag suppression of injected entries
+ * @param {object} [p.env] — process env of the launch (model resolution + opt-out checks)
+ * @param {object|null} [p.launchSettings] — merged --settings object (model resolution signal)
+ * @param {object|null|undefined} [p.resume] — explicit resume intent {resumeValue, picker, fork};
+ *   `undefined` parses from extraArgs (PTY path); explicit null forces the fresh pipeline
+ * @param {function} [p.modelReader] — (spawnDir, env, {launchSettings}) => modelId|null
+ * @param {boolean} [p.insideLogDir] — IM-worker spawns skip the whole pin/match machinery
+ * @param {string} [p.logDir]
+ * @param {boolean} [p.suppressInjection] — caller-side suppression (PTY: rejected-binary
+ *   set / skip-once token). Zeroes the injection and drops the pending record.
+ * @param {boolean} [p.persistPending] — record the effective injection for the wire-side
+ *   binding (v2-writer Bind A). PTY passes true; SDK also passes true (its wire traffic
+ *   flows through the same proxy). Set false only for dry-run callers.
+ * @returns {{
+ *   sysPrompt: {args: string[], loaded: string[], model: string|null, entries: object[], suppressed?: string, pinned?: boolean, noRecord?: boolean, noRecordNotice?: boolean},
+ *   resume: object|null,
+ *   resolvedModelId: string|null,
+ *   diagnostic: null|'no-match'|'no-model'|'builtin-disabled',
+ * }}
+ */
+export function resolveLaunchSystemPrompt(p) {
+  const {
+    spawnDir,
+    extraArgs,
+    env = process.env,
+    launchSettings = null,
+    resume: resumeIntent,
+    modelReader = _defaultModelReader,
+    insideLogDir = false,
+    logDir = LOG_DIR,
+    suppressInjection = false,
+    persistPending = true,
+  } = p;
+
+  const out = {
+    sysPrompt: { args: [], loaded: [], model: null, entries: [] },
+    resume: null,
+    resolvedModelId: null,
+    diagnostic: null,
+  };
+  if (!spawnDir) return out;
+
+  // Continuation launches (-c/--continue/-r/--resume): pin the resumed conversation's
+  // original injection — never re-render variables. IM workers (insideLogDir) skip the
+  // whole snapshot machinery: their persona file must be re-read on every launch.
+  const resume = insideLogDir ? null : (resumeIntent !== undefined ? resumeIntent : parseResumeArgs(extraArgs));
+  out.resume = resume;
+  let pendingRec = null;
+  let pinned = null;
+  if (resume && env.CCV_DISABLE_AUTO_SYSTEM_PROMPT !== '1') {
+    const targetUuid = resume.resumeValue ?? resolveContinueTargetUuid(spawnDir);
+    if (targetUuid) {
+      const snap = readSnapshot(spawnDir, targetUuid);
+      if (snap) {
+        // Manual-flag suppression BEFORE materialize (suppressed entries never hit disk).
+        const kept = suppressManuallyFlaggedPinned(snap.entries, extraArgs);
+        const m = materializePinnedEntries(kept);
+        pinned = { args: m.args, loaded: m.loaded, model: snap.model, entries: m.entries, pinned: true };
+        // The pending carries the SNAPSHOT's entries (post-suppression), not the
+        // materialized subset — a transient temp-write failure must not degrade the
+        // permanent record via Bind B.
+        pendingRec = { entries: kept, model: snap.model, resumeExpected: true, resolvedUuid: targetUuid, fork: resume.fork };
+      } else {
+        // F2: target identified but no snapshot → inject NOTHING this launch (never
+        // alter the system text an existing context already has).
+        pinned = { args: [], loaded: [], model: null, entries: [], pinned: true, noRecord: true, noRecordNotice: injectionConfigured(spawnDir, logDir) };
+      }
+    }
+    // Bare -r (picker): the target is unknowable at spawn → normal pipeline, and NO
+    // pending. -c with no transcripts (targetUuid null): claude fails and the caller's
+    // retry respawns without -c — treat as fresh below.
+  }
+
+  if (pinned) {
+    out.sysPrompt = pinned;
+  } else {
+    // launchSettings is this launch's own live configuration — launchers like cfuse
+    // deliver ANTHROPIC_MODEL exclusively inside it, so it must participate in model
+    // resolution or model-specific entries silently never match.
+    const resolvedModelId = insideLogDir ? null : modelReader(spawnDir, env, { launchSettings });
+    out.resolvedModelId = resolvedModelId;
+    let sysPrompt = buildSystemPromptFileArgs(spawnDir, extraArgs, env, {
+      modelId: resolvedModelId,
+      globalModelDir: join(logDir, MODEL_PROMPT_DIR),
+    });
+    if (suppressInjection) {
+      sysPrompt = { args: [], loaded: [], model: null, entries: [] };
+    } else if (sysPrompt.builtinDisabled) {
+      // The resolved model hit a built-in preset that the user tombstone-disabled —
+      // distinct from 'no-match' (a likely misnamed file): this is an intentional opt-out.
+      out.diagnostic = 'builtin-disabled';
+    } else if (resolvedModelId && !sysPrompt.model && !sysPrompt.suppressed
+      && (existsSync(join(spawnDir, MODEL_PROMPT_DIR)) || existsSync(join(logDir, MODEL_PROMPT_DIR)))) {
+      // A system_prompt dir is configured but the resolved model matched no entry
+      // (likely a misnamed file).
+      out.diagnostic = 'no-match';
+    } else if (!resolvedModelId && !sysPrompt.suppressed && !insideLogDir
+      && (listModelPrompts(join(spawnDir, MODEL_PROMPT_DIR)).length > 0
+        || listModelPrompts(join(logDir, MODEL_PROMPT_DIR)).length > 0)) {
+      // Entries exist but NO model signal resolved at all, so matching never ran.
+      out.diagnostic = 'no-model';
+    }
+    // Resolve `${...}` template variables in the injected files. Skipped entirely when
+    // suppression zeroed the args (a rejected binary never pays the render cost).
+    if (sysPrompt.args.length > 0) {
+      sysPrompt = renderSystemPromptFileArgs(sysPrompt, { cwd: spawnDir, modelId: resolvedModelId });
+    } else {
+      sysPrompt = { ...sysPrompt, entries: [] };
+    }
+    out.sysPrompt = sysPrompt;
+  }
+
+  // Unified suppression (pin and fresh alike): nothing was injected → nothing can be bound.
+  if (suppressInjection) {
+    out.sysPrompt = { args: [], loaded: [], model: null, entries: [] };
+    pendingRec = null;
+  }
+
+  // Record this launch's effective injection for the binding channels (wire Bind A /
+  // SessionStart Bind B). Empty pendings are never queued (see pty-manager history).
+  const effectiveEntries = (out.sysPrompt.entries || []).filter(e => e && !e.unavailable);
+  if (pendingRec && pendingRec.entries.length === 0) pendingRec = null;
+  const rec = pendingRec || (!resume && !pinned && effectiveEntries.length > 0
+    ? { entries: effectiveEntries, model: out.sysPrompt.model ?? null, resumeExpected: false, resolvedUuid: null, fork: false }
+    : null);
+  if (persistPending && rec) {
+    try { appendPending(spawnDir, rec, logDir); } catch (err) { reportSwallowed('launch-config.appendPending', err); }
+  }
+  out.pendingRec = rec;
+  return out;
+}
+
+/**
+ * Convert a flat launch-args array (['--system-prompt-file', path, ...]) into the SDK
+ * query() options.extraArgs shape ({ 'system-prompt-file': path, ... }). Boolean flags
+ * (no value) map to null. Unknown pairing (trailing flag) maps to null — the SDK
+ * appends it bare, mirroring claude argv semantics.
+ */
+export function launchArgsToExtraArgs(args) {
+  const out = {};
+  if (!Array.isArray(args)) return out;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (typeof a !== 'string' || !a.startsWith('--')) continue;
+    const eq = a.indexOf('=');
+    if (eq > 2) { out[a.slice(2, eq)] = a.slice(eq + 1); continue; }
+    const key = a.slice(2);
+    const next = args[i + 1];
+    if (typeof next === 'string' && !next.startsWith('--')) { out[key] = next; i++; }
+    else out[key] = null;
+  }
+  return out;
+}
+
+/**
+ * Split user CLI args for the SDK link: flags with SDK-native options are lifted out
+ * (--model / -c / --continue / -r / --resume / --fork-session — also needed at the
+ * sdk-manager level for resume-pin semantics); everything else rides along in `rest`
+ * (later converted to options.extraArgs verbatim). A valueless `-r` (interactive
+ * picker) can't work headless — reported via `pickerResume` so the caller can warn.
+ */
+export function splitSdkLaunchArgs(args) {
+  const out = { model: null, continue: false, resume: null, forkSession: false, pickerResume: false, rest: [] };
+  if (!Array.isArray(args)) return out;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (typeof a !== 'string') { out.rest.push(a); continue; }
+    if (a === '-c' || a === '--continue') { out.continue = true; continue; }
+    if (a === '--fork-session') { out.forkSession = true; continue; }
+    if (a === '-r' || a === '--resume') {
+      const next = args[i + 1];
+      if (typeof next === 'string' && next && !next.startsWith('-')) { out.resume = next; i++; }
+      else out.pickerResume = true;
+      continue;
+    }
+    let m = a.match(/^(?:-r|--resume)=(.+)$/);
+    if (m) { out.resume = m[1]; continue; }
+    m = a.match(/^--model=(.+)$/);
+    if (m) { out.model = m[1]; continue; }
+    if (a === '--model') {
+      const next = args[i + 1];
+      if (typeof next === 'string' && next && !next.startsWith('-')) { out.model = next; i++; continue; }
+      out.rest.push(a); continue; // valueless --model: pass through, claude surfaces its own usage error
+    }
+    out.rest.push(a);
+  }
+  return out;
+}

package/server/lib/log-file-utils.js

@@ -0,0 +1,21 @@
+// Log-file naming primitives — shared leaf extracted from log-management.js to
+// break the static cycle log-management.js ↔ v2/adapter.js (v2 read/write paths
+// need these primitives but must not import the v1 session listing, which itself
+// imports the v2 adapter). Keep this module dependency-free.
+
+export function isLogFileName(name) {
+  return name.endsWith('.jsonl');
+}
+
+// 解析日志文件名里的时间戳 `YYYYMMDD_HHMMSS`（带不带 `<pid>__` 前缀都适用）。
+// 用于「按时间排序 / 判最新」——文件名整串排序会把 `<pid>__` 前缀（'1' < 'c'）的最新文件排到最底，
+// 必须按时间戳排。无法解析时返回 ''（排到最后）。v2 convert 消费，防漂移。
+export function parseLogTs(name) {
+  const m = name.match(/_(\d{8}_\d{6})\.jsonl$/);
+  return m ? m[1] : '';
+}
+
+// A session whose journal moved within this window is treated as live and
+// refused by deleteLogFiles (cross-process guard; the in-process guard is the
+// caller's own writer state).
+export const LIVE_SESSION_MTIME_MS = 5 * 60 * 1000;

package/server/lib/log-management.js

@@ -1,11 +1,12 @@
 import { existsSync, realpathSync, readdirSync, readFileSync, statSync, mkdirSync, renameSync } from 'node:fs';
 import { readFile, stat, readdir } from 'node:fs/promises';
 import { join, sep, dirname, basename } from 'node:path';
-import { reconstructEntries } from './delta-reconstructor.js';
+import { reconstructEntries } from '@ccv/core/delta-reconstructor';
 import { sanitizePathComponent } from './v2/layout.js';
 import { listV2Sessions } from './v2/adapter.js';
 import { summarizeSessionPage } from './v2/session-list.js';
 import { listSessionIds } from './v2/replay.js';
+import { isLogFileName, LIVE_SESSION_MTIME_MS } from './log-file-utils.js';
 
 // wire-v2 S5 addressing (spec §12): 'v2:<project>/<session_id>' in every
 // existing ?file= parameter slot. Components must survive the same whitelist
@@ -63,17 +64,10 @@ export function validateLogPath(logDir, file) {
   return realPath;
 }
 
-export function isLogFileName(name) {
-  return name.endsWith('.jsonl');
-}
-
-// 解析日志文件名里的时间戳 `YYYYMMDD_HHMMSS`（带不带 `<pid>__` 前缀都适用）。
-// 用于「按时间排序 / 判最新」——文件名整串排序会把 `<pid>__` 前缀（'1' < 'c'）的最新文件排到最底，
-// 必须按时间戳排。无法解析时返回 ''（排到最后）。v2 convert 消费，防漂移。
-export function parseLogTs(name) {
-  const m = name.match(/_(\d{8}_\d{6})\.jsonl$/);
-  return m ? m[1] : '';
-}
+// isLogFileName / parseLogTs / LIVE_SESSION_MTIME_MS live in log-file-utils.js
+// (shared leaf, cycle break: v2/* must not import this module). Re-exported here
+// so existing consumers and tests keep their module path.
+export { isLogFileName, parseLogTs, LIVE_SESSION_MTIME_MS } from './log-file-utils.js';
 
 // meta.startTs (ISO) → the v1 list's compact local-time stamp 'YYYYMMDD_HHMMSS'
 // so formatTimestamp / the desc sort work on v2 items unchanged.
@@ -371,8 +365,3 @@ export function deleteLogFiles(logDir, files, opts = {}) {
   }
   return results;
 }
-
-// A session whose journal moved within this window is treated as live and
-// refused by deleteLogFiles (cross-process guard; the in-process guard is the
-// caller's own writer state).
-export const LIVE_SESSION_MTIME_MS = 5 * 60 * 1000;

package/server/lib/log-stream.js

@@ -12,7 +12,7 @@
 
 import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs';
 import { open as fsOpen, stat as fsStat } from 'node:fs/promises';
-import { isCheckpointEntry, isDeltaEntry, reconstructSegment } from './delta-reconstructor.js';
+import { isCheckpointEntry, isDeltaEntry, reconstructSegment } from '@ccv/core/delta-reconstructor';
 import { isV2SessionDir, iterateV2RawEntries, iterateV2RawEntriesAsync, readV2WindowedEntries, streamV2WindowedEntries } from './v2/adapter.js';
 
 const READ_CHUNK_SIZE = 1024 * 1024; // 1MB

package/server/lib/log-watcher.js

@@ -1,7 +1,7 @@
 import { readFileSync, existsSync } from 'node:fs';
 import { isMainAgentEntry, extractCachedContent } from './kv-cache-analyzer.js';
 import { buildContextWindowEvent, getContextSizeForModel } from './context-watcher.js';
-import { reconstructEntries } from './delta-reconstructor.js';
+import { reconstructEntries } from '@ccv/core/delta-reconstructor';
 import { enrichEntry } from './enrich-plan-input.js';
 import { enrichEntry as enrichWorkflowEntry } from './enrich-workflow.js';
 import { sseWrite } from './wire-compress.js';

package/server/lib/model-system-prompts.js

@@ -1,6 +1,6 @@
 import { readdirSync, readFileSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { isNonEmptyFile } from './system-prompt-files.js';
+import { isNonEmptyFile } from './file-api.js';
 
 // 「按模型定制 system prompt」的文件夹与文件名语法。
 // 全局目录 <LOG_DIR>/system_prompt/ 与工作区目录 <workspace>/system_prompt/ 各放一套；
@@ -261,10 +261,26 @@ function modelIdVariants(id) {
   return MODEL_ID_ALIASES[id] || [id];
 }
 
+// 供内置预设匹配复用的导出包装：入参任意大小写，先剥 `[1m]` 类方括号后缀
+// （spawn 渲染管线对 model.name 做同样的剥离；上游 resolver 正常会剥，这里兜底），
+// 再 toLowerCase 展开别名——避免大写 env（如 K3）或带后缀的裸名（k3[1m]）绕过别名表。
+// 单一别名源，勿在别处复制 MODEL_ID_ALIASES。
+// Exported wrapper for the built-in preset matcher: strips a trailing bracket suffix
+// and lowercases before expanding, so uppercase ids (K3) or suffixed shorthands
+// (k3[1m]) cannot bypass the alias table.
+export function expandModelIdVariants(modelId) {
+  if (!modelId || typeof modelId !== 'string') return [];
+  const stripped = modelId.replace(/\s*\[[^\]]*\]$/, '').toLowerCase();
+  return modelIdVariants(stripped);
+}
+
 export function matchModelPrompt(modelId, candidates) {
   if (!modelId || typeof modelId !== 'string') return null;
   if (!Array.isArray(candidates)) return null;
-  const variants = modelIdVariants(modelId.toLowerCase());
+  // 与内置层（builtin-model-prompts.js）同一展开：剥 `[1m]` 类后缀 + lowercase + 别名。
+  // 若用户层不剥后缀而内置层剥（k3[1m] + 用户有 KIMI-K3_SYSTEM.md），用户文件会
+  // 静默 miss、内置反客为主 —— 违反「用户文件永远优先」，两层必须同语义。
+  const variants = expandModelIdVariants(modelId);
   for (const cand of candidates) {
     if (!cand || !cand.dir) continue;
     const hits = listModelPrompts(cand.dir).filter((e) => {

package/server/lib/prefs-store.js

@@ -3,7 +3,7 @@
 // preferences.json holds UI prefs AND the (base64) LAN password (auth) AND per-project
 // forks (prefsByProject). Multiple writers touch it — the global POST /api/preferences,
 // lib/auth.js, and the new project-prefs routes — so every write here goes through ONE
-// async file lock + atomic tmp→rename, mirroring server/lib/ask-store.js. Same-process
+// async file lock + atomic tmp→rename, mirroring server/lib/ask/ask-store.js. Same-process
 // callers serialize via withFileLockAsync's per-lockPath Promise chain; cross-process
 // callers mutex on the lock file. This prevents a concurrent writer from clobbering the
 // password-bearing file or losing a fork update.
@@ -12,7 +12,7 @@ import { join, dirname } from 'node:path';
 import { randomBytes } from 'node:crypto';
 import { renameSyncWithRetry } from './file-api.js';
 import { withFileLockAsync } from './async-file-lock.js';
-import { mergeApprovalModalPrefs } from './approval-modal-prefs.js';
+import { mergeApprovalModalPrefs } from '@ccv/core/approval-modal-prefs';
 import { reconcileVoicePackPrefs } from './voice-pack-manager.js';
 import { LOG_DIR } from '../../findcc.js';
 

package/server/lib/project-prefs.js

@@ -9,9 +9,9 @@
 // A project "has a fork" iff a key exists for it (hasOwnProperty). Removing a fork
 // (toggle off) deletes the key so the project inherits global again.
 import { basename } from 'node:path';
-import { mergeApprovalModalPrefs } from './approval-modal-prefs.js';
-import { listPlatforms } from './im-config.js';
-import { _projectName } from '../interceptor.js';
+import { mergeApprovalModalPrefs } from '@ccv/core/approval-modal-prefs';
+import { listPlatforms } from './im/im-config.js';
+import { getProjectName } from './project-state.js';
 
 // SINGLE SOURCE of "what must never live inside a fork": secrets (auth password + IM creds),
 // machine-level paths (logDir/claudeConfigDir), and the internal forks map. snapshotForFork /
@@ -33,17 +33,17 @@ export function getCurrentProjectKey() {
 
 /** Human-readable project name for display (interceptor's sanitized basename). */
 export function getCurrentProjectName() {
-  return _projectName || basename(getCurrentProjectKey());
+  return getProjectName() || basename(getCurrentProjectKey());
 }
 
 /**
  * Whether the server is currently serving a concrete project. In workspace mode the
- * project is unknown until a workspace is launched (interceptor _projectName / env are
+ * project is unknown until a workspace is launched (project-state name / env are
  * empty) — refuse to fork under the server's own cwd in that window.
  */
 export function hasActiveProject() {
   if (process.env.CCV_WORKSPACE_MODE === '1') {
-    return !!(process.env.CCV_PROJECT_DIR || _projectName);
+    return !!(process.env.CCV_PROJECT_DIR || getProjectName());
   }
   return true;
 }

package/server/lib/project-state.js

@@ -0,0 +1,15 @@
+// Mutable "current project name" state — shared leaf (same pattern as findcc's
+// LOG_DIR). server/interceptor.js owns the value and pushes it at every rebind
+// (module init, initForWorkspace, resetWorkspace); lib readers such as
+// project-prefs.js must not import the interceptor (a stateful L2 module), so
+// they read through this leaf instead.
+
+let _currentProjectName = '';
+
+export function getProjectName() {
+  return _currentProjectName;
+}
+
+export function setProjectName(name) {
+  _currentProjectName = typeof name === 'string' ? name : '';
+}

package/server/lib/{proxy-retry.js → proxy/proxy-retry.js}

@@ -15,9 +15,9 @@
 //   - Streaming responses: only read status + headers to decide whether to retry; never retry after the body has
 //     started being sent (retry-before-first-byte strategy).
 //   - race/stagger use AbortController; cancelled requests must be released correctly.
-import { resolveProfileModel } from './interceptor-core.js';
+import { resolveProfileModel } from '../interceptor-core.js';
 import { readFileSync, existsSync } from 'node:fs';
-import { reportSwallowed } from './error-report.js';
+import { reportSwallowed } from '@ccv/core/error-report';
 
 // ── Configuration ─────────────────────────────────────────────────
 

package/server/lib/{proxy-stats.js → proxy/proxy-stats.js}

@@ -8,8 +8,8 @@
 //   - Fully separated from cc-viewer's existing session logs (*.jsonl written by interceptor), no cross-contamination.
 import { mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { AsyncWriteQueue } from './async-write-queue.js';
-import { reportSwallowed } from './error-report.js';
+import { AsyncWriteQueue } from '../async-write-queue.js';
+import { reportSwallowed } from '@ccv/core/error-report';
 
 // ── Detail record schema ──────────────────────────────────────────────
 // Appends one JSON line after each proxied LLM API request completes. Fields align with llm-retry-proxy's retry records.
@@ -136,7 +136,7 @@ export function flushRecords() {
 }
 
 // ── Stats-update notifier (dependency inversion, review P2) ────────────────
-// proxy.js used to dynamically import('./server.js') to reach the statsWorker
+// proxy.js used to dynamically import('../server.js') to reach the statsWorker
 // singleton — if a future proxy-only process did that first, server.js's
 // module-load side effects would boot a second viewer. The owner (server.js)
 // now registers its notify callback here at load time; proxy.js just emits.

package/server/lib/sdk-adapter.js

@@ -1,81 +1,13 @@
 /**
- * sdk-adapter.js — Convert Agent SDK messages to JSONL entry format.
+ * sdk-adapter.js — SDK-mode approval helpers.
  *
- * The frontend expects entries shaped like intercepted Claude API request/response pairs.
- * This adapter converts SDKAssistantMessage objects into that format so the
- * existing SSE pipeline and ChatView rendering work unchanged.
+ * NOTE: SDK-mode display entries are no longer synthesized here. The SDK child
+ * process talks to the API through cc-viewer's loopback proxy, so entries reach
+ * the frontend via the same wire path as PTY mode (fetch hook → V2Writer →
+ * live-feed → SSE). Only the approval-close mapping below remains in use
+ * (server.js interruptTurn fan-out).
  */
 
-// Minimal tool stubs — only used as fallback if SDK doesn't provide real tools
-const STUB_TOOLS = [
-  { name: 'Bash' }, { name: 'Edit' }, { name: 'Read' },
-  { name: 'Write' }, { name: 'Glob' }, { name: 'Agent' },
-];
-
-/**
- * Convert an SDK assistant message + accumulated conversation into a JSONL entry.
- *
- * @param {object} assistantMsg — SDKAssistantMessage (has .message: BetaMessage)
- * @param {Array} messages — Accumulated conversation messages [{role, content}]
- * @param {string} model — Model name
- * @param {string} projectName — Project name
- * @param {object} [opts] — Additional options
- * @param {string} [opts.timestamp] — Stable timestamp for dedup (same per turn)
- * @param {boolean} [opts.inProgress] — Whether response is still streaming
- * @param {string} [opts.requestId] — Request ID for in-progress entries
- * @param {Array} [opts.tools] — Real tools list from SDK init message
- * @returns {object} JSONL entry compatible with frontend expectations
- */
-export function sdkToJSONLEntry(assistantMsg, messages, model, projectName, opts = {}) {
-  const respBody = assistantMsg?.message || null;
-  const entry = {
-    timestamp: opts.timestamp || new Date().toISOString(),
-    project: projectName || 'sdk',
-    url: 'https://api.anthropic.com/v1/messages?beta=true',
-    method: 'POST',
-    headers: {},
-    body: {
-      model: model || respBody?.model || 'claude-opus-4-6',
-      system: [{ type: 'text', text: 'You are Claude Code' }],
-      tools: opts.tools || STUB_TOOLS,
-      messages: messages || [],
-      metadata: {},
-    },
-    response: opts.inProgress ? null : {
-      status: 200,
-      statusText: 'OK',
-      headers: {},
-      body: respBody,
-    },
-    duration: 0,
-    isStream: false,
-    mainAgent: true,
-  };
-
-  if (opts.inProgress) {
-    entry.inProgress = true;
-    entry.requestId = opts.requestId || `sdk_${Date.now()}`;
-  }
-
-  return entry;
-}
-
-/**
- * Build a streaming status event payload.
- */
-export function buildStreamingStatus(active, meta = {}) {
-  if (active) {
-    return {
-      active: true,
-      model: meta.model || null,
-      startTime: meta.startTime || Date.now(),
-      bytesReceived: 0,
-      chunksReceived: 0,
-    };
-  }
-  return { active: false };
-}
-
 /**
  * Map an SDK approval `kind` to the WS broadcast message type that closes that
  * kind's modal on every client. Used when interruptTurn() drains pending approvals