@zzusp/ccsm 1.0.1 → 1.0.3

package/server/lib/delete.ts

@@ -1,192 +1,192 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import readline from 'node:readline';
-import { isUnderClaudeRoot, PATHS } from './claude-paths.ts';
-import { RECENT_ACTIVITY_WINDOW_MS } from './constants.ts';
-import { dirSize, fileSize } from './fs-size.ts';
-import { isSafeId } from './safe-id.ts';
-import { safeRemove } from './safe-remove.ts';
-import {
-  buildActiveSessionMap,
-  readActivePidEntries,
-} from './active-sessions.ts';
-import type {
-  DeletedItem,
-  DeleteRequestItem,
-  DeleteResult,
-  RelatedBytes,
-  SkippedItem,
-} from '../types.ts';
-
-export type { DeleteRequestItem, DeleteResult } from '../types.ts';
-
-const HISTORY_TMP_SUFFIX = '.tmp-clean';
-
-export async function deleteSessions(items: DeleteRequestItem[]): Promise<DeleteResult> {
-  const liveMap = buildActiveSessionMap();
-  const deleted: DeletedItem[] = [];
-  const skipped: SkippedItem[] = [];
-  const targetIds = new Set<string>();
-
-  for (const item of items) {
-    if (!isSafeId(item.projectId) || !isSafeId(item.sessionId)) {
-      skipped.push({ ...item, reason: 'invalid id' });
-      continue;
-    }
-
-    const projectDir = path.join(PATHS.projects, item.projectId);
-    const jsonlPath = path.join(projectDir, `${item.sessionId}.jsonl`);
-    const subdirPath = path.join(projectDir, item.sessionId);
-    const fhPath = path.join(PATHS.fileHistory, item.sessionId);
-    const sePath = path.join(PATHS.sessionEnv, item.sessionId);
-
-    const escaped = [jsonlPath, subdirPath, fhPath, sePath].find(
-      (p) => !isUnderClaudeRoot(p),
-    );
-    if (escaped) {
-      skipped.push({ ...item, reason: `path escapes ~/.claude: ${escaped}` });
-      continue;
-    }
-
-    if (liveMap.has(item.sessionId)) {
-      skipped.push({
-        ...item,
-        reason: `live PID ${liveMap.get(item.sessionId)} owns this session`,
-      });
-      continue;
-    }
-
-    if (isRecentlyActive(jsonlPath)) {
-      skipped.push({
-        ...item,
-        reason: 'jsonl modified within the last 5 minutes — could still be in use',
-      });
-      continue;
-    }
-
-    if (!fs.existsSync(jsonlPath) && !fs.existsSync(subdirPath)) {
-      skipped.push({ ...item, reason: 'no files for this session' });
-      continue;
-    }
-
-    const related: RelatedBytes = {
-      jsonl: fileSize(jsonlPath),
-      subdir: dirSize(subdirPath),
-      fileHistory: dirSize(fhPath),
-      sessionEnv: dirSize(sePath),
-    };
-    const cleaned: string[] = [];
-
-    if (safeRemove(jsonlPath)) cleaned.push('projects/<id>.jsonl');
-    if (safeRemove(subdirPath)) cleaned.push('projects/<id>/');
-    if (safeRemove(fhPath)) cleaned.push('file-history/<id>/');
-    if (safeRemove(sePath)) cleaned.push('session-env/<id>/');
-
-    deleted.push({
-      ...item,
-      freedBytes:
-        related.jsonl + related.subdir + related.fileHistory + related.sessionEnv,
-      cleaned,
-      relatedBytes: related,
-    });
-    targetIds.add(item.sessionId);
-  }
-
-  let historyLinesRemoved = 0;
-  if (targetIds.size > 0) {
-    historyLinesRemoved = await rewriteHistoryWithout(targetIds);
-    cleanupDeadPidFiles(targetIds);
-  }
-
-  return { deleted, skipped, historyLinesRemoved };
-}
-
-function isRecentlyActive(jsonlPath: string): boolean {
-  try {
-    return Date.now() - fs.statSync(jsonlPath).mtimeMs < RECENT_ACTIVITY_WINDOW_MS;
-  } catch {
-    return false;
-  }
-}
-
-async function rewriteHistoryWithout(sessionIds: Set<string>): Promise<number> {
-  if (!fs.existsSync(PATHS.history)) return 0;
-
-  const tmpPath = PATHS.history + HISTORY_TMP_SUFFIX;
-  if (fs.existsSync(tmpPath)) fs.rmSync(tmpPath, { force: true });
-
-  let removed = 0;
-  try {
-    const out = fs.createWriteStream(tmpPath, { encoding: 'utf8' });
-    const rl = readline.createInterface({
-      input: fs.createReadStream(PATHS.history, { encoding: 'utf8' }),
-      crlfDelay: Infinity,
-    });
-
-    for await (const raw of rl) {
-      if (!raw) {
-        out.write(os.EOL);
-        continue;
-      }
-      let drop = false;
-      try {
-        const obj = JSON.parse(raw) as { sessionId?: unknown };
-        if (typeof obj.sessionId === 'string' && sessionIds.has(obj.sessionId)) {
-          drop = true;
-        }
-      } catch {
-        /* keep malformed lines */
-      }
-      if (drop) {
-        removed += 1;
-      } else {
-        out.write(raw);
-        out.write(os.EOL);
-      }
-    }
-    await new Promise<void>((resolve, reject) => {
-      out.end((err: Error | null | undefined) => (err ? reject(err) : resolve()));
-    });
-  } catch (err) {
-    fs.rmSync(tmpPath, { force: true });
-    throw err;
-  }
-
-  if (removed === 0) {
-    fs.rmSync(tmpPath, { force: true });
-    return 0;
-  }
-
-  // Windows-safe atomic-ish replace: backup original, swap tmp in, drop backup.
-  // unlink + rename is the alternative but loses recoverability mid-failure.
-  const backup = PATHS.history + '.bak-' + Date.now();
-  fs.renameSync(PATHS.history, backup);
-  try {
-    fs.renameSync(tmpPath, PATHS.history);
-    fs.rmSync(backup, { force: true });
-  } catch (err) {
-    if (fs.existsSync(backup)) {
-      try {
-        fs.renameSync(backup, PATHS.history);
-      } catch {
-        /* keep backup for manual recovery */
-      }
-    }
-    fs.rmSync(tmpPath, { force: true });
-    throw err;
-  }
-  return removed;
-}
-
-function cleanupDeadPidFiles(sessionIds: Set<string>): void {
-  for (const entry of readActivePidEntries()) {
-    if (!sessionIds.has(entry.sessionId)) continue;
-    if (entry.alive) continue;
-    try {
-      fs.rmSync(entry.sourceFile, { force: true });
-    } catch {
-      /* ignore */
-    }
-  }
-}
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import { isUnderClaudeRoot, PATHS } from './claude-paths.ts';
+import { RECENT_ACTIVITY_WINDOW_MS } from './constants.ts';
+import { dirSize, fileSize } from './fs-size.ts';
+import { isSafeId } from './safe-id.ts';
+import { safeRemove } from './safe-remove.ts';
+import {
+  buildActiveSessionMap,
+  readActivePidEntries,
+} from './active-sessions.ts';
+import type {
+  DeletedItem,
+  DeleteRequestItem,
+  DeleteResult,
+  RelatedBytes,
+  SkippedItem,
+} from '../types.ts';
+
+export type { DeleteRequestItem, DeleteResult } from '../types.ts';
+
+const HISTORY_TMP_SUFFIX = '.tmp-clean';
+
+export async function deleteSessions(items: DeleteRequestItem[]): Promise<DeleteResult> {
+  const liveMap = buildActiveSessionMap();
+  const deleted: DeletedItem[] = [];
+  const skipped: SkippedItem[] = [];
+  const targetIds = new Set<string>();
+
+  for (const item of items) {
+    if (!isSafeId(item.projectId) || !isSafeId(item.sessionId)) {
+      skipped.push({ ...item, reason: 'invalid id' });
+      continue;
+    }
+
+    const projectDir = path.join(PATHS.projects, item.projectId);
+    const jsonlPath = path.join(projectDir, `${item.sessionId}.jsonl`);
+    const subdirPath = path.join(projectDir, item.sessionId);
+    const fhPath = path.join(PATHS.fileHistory, item.sessionId);
+    const sePath = path.join(PATHS.sessionEnv, item.sessionId);
+
+    const escaped = [jsonlPath, subdirPath, fhPath, sePath].find(
+      (p) => !isUnderClaudeRoot(p),
+    );
+    if (escaped) {
+      skipped.push({ ...item, reason: `path escapes ~/.claude: ${escaped}` });
+      continue;
+    }
+
+    if (liveMap.has(item.sessionId)) {
+      skipped.push({
+        ...item,
+        reason: `live PID ${liveMap.get(item.sessionId)} owns this session`,
+      });
+      continue;
+    }
+
+    if (isRecentlyActive(jsonlPath)) {
+      skipped.push({
+        ...item,
+        reason: 'jsonl modified within the last 5 minutes — could still be in use',
+      });
+      continue;
+    }
+
+    if (!fs.existsSync(jsonlPath) && !fs.existsSync(subdirPath)) {
+      skipped.push({ ...item, reason: 'no files for this session' });
+      continue;
+    }
+
+    const related: RelatedBytes = {
+      jsonl: fileSize(jsonlPath),
+      subdir: dirSize(subdirPath),
+      fileHistory: dirSize(fhPath),
+      sessionEnv: dirSize(sePath),
+    };
+    const cleaned: string[] = [];
+
+    if (safeRemove(jsonlPath)) cleaned.push('projects/<id>.jsonl');
+    if (safeRemove(subdirPath)) cleaned.push('projects/<id>/');
+    if (safeRemove(fhPath)) cleaned.push('file-history/<id>/');
+    if (safeRemove(sePath)) cleaned.push('session-env/<id>/');
+
+    deleted.push({
+      ...item,
+      freedBytes:
+        related.jsonl + related.subdir + related.fileHistory + related.sessionEnv,
+      cleaned,
+      relatedBytes: related,
+    });
+    targetIds.add(item.sessionId);
+  }
+
+  let historyLinesRemoved = 0;
+  if (targetIds.size > 0) {
+    historyLinesRemoved = await rewriteHistoryWithout(targetIds);
+    cleanupDeadPidFiles(targetIds);
+  }
+
+  return { deleted, skipped, historyLinesRemoved };
+}
+
+function isRecentlyActive(jsonlPath: string): boolean {
+  try {
+    return Date.now() - fs.statSync(jsonlPath).mtimeMs < RECENT_ACTIVITY_WINDOW_MS;
+  } catch {
+    return false;
+  }
+}
+
+async function rewriteHistoryWithout(sessionIds: Set<string>): Promise<number> {
+  if (!fs.existsSync(PATHS.history)) return 0;
+
+  const tmpPath = PATHS.history + HISTORY_TMP_SUFFIX;
+  if (fs.existsSync(tmpPath)) fs.rmSync(tmpPath, { force: true });
+
+  let removed = 0;
+  try {
+    const out = fs.createWriteStream(tmpPath, { encoding: 'utf8' });
+    const rl = readline.createInterface({
+      input: fs.createReadStream(PATHS.history, { encoding: 'utf8' }),
+      crlfDelay: Infinity,
+    });
+
+    for await (const raw of rl) {
+      if (!raw) {
+        out.write(os.EOL);
+        continue;
+      }
+      let drop = false;
+      try {
+        const obj = JSON.parse(raw) as { sessionId?: unknown };
+        if (typeof obj.sessionId === 'string' && sessionIds.has(obj.sessionId)) {
+          drop = true;
+        }
+      } catch {
+        /* keep malformed lines */
+      }
+      if (drop) {
+        removed += 1;
+      } else {
+        out.write(raw);
+        out.write(os.EOL);
+      }
+    }
+    await new Promise<void>((resolve, reject) => {
+      out.end((err: Error | null | undefined) => (err ? reject(err) : resolve()));
+    });
+  } catch (err) {
+    fs.rmSync(tmpPath, { force: true });
+    throw err;
+  }
+
+  if (removed === 0) {
+    fs.rmSync(tmpPath, { force: true });
+    return 0;
+  }
+
+  // Windows-safe atomic-ish replace: backup original, swap tmp in, drop backup.
+  // unlink + rename is the alternative but loses recoverability mid-failure.
+  const backup = PATHS.history + '.bak-' + Date.now();
+  fs.renameSync(PATHS.history, backup);
+  try {
+    fs.renameSync(tmpPath, PATHS.history);
+    fs.rmSync(backup, { force: true });
+  } catch (err) {
+    if (fs.existsSync(backup)) {
+      try {
+        fs.renameSync(backup, PATHS.history);
+      } catch {
+        /* keep backup for manual recovery */
+      }
+    }
+    fs.rmSync(tmpPath, { force: true });
+    throw err;
+  }
+  return removed;
+}
+
+function cleanupDeadPidFiles(sessionIds: Set<string>): void {
+  for (const entry of readActivePidEntries()) {
+    if (!sessionIds.has(entry.sessionId)) continue;
+    if (entry.alive) continue;
+    try {
+      fs.rmSync(entry.sourceFile, { force: true });
+    } catch {
+      /* ignore */
+    }
+  }
+}

