@scrylog/cli 0.3.0 → 0.3.2

package/src/daemon/collectors/claude/collector.ts

@@ -1,423 +0,0 @@
-import { existsSync, statSync, unwatchFile, watch, watchFile } from "node:fs";
-import type { FSWatcher } from "node:fs";
-import { join, basename, dirname } from "node:path";
-import type { ScrylogConfig } from "../../../shared/config";
-import type { SessionModel } from "../../../shared/types";
-import type { DaemonStore } from "../../store";
-import type { Collector } from "../../scheduler";
-import type { Logger } from "../../../shared/logger";
-import { NOOP_LOGGER } from "../../../shared/logger";
-import { ensureHooksDirSafe } from "../../../shared/platform";
-import type { GitCollector } from "../git";
-import { parseJsonlFile, parseJsonlHead } from "./jsonl";
-import { inferState, extractSummary, extractTitle, isLocalCommandTranscript } from "./transcript";
-import { ClaudeHookFileData, isValidHookData, readHookData, isHookNewer, getHookTime, getExistingHookData, mergeHookIntoModel, mergeClaudeMeta, hasClaudePermissionPrompt } from "./hooks";
-import { discoverTranscripts, getClaudeDir, decodeClaudeProjectSlug, getClaudeProcessPids } from "./discovery";
-
-interface WatchedTranscript {
-  sessionId: string;
-  path: string;
-  lastModified: number;
-  size: number;
-  processedLastModified?: number;
-  processedSize?: number;
-}
-
-export class ClaudeCollector implements Collector {
-  name = "claude";
-  private store?: DaemonStore;
-  private config?: ScrylogConfig;
-  private logger: Logger = NOOP_LOGGER;
-  private watched = new Map<string, WatchedTranscript>();
-  private hookWatched = new Set<string>();
-  private hookDirWatcher?: FSWatcher;
-  private lastProcessedSeq = new Map<string, number>();
-  private discoveryTimer?: ReturnType<typeof setInterval>;
-  private fallbackTimer?: ReturnType<typeof setInterval>;
-
-  constructor(private readonly gitCollector?: GitCollector) {}
-
-  async start(store: DaemonStore, config: ScrylogConfig, logger: Logger): Promise<void> {
-    this.store = store;
-    this.config = config;
-    this.logger = logger;
-
-    const claudeDir = getClaudeDir(config);
-    logger.info("claude", "Collector started", { event: "collector.started", collector: this.name, claudeDir, hooksEnabled: config.claude.hooksEnabled });
-
-    if (config.claude.hooksEnabled) {
-      this.startHooksDirWatcher(config.claude.hooksDir);
-    }
-
-    this.run();
-    this.discoveryTimer = setInterval(() => this.run(), 30_000);
-    this.fallbackTimer = setInterval(() => this.rereadWatched(), 5_000);
-  }
-
-  async stop(): Promise<void> {
-    if (this.discoveryTimer) clearInterval(this.discoveryTimer);
-    if (this.fallbackTimer) clearInterval(this.fallbackTimer);
-
-    for (const { path } of this.watched.values()) {
-      try { unwatchFile(path); } catch { /* ignore */ }
-    }
-    this.watched.clear();
-
-    for (const hookFile of this.hookWatched) {
-      try { unwatchFile(hookFile); } catch { /* ignore */ }
-    }
-    this.hookWatched.clear();
-    this.lastProcessedSeq.clear();
-
-    if (this.hookDirWatcher) {
-      try { this.hookDirWatcher.close(); } catch { /* ignore */ }
-      this.hookDirWatcher = undefined;
-    }
-
-    this.logger.info("claude", "Collector stopped", { event: "collector.stopped", collector: this.name });
-  }
-
-  // ── Internal ───────────────────────────────────────────────────────────────
-
-  private run(): void {
-    const store = this.store!;
-    const config = this.config!;
-    const claudeDir = getClaudeDir(config);
-
-    // Build set of session IDs that are hook-managed, so discoverTranscripts
-    // can include their transcripts even past the 24h cutoff.
-    const hookManagedIds = new Set<string>();
-    for (const session of store.getSessions()) {
-      if (session.detectionSource === "claude-hook" && session.tool === "claude") {
-        hookManagedIds.add(session.claude?.sessionId ?? session.id.replace(/^claude:/, ""));
-      }
-    }
-
-    const transcripts = discoverTranscripts(claudeDir, hookManagedIds);
-    const processSnapshot = this.store?.getCollectorProcessSnapshot?.() ?? [];
-    const runningPids = getClaudeProcessPids(this.logger, config.daemon?.commandTimeoutMs, processSnapshot);
-    const hasRunning = runningPids.length > 0;
-
-    this.logger.debug("claude", "Discovery cycle", {
-      event: "collector.discovery_completed",
-      collector: this.name,
-      claudeDir,
-      transcripts: transcripts.length,
-      runningPids: runningPids.length,
-      hasRunning,
-    });
-
-    for (const transcript of transcripts) {
-      this.processTranscript(transcript, hasRunning);
-    }
-
-    const trackedPaths = new Set(transcripts.map((t) => t.path));
-    for (const path of trackedPaths) {
-      if (!this.watched.has(path)) {
-        const transcript = transcripts.find((t) => t.path === path);
-        if (!transcript) continue;
-        this.watched.set(path, transcript);
-        this.logger.debug("claude", "Watching transcript", { sessionId: transcript.sessionId, path });
-        watchFile(path, { interval: 2000 }, () => {
-          const t = this.watched.get(path);
-          if (t) this.processTranscript(t, true);
-        });
-      }
-    }
-
-    for (const [path, transcript] of this.watched) {
-      if (!trackedPaths.has(path)) {
-        try { unwatchFile(path); } catch { /* ignore */ }
-        this.watched.delete(path);
-        this.logger.debug("claude", "Stopped watching transcript", { sessionId: transcript.sessionId });
-        // Don't remove hook-managed sessions — they have an authoritative lifecycle
-        // managed by hooks (SessionEnd). Only remove transcript-sourced sessions.
-        const existingSession = store.getSession(`claude:${transcript.sessionId}`);
-        if (existingSession?.detectionSource !== "claude-hook" && existingSession?.source === "standalone") {
-          store.removeSession(`claude:${transcript.sessionId}`);
-        }
-      }
-    }
-
-    store.setCollectorStatus(this.name, { running: true, lastRunAt: Date.now() });
-  }
-
-  private processTranscript(transcript: import("./discovery").DiscoveredTranscript, _hasRunning: boolean): void {
-    const store = this.store!;
-    const config = this.config!;
-
-    // Do not re-add sessions that were explicitly ended via SessionEnd hook.
-    // The transcript file persists on disk after the session ends; without this
-    // guard, the discovery cycle would recreate the session immediately after
-    // the webhook removed it.
-    if (store.isLocalCommand(transcript.sessionId)) {
-      store.removeSession(`claude:${transcript.sessionId}`);
-      return;
-    }
-
-    const existingSession = store.getSession(`claude:${transcript.sessionId}`);
-    const watched = this.watched.get(transcript.path);
-    if (
-      watched?.processedLastModified === transcript.lastModified
-      && watched.processedSize === transcript.size
-      && existingSession
-    ) {
-      return;
-    }
-
-    const transcriptMaxBytes = config.retention?.transcriptMaxBytes;
-    const entries = parseJsonlFile(transcript.path, transcriptMaxBytes);
-    const localCommandEntries = transcriptMaxBytes && transcript.size > transcriptMaxBytes
-      ? parseJsonlHead(transcript.path, Math.min(transcriptMaxBytes, 64 * 1024))
-      : entries;
-
-    // Skip headless batch runs — they are not interactive sessions
-    if (isLocalCommandTranscript(localCommandEntries)) {
-      this.logger.debug("claude", "Skipping local-command transcript", { sessionId: transcript.sessionId });
-      store.removeSession(`claude:${transcript.sessionId}`);
-      store.markLocalCommand(transcript.sessionId);
-      this.lastProcessedSeq.delete(transcript.sessionId);
-      return;
-    }
-
-    const state = inferState(entries);
-    const summary = extractSummary(entries);
-    const title = extractTitle(entries);
-
-    let model: SessionModel = {
-      id: `claude:${transcript.sessionId}`,
-      source: "standalone",
-      tool: "claude",
-      state,
-      // Use first user message as title when available, falling back to summary
-      summary: title ?? summary,
-      lastActivity: transcript.lastModified,
-      claude: {
-        sessionId: transcript.sessionId,
-        transcriptPath: transcript.path,
-      },
-      hasAttention: state === "waiting-input",
-      detectionSource: "claude-transcript",
-    };
-
-    // If the session is already managed by hooks, the transcript must never
-    // overwrite state, hasAttention, or activeTool. It can only fill missing
-    // metadata (e.g. transcriptPath).
-    if (existingSession?.detectionSource === "claude-hook") {
-      model = {
-        ...model,
-        state: existingSession.state,
-        hasAttention: existingSession.hasAttention,
-        summary: existingSession.summary || model.summary,
-        activeTool: existingSession.activeTool,
-        detectionSource: "claude-hook",
-        claude: mergeClaudeMeta(
-          {
-            sessionId: existingSession.claude?.sessionId ?? transcript.sessionId,
-            transcriptPath: existingSession.claude?.transcriptPath || transcript.path,
-          },
-          existingSession.claude ?? {},
-        ),
-        lastActivity: existingSession.lastActivity,
-      };
-    } else if (config.claude.hooksEnabled) {
-      // Hooks are authoritative for live session state. The transcript is only
-      // used for discovery and to fill metadata hooks do not provide.
-      const fileHookData = readHookData(config.claude.hooksDir, transcript.sessionId);
-      const storeHookData = getExistingHookData(existingSession);
-      const preferredHookData = [fileHookData, storeHookData]
-        .filter((value): value is Partial<SessionModel> => value !== null)
-        .sort((a, b) => getHookTime(b) - getHookTime(a))[0];
-
-      if (preferredHookData && getHookTime(preferredHookData) >= transcript.lastModified && isHookNewer(existingSession, preferredHookData)) {
-        model = mergeHookIntoModel(model, preferredHookData, transcript.path);
-      }
-    }
-
-    // Apply tmux-based permission prompt detection only for sessions NOT
-    // managed by hooks, since hook-managed sessions get authoritative state
-    // from the PermissionRequest event.
-    if (model.detectionSource !== "claude-hook" && hasClaudePermissionPrompt(existingSession?.sample)) {
-      model = { ...model, state: "waiting-input", hasAttention: true, summary: "Do you want to proceed?" };
-    }
-
-    // Resolve git project info from currentPath (populated by hooks or transcript)
-    // Fallback: decode the project path from the transcript directory slug when hooks
-    // have not provided a currentPath (e.g. transcript-only sessions or sessions whose
-    // hook file is absent).
-    if (!model.currentPath) {
-      const slug = basename(dirname(transcript.path));
-      const decoded = decodeClaudeProjectSlug(slug);
-      if (decoded) model = { ...model, currentPath: decoded };
-    }
-    if (this.gitCollector && model.currentPath && !model.project) {
-      const project = this.gitCollector.resolve(model.currentPath);
-      if (project) model = { ...model, project };
-    }
-
-    store.upsertSession(model);
-    const currentWatched = this.watched.get(transcript.path);
-    if (currentWatched) {
-      this.watched.set(transcript.path, {
-        ...currentWatched,
-        lastModified: transcript.lastModified,
-        size: transcript.size,
-        processedLastModified: transcript.lastModified,
-        processedSize: transcript.size,
-      });
-    }
-    this.logger.debug("claude", "Processed transcript", { event: "transcript.processed", sessionId: transcript.sessionId, state, detectionSource: model.detectionSource, path: transcript.path });
-
-    this.syncChildSessionIds();
-  }
-
-  /** Re-process all watched transcripts (fallback polling) */
-  private rereadWatched(): void {
-    for (const transcript of this.watched.values()) {
-      try {
-        const stat = statSync(transcript.path);
-        this.processTranscript({ ...transcript, lastModified: stat.mtimeMs, size: stat.size }, true);
-      } catch {
-        // File may have been removed
-      }
-    }
-  }
-
-  /** Watch the hooks directory for new/changed files so state updates are near-immediate */
-  private startHooksDirWatcher(hooksDir: string): void {
-    try {
-      ensureHooksDirSafe(hooksDir);
-    } catch {
-      // Directory may be unwritable or fail ownership/permission validation — handled below
-    }
-
-    if (!existsSync(hooksDir)) {
-      this.logger.debug("claude", "Hooks dir not found — skipping watcher", { hooksDir });
-      return;
-    }
-
-    // Watch for new files appearing in the hooks dir
-    try {
-      this.hookDirWatcher = watch(hooksDir, (eventType, filename) => {
-        if (!filename || !filename.endsWith(".json")) return;
-        const sessionId = basename(filename, ".json");
-        this.onHookFileChanged(hooksDir, sessionId, filename);
-      });
-    } catch {
-      this.logger.debug("claude", "Could not watch hooks dir", { hooksDir });
-    }
-  }
-
-  /** Called when a hook file is created or modified */
-  private onHookFileChanged(hooksDir: string, sessionId: string, filename: string): void {
-    const hookFile = join(hooksDir, filename);
-
-    // Start watching this specific file if not already
-    if (!this.hookWatched.has(hookFile)) {
-      this.hookWatched.add(hookFile);
-      watchFile(hookFile, { interval: 500 }, () => {
-        this.onHookFileChanged(hooksDir, sessionId, filename);
-      });
-    }
-
-    // Skip duplicate processing: if the hookSeq hasn't changed, this is a
-    // redundant event from the directory watcher and per-file watchFile.
-    const hookData = readHookData(hooksDir, sessionId);
-    if (!hookData) {
-      // Hook file was deleted (SessionEnd) — clean up watcher
-      this.unwatchHookFile(hookFile);
-      return;
-    }
-    const incomingSeq = hookData.claude?.hookSeq ?? 0;
-    const lastSeq = this.lastProcessedSeq.get(sessionId) ?? -1;
-    if (incomingSeq <= lastSeq) return;
-    this.lastProcessedSeq.set(sessionId, incomingSeq);
-
-    this.logger.debug("claude", "Hook received — refreshing session", { event: "integration.event_received", sessionId, hookSeq: incomingSeq });
-
-    // Find the corresponding transcript to re-process
-    const transcriptEntry = [...this.watched.values()].find((t) => t.sessionId === sessionId);
-    if (transcriptEntry) {
-      try {
-        const stat = statSync(transcriptEntry.path);
-        this.processTranscript({ ...transcriptEntry, lastModified: stat.mtimeMs, size: stat.size }, true);
-      } catch {
-        // Transcript may have been removed
-      }
-      return;
-    }
-
-    // The transcript may not be watched yet (e.g. a sub-agent session created by SubagentStop hook).
-    // hookData was already read above for dedup — use it to create a minimal session entry.
-
-    const existing = this.store!.getSession(`claude:${sessionId}`);
-    if (existing && !isHookNewer(existing, hookData)) {
-      return;
-    }
-    if (existing) {
-      // Merge hook data into existing session
-      const mergedSummary = hookData.summary ?? existing.summary;
-      this.store!.upsertSession({
-        ...existing,
-        ...hookData,
-        id: existing.id,
-        source: existing.source,
-        summary: mergedSummary,
-        lastActivity: (hookData.lastActivity as number | undefined) ?? existing.lastActivity,
-        activeTool: hookData.activeTool ?? existing.activeTool,
-        claude: mergeClaudeMeta(
-          {
-            sessionId,
-            transcriptPath: (hookData.claude?.transcriptPath || existing.claude?.transcriptPath || "") as string,
-          },
-          hookData.claude ?? {},
-        ),
-      });
-      this.logger.debug("claude", "Hook merged into session (no transcript)", { event: "session.upsert_from_hook", sessionId, state: hookData.state });
-    } else {
-      // Minimal stub for a sub-agent session discovered only via hook (e.g. SubagentStop)
-      const currentPath = hookData.currentPath as string | undefined;
-      const project = (this.gitCollector && currentPath)
-        ? this.gitCollector.resolve(currentPath) ?? undefined
-        : undefined;
-      const stub: SessionModel = {
-        id: `claude:${sessionId}`,
-        source: "standalone",
-        tool: "claude",
-        state: (hookData.state as SessionModel["state"]) ?? "idle",
-        summary: hookData.summary ?? "Claude sub-agent",
-        lastActivity: (hookData.lastActivity as number) ?? Date.now(),
-        hasAttention: hookData.hasAttention,
-        activeTool: hookData.activeTool,
-        currentPath,
-        project,
-        parentSessionId: hookData.parentSessionId,
-        detectionSource: "claude-hook",
-        claude: mergeClaudeMeta(
-          {
-            sessionId,
-            transcriptPath: (hookData.claude?.transcriptPath ?? "") as string,
-          },
-          hookData.claude ?? {},
-        ),
-      };
-      this.store!.upsertSession(stub);
-      this.logger.debug("claude", "Sub-agent session created from hook", { event: "session.upsert_from_hook", sessionId, parentSessionId: hookData.parentSessionId, state: stub.state });
-    }
-
-    this.syncChildSessionIds();
-  }
-
-  /** Stop watching a per-file watcher and clean up tracking state */
-  private unwatchHookFile(hookFile: string): void {
-    if (this.hookWatched.has(hookFile)) {
-      this.hookWatched.delete(hookFile);
-      try { unwatchFile(hookFile); } catch { /* ignore */ }
-    }
-  }
-
-  /** Rebuild childSessionIds on parent sessions after any session upsert */
-  private syncChildSessionIds(): void {
-    this.store!.syncChildSessionIds();
-  }
-}

