@scrylog/cli 0.1.0

package/src/daemon/collectors/process.ts

@@ -0,0 +1,201 @@
+import type { ScrylogConfig } from "../../shared/config";
+import type { ProcessInfo } from "../../shared/types";
+import { parseIntSafe, runCommand, maybeRunCommand } from "../../shared/utils";
+import { IS_WINDOWS } from "../../shared/platform";
+import type { DaemonStore } from "../store";
+import type { Collector } from "../scheduler";
+import type { Logger } from "../../shared/logger";
+import { NOOP_LOGGER } from "../../shared/logger";
+
+export function collectProcesses(timeoutMs?: number): ProcessInfo[] {
+  if (IS_WINDOWS) {
+    const output = runCommand(["wmic", "process", "get", "ProcessId,ParentProcessId,CommandLine", "/format:csv"], timeoutMs);
+    return parseWindowsProcesses(output);
+  }
+  const output = runCommand(["ps", "-ax", "-o", "pid=,ppid=,state=,etime=,comm=,command="], timeoutMs);
+  return parseProcesses(output);
+}
+
+export function parseProcesses(output: string): ProcessInfo[] {
+  return output
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      const match = line.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.*)$/);
+      if (!match) {
+        return null;
+      }
+
+      return {
+        pid: parseIntSafe(match[1] ?? ""),
+        ppid: parseIntSafe(match[2] ?? ""),
+        state: match[3] ?? "",
+        elapsed: match[4] ?? "",
+        comm: match[5] ?? "",
+        command: match[6] ?? "",
+      } satisfies ProcessInfo;
+    })
+    .filter((p): p is ProcessInfo => Boolean(p));
+}
+
+export function parseWindowsProcesses(output: string): ProcessInfo[] {
+  const lines = output.split(/\r?\n/).filter(Boolean);
+  const result: ProcessInfo[] = [];
+
+  for (const line of lines) {
+    // WMIC CSV format: Node,CommandLine,ParentProcessId,ProcessId
+    // CommandLine may contain commas, so split from the right.
+    const parts = line.split(",");
+    if (parts.length < 4) continue;
+
+    const pidStr = parts[parts.length - 1]?.trim();
+    const ppidStr = parts[parts.length - 2]?.trim();
+    const command = parts.slice(1, parts.length - 2).join(",").trim();
+    const pid = parseIntSafe(pidStr ?? "", 0);
+    const ppid = parseIntSafe(ppidStr ?? "", 0);
+    if (!pid) continue;
+
+    result.push({
+      pid,
+      ppid,
+      state: "?",
+      elapsed: "",
+      comm: "",
+      command,
+    });
+  }
+
+  return result;
+}
+
+export function buildProcessTree(rootPid: number, processes: ProcessInfo[]): ProcessInfo[] {
+  if (!rootPid) {
+    return [];
+  }
+
+  const byParent = new Map<number, ProcessInfo[]>();
+  const byPid = new Map<number, ProcessInfo>();
+
+  for (const process of processes) {
+    byPid.set(process.pid, process);
+    const existing = byParent.get(process.ppid);
+    if (existing) {
+      existing.push(process);
+    } else {
+      byParent.set(process.ppid, [process]);
+    }
+  }
+
+  if (!byPid.has(rootPid)) {
+    return [];
+  }
+
+  const seen = new Set<number>();
+  const ordered: ProcessInfo[] = [];
+  const queue: number[] = [rootPid];
+
+  while (queue.length > 0) {
+    const pid = queue.shift()!;
+    if (seen.has(pid)) {
+      continue;
+    }
+    seen.add(pid);
+
+    const process = byPid.get(pid);
+    if (process) {
+      ordered.push(process);
+    }
+
+    const children = byParent.get(pid) ?? [];
+    children.sort((a, b) => a.pid - b.pid);
+    for (const child of children) {
+      queue.push(child.pid);
+    }
+  }
+
+  return ordered;
+}
+
+/**
+ * Walk the process tree upward from childPid until we find a PID that exists
+ * in the candidate set. Returns the matched PID or undefined.
+ * Prevents infinite loops via a visited set.
+ */
+export function findAncestorInSet(
+  childPid: number,
+  candidateSet: ReadonlySet<number>,
+  processes: ProcessInfo[],
+): number | undefined {
+  const byPid = new Map(processes.map((p) => [p.pid, p]));
+  const visited = new Set<number>();
+  let current = childPid;
+
+  while (current > 1) {
+    if (visited.has(current)) break;
+    visited.add(current);
+
+    if (candidateSet.has(current)) return current;
+
+    const info = byPid.get(current);
+    if (!info) break;
+    current = info.ppid;
+  }
+
+  return undefined;
+}
+
+/**
+ * Collector that periodically refreshes the process list.
+ * Exposes the latest snapshot for other collectors to use.
+ */
+export class ProcessCollector implements Collector {
+  name = "process";
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private _processes: ProcessInfo[] = [];
+  private logger: Logger = NOOP_LOGGER;
+
+  get processes(): ProcessInfo[] {
+    return this._processes;
+  }
+
+  start(store: DaemonStore, config: ScrylogConfig, logger: Logger): void {
+    this.logger = logger;
+    logger.info("process", "Collector started", { event: "collector.started", collector: this.name, intervalMs: config.daemon.pollIntervalMs });
+
+    const refresh = () => {
+      if (IS_WINDOWS) {
+        const result = maybeRunCommand(["wmic", "process", "get", "ProcessId,ParentProcessId,CommandLine", "/format:csv"], config.daemon.commandTimeoutMs);
+        if (result.ok) {
+          this._processes = parseWindowsProcesses(result.output);
+          logger.debug("process", "Process list refreshed", { event: "collector.poll_completed", collector: this.name, count: this._processes.length });
+          store.setCollectorStatus(this.name, { running: true, lastRunAt: Date.now() });
+        } else {
+          logger.warn("process", "wmic command failed", { event: "collector.poll_failed", collector: this.name, errorMessage: result.error });
+          store.setCollectorStatus(this.name, { lastError: result.error });
+        }
+        return;
+      }
+
+      const result = maybeRunCommand(["ps", "-ax", "-o", "pid=,ppid=,state=,etime=,comm=,command="], config.daemon.commandTimeoutMs);
+      if (result.ok) {
+        this._processes = parseProcesses(result.output);
+        logger.debug("process", "Process list refreshed", { event: "collector.poll_completed", collector: this.name, count: this._processes.length });
+        store.setCollectorStatus(this.name, { running: true, lastRunAt: Date.now() });
+      } else {
+        logger.warn("process", "ps command failed", { event: "collector.poll_failed", collector: this.name, errorMessage: result.error });
+        store.setCollectorStatus(this.name, { lastError: result.error });
+      }
+    };
+
+    refresh();
+    this.timer = setInterval(refresh, config.daemon.pollIntervalMs);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.logger.info("process", "Collector stopped", { event: "collector.stopped", collector: this.name });
+  }
+}

