@scrylog/cli 0.1.0

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

@@ -0,0 +1,472 @@
+import type { SessionModel } from "../../../shared/types";
+import type { SnapshotHistory } from "../../../shared/types";
+import type { ScrylogConfig } from "../../../shared/config";
+import type { DaemonStore } from "../../store";
+import type { Collector } from "../../scheduler";
+import type { Logger } from "../../../shared/logger";
+import { NOOP_LOGGER } from "../../../shared/logger";
+import type { ProcessCollector } from "../process";
+import { buildProcessTree, findAncestorInSet } from "../process";
+import type { GitCollector } from "../git";
+import { findOpencodeInTree } from "../opencode/discovery";
+import { collectTmuxState, capturePane } from "./parse";
+import {
+  isOpenCodeManagedSession,
+  isClaudeManagedSession,
+  isCodexManagedSession,
+  clearStaleClaudeTmuxBindings,
+  clearStaleCodexTmuxBindings,
+  clearStaleOpenCodeTmuxBindings,
+  managedStableForMs,
+  detectClaudePermissionPrompt,
+  detectCodexPermissionPrompt,
+  isClaudePaneCandidate,
+  isCodexPaneCandidate,
+  isOpenCodePaneCandidate,
+  shouldHideOpenCodePane,
+  looksLikeAgent,
+  paneModelToSession,
+} from "./enrichment";
+import { classifyPane } from "../../../legacy/classifier";
+
+/**
+ * Tmux collector: runs on a periodic timer, builds pane models, and writes
+ * them to the store. Delegates classification to legacy detect/classifier.
+ */
+export class TmuxCollector implements Collector {
+  name = "tmux";
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private history = new Map<string, SnapshotHistory>();
+  private logger: Logger = NOOP_LOGGER;
+
+  constructor(
+    private readonly processCollector: ProcessCollector,
+    private readonly gitCollector: GitCollector,
+  ) {}
+
+  start(store: DaemonStore, config: ScrylogConfig, logger: Logger): void {
+    this.logger = logger;
+    const run = () => {
+      try {
+        this.collect(store, config);
+        store.setCollectorStatus(this.name, { running: true, lastRunAt: Date.now() });
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        store.setCollectorStatus(this.name, { lastError: msg });
+        store.reportError(this.name, msg);
+      }
+    };
+
+    logger.info("tmux", "Collector started", { event: "collector.started", collector: this.name, intervalMs: config.daemon.pollIntervalMs });
+    run();
+    this.timer = setInterval(run, config.daemon.pollIntervalMs);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.logger.info("tmux", "Collector stopped", { event: "collector.stopped", collector: this.name });
+  }
+
+  private collect(store: DaemonStore, config: ScrylogConfig): void {
+    const tmux = collectTmuxState(config.daemon.commandTimeoutMs);
+    store.setTmuxSessions(tmux.sessions);
+
+    if (tmux.errors.length > 0) {
+      this.logger.warn("tmux", "tmux reported errors", { event: "collector.poll_partial", collector: this.name, errors: tmux.errors });
+    }
+
+    for (const msg of tmux.errors) {
+      store.reportError(this.name, msg);
+    }
+
+    if (tmux.panes.length === 0) {
+      this.logger.debug("tmux", "No panes found — clearing fallback sessions", { event: "collector.poll_completed", collector: this.name, panes: 0 });
+      clearStaleOpenCodeTmuxBindings(store, new Set());
+      // Remove all sessions that came from tmux
+      const current = store.getSessions();
+      for (const session of current) {
+        if (session.source === "tmux" && session.detectionSource === "fallback-detection") {
+          store.removeSession(session.id);
+        }
+      }
+      return;
+    }
+
+    this.logger.debug("tmux", "Collected panes", { event: "collector.poll_completed", collector: this.name, panes: tmux.panes.length, sessions: tmux.sessions.length });
+
+    const allProcesses = this.processCollector.processes;
+    const now = Date.now();
+
+    // Build set of known SDK PIDs for PID-ancestry matching
+    const sdkPidMap = store.getSdkPids();
+    const sdkPidSet = new Set(sdkPidMap.keys());
+
+    const newFallbackSessions: SessionModel[] = [];
+
+    for (const pane of tmux.panes) {
+      const processTree = buildProcessTree(pane.panePid, allProcesses);
+      const shouldPreview = looksLikeAgent(processTree, pane.currentCommand);
+      const sample = shouldPreview
+        ? capturePane(pane.paneId, config.tmux.previewLines, config.daemon.commandTimeoutMs)
+        : null;
+
+      const result = classifyPane({
+        pane: {
+          ...pane,
+          project: this.gitCollector.resolve(pane.currentPath),
+        },
+        processTree,
+        sample,
+        history: this.history.get(pane.paneId),
+        now,
+      });
+
+      this.history.set(pane.paneId, result.history);
+
+      if (shouldHideOpenCodePane(config.opencode, pane, processTree, result.pane.tool)) {
+        this.logger.debug("tmux", "Hiding OpenCode pane in SSE mode", {
+          paneId: pane.paneId,
+          currentCommand: pane.currentCommand,
+        });
+        continue;
+      }
+
+      // Check if any process in the tree belongs to a known SDK instance
+      // Walk all PIDs in the process tree and check for ancestor match
+      const allTreePids = new Set(processTree.map((p) => p.pid));
+      allTreePids.add(pane.panePid);
+
+      let matchedSdkPid: number | undefined;
+      for (const pid of allTreePids) {
+        const ancestor = findAncestorInSet(pid, sdkPidSet, allProcesses);
+        if (ancestor !== undefined) {
+          matchedSdkPid = ancestor;
+          break;
+        }
+      }
+
+      // ── M0: plugin-written tmux pane option ──────────────────────────────────
+      // The scrylog opencode plugin writes @opencode-session to the pane user
+      // option whenever session.created / session.updated fires. When present,
+      // this is an exact, authoritative match — skip all other heuristics.
+      if (pane.opencodeSession) {
+        const current = store.getSessions();
+        const pluginSession = current.find(
+          (s) =>
+            isOpenCodeManagedSession(s) &&
+            s.opencode?.sessionId === pane.opencodeSession &&
+            (!s.legacyPaneId || s.legacyPaneId === pane.paneId),
+        );
+        if (pluginSession) {
+          store.clearTmuxBindingForPane(pane.paneId, pluginSession.id);
+          const enriched: SessionModel = {
+            ...pluginSession,
+            source: "tmux",
+            project: result.pane.project,
+            tmux: {
+              session: pane.sessionName,
+              window: String(pane.windowIndex),
+              pane: pane.paneId,
+            },
+            legacyPaneId: pane.paneId,
+            processTree: result.pane.processTree,
+            processChain: result.pane.processChain,
+            sample: result.pane.sample,
+            stableForMs: managedStableForMs(pluginSession),
+            currentCommand: pane.currentCommand,
+            currentPath: pane.currentPath,
+            panePid: pane.panePid,
+            tty: pane.tty,
+            paneTitle: pane.title,
+          };
+          this.logger.debug("tmux", "Pane matched by plugin pane option — enriching", {
+            paneId: pane.paneId,
+            sessionId: pane.opencodeSession,
+          });
+          store.upsertSession(enriched);
+          continue;
+        }
+        // Exact session ID is authoritative. If the referenced session is not in
+        // the store yet, do not attempt any automatic OpenCode pane matching.
+        this.logger.debug("tmux", "Plugin pane option set but session not found in store yet", {
+          paneId: pane.paneId,
+          opencodeSession: pane.opencodeSession,
+        });
+        newFallbackSessions.push(paneModelToSession(result.pane));
+        continue;
+      }
+
+      // ── M1: hook-written @claude-session pane option ─────────────────────────
+      // The scrylog-claude-hook binary writes @claude-session to the pane when
+      // Claude runs inside tmux. This is an exact, authoritative match.
+      if (pane.claudeSession) {
+        const current = store.getSessions();
+        const linkedSession = current.find(
+          (s) =>
+            isClaudeManagedSession(s) &&
+            s.claude?.sessionId === pane.claudeSession &&
+            (!s.legacyPaneId || s.legacyPaneId === pane.paneId),
+        );
+        if (linkedSession) {
+          // Only apply detectClaudePermissionPrompt for non-hook-managed sessions.
+          // Hook-managed sessions have authoritative state from the PermissionRequest
+          // event and must not be overridden by stale tmux screen sampling.
+          const claudePrompt = linkedSession.detectionSource === "claude-hook"
+            ? null
+            : detectClaudePermissionPrompt(result.pane.sample);
+          store.clearTmuxBindingForPane(pane.paneId, linkedSession.id);
+          const enriched: SessionModel = {
+            ...linkedSession,
+            source: "tmux",
+            ...(claudePrompt ? {
+              state: claudePrompt.state,
+              hasAttention: claudePrompt.hasAttention,
+              summary: claudePrompt.summary,
+            } : {}),
+            project: result.pane.project,
+            tmux: {
+              session: pane.sessionName,
+              window: String(pane.windowIndex),
+              pane: pane.paneId,
+            },
+            legacyPaneId: pane.paneId,
+            processTree: result.pane.processTree,
+            processChain: result.pane.processChain,
+            sample: result.pane.sample,
+            stableForMs: managedStableForMs(linkedSession),
+            currentCommand: pane.currentCommand,
+            currentPath: pane.currentPath,
+            panePid: pane.panePid,
+            tty: pane.tty,
+            paneTitle: pane.title,
+          };
+          this.logger.debug("tmux", "Pane matched by @claude-session option — enriching", {
+            paneId: pane.paneId,
+            claudeSessionId: pane.claudeSession,
+          });
+          store.upsertSession(enriched);
+          continue;
+        }
+        // Check if deliberately excluded (local-command batch run)
+        if (store.isLocalCommand(pane.claudeSession)) {
+          this.logger.debug("tmux", "Skipping fallback for local-command session", {
+            paneId: pane.paneId,
+            claudeSession: pane.claudeSession,
+          });
+          continue;
+        }
+        // Authoritative but not yet in store — keep as fallback
+        this.logger.debug("tmux", "@claude-session set but session not in store yet", {
+          paneId: pane.paneId,
+          claudeSession: pane.claudeSession,
+        });
+        newFallbackSessions.push(paneModelToSession(result.pane));
+        continue;
+      }
+
+      // ── M1.5: hook-written @codex-session pane option ────────────────────────
+      // The scrylog-codex-hook binary writes @codex-session to the pane when
+      // Codex runs inside tmux. This is an exact, authoritative match.
+      if (pane.codexSession) {
+        const current = store.getSessions();
+        const linkedSession = current.find(
+          (s) =>
+            isCodexManagedSession(s) &&
+            s.codex?.sessionId === pane.codexSession &&
+            (!s.legacyPaneId || s.legacyPaneId === pane.paneId),
+        );
+        if (linkedSession) {
+          const codexPrompt = linkedSession.detectionSource === "codex-hook"
+            ? null
+            : detectCodexPermissionPrompt(result.pane.sample);
+          store.clearTmuxBindingForPane(pane.paneId, linkedSession.id);
+          const enriched: SessionModel = {
+            ...linkedSession,
+            source: "tmux",
+            ...(codexPrompt ? {
+              state: codexPrompt.state,
+              hasAttention: codexPrompt.hasAttention,
+              summary: codexPrompt.summary,
+            } : {}),
+            project: result.pane.project,
+            tmux: {
+              session: pane.sessionName,
+              window: String(pane.windowIndex),
+              pane: pane.paneId,
+            },
+            legacyPaneId: pane.paneId,
+            processTree: result.pane.processTree,
+            processChain: result.pane.processChain,
+            sample: result.pane.sample,
+            stableForMs: managedStableForMs(linkedSession),
+            currentCommand: pane.currentCommand,
+            currentPath: pane.currentPath,
+            panePid: pane.panePid,
+            tty: pane.tty,
+            paneTitle: pane.title,
+          };
+          this.logger.debug("tmux", "Pane matched by @codex-session option — enriching", {
+            paneId: pane.paneId,
+            codexSessionId: pane.codexSession,
+          });
+          store.upsertSession(enriched);
+          continue;
+        }
+        // Authoritative but not yet in store — keep as fallback
+        this.logger.debug("tmux", "@codex-session set but session not in store yet", {
+          paneId: pane.paneId,
+          codexSession: pane.codexSession,
+        });
+        newFallbackSessions.push(paneModelToSession(result.pane));
+        continue;
+      }
+
+      // Claude panes without the pane option: keep as fallback to avoid duplicate
+      // entries once the hook fires and the pane option is set.
+      if (isClaudePaneCandidate(processTree, pane.currentCommand)) {
+        newFallbackSessions.push(paneModelToSession(result.pane));
+        continue;
+      }
+
+      // Codex panes without the pane option: keep as fallback.
+      if (isCodexPaneCandidate(processTree, pane.currentCommand)) {
+        newFallbackSessions.push(paneModelToSession(result.pane));
+        continue;
+      }
+
+      // OpenCode panes inside tmux must only correlate by exact session ID.
+      // Without the plugin-written pane option, keep a temporary fallback pane
+      // row and avoid heuristic matching to DB/SDK sessions.
+      if (isOpenCodePaneCandidate(pane, processTree, result.pane.tool)) {
+        newFallbackSessions.push(paneModelToSession(result.pane));
+        continue;
+      }
+
+      if (matchedSdkPid !== undefined) {
+        // Find the SDK sessions for this instance and enrich them with tmux context.
+        const instanceUrl = sdkPidMap.get(matchedSdkPid);
+        const current = store.getSessions();
+        const sdkSessionsForInstance = current.filter(
+          (s) =>
+            isOpenCodeManagedSession(s) &&
+            s.opencode?.instanceUrl === instanceUrl &&
+            !s.legacyPaneId,
+        );
+
+        for (const sdkSession of sdkSessionsForInstance) {
+          const enriched: SessionModel = {
+            ...sdkSession,
+            // Switch to tmux source so TUI groups it with tmux sessions
+            source: "tmux",
+            project: result.pane.project,
+            tmux: {
+              session: pane.sessionName,
+              window: String(pane.windowIndex),
+              pane: pane.paneId,
+            },
+            legacyPaneId: pane.paneId,
+            // Extended fields from pane analysis
+            processTree: result.pane.processTree,
+            processChain: result.pane.processChain,
+            sample: result.pane.sample,
+            stableForMs: managedStableForMs(sdkSession),
+            currentCommand: pane.currentCommand,
+            currentPath: pane.currentPath,
+            panePid: pane.panePid,
+            tty: pane.tty,
+            paneTitle: pane.title,
+          };
+          this.logger.debug("tmux", "Pane covered by SDK — enriching SDK session", {
+            paneId: pane.paneId,
+            sdkSessionId: sdkSession.id,
+            instanceUrl,
+          });
+          store.upsertSession(enriched);
+        }
+        // Don't create a fallback entry for this pane
+        this.logger.debug("tmux", "Pane covered by SDK — skipping fallback entry", {
+          paneId: pane.paneId,
+          matchedSdkPid,
+          instanceUrl,
+        });
+      } else {
+        // PID ancestry via sdkPidMap failed (e.g. registerSdkPid not yet called).
+        // Attempt URL-from-args matching: walk the pane's ancestor chain looking
+        // for an opencode process and derive the instance URL from its args.
+        // This is deterministic and has no false positives unlike path matching.
+        const ancestor = findOpencodeInTree(processTree);
+        if (ancestor) {
+          const current = store.getSessions();
+          const sdkSessionsForInstance = current.filter(
+            (s) =>
+              isOpenCodeManagedSession(s) &&
+              s.opencode?.instanceUrl === ancestor.url &&
+              !s.legacyPaneId,
+          );
+
+          if (sdkSessionsForInstance.length > 0) {
+            for (const sdkSession of sdkSessionsForInstance) {
+              const enriched: SessionModel = {
+                ...sdkSession,
+                source: "tmux",
+                project: result.pane.project,
+                tmux: {
+                  session: pane.sessionName,
+                  window: String(pane.windowIndex),
+                  pane: pane.paneId,
+                },
+                legacyPaneId: pane.paneId,
+                processTree: result.pane.processTree,
+                processChain: result.pane.processChain,
+                sample: result.pane.sample,
+                stableForMs: managedStableForMs(sdkSession),
+                currentCommand: pane.currentCommand,
+                currentPath: pane.currentPath,
+                panePid: pane.panePid,
+                tty: pane.tty,
+                paneTitle: pane.title,
+              };
+              this.logger.debug("tmux", "Pane matched SDK session by URL-from-args — enriching", {
+                paneId: pane.paneId,
+                sdkSessionId: sdkSession.id,
+                instanceUrl: ancestor.url,
+              });
+              store.upsertSession(enriched);
+            }
+            this.logger.debug("tmux", "Pane covered by URL-from-args match — skipping fallback", {
+              paneId: pane.paneId,
+              instanceUrl: ancestor.url,
+            });
+          } else {
+            newFallbackSessions.push(paneModelToSession(result.pane));
+          }
+        } else {
+          newFallbackSessions.push(paneModelToSession(result.pane));
+        }
+      }
+    }
+
+    // Prune history for gone panes
+    const livePaneIds = new Set(tmux.panes.map((pane) => pane.paneId));
+    clearStaleOpenCodeTmuxBindings(store, livePaneIds);
+    clearStaleClaudeTmuxBindings(store, livePaneIds);
+    clearStaleCodexTmuxBindings(store, livePaneIds);
+
+    for (const paneId of [...this.history.keys()]) {
+      if (!livePaneIds.has(paneId)) {
+        this.history.delete(paneId);
+      }
+    }
+
+    // Replace only fallback sessions (non-enriched); keep SDK-sourced sessions
+    const current = store.getSessions();
+    const nonFallback = current.filter(
+      (s) => !(s.source === "tmux" && s.detectionSource === "fallback-detection"),
+    );
+
+    store.setSessions([...nonFallback, ...newFallbackSessions]);
+  }
+}