@zzusp/ccsm 1.0.0 → 1.0.2

package/server/lib/bundle.ts

@@ -1,86 +1,86 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import readline from 'node:readline';
-
-/**
- * The literal placeholder that stands in for the project root inside a bundle.
- * Export replaces the device-specific absolute path with this; import swaps it
- * back to the local target path. Single-quoted on purpose — it is a literal
- * string, NOT a template interpolation.
- */
-export const SENTINEL = '${CLAUDE_PROJECT_ROOT}';
-
-/**
- * Rewrite a single top-level string field of a JSONL line, only when its value
- * exactly equals `fromValue`. Lines that don't carry the field (the fast path),
- * fail to parse, or hold a different value pass through byte-for-byte unchanged —
- * so message bodies and unrelated records are never touched. Re-serialization
- * via JSON.stringify changes key order/whitespace only, which is semantically
- * irrelevant to every consumer (Claude Code and this app both re-parse).
- */
-export function rewriteLineField(
-  raw: string,
-  field: string,
-  fromValue: string,
-  toValue: string,
-): string {
-  if (!raw.includes(`"${field}"`)) return raw;
-  let obj: Record<string, unknown>;
-  try {
-    obj = JSON.parse(raw) as Record<string, unknown>;
-  } catch {
-    return raw;
-  }
-  if (obj[field] !== fromValue) return raw;
-  obj[field] = toValue;
-  return JSON.stringify(obj);
-}
-
-/**
- * Stream a JSONL/NDJSON file line-by-line, rewriting `field` from `fromValue` to
- * `toValue` where present, into `destPath`. Never slurps the whole file. Returns
- * the line count and the sha256 of the exact bytes written. Blank lines are
- * dropped (they carry no record).
- */
-export async function transformFile(
-  srcPath: string,
-  destPath: string,
-  field: string,
-  fromValue: string,
-  toValue: string,
-): Promise<{ lines: number; sha256: string }> {
-  const hash = crypto.createHash('sha256');
-  const out = fs.createWriteStream(destPath, { encoding: 'utf8' });
-  const rl = readline.createInterface({
-    input: fs.createReadStream(srcPath, { encoding: 'utf8' }),
-    crlfDelay: Infinity,
-  });
-
-  let lines = 0;
-  try {
-    for await (const raw of rl) {
-      if (!raw) continue;
-      const chunk = rewriteLineField(raw, field, fromValue, toValue) + '\n';
-      hash.update(chunk);
-      out.write(chunk);
-      lines += 1;
-    }
-    await new Promise<void>((resolve, reject) => {
-      out.end((err?: Error | null) => (err ? reject(err) : resolve()));
-    });
-  } catch (err) {
-    out.destroy();
-    throw err;
-  }
-
-  return { lines, sha256: hash.digest('hex') };
-}
-
-export function sha256(data: string | Buffer): string {
-  return crypto.createHash('sha256').update(data).digest('hex');
-}
-
-/** sha256 of a file's raw bytes. For small files (memory entries); sync read. */
-export function sha256File(p: string): string {
-  return sha256(fs.readFileSync(p));
-}
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import readline from 'node:readline';
+
+/**
+ * The literal placeholder that stands in for the project root inside a bundle.
+ * Export replaces the device-specific absolute path with this; import swaps it
+ * back to the local target path. Single-quoted on purpose — it is a literal
+ * string, NOT a template interpolation.
+ */
+export const SENTINEL = '${CLAUDE_PROJECT_ROOT}';
+
+/**
+ * Rewrite a single top-level string field of a JSONL line, only when its value
+ * exactly equals `fromValue`. Lines that don't carry the field (the fast path),
+ * fail to parse, or hold a different value pass through byte-for-byte unchanged —
+ * so message bodies and unrelated records are never touched. Re-serialization
+ * via JSON.stringify changes key order/whitespace only, which is semantically
+ * irrelevant to every consumer (Claude Code and this app both re-parse).
+ */
+export function rewriteLineField(
+  raw: string,
+  field: string,
+  fromValue: string,
+  toValue: string,
+): string {
+  if (!raw.includes(`"${field}"`)) return raw;
+  let obj: Record<string, unknown>;
+  try {
+    obj = JSON.parse(raw) as Record<string, unknown>;
+  } catch {
+    return raw;
+  }
+  if (obj[field] !== fromValue) return raw;
+  obj[field] = toValue;
+  return JSON.stringify(obj);
+}
+
+/**
+ * Stream a JSONL/NDJSON file line-by-line, rewriting `field` from `fromValue` to
+ * `toValue` where present, into `destPath`. Never slurps the whole file. Returns
+ * the line count and the sha256 of the exact bytes written. Blank lines are
+ * dropped (they carry no record).
+ */
+export async function transformFile(
+  srcPath: string,
+  destPath: string,
+  field: string,
+  fromValue: string,
+  toValue: string,
+): Promise<{ lines: number; sha256: string }> {
+  const hash = crypto.createHash('sha256');
+  const out = fs.createWriteStream(destPath, { encoding: 'utf8' });
+  const rl = readline.createInterface({
+    input: fs.createReadStream(srcPath, { encoding: 'utf8' }),
+    crlfDelay: Infinity,
+  });
+
+  let lines = 0;
+  try {
+    for await (const raw of rl) {
+      if (!raw) continue;
+      const chunk = rewriteLineField(raw, field, fromValue, toValue) + '\n';
+      hash.update(chunk);
+      out.write(chunk);
+      lines += 1;
+    }
+    await new Promise<void>((resolve, reject) => {
+      out.end((err?: Error | null) => (err ? reject(err) : resolve()));
+    });
+  } catch (err) {
+    out.destroy();
+    throw err;
+  }
+
+  return { lines, sha256: hash.digest('hex') };
+}
+
+export function sha256(data: string | Buffer): string {
+  return crypto.createHash('sha256').update(data).digest('hex');
+}
+
+/** sha256 of a file's raw bytes. For small files (memory entries); sync read. */
+export function sha256File(p: string): string {
+  return sha256(fs.readFileSync(p));
+}

