@zzusp/ccsm 1.0.0

package/server/lib/load-session.ts

@@ -0,0 +1,209 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { PATHS } from './claude-paths.ts';
+import { MAX_SESSION_MESSAGES } from './constants.ts';
+import { SYSTEM_TAG_RE, pickTitleText } from './system-tags.ts';
+import type { Block, Message, SessionDetail, SessionMeta } from '../types.ts';
+
+export async function loadSessionDetail(
+  projectId: string,
+  sessionId: string,
+): Promise<SessionDetail | null> {
+  const jsonlPath = path.join(PATHS.projects, projectId, `${sessionId}.jsonl`);
+  if (!fs.existsSync(jsonlPath)) return null;
+
+  let bytes = 0;
+  let mtimeIso: string | null = null;
+  try {
+    const stat = fs.statSync(jsonlPath);
+    bytes = stat.size;
+    mtimeIso = stat.mtime.toISOString();
+  } catch {
+    /* ignore */
+  }
+
+  const meta: SessionMeta = {
+    sessionId,
+    projectId,
+    cwd: null,
+    gitBranch: null,
+    version: null,
+    firstAt: null,
+    lastAt: null,
+    messageCount: 0,
+    bytes,
+    title: '(untitled)',
+    customTitle: null,
+  };
+
+  const messages: Message[] = [];
+  let truncated = false;
+  // Latest `ai-title` record wins (Claude rewrites it every turn). Kept off
+  // the wire shape; just used to seed `meta.title` once parsing finishes.
+  let aiTitle: string | null = null;
+
+  const rl = readline.createInterface({
+    input: fs.createReadStream(jsonlPath, { encoding: 'utf8' }),
+    crlfDelay: Infinity,
+  });
+
+  for await (const raw of rl) {
+    const line = raw.trim();
+    if (!line) continue;
+    let obj: Record<string, unknown>;
+    try {
+      obj = JSON.parse(line) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+
+    captureMeta(obj, meta);
+    if (obj.type === 'ai-title' && typeof obj.aiTitle === 'string') {
+      aiTitle = obj.aiTitle;
+    }
+
+    if (obj.type !== 'user' && obj.type !== 'assistant') continue;
+    if (messages.length >= MAX_SESSION_MESSAGES) {
+      truncated = true;
+      continue;
+    }
+
+    const msg = buildMessage(obj);
+    if (msg) messages.push(msg);
+  }
+
+  messages.sort((a, b) => (a.ts ?? '').localeCompare(b.ts ?? ''));
+
+  // Match `parseJsonlMeta`: file mtime advances on untimestamped meta rewrites
+  // (ai-title rotate, rename), so fold it into lastAt to stay in sync with
+  // `claude code resume`.
+  if (mtimeIso && (!meta.lastAt || mtimeIso > meta.lastAt)) {
+    meta.lastAt = mtimeIso;
+  }
+
+  meta.messageCount = messages.length;
+  meta.title = aiTitle || deriveAutoTitle(messages);
+  return { meta, messages, truncated };
+}
+
+function captureMeta(obj: Record<string, unknown>, meta: SessionMeta): void {
+  if (typeof obj.cwd === 'string' && !meta.cwd) meta.cwd = obj.cwd;
+  if (typeof obj.gitBranch === 'string' && !meta.gitBranch) meta.gitBranch = obj.gitBranch;
+  if (typeof obj.version === 'string' && !meta.version) meta.version = obj.version;
+  if (obj.type === 'custom-title' && typeof obj.customTitle === 'string') {
+    meta.customTitle = obj.customTitle;
+  }
+  const ts = typeof obj.timestamp === 'string' ? obj.timestamp : null;
+  if (ts) {
+    if (!meta.firstAt) meta.firstAt = ts;
+    meta.lastAt = ts;
+  }
+}
+
+function deriveAutoTitle(messages: Message[]): string {
+  for (const m of messages) {
+    if (m.type !== 'user' || m.isMeta) continue;
+    for (const block of m.blocks) {
+      if (block.type !== 'text') continue;
+      const usable = pickTitleText(block.text);
+      if (!usable) continue;
+      const line = usable.trim().split('\n')[0] ?? '';
+      if (!line) continue;
+      return line.length > 80 ? line.slice(0, 80) + '…' : line;
+    }
+  }
+  return '(untitled)';
+}
+
+function buildMessage(obj: Record<string, unknown>): Message | null {
+  const type = obj.type === 'user' ? 'user' : 'assistant';
+  const message = (obj.message ?? {}) as { content?: unknown; model?: unknown };
+  const blocks = parseContent(message.content);
+
+  let isMeta = false;
+  if (type === 'user' && blocks.length === 1 && blocks[0]!.type === 'text') {
+    if (SYSTEM_TAG_RE.test(blocks[0]!.text)) isMeta = true;
+  }
+
+  return {
+    uuid: typeof obj.uuid === 'string' ? obj.uuid : '',
+    parentUuid: typeof obj.parentUuid === 'string' ? obj.parentUuid : null,
+    type,
+    ts: typeof obj.timestamp === 'string' ? obj.timestamp : null,
+    model: typeof message.model === 'string' ? message.model : null,
+    blocks,
+    isMeta,
+  };
+}
+
+function parseContent(content: unknown): Block[] {
+  if (typeof content === 'string') {
+    return [{ type: 'text', text: content }];
+  }
+  if (!Array.isArray(content)) return [];
+
+  const out: Block[] = [];
+  for (const raw of content) {
+    if (!raw || typeof raw !== 'object') continue;
+    const b = raw as Record<string, unknown>;
+    switch (b.type) {
+      case 'text':
+        out.push({ type: 'text', text: typeof b.text === 'string' ? b.text : '' });
+        break;
+      case 'tool_use':
+        out.push({
+          type: 'tool_use',
+          id: typeof b.id === 'string' ? b.id : '',
+          name: typeof b.name === 'string' ? b.name : '(unknown)',
+          input: b.input ?? null,
+        });
+        break;
+      case 'tool_result':
+        out.push({
+          type: 'tool_result',
+          toolUseId: typeof b.tool_use_id === 'string' ? b.tool_use_id : '',
+          content: stringifyToolResult(b.content),
+          isError: b.is_error === true,
+        });
+        break;
+      case 'thinking':
+        out.push({
+          type: 'thinking',
+          text: typeof b.thinking === 'string' ? b.thinking : '',
+        });
+        break;
+      case 'image': {
+        const src = b.source as { media_type?: unknown } | undefined;
+        out.push({
+          type: 'image',
+          mediaType: typeof src?.media_type === 'string' ? src.media_type : null,
+        });
+        break;
+      }
+      default:
+        out.push({ type: 'unknown', raw: b });
+    }
+  }
+  return out;
+}
+
+function stringifyToolResult(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((b) => {
+        if (b && typeof b === 'object' && (b as { type?: unknown }).type === 'text') {
+          const t = (b as { text?: unknown }).text;
+          return typeof t === 'string' ? t : '';
+        }
+        if (b && typeof b === 'object' && (b as { type?: unknown }).type === 'image') {
+          return '[image]';
+        }
+        return '';
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+  return '';
+}

package/server/lib/open-folder.ts

@@ -0,0 +1,40 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+
+export interface OpenFolderResult {
+  ok: boolean;
+  error?: string;
+}
+
+export function openFolder(folderPath: string): OpenFolderResult {
+  try {
+    const st = fs.statSync(folderPath);
+    if (!st.isDirectory()) return { ok: false, error: 'not a directory' };
+  } catch {
+    return { ok: false, error: 'path not found' };
+  }
+
+  let cmd: string;
+  let args: string[];
+  if (process.platform === 'win32') {
+    cmd = 'explorer.exe';
+    args = [folderPath];
+  } else if (process.platform === 'darwin') {
+    cmd = 'open';
+    args = [folderPath];
+  } else {
+    cmd = 'xdg-open';
+    args = [folderPath];
+  }
+
+  try {
+    const child = spawn(cmd, args, { detached: true, stdio: 'ignore' });
+    child.on('error', (err) => {
+      console.error(`[open-folder] spawn ${cmd} failed:`, err);
+    });
+    child.unref();
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: (err as Error).message };
+  }
+}

package/server/lib/parse-jsonl.ts

@@ -0,0 +1,107 @@
+import fs from 'node:fs';
+import readline from 'node:readline';
+import { SYSTEM_TAG_RE, pickTitleText } from './system-tags.ts';
+
+export interface JsonlMeta {
+  title: string;
+  /** Latest `custom-title` record value, or null if never renamed. */
+  customTitle: string | null;
+  firstAt: string | null;
+  lastAt: string | null;
+  messageCount: number;
+  cwdFromMessages: string | null;
+}
+
+export async function parseJsonlMeta(filePath: string): Promise<JsonlMeta> {
+  let firstUserTitle = '';
+  let aiTitle: string | null = null;
+  let customTitle: string | null = null;
+  let firstAt: string | null = null;
+  let lastAt: string | null = null;
+  let messageCount = 0;
+  let cwdFromMessages: string | null = null;
+
+  const rl = readline.createInterface({
+    input: fs.createReadStream(filePath, { encoding: 'utf8' }),
+    crlfDelay: Infinity,
+  });
+
+  for await (const raw of rl) {
+    const line = raw.trim();
+    if (!line) continue;
+    let obj: Record<string, unknown>;
+    try {
+      obj = JSON.parse(line) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+
+    const ts = typeof obj.timestamp === 'string' ? obj.timestamp : null;
+    if (ts) {
+      if (!firstAt) firstAt = ts;
+      lastAt = ts;
+    }
+
+    if (obj.cwd && typeof obj.cwd === 'string' && !cwdFromMessages) {
+      cwdFromMessages = obj.cwd;
+    }
+
+    if (obj.type === 'custom-title' && typeof obj.customTitle === 'string') {
+      customTitle = obj.customTitle;
+    }
+
+    // Claude Code rewrites this record every turn; the latest copy is canonical.
+    if (obj.type === 'ai-title' && typeof obj.aiTitle === 'string') {
+      aiTitle = obj.aiTitle;
+    }
+
+    if (obj.type === 'user' || obj.type === 'assistant') {
+      messageCount += 1;
+
+      if (!firstUserTitle && obj.type === 'user') {
+        const msg = obj.message as { content?: unknown } | undefined;
+        const candidate = extractUserText(msg?.content);
+        if (candidate && !SYSTEM_TAG_RE.test(candidate)) {
+          const usable = pickTitleText(candidate);
+          if (usable) {
+            firstUserTitle = usable.slice(0, 80).replace(/\s+/g, ' ').trim();
+          }
+        }
+      }
+    }
+  }
+
+  // `claude code resume` keys off file mtime, which advances even when Claude Code
+  // rewrites untimestamped meta records (ai-title rotate, custom-title/agent-name on
+  // rename, last-prompt, permission-mode). Reconcile so the UI agrees with resume.
+  const mtimeIso = fs.statSync(filePath).mtime.toISOString();
+  const reconciledLastAt = !lastAt || mtimeIso > lastAt ? mtimeIso : lastAt;
+
+  return {
+    title: aiTitle || firstUserTitle || '(untitled)',
+    customTitle,
+    firstAt,
+    lastAt: reconciledLastAt,
+    messageCount,
+    cwdFromMessages,
+  };
+}
+
+function extractUserText(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (
+        block &&
+        typeof block === 'object' &&
+        'type' in block &&
+        block.type === 'text' &&
+        'text' in block &&
+        typeof (block as { text: unknown }).text === 'string'
+      ) {
+        return (block as { text: string }).text;
+      }
+    }
+  }
+  return '';
+}

package/server/lib/port.ts

@@ -0,0 +1,23 @@
+import { createServer } from 'node:net';
+
+export async function findAvailablePort(
+  start: number,
+  end: number,
+  host = '127.0.0.1',
+): Promise<number> {
+  for (let port = start; port <= end; port++) {
+    if (await isPortFree(port, host)) return port;
+  }
+  throw new Error(`No free port in range ${start}..${end} on ${host}`);
+}
+
+function isPortFree(port: number, host: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, host);
+  });
+}

