@scrylog/cli 0.3.0 → 0.3.2

package/src/daemon/collectors/process.ts

@@ -1,201 +0,0 @@
-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

@@ -1,128 +0,0 @@
-# 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