package/server/lib/claude-paths.test.ts

@@ -0,0 +1,126 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// claude-paths.ts 在模块加载期就锁定 `os.homedir() + .claude` 作为根，
+// 所以这里全部用动态 import + vi.resetModules，让每个 case 拿到一份新评估的常量。
+
+let tmpHome: string;
+
+beforeEach(() => {
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'ccsm-test-home-'));
+  vi.resetModules();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllEnvs();
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+describe('isUnderClaudeRoot (POSIX 语义)', () => {
+  it('对 ~/.claude/ 内的路径返回 true', async () => {
+    vi.spyOn(os, 'homedir').mockReturnValue(tmpHome);
+    const { isUnderClaudeRoot, PATHS } = await import('./claude-paths.ts');
+
+    expect(isUnderClaudeRoot(PATHS.root)).toBe(true);
+    expect(isUnderClaudeRoot(PATHS.projects)).toBe(true);
+    expect(isUnderClaudeRoot(path.join(PATHS.projects, 'some-proj', 'a.jsonl'))).toBe(true);
+    expect(isUnderClaudeRoot(PATHS.history)).toBe(true);
+  });
+
+  it('对 ~/.claude/ 外的路径返回 false', async () => {
+    vi.spyOn(os, 'homedir').mockReturnValue(tmpHome);
+    const { isUnderClaudeRoot } = await import('./claude-paths.ts');
+
+    expect(isUnderClaudeRoot(path.join(tmpHome, 'other'))).toBe(false);
+    expect(isUnderClaudeRoot('/etc/passwd')).toBe(false);
+    expect(isUnderClaudeRoot(tmpHome)).toBe(false); // 父目录本身不算
+  });
+
+  it('挡住 prefix-only 但实为兄弟目录的路径（防 .claude_evil 形态）', async () => {
+    vi.spyOn(os, 'homedir').mockReturnValue(tmpHome);
+    const { isUnderClaudeRoot } = await import('./claude-paths.ts');
+
+    // ~/.claude_evil 与 ~/.claude 同前缀，但不是子目录，必须拒绝
+    expect(isUnderClaudeRoot(path.join(tmpHome, '.claude_evil', 'x'))).toBe(false);
+    expect(isUnderClaudeRoot(path.join(tmpHome, '.claude-other'))).toBe(false);
+  });
+
+  it('包含 .. 的目标先 path.resolve 再判断，逃逸出 root 的会被拒绝', async () => {
+    vi.spyOn(os, 'homedir').mockReturnValue(tmpHome);
+    const { isUnderClaudeRoot, PATHS } = await import('./claude-paths.ts');
+
+    // .claude/projects/../../escape 解析后位于 tmpHome 之外
+    const escaped = path.join(PATHS.projects, '..', '..', 'escape');
+    expect(isUnderClaudeRoot(escaped)).toBe(false);
+  });
+});
+
+describe('isUnderClaudeRoot (Windows 大小写折叠语义)', () => {
+  // claude-paths 现在按 process.platform 显式选 path.win32 / path.posix，
+  // 所以在 POSIX runtime 上把 platform 设成 'win32' + 喂真实 Windows 路径形式
+  // （盘符 + 反斜杠 / UNC），就能跑通真实的 path.win32 盘符正规化 + 大小写折叠分支，
+  // 不再靠 POSIX 假根模拟。isUnderClaudeRoot 是纯字符串比较，不碰 fs，无需铺真实目录。
+  // async 包装：必须 `return await fn()`，让 finally 的平台还原发生在 await import + 断言
+  // 全部完成之后。若写成同步 `return fn()`，finally 会在动态 import 真正求值模块前就还原，
+  // 模块顶层读到的就不是 'win32' 了。
+  async function withWin32<T>(fn: () => Promise<T>): Promise<T> {
+    const origPlatform = process.platform;
+    Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+    try {
+      return await fn();
+    } finally {
+      Object.defineProperty(process, 'platform', { value: origPlatform, configurable: true });
+    }
+  }
+
+  it('真实 C:\\ 路径：盘符大小写 + 路径大小写折叠后判同一子树', async () => {
+    await withWin32(async () => {
+      vi.spyOn(os, 'homedir').mockReturnValue('C:\\Users\\Foo');
+      const { isUnderClaudeRoot, PATHS } = await import('./claude-paths.ts');
+
+      expect(PATHS.root).toBe('C:\\Users\\Foo\\.claude');
+
+      // root 自身 + 子路径
+      expect(isUnderClaudeRoot('C:\\Users\\Foo\\.claude')).toBe(true);
+      expect(isUnderClaudeRoot('C:\\Users\\Foo\\.claude\\projects\\bar')).toBe(true);
+      // 盘符小写 + 整段大小写互换仍判为同一子树
+      expect(isUnderClaudeRoot('c:\\users\\foo\\.claude\\projects\\bar')).toBe(true);
+      expect(isUnderClaudeRoot('C:\\USERS\\FOO\\.CLAUDE')).toBe(true);
+      // 兄弟目录（同前缀非子树）拒绝
+      expect(isUnderClaudeRoot('C:\\Users\\Foo\\.claude_evil')).toBe(false);
+      // 父目录本身不算
+      expect(isUnderClaudeRoot('C:\\Users\\Foo')).toBe(false);
+      // 含 .. 逃逸出 root 的被 path.win32.resolve 解析后拒绝
+      expect(isUnderClaudeRoot('C:\\Users\\Foo\\.claude\\..\\..\\escape')).toBe(false);
+    });
+  });
+
+  it('UNC 路径（\\\\server\\share\\...）同样走 win32 正规化 + 折叠', async () => {
+    await withWin32(async () => {
+      vi.spyOn(os, 'homedir').mockReturnValue('\\\\server\\share\\Foo');
+      const { isUnderClaudeRoot, PATHS } = await import('./claude-paths.ts');
+
+      expect(PATHS.root).toBe('\\\\server\\share\\Foo\\.claude');
+      expect(isUnderClaudeRoot('\\\\server\\share\\Foo\\.claude')).toBe(true);
+      expect(isUnderClaudeRoot('\\\\SERVER\\SHARE\\FOO\\.claude\\file-history\\sid')).toBe(true);
+      expect(isUnderClaudeRoot('\\\\server\\share\\Foo\\.claude_evil')).toBe(false);
+    });
+  });
+});
+
+describe('PATHS 派生项', () => {
+  it('所有子路径都基于 root 拼接，方便集中改 layout', async () => {
+    vi.spyOn(os, 'homedir').mockReturnValue(tmpHome);
+    const { PATHS } = await import('./claude-paths.ts');
+
+    expect(PATHS.root).toBe(path.join(tmpHome, '.claude'));
+    expect(PATHS.projects).toBe(path.join(PATHS.root, 'projects'));
+    expect(PATHS.fileHistory).toBe(path.join(PATHS.root, 'file-history'));
+    expect(PATHS.sessionEnv).toBe(path.join(PATHS.root, 'session-env'));
+    expect(PATHS.sessions).toBe(path.join(PATHS.root, 'sessions'));
+    expect(PATHS.history).toBe(path.join(PATHS.root, 'history.jsonl'));
+  });
+});