package/src/daemon/collectors/claude/discovery.ts

@@ -1,127 +0,0 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, basename, dirname } from "node:path";
-import type { ScrylogConfig } from "../../../shared/config";
-import type { Logger } from "../../../shared/logger";
-import { maybeRunCommand } from "../../../shared/utils";
-import { IS_WINDOWS } from "../../../shared/platform";
-import { isKnownClaudeProbePath } from "../../../shared/session-exclusions";
-
-export interface DiscoveredTranscript {
-  sessionId: string;
-  path: string;
-  lastModified: number;
-  size: number;
-}
-
-export function getClaudeDir(config: ScrylogConfig): string {
-  return config.claude.claudeDir ?? join(homedir(), ".claude");
-}
-
-/**
- * Decodes a Claude project slug (e.g. "-Volumes-Files-Workspace-Projects-other-scrylog-feature-daemon")
- * back to an absolute filesystem path ("/Volumes/Files/Workspace/Projects/other/scrylog-feature-daemon").
- *
- * Claude encodes project paths by replacing each "/" with "-", producing an ambiguous slug when
- * directory names themselves contain hyphens. This function resolves the ambiguity by greedily
- * walking the real filesystem: at each level it tries consuming 1, 2, 3… hyphen-separated parts
- * as a single directory name, choosing the first candidate that exists on disk.
- *
- * Returns null if the slug does not start with "-" or no matching path is found.
- */
-export function decodeClaudeProjectSlug(slug: string): string | null {
-  if (!slug.startsWith("-")) return null;
-  const parts = slug.slice(1).split("-");
-
-  function walk(current: string, remaining: string[]): string | null {
-    if (remaining.length === 0) return existsSync(current) ? current : null;
-    for (let i = 1; i <= remaining.length; i++) {
-      const name = remaining.slice(0, i).join("-");
-      const candidate = join(current, name);
-      if (i === remaining.length) {
-        // Last possible split — accept if exists
-        if (existsSync(candidate)) return candidate;
-      } else if (existsSync(candidate) && statSync(candidate).isDirectory()) {
-        const result = walk(candidate, remaining.slice(i));
-        if (result !== null) return result;
-      }
-    }
-    return null;
-  }
-
-  const root = IS_WINDOWS ? `${process.env.SYSTEMDRIVE ?? "C:"}\\` : "/";
-  return walk(root, parts);
-}
-
-export function discoverTranscripts(claudeDir: string, hookManagedIds?: ReadonlySet<string>): DiscoveredTranscript[] {
-  const projectsDir = join(claudeDir, "projects");
-  const results: DiscoveredTranscript[] = [];
-
-  if (!existsSync(projectsDir)) return results;
-
-  const cutoff = Date.now() - 24 * 60 * 60 * 1000;
-
-  try {
-    for (const projectSlug of readdirSync(projectsDir)) {
-      // Skip project directories emitted by known headless probe tools
-      // (e.g. CodexBar's ClaudeProbe). Their transcripts are not interactive
-      // sessions and would otherwise show as permanent "working" ghosts.
-      if (isKnownClaudeProbePath(projectSlug)) continue;
-      const projectPath = join(projectsDir, projectSlug);
-      try {
-        if (!statSync(projectPath).isDirectory()) continue;
-        for (const file of readdirSync(projectPath)) {
-          if (!file.endsWith(".jsonl")) continue;
-          const fullPath = join(projectPath, file);
-          try {
-            const stat = statSync(fullPath);
-            const sessionId = basename(file, ".jsonl");
-            // Include transcripts beyond the cutoff if the session is hook-managed,
-            // since hooks provide authoritative lifecycle and may keep a session
-            // alive beyond 24 hours of inactivity in the transcript file.
-            if (stat.mtimeMs < cutoff && !hookManagedIds?.has(sessionId)) continue;
-            results.push({
-              sessionId,
-              path: fullPath,
-              lastModified: stat.mtimeMs,
-              size: stat.size,
-            });
-          } catch {
-            // Skip unreadable files
-          }
-        }
-      } catch {
-        // Skip unreadable project directories
-      }
-    }
-  } catch {
-    // projects dir not accessible
-  }
-
-  return results;
-}
-
-export function getClaudeProcessPids(logger: Logger, timeoutMs?: number, processes?: { pid: number; command: string }[]): number[] {
-  const result = maybeRunCommand(["pgrep", "-f", "claude"], timeoutMs);
-  if (result.ok) {
-    return result.output
-      .split(/\r?\n/)
-      .filter(Boolean)
-      .map((s) => Number.parseInt(s, 10))
-      .filter((n) => !Number.isNaN(n));
-  }
-
-  logger.debug("claude", "pgrep failed — falling back to process collector data", { error: result.error });
-
-  if (processes && processes.length > 0) {
-    return processes
-      .filter((p) => isClaudeProcessCommand(p.command))
-      .map((p) => p.pid);
-  }
-
-  return [];
-}
-
-export function isClaudeProcessCommand(command: string): boolean {
-  return /(?:^|[\\/])claude(?:\.exe)?(?:\s|$)/i.test(command) && !/(scrylog|hook)/i.test(command);
-}