package/server/lib/disk-usage.ts

@@ -1,81 +1,81 @@
-import { scanProjectsForDisk } from './scan.ts';
-import type {
-  DiskUsage,
-  DiskUsageMonthRow,
-  DiskUsageProjectRow,
-  DiskUsageTopSession,
-  RelatedBytes,
-} from '../types.ts';
-
-const TOP_N = 20;
-
-export async function computeDiskUsage(): Promise<DiskUsage> {
-  const projects = await scanProjectsForDisk();
-
-  const byProject: DiskUsageProjectRow[] = [];
-  const monthMap = new Map<string, { bytes: number; count: number }>();
-  const flat: Array<{
-    projectId: string;
-    sessionId: string;
-    title: string;
-    customTitle: string | null;
-    bytes: number;
-    lastAt: string | null;
-  }> = [];
-
-  for (const p of projects) {
-    byProject.push({
-      projectId: p.id,
-      decodedCwd: p.decodedCwd,
-      totalBytes: p.totalBytes,
-      sessionCount: p.sessionCount,
-    });
-
-    for (const s of p.sessions) {
-      const total = sessionTotal(s.relatedBytes);
-      const month = s.lastAt ? s.lastAt.slice(0, 7) : 'unknown';
-      const acc = monthMap.get(month) ?? { bytes: 0, count: 0 };
-      acc.bytes += total;
-      acc.count += 1;
-      monthMap.set(month, acc);
-      flat.push({
-        projectId: p.id,
-        sessionId: s.id,
-        title: s.title,
-        customTitle: s.customTitle,
-        bytes: total,
-        lastAt: s.lastAt,
-      });
-    }
-  }
-
-  byProject.sort((a, b) => b.totalBytes - a.totalBytes);
-
-  const byMonth: DiskUsageMonthRow[] = [...monthMap.entries()]
-    .map(([month, v]) => ({ month, totalBytes: v.bytes, sessionCount: v.count }))
-    .sort((a, b) => a.month.localeCompare(b.month));
-
-  const topSessions: DiskUsageTopSession[] = flat
-    .sort((a, b) => b.bytes - a.bytes)
-    .slice(0, TOP_N)
-    .map((f) => ({
-      projectId: f.projectId,
-      sessionId: f.sessionId,
-      title: f.title,
-      customTitle: f.customTitle,
-      totalBytes: f.bytes,
-      lastAt: f.lastAt,
-    }));
-
-  return {
-    byProject,
-    byMonth,
-    topSessions,
-    totalBytes: byProject.reduce((acc, r) => acc + r.totalBytes, 0),
-    totalSessions: flat.length,
-  };
-}
-
-function sessionTotal(r: RelatedBytes): number {
-  return r.jsonl + r.subdir + r.fileHistory + r.sessionEnv;
-}
+import { scanProjectsForDisk } from './scan.ts';
+import type {
+  DiskUsage,
+  DiskUsageMonthRow,
+  DiskUsageProjectRow,
+  DiskUsageTopSession,
+  RelatedBytes,
+} from '../types.ts';
+
+const TOP_N = 20;
+
+export async function computeDiskUsage(): Promise<DiskUsage> {
+  const projects = await scanProjectsForDisk();
+
+  const byProject: DiskUsageProjectRow[] = [];
+  const monthMap = new Map<string, { bytes: number; count: number }>();
+  const flat: Array<{
+    projectId: string;
+    sessionId: string;
+    title: string;
+    customTitle: string | null;
+    bytes: number;
+    lastAt: string | null;
+  }> = [];
+
+  for (const p of projects) {
+    byProject.push({
+      projectId: p.id,
+      decodedCwd: p.decodedCwd,
+      totalBytes: p.totalBytes,
+      sessionCount: p.sessionCount,
+    });
+
+    for (const s of p.sessions) {
+      const total = sessionTotal(s.relatedBytes);
+      const month = s.lastAt ? s.lastAt.slice(0, 7) : 'unknown';
+      const acc = monthMap.get(month) ?? { bytes: 0, count: 0 };
+      acc.bytes += total;
+      acc.count += 1;
+      monthMap.set(month, acc);
+      flat.push({
+        projectId: p.id,
+        sessionId: s.id,
+        title: s.title,
+        customTitle: s.customTitle,
+        bytes: total,
+        lastAt: s.lastAt,
+      });
+    }
+  }
+
+  byProject.sort((a, b) => b.totalBytes - a.totalBytes);
+
+  const byMonth: DiskUsageMonthRow[] = [...monthMap.entries()]
+    .map(([month, v]) => ({ month, totalBytes: v.bytes, sessionCount: v.count }))
+    .sort((a, b) => a.month.localeCompare(b.month));
+
+  const topSessions: DiskUsageTopSession[] = flat
+    .sort((a, b) => b.bytes - a.bytes)
+    .slice(0, TOP_N)
+    .map((f) => ({
+      projectId: f.projectId,
+      sessionId: f.sessionId,
+      title: f.title,
+      customTitle: f.customTitle,
+      totalBytes: f.bytes,
+      lastAt: f.lastAt,
+    }));
+
+  return {
+    byProject,
+    byMonth,
+    topSessions,
+    totalBytes: byProject.reduce((acc, r) => acc + r.totalBytes, 0),
+    totalSessions: flat.length,
+  };
+}
+
+function sessionTotal(r: RelatedBytes): number {
+  return r.jsonl + r.subdir + r.fileHistory + r.sessionEnv;
+}