package/server/lib/safe-id.ts

@@ -0,0 +1,6 @@
+export function isSafeId(id: string): boolean {
+  if (!id) return false;
+  if (id.includes('/') || id.includes('\\') || id.includes('..')) return false;
+  if (id.startsWith('.')) return false;
+  return true;
+}

package/server/lib/scan.ts

@@ -0,0 +1,183 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PATHS } from './claude-paths.ts';
+import { RECENT_ACTIVITY_WINDOW_MS } from './constants.ts';
+import { decodeCwd } from './encode-cwd.ts';
+import { dirSize, fileSize } from './fs-size.ts';
+import { parseJsonlMeta } from './parse-jsonl.ts';
+import { buildActiveSessionMap } from './active-sessions.ts';
+import type { ProjectSummary, RelatedBytes, SessionSummary } from '../types.ts';
+
+const JSONL_EXT = '.jsonl';
+
+function listSessionIdsInProject(projectDir: string): string[] {
+  if (!fs.existsSync(projectDir)) return [];
+  const ids: string[] = [];
+  for (const ent of fs.readdirSync(projectDir, { withFileTypes: true })) {
+    if (ent.isFile() && ent.name.endsWith(JSONL_EXT)) {
+      ids.push(ent.name.slice(0, -JSONL_EXT.length));
+    }
+  }
+  return ids;
+}
+
+function decodeProjectId(encoded: string, sampleCwd: string | null): {
+  decoded: string;
+  resolved: boolean;
+} {
+  if (sampleCwd) return { decoded: sampleCwd, resolved: true };
+  const decoded = decodeCwd(encoded);
+  let resolved = false;
+  try {
+    resolved = fs.statSync(decoded).isDirectory();
+  } catch {
+    resolved = false;
+  }
+  return { decoded, resolved };
+}
+
+export async function resolveProjectCwd(
+  projectId: string,
+): Promise<{ decoded: string; resolved: boolean } | null> {
+  const projectDir = path.join(PATHS.projects, projectId);
+  if (!fs.existsSync(projectDir)) return null;
+
+  const sessionIds = listSessionIdsInProject(projectDir);
+  let sampleCwd: string | null = null;
+  for (const id of sessionIds) {
+    const jsonlPath = path.join(projectDir, `${id}${JSONL_EXT}`);
+    if (!fs.existsSync(jsonlPath)) continue;
+    const meta = await parseJsonlMeta(jsonlPath);
+    if (meta.cwdFromMessages) {
+      sampleCwd = meta.cwdFromMessages;
+      break;
+    }
+  }
+  return decodeProjectId(projectId, sampleCwd);
+}
+
+export async function listProjects(): Promise<ProjectSummary[]> {
+  if (!fs.existsSync(PATHS.projects)) return [];
+  const result: ProjectSummary[] = [];
+
+  for (const ent of fs.readdirSync(PATHS.projects, { withFileTypes: true })) {
+    if (!ent.isDirectory()) continue;
+    const projectId = ent.name;
+    const projectDir = path.join(PATHS.projects, projectId);
+
+    const sessionIds = listSessionIdsInProject(projectDir);
+    let sampleCwd: string | null = null;
+    let totalBytes = 0;
+    let lastActiveAt: string | null = null;
+
+    for (const id of sessionIds) {
+      const jsonlPath = path.join(projectDir, `${id}${JSONL_EXT}`);
+      const subdirPath = path.join(projectDir, id);
+      totalBytes += fileSize(jsonlPath);
+      totalBytes += dirSize(subdirPath);
+      totalBytes += dirSize(path.join(PATHS.fileHistory, id));
+      totalBytes += dirSize(path.join(PATHS.sessionEnv, id));
+
+      if (!sampleCwd && fs.existsSync(jsonlPath)) {
+        const meta = await parseJsonlMeta(jsonlPath);
+        sampleCwd = meta.cwdFromMessages;
+        if (meta.lastAt && (!lastActiveAt || meta.lastAt > lastActiveAt)) {
+          lastActiveAt = meta.lastAt;
+        }
+      } else if (fs.existsSync(jsonlPath)) {
+        try {
+          const mtime = fs.statSync(jsonlPath).mtime.toISOString();
+          if (!lastActiveAt || mtime > lastActiveAt) lastActiveAt = mtime;
+        } catch {
+          // ignore
+        }
+      }
+    }
+
+    const { decoded, resolved } = decodeProjectId(projectId, sampleCwd);
+
+    result.push({
+      id: projectId,
+      encodedCwd: projectId,
+      decodedCwd: decoded,
+      cwdResolved: resolved,
+      sessionCount: sessionIds.length,
+      totalBytes,
+      lastActiveAt,
+    });
+  }
+
+  result.sort((a, b) => {
+    const at = a.lastActiveAt ?? '';
+    const bt = b.lastActiveAt ?? '';
+    return bt.localeCompare(at);
+  });
+  return result;
+}
+
+export async function listSessionsForProject(projectId: string): Promise<SessionSummary[]> {
+  const projectDir = path.join(PATHS.projects, projectId);
+  if (!fs.existsSync(projectDir)) return [];
+
+  const activeMap = buildActiveSessionMap();
+  const ids = listSessionIdsInProject(projectDir);
+  const out: SessionSummary[] = [];
+
+  for (const id of ids) {
+    const jsonlPath = path.join(projectDir, `${id}${JSONL_EXT}`);
+    const subdirPath = path.join(projectDir, id);
+    const fhPath = path.join(PATHS.fileHistory, id);
+    const sePath = path.join(PATHS.sessionEnv, id);
+
+    const related: RelatedBytes = {
+      jsonl: fileSize(jsonlPath),
+      subdir: dirSize(subdirPath),
+      fileHistory: dirSize(fhPath),
+      sessionEnv: dirSize(sePath),
+    };
+
+    let title = '(no jsonl)';
+    let customTitle: string | null = null;
+    let firstAt: string | null = null;
+    let lastAt: string | null = null;
+    let messageCount = 0;
+
+    if (fs.existsSync(jsonlPath)) {
+      const meta = await parseJsonlMeta(jsonlPath);
+      title = meta.title;
+      customTitle = meta.customTitle;
+      firstAt = meta.firstAt;
+      lastAt = meta.lastAt;
+      messageCount = meta.messageCount;
+    }
+
+    const livePid = activeMap.get(id) ?? null;
+    let isRecentlyActive = false;
+    if (fs.existsSync(jsonlPath)) {
+      try {
+        const mtimeMs = fs.statSync(jsonlPath).mtimeMs;
+        isRecentlyActive = Date.now() - mtimeMs < RECENT_ACTIVITY_WINDOW_MS;
+      } catch {
+        // ignore
+      }
+    }
+
+    out.push({
+      id,
+      projectId,
+      title,
+      customTitle,
+      firstAt,
+      lastAt,
+      messageCount,
+      bytes: related.jsonl,
+      relatedBytes: related,
+      isLivePid: livePid !== null,
+      isRecentlyActive,
+      livePid,
+    });
+  }
+
+  out.sort((a, b) => (b.lastAt ?? '').localeCompare(a.lastAt ?? ''));
+  return out;
+}