package/server/lib/claude-paths.ts

@@ -1,36 +1,43 @@
-import os from 'node:os';
-import path from 'node:path';
-
-const claudeRoot = path.join(os.homedir(), '.claude');
-
-export const PATHS = {
-  root: claudeRoot,
-  projects: path.join(claudeRoot, 'projects'),
-  fileHistory: path.join(claudeRoot, 'file-history'),
-  sessionEnv: path.join(claudeRoot, 'session-env'),
-  sessions: path.join(claudeRoot, 'sessions'),
-  history: path.join(claudeRoot, 'history.jsonl'),
-} as const;
-
-const isWin = process.platform === 'win32';
-
-function normalizeForCompare(p: string): string {
-  const resolved = path.resolve(p);
-  return isWin ? resolved.toLowerCase() : resolved;
-}
-
-const claudeRootNorm = normalizeForCompare(claudeRoot);
-
-export function isUnderClaudeRoot(target: string): boolean {
-  const norm = normalizeForCompare(target);
-  return norm === claudeRootNorm || norm.startsWith(claudeRootNorm + path.sep);
-}
-
-export function getCacheDir(): string {
-  const env = process.env;
-  const base =
-    env.XDG_CACHE_HOME ??
-    env.LOCALAPPDATA ??
-    path.join(os.homedir(), '.cache');
-  return path.join(base, 'claude-session-viewer');
-}
+import os from 'node:os';
+import path from 'node:path';
+
+const isWin = process.platform === 'win32';
+
+// 显式按平台选 path 实现，而不是用 node:path 默认导出。
+// 真实运行时这与默认导出等价（Windows 上默认就是 path.win32，POSIX 上是 path.posix），
+// 行为零变化；好处是单测能在 macOS / Linux 上把 process.platform 设成 'win32' 后喂真实
+// `C:\...` / UNC 形式，跑通 Windows 盘符正规化 + 大小写折叠的全分支——
+// 默认导出在 POSIX runtime 会把 `C:\...` 当相对路径，没法测真实 Windows 路径形态。
+const platformPath = isWin ? path.win32 : path.posix;
+
+const claudeRoot = platformPath.join(os.homedir(), '.claude');
+
+export const PATHS = {
+  root: claudeRoot,
+  projects: platformPath.join(claudeRoot, 'projects'),
+  fileHistory: platformPath.join(claudeRoot, 'file-history'),
+  sessionEnv: platformPath.join(claudeRoot, 'session-env'),
+  sessions: platformPath.join(claudeRoot, 'sessions'),
+  history: platformPath.join(claudeRoot, 'history.jsonl'),
+} as const;
+
+function normalizeForCompare(p: string): string {
+  const resolved = platformPath.resolve(p);
+  return isWin ? resolved.toLowerCase() : resolved;
+}
+
+const claudeRootNorm = normalizeForCompare(claudeRoot);
+
+export function isUnderClaudeRoot(target: string): boolean {
+  const norm = normalizeForCompare(target);
+  return norm === claudeRootNorm || norm.startsWith(claudeRootNorm + platformPath.sep);
+}
+
+export function getCacheDir(): string {
+  const env = process.env;
+  const base =
+    env.XDG_CACHE_HOME ??
+    env.LOCALAPPDATA ??
+    platformPath.join(os.homedir(), '.cache');
+  return platformPath.join(base, 'claude-session-viewer');
+}

