@scrylog/cli 0.3.0 → 0.3.2

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

@@ -1,492 +0,0 @@
-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),
-              windowName: pane.windowName,
-              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),
-              windowName: pane.windowName,
-              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),
-              windowName: pane.windowName,
-              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),
-              windowName: pane.windowName,
-              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),
-                  windowName: pane.windowName,
-                  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"),
-    );
-
-    // Fallback sessions are rebuilt from scratch every poll. Git project
-    // resolution can transiently fail (or currentPath can come through empty),
-    // so inherit the previously-resolved project/currentPath to keep the TUI
-    // group membership stable instead of oscillating between polls.
-    const previousFallback = new Map(
-      current
-        .filter((s) => s.source === "tmux" && s.detectionSource === "fallback-detection")
-        .map((s) => [s.id, s]),
-    );
-    const mergedFallbacks = newFallbackSessions.map((session) => {
-      const prev = previousFallback.get(session.id);
-      if (!prev || session.project) return session;
-      return { ...session, project: prev.project, currentPath: session.currentPath || prev.currentPath };
-    });
-
-    store.setSessions([...nonFallback, ...mergedFallbacks]);
-  }
-}