@scrylog/cli 0.1.0

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

@@ -0,0 +1,413 @@
+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") {
+          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!;
+    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

@@ -0,0 +1,148 @@
+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";
+
+export interface DiscoveredTranscript {
+  sessionId: string;
+  path: string;
+  lastModified: number;
+  size: number;
+}
+
+export function getClaudeDir(config: ScrylogConfig): string {
+  return config.claude.claudeDir ?? join(homedir(), ".claude");
+}
+
+// Internal: project slugs known to generate headless probe transcripts.
+// Third-party tools (e.g. CodexBar's ClaudeProbe on macOS) launch `claude`
+// periodically to run slash commands like `/usage` for their own telemetry.
+// Each run leaves a tiny transcript that scrylog misreads as an interactive
+// "working" session, cluttering the TUI with ghosts.
+// Not user-configurable — extend here when new probe sources are identified.
+// Patterns are matched case-insensitively with `*` wildcards; on tiers where
+// these tools do not run (Linux/WSL 2, Windows native) the list is a no-op.
+const KNOWN_PROBE_SLUG_GLOBS: readonly string[] = ["*CodexBar-ClaudeProbe*"];
+
+function matchesGlob(value: string, pattern: string): boolean {
+  const re = new RegExp(
+    "^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$",
+    "i",
+  );
+  return re.test(value);
+}
+
+function isKnownProbeSlug(slug: string): boolean {
+  return KNOWN_PROBE_SLUG_GLOBS.some((pattern) => matchesGlob(slug, pattern));
+}
+
+/**
+ * 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 (isKnownProbeSlug(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);
+}