package/server/lib/cleanup-suggestions.ts

@@ -0,0 +1,131 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isUnderClaudeRoot, PATHS } from './claude-paths.ts';
+import { dirSize } from './fs-size.ts';
+import { isSafeId } from './safe-id.ts';
+import { safeRemove } from './safe-remove.ts';
+import { scanProjectsForDisk } from './scan.ts';
+import type {
+  DiskCleanupLargeSession,
+  DiskCleanupOrphan,
+  DiskCleanupSuggestions,
+} from '../types.ts';
+
+const TOP_N_SESSIONS = 10;
+const JSONL_EXT = '.jsonl';
+
+/**
+ * 扫描所有 projects/<encoded>/*.jsonl 收集 sid 全集——后面 file-history/<sid>/、
+ * session-env/<sid>/ 与该集合做差，剩下的就是孤儿。
+ */
+function collectKnownSessionIds(): Set<string> {
+  const known = new Set<string>();
+  if (!fs.existsSync(PATHS.projects)) return known;
+  for (const proj of fs.readdirSync(PATHS.projects, { withFileTypes: true })) {
+    if (!proj.isDirectory()) continue;
+    const projectDir = path.join(PATHS.projects, proj.name);
+    if (!isUnderClaudeRoot(projectDir)) continue;
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(projectDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const ent of entries) {
+      if (ent.isFile() && ent.name.endsWith(JSONL_EXT)) {
+        known.add(ent.name.slice(0, -JSONL_EXT.length));
+      } else if (ent.isDirectory()) {
+        // projects/<encoded>/<sid>/ 子目录也是 session 主体的一部分（即使 jsonl 已被外部删），
+        // 也算"已知"，不当孤儿处理。
+        known.add(ent.name);
+      }
+    }
+  }
+  return known;
+}
+
+/**
+ * 扫 file-history/ 或 session-env/ 下的子目录，过滤掉已知 sid，剩下的就是孤儿。
+ * 每条返回大小（用 fs-size.dirSize 复用统一 du 逻辑）。
+ */
+function scanOrphans(rootDir: string, known: Set<string>): DiskCleanupOrphan[] {
+  if (!fs.existsSync(rootDir)) return [];
+  const out: DiskCleanupOrphan[] = [];
+  for (const ent of fs.readdirSync(rootDir, { withFileTypes: true })) {
+    if (!ent.isDirectory()) continue;
+    const sid = ent.name;
+    if (!isSafeId(sid)) continue;
+    if (known.has(sid)) continue;
+    const full = path.join(rootDir, sid);
+    if (!isUnderClaudeRoot(full)) continue;
+    out.push({ sessionId: sid, sizeBytes: dirSize(full) });
+  }
+  out.sort((a, b) => b.sizeBytes - a.sizeBytes);
+  return out;
+}
+
+export async function computeCleanupSuggestions(): Promise<DiskCleanupSuggestions> {
+  const projects = await scanProjectsForDisk();
+
+  // 大会话：扫每个项目的会话，按总占用排序取 top 10
+  const flat: DiskCleanupLargeSession[] = [];
+  for (const p of projects) {
+    for (const s of p.sessions) {
+      const r = s.relatedBytes;
+      const total = r.jsonl + r.subdir + r.fileHistory + r.sessionEnv;
+      if (total <= 0) continue;
+      flat.push({
+        sessionId: s.id,
+        projectId: p.id,
+        projectPath: p.decodedCwd,
+        title: s.title,
+        customTitle: s.customTitle,
+        sizeBytes: total,
+        lastActivity: s.lastAt,
+      });
+    }
+  }
+  flat.sort((a, b) => b.sizeBytes - a.sizeBytes);
+  const largeSessions = flat.slice(0, TOP_N_SESSIONS);
+
+  // 孤儿：file-history/<sid>/ 或 session-env/<sid>/ 但 sid 不在任何 .jsonl 中
+  const known = collectKnownSessionIds();
+  const orphanFileHistory = scanOrphans(PATHS.fileHistory, known);
+  const orphanSessionEnv = scanOrphans(PATHS.sessionEnv, known);
+
+  return { largeSessions, orphanFileHistory, orphanSessionEnv };
+}
+
+/**
+ * 删一个孤儿目录（file-history/<sid>/ 或 session-env/<sid>/）。
+ *
+ * 这里不复用 deleteSessions 的主流程：那条路径以 projects/<pid>/<sid>.jsonl 为锚点，
+ * jsonl + subdir 都不存在时会被 "no files for this session" 早退出，没法处理"主体已没了
+ * 但侧 store 还在"的纯孤儿场景。但「路径校验 + 实际 rm」这道安全网两条删除路径必须一致，
+ * 所以共用 safeRemove —— 差异只在前置判定（这里是"二次确认仍是孤儿"，deleteSessions 是
+ * "跳过 live PID / 5 分钟内活跃"）。
+ *
+ * 调用方负责 sid 已过 isSafeId、kind 已经过白名单校验。
+ */
+export function deleteOrphan(
+  kind: 'file-history' | 'session-env',
+  sessionId: string,
+): { ok: true; freedBytes: number } | { ok: false; reason: string } {
+  const rootDir = kind === 'file-history' ? PATHS.fileHistory : PATHS.sessionEnv;
+  const target = path.join(rootDir, sessionId);
+  if (!isUnderClaudeRoot(target)) {
+    return { ok: false, reason: `path escapes ~/.claude: ${target}` };
+  }
+  if (!fs.existsSync(target)) {
+    return { ok: false, reason: 'orphan no longer exists' };
+  }
+  // 二次保险：确认它现在确实还是孤儿（避免并发场景下用户先点了"导入"再点"删除"）
+  const known = collectKnownSessionIds();
+  if (known.has(sessionId)) {
+    return { ok: false, reason: 'session is no longer orphaned' };
+  }
+  const freedBytes = dirSize(target);
+  safeRemove(target);
+  return { ok: true, freedBytes };
+}
+

package/server/lib/constants.ts

@@ -1,7 +1,8 @@
-export {
-  MAX_SESSION_MESSAGES,
-  RECENT_ACTIVITY_WINDOW_MIN,
-} from '../../shared/constants.ts';
-import { RECENT_ACTIVITY_WINDOW_MIN } from '../../shared/constants.ts';
-
-export const RECENT_ACTIVITY_WINDOW_MS = RECENT_ACTIVITY_WINDOW_MIN * 60 * 1000;
+export {
+  INTERRUPTED_MARKER_RE,
+  MAX_SESSION_MESSAGES,
+  RECENT_ACTIVITY_WINDOW_MIN,
+} from '../../shared/constants.ts';
+import { RECENT_ACTIVITY_WINDOW_MIN } from '../../shared/constants.ts';
+
+export const RECENT_ACTIVITY_WINDOW_MS = RECENT_ACTIVITY_WINDOW_MIN * 60 * 1000;