package/server/lib/search-all.ts

@@ -0,0 +1,130 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PATHS, isUnderClaudeRoot } from './claude-paths.ts';
+import { decodeCwd } from './encode-cwd.ts';
+import { isSafeId } from './safe-id.ts';
+import { parseJsonlMeta } from './parse-jsonl.ts';
+import { searchSessionFile, type SearchSessionOpts } from './search-session.ts';
+import type { SearchBlockKind, SearchEvent, SearchSessionHit } from '../types.ts';
+
+const JSONL_EXT = '.jsonl';
+
+export interface SearchAllOpts {
+  query: string;
+  include: ReadonlySet<SearchBlockKind>;
+  perSession: number;
+  maxSessions: number;
+}
+
+interface SessionFileEntry {
+  projectId: string;
+  sessionId: string;
+  filePath: string;
+  mtimeMs: number;
+}
+
+export async function* searchAll(opts: SearchAllOpts): AsyncGenerator<SearchEvent> {
+  const startedAt = Date.now();
+  const files = enumerateSessionFiles();
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+
+  const sessionOpts: SearchSessionOpts = {
+    include: opts.include,
+    perSession: opts.perSession,
+  };
+
+  let scanned = 0;
+  let matched = 0;
+  let truncated = false;
+
+  for (const entry of files) {
+    if (matched >= opts.maxSessions) {
+      truncated = true;
+      break;
+    }
+    scanned++;
+
+    let result;
+    try {
+      result = await searchSessionFile(entry.filePath, opts.query, sessionOpts);
+    } catch {
+      continue;
+    }
+    if (result.snippets.length === 0) continue;
+
+    let meta;
+    try {
+      meta = await parseJsonlMeta(entry.filePath);
+    } catch {
+      continue;
+    }
+
+    matched++;
+    const decodedCwd = meta.cwdFromMessages ?? decodeCwd(entry.projectId);
+    const hit: SearchSessionHit = {
+      type: 'session',
+      projectId: entry.projectId,
+      sessionId: entry.sessionId,
+      projectDecodedCwd: decodedCwd,
+      title: meta.title,
+      customTitle: meta.customTitle,
+      lastAt: meta.lastAt,
+      hasMore: result.hasMore,
+      snippets: result.snippets,
+    };
+    yield hit;
+  }
+
+  yield {
+    type: 'done',
+    scanned,
+    matched,
+    durationMs: Date.now() - startedAt,
+    truncated,
+  };
+}
+
+function enumerateSessionFiles(): SessionFileEntry[] {
+  if (!fs.existsSync(PATHS.projects)) return [];
+  const out: SessionFileEntry[] = [];
+
+  let projects: fs.Dirent[];
+  try {
+    projects = fs.readdirSync(PATHS.projects, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+
+  for (const projEnt of projects) {
+    if (!projEnt.isDirectory()) continue;
+    if (!isSafeId(projEnt.name)) continue;
+    const projectId = projEnt.name;
+    const projectDir = path.join(PATHS.projects, projectId);
+    if (!isUnderClaudeRoot(projectDir)) continue;
+
+    let files: fs.Dirent[];
+    try {
+      files = fs.readdirSync(projectDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const fileEnt of files) {
+      if (!fileEnt.isFile() || !fileEnt.name.endsWith(JSONL_EXT)) continue;
+      const sessionId = fileEnt.name.slice(0, -JSONL_EXT.length);
+      if (!isSafeId(sessionId)) continue;
+      const filePath = path.join(projectDir, fileEnt.name);
+      if (!isUnderClaudeRoot(filePath)) continue;
+
+      let mtimeMs = 0;
+      try {
+        mtimeMs = fs.statSync(filePath).mtimeMs;
+      } catch {
+        continue;
+      }
+      out.push({ projectId, sessionId, filePath, mtimeMs });
+    }
+  }
+
+  return out;
+}