package/server/lib/encode-cwd.ts

@@ -1,24 +1,24 @@
-import path from 'node:path';
-
-const WIN_DRIVE_DOUBLE_DASH = /^([A-Za-z])--/;
-
-export function decodeCwd(encoded: string): string {
-  if (WIN_DRIVE_DOUBLE_DASH.test(encoded)) {
-    const drive = encoded[0]!.toUpperCase();
-    const rest = encoded.slice(3).replace(/-/g, '\\');
-    return `${drive}:\\${rest}`;
-  }
-  if (encoded.startsWith('-')) {
-    return '/' + encoded.slice(1).replace(/-/g, '/');
-  }
-  return encoded;
-}
-
-export function encodeCwd(cwd: string): string {
-  if (path.isAbsolute(cwd) && /^[A-Za-z]:[\\/]/.test(cwd)) {
-    const drive = cwd[0]!.toUpperCase();
-    const rest = cwd.slice(3).replace(/[\\/]/g, '-');
-    return `${drive}--${rest}`;
-  }
-  return cwd.replace(/\//g, '-');
-}
+import path from 'node:path';
+
+const WIN_DRIVE_DOUBLE_DASH = /^([A-Za-z])--/;
+
+export function decodeCwd(encoded: string): string {
+  if (WIN_DRIVE_DOUBLE_DASH.test(encoded)) {
+    const drive = encoded[0]!.toUpperCase();
+    const rest = encoded.slice(3).replace(/-/g, '\\');
+    return `${drive}:\\${rest}`;
+  }
+  if (encoded.startsWith('-')) {
+    return '/' + encoded.slice(1).replace(/-/g, '/');
+  }
+  return encoded;
+}
+
+export function encodeCwd(cwd: string): string {
+  if (path.isAbsolute(cwd) && /^[A-Za-z]:[\\/]/.test(cwd)) {
+    const drive = cwd[0]!.toUpperCase();
+    const rest = cwd.slice(3).replace(/[\\/]/g, '-');
+    return `${drive}--${rest}`;
+  }
+  return cwd.replace(/\//g, '-');
+}