package/src/daemon/collectors/tmux/README.md

@@ -0,0 +1,128 @@
+# Tmux Collector
+
+Scans all tmux panes, classifies their contents and process trees, and produces
+`SessionModel` entries. Acts as a **fallback layer** that enriches sessions
+already tracked by the Claude/OpenCode SDK collectors with pane context
+(session, window, pane IDs, process tree, screen sample, working directory).
+
+## Data Flow
+
+```
+  tmux list-sessions    tmux list-panes -a    tmux capture-pane
+         │                      │                     │
+         │                      │                     │
+         ▼                      ▼                     ▼
+  ┌──────────────────────────────────────────────────────────┐
+  │                      parse.ts                             │
+  │   collectTmuxState() ──► parseSessions() + parsePanes() │
+  │   capturePane()                                          │
+  └──────────────────────────┬───────────────────────────────┘
+                             │  TmuxCollectionResult
+                             │
+                             ▼
+  ┌──────────────────────────────────────────────────────────┐
+  │                   enrichment.ts                          │
+  │   isClaudeManagedSession()  │  isOpenCodeManagedSession() │
+  │   detectClaudePermissionPrompt()                        │
+  │   paneModelToSession()                                  │
+  │   shouldHideOpenCodePane()  │  looksLikeAgent()          │
+  │   clearStaleClaudeTmuxBindings()                        │
+  │   clearStaleOpenCodeTmuxBindings()                      │
+  └──────────────────────────┬───────────────────────────────┘
+                             │
+                             ▼
+  ┌──────────────────────────────────────────────────────────┐
+  │                     collector.ts                        │
+  │                                                          │
+  │   for each pane:                                         │
+  │     processTree ◄── ProcessCollector                     │
+  │                                                          │
+  │   Matching hierarchy (first match wins):                 │
+  │   ┌──────────────────────────────────────────┐           │
+  │   │  M0  @opencode-session pane option       │──► enrich │
+  │   │      (plugin-written, authoritative)       │           │
+  │   │                                          │           │
+  │   │  M1  @claude-session pane option         │──► enrich │
+  │   │      (hook-written, authoritative)       │           │
+  │   │      + detectClaudePermissionPrompt()    │           │
+  │   │                                          │           │
+  │   │  M1.5 @codex-session pane option         │──► enrich │
+  │   │      (hook-written, authoritative)       │           │
+  │   │                                          │           │
+  │   │  M2  Claude pane candidate               │──► fallback│
+  │   │      (heuristic, no option set yet)       │           │
+  │   │                                          │           │
+  │   │  M3  OpenCode pane candidate             │──► fallback│
+  │   │      (heuristic, no option set yet)       │           │
+  │   │                                          │           │
+  │   │  M4  SDK PID ancestry match              │──► enrich │
+  │   │      (via store.getSdkPids())             │           │
+  │   │                                          │           │
+  │   │  M5  URL-from-args match                 │──► enrich │
+  │   │      (findOpencodeInTree from process)   │           │
+  │   │                                          │           │
+  │   │  M6  Generic pane                        │──► fallback│
+  │   │      (classifyPane() from legacy/)        │           │
+  │   └──────────────────────────────────────────┘           │
+  │                                                          │
+  │   store.upsertSession()  /  store.setSessions()          │
+  │   (setSessions preserves non-fallback, replaces fallback) │
+  └──────────────────────────────────────────────────────────┘
+         │
+         ▼
+    DaemonStore ──► /api/events SSE ──► TUI
+```
+
+## Modules
+
+| File | Responsibility | Key Exports |
+|------|-------------|-------------|
+| `parse.ts` | Run `tmux list-sessions` and `tmux list-panes -a`; parse tab-delimited output; capture pane screen samples | `collectTmuxState()`, `parseSessions()`, `parsePanes()`, `capturePane()`, `PANE_FORMAT`, `SESSION_FORMAT`, `TmuxCollectionResult` |
+| `enrichment.ts` | Predicates to identify managed sessions (Claude/Codex/OpenCode); detect permission prompts from pane sample; decide whether to hide a pane; convert a classified pane into a `SessionModel` | `isClaudeManagedSession()`, `isCodexManagedSession()`, `isOpenCodeManagedSession()`, `detectClaudePermissionPrompt()`, `detectCodexPermissionPrompt()`, `isCodexPaneCandidate()`, `shouldHideOpenCodePane()`, `paneModelToSession()`, `managedStableForMs()`, `clearStaleClaudeTmuxBindings()`, `clearStaleCodexTmuxBindings()`, `clearStaleOpenCodeTmuxBindings()` |
+| `collector.ts` | Iterate over all panes; build process trees; run the 7-tier matching hierarchy; prune stale tmux bindings | `TmuxCollector` (implements `Collector`) |
+| `index.ts` | Public re-exports | `TmuxCollector`, enrichment + parse functions |
+
+## Matching Hierarchy Detail
+
+The collector processes each pane independently. For every pane it builds the
+process tree (descendants of `pane_pid`) and then attempts each match in order:
+
+| Tier | Match | What Happens | Rationale |
+|------|-------|--------------|-----------|
+| **M0** | `@opencode-session` pane user option present | Enrich the matching SDK session with tmux metadata (pane ID, process tree, sample, etc.) | Exact session ID from the scrylog OpenCode plugin — authoritative |
+| **M1** | `@claude-session` pane user option present | Enrich the matching Claude session with tmux metadata + apply `detectClaudePermissionPrompt()` only if not hook-managed | Exact session ID from scrylog-claude-hook — authoritative |
+| **M1.5** | `@codex-session` pane user option present | Enrich the matching Codex session with tmux metadata + apply `detectCodexPermissionPrompt()` only if not hook-managed | Exact session ID from scrylog-codex-hook — authoritative |
+| **M2** | Process tree / command contains `claude` (but no pane option yet) | Create a **fallback** `SessionModel` with `detectionSource: "fallback-detection"` | Heuristic; may be upgraded to M1 later when the hook fires |
+| **M3** | Process tree / command indicates OpenCode (but no pane option yet) | Create a **fallback** `SessionModel` | Heuristic; may be upgraded to M0 later when the plugin fires |
+| **M4** | A PID in the process tree is an ancestor of a known SDK PID (`store.getSdkPids()`) | Enrich all SDK sessions belonging to that instance URL | PID-ancestry deduplication — prevents duplicate rows for the same physical pane |
+| **M5** | A process in the tree is an OpenCode server with a derivable URL (`findOpencodeInTree()`) | Enrich all SDK sessions for that instance URL | URL-based fallback when `registerSdkPid` hasn't happened yet |
+| **M6** | None of the above match | Create a **fallback** `SessionModel` via `classifyPane()` from `legacy/classifier.ts` | Generic shell/editor pane |
+
+**Important:** Fallback sessions (`detectionSource: "fallback-detection"`) are
+replaced wholesale each poll cycle. Enriched sessions (M0, M1, M4, M5) are
+upserted and persist across polls.
+
+## `stableForMs` for Managed Sessions
+
+When a Claude/OpenCode session is enriched with tmux data, `stableForMs` is
+computed from the session's own `stateChangedAt` / `lastActivity` — **not** from
+the pane classifier's heuristic timer. This prevents the TUI timer from jumping
+to minutes the instant tmux enrichment happens.
+
+## Interactions
+
+| Component | How |
+|-----------|-----|
+| `ProcessCollector` | `buildProcessTree(panePid, allProcesses)` — gets full descendant tree of the pane's root process |
+| `GitCollector` | Resolves `currentPath` → `project` for every pane before classification |
+| `ClaudeCollector` | Supplies hook-managed sessions that M1 matches against; `store.isLocalCommand()` filters excluded batch-run sessions |
+| `CodexCollector` | Supplies hook-managed sessions that M1.5 matches against |
+| `OpenCodeCollector` | Supplies SDK sessions that M0/M4/M5 match against; `store.registerSdkPid()` populates the PID map used in M4 |
+| `legacy/classifier.ts` | `classifyPane()` — M6 fallback heuristics for tool/state/summary detection |
+| `Scheduler` | Calls `start()` → sets up poll interval from `config.daemon.pollIntervalMs` |
+
+## Detection Sources
+
+This collector **does not** produce its own `detectionSource`. It sets:
+- `source: "tmux"` on enriched sessions (they keep their original `detectionSource`)
+- `source: "tmux"` + `detectionSource: "fallback-detection"` on M2/M3/M6 fallback sessions