@scrylog/cli 0.2.0 → 0.3.1

package/src/daemon/store.ts

@@ -1,588 +0,0 @@
-import { EventEmitter } from "node:events";
-import type { Logger } from "../shared/logger";
-import { NOOP_LOGGER } from "../shared/logger";
-import type { CollectorStatus, DaemonState, SessionInfo, SessionModel, StoreEvent } from "../shared/types";
-import type { RetentionConfig } from "../shared/config";
-
-/**
- * Returns true when an incoming claude-hook "working" event represents an explicit
- * user response to a pending attention (permission or question), so the attention
- * can be cleared. Background working events (unrelated subagent activity) return false.
- */
-function resolvesAttention(existing: SessionModel, incoming: SessionModel): boolean {
-  const evt = incoming.claude?.hookEventType;
-  if (evt === "UserPromptSubmit" || evt === "PermissionDenied") return true;
-  if (
-    (evt === "PreToolUse" || evt === "PostToolUse")
-    && existing.claude?.attentionKind === "permission"
-    && incoming.claude?.toolName === existing.claude.toolName
-  ) return true;
-  return false;
-}
-
-/**
- * In-memory state store for the daemon.
- * Maintains all session data and emits typed StoreEvent events on changes.
- */
-export class DaemonStore extends EventEmitter {
-  private state: DaemonState = {
-    tmuxSessions: [],
-    sessions: [],
-    collectorStatus: {},
-    usage: { providers: [], lastRefreshedAt: 0 },
-    startedAt: Date.now(),
-    refreshedAt: 0,
-  };
-
-  /** Maps SDK process PID → instance URL for PID-ancestry-based deduplication */
-  private sdkPids = new Map<number, string>();
-
-  /** Session IDs that were deliberately excluded as local-command (batch) transcripts */
-  private localCommandIds = new Map<string, number>();
-
-  /** Session IDs whose idle transition was suppressed because of active children.
-   * When the last child goes inactive, the parent is transitioned to idle. */
-  private suppressedIdle = new Set<string>();
-
-  constructor(private readonly logger: Logger = NOOP_LOGGER) {
-    super();
-  }
-
-  // ── Reads ──────────────────────────────────────────────────────────────────
-
-  getState(): Readonly<DaemonState> {
-    return this.state;
-  }
-
-  getSessions(): SessionModel[] {
-    return [...this.state.sessions];
-  }
-
-  getSession(id: string): SessionModel | undefined {
-    return this.state.sessions.find((s) => s.id === id);
-  }
-
-  getTmuxSessions(): SessionInfo[] {
-    return [...this.state.tmuxSessions];
-  }
-
-  // ── Writes ─────────────────────────────────────────────────────────────────
-
-  /** Replace the full sessions list and emit diff events */
-  setSessions(sessions: SessionModel[]): void {
-    // Prune suppressedIdle entries that no longer exist
-    const sessionIds = new Set(sessions.map((s) => s.id));
-    for (const id of this.suppressedIdle) {
-      if (!sessionIds.has(id)) {
-        this.suppressedIdle.delete(id);
-      }
-    }
-
-    const previous = new Map(this.state.sessions.map((s) => [s.id, s]));
-    const next = new Map(sessions.map((s) => [s.id, s]));
-
-    // Removed
-    for (const [id] of previous) {
-      if (!next.has(id)) {
-        this.logger.info("store", "Session removed", { event: "session.removed", sessionId: id });
-        this.emit("store:event", { type: "session:removed", sessionId: id } satisfies StoreEvent);
-      }
-    }
-
-    // Added or updated
-    for (const [id, session] of next) {
-      if (!previous.has(id)) {
-        this.logger.info("store", "Session added", { event: "session.added", sessionId: id, tool: session.tool, state: session.state });
-        this.emit("store:event", { type: "session:added", session } satisfies StoreEvent);
-      } else {
-        const prev = previous.get(id)!;
-        if (prev.state !== session.state) {
-          this.logger.info("store", "Session state changed", {
-            event: "session.state_changed",
-            sessionId: id,
-            previousState: prev.state,
-            state: session.state,
-            tool: session.tool,
-          });
-        } else {
-          this.logger.debug("store", "Session updated", { event: "session.updated", sessionId: id, state: session.state });
-        }
-        this.emit("store:event", { type: "session:updated", session } satisfies StoreEvent);
-      }
-    }
-
-    this.state = { ...this.state, sessions, refreshedAt: Date.now() };
-    this.emit("store:event", { type: "state:refreshed", timestamp: this.state.refreshedAt } satisfies StoreEvent);
-  }
-
-  /** Upsert a single session */
-  upsertSession(incoming: SessionModel): void {
-    const existing = this.state.sessions.find((s) => s.id === incoming.id);
-
-    // If the existing session has been enriched with tmux context (legacyPaneId
-    // is set) but the incoming write does not carry tmux context, preserve the
-    // enrichment fields. This prevents the opencode SDK/DB/cluade collectors from
-    // wiping out tmux enrichment on every poll/SSE cycle.
-    let session = incoming;
-    if (existing?.legacyPaneId && !incoming.legacyPaneId) {
-      const stableForMs = existing.state !== incoming.state ? 0 : existing.stableForMs;
-      session = {
-        ...incoming,
-        source: existing.source,
-        project: existing.project ?? incoming.project,
-        tmux: existing.tmux,
-        legacyPaneId: existing.legacyPaneId,
-        processTree: existing.processTree,
-        processChain: existing.processChain,
-        sample: existing.sample,
-        stableForMs,
-        panePid: existing.panePid,
-        tty: existing.tty,
-        paneTitle: existing.paneTitle,
-        currentCommand: existing.currentCommand,
-        currentPath: existing.currentPath ?? incoming.currentPath,
-      };
-    } else if (existing?.tmux && !incoming.tmux && existing.id === incoming.id) {
-      // Debug: detect when tmux enrichment would be lost because legacyPaneId
-      // guard didn't trigger but tmux data exists on existing session
-      this.logger.warn("store", "TMUX enrichment at risk", {
-        event: "session.enrichment_at_risk",
-        sessionId: incoming.id,
-        existingSource: existing.source,
-        incomingSource: incoming.source,
-        existingLegacyPaneId: existing.legacyPaneId,
-        incomingLegacyPaneId: incoming.legacyPaneId,
-        existingTmux: !!existing.tmux,
-        incomingTmux: !!incoming.tmux,
-        existingDetectionSource: existing.detectionSource,
-        incomingDetectionSource: incoming.detectionSource,
-      });
-    }
-
-    // For all sessions: preserve a previously-resolved project/currentPath when
-    // the incoming model lacks them. Project resolution can transiently fail
-    // (Claude slug decode returning null, OpenCode directory not yet populated),
-    // and once resolved the association must not oscillate back to undefined.
-    // An incoming model that carries a non-empty project still wins.
-    if (existing && !session.project && existing.project) {
-      session = { ...session, project: existing.project };
-    }
-    if (existing && !session.currentPath && existing.currentPath) {
-      session = { ...session, currentPath: existing.currentPath };
-    }
-
-    // Preserve stateChangedAt from the stored session when the incoming model
-    // doesn't carry it (e.g. built by processTranscript from file state only).
-    if (existing && !session.stateChangedAt && existing.stateChangedAt) {
-      session = { ...session, stateChangedAt: existing.stateChangedAt };
-    }
-
-    if (existing && existing.state !== session.state) {
-      const now = Date.now();
-      const hasActiveChildren = session.parentSessionId === undefined
-        && session.state === "idle"
-        && (existing.state === "working" || existing.state === "waiting-input")
-        && this.state.sessions.some(
-          (s) => s.parentSessionId === session.id
-            && (s.state === "working" || s.state === "waiting-input"),
-        );
-      if (hasActiveChildren) {
-        this.suppressedIdle.add(session.id);
-        session = { ...session, state: existing.state, stateChangedAt: existing.stateChangedAt };
-      } else {
-        this.suppressedIdle.delete(session.id);
-
-        // For hook-managed Claude sessions: pending attention (waiting-input +
-        // hasAttention) takes precedence over concurrent background working events
-        // until the user explicitly responds. Background subagent activity must not
-        // clear the permission/question from the dashboard.
-        const pendingAttention = existing.state === "waiting-input"
-          && existing.hasAttention === true
-          && session.state === "working"
-          && session.detectionSource === "claude-hook"
-          && !resolvesAttention(existing, session);
-
-        if (pendingAttention) {
-          // Revert to waiting-input, advancing only the claude metadata (hookSeq etc.)
-          // so subsequent events are not rejected as stale.
-          session = {
-            ...session,
-            state: "waiting-input" as SessionModel["state"],
-            hasAttention: true,
-            summary: existing.summary,
-            activeTool: existing.activeTool,
-            stateChangedAt: existing.stateChangedAt,
-            stableForMs: existing.stableForMs,
-          };
-        } else {
-          const isGracePeriodIdleToWorking = existing.state === "idle"
-            && session.state === "working"
-            && existing.lastChildActiveAt
-            && (now - existing.lastChildActiveAt) < 1500;
-
-          if (session.state === "working") {
-            session = {
-              ...session,
-              stableForMs: 0,
-              stateChangedAt: now,
-              lastWorkingChangedAt: isGracePeriodIdleToWorking
-                ? (existing.lastWorkingChangedAt ?? now)
-                : now,
-            };
-          } else {
-            session = { ...session, stableForMs: 0, stateChangedAt: now };
-
-            if (session.state === "waiting-input" || session.state === "error") {
-              session = { ...session, lastWorkingChangedAt: undefined, lastChildActiveAt: undefined };
-            }
-          }
-        }
-      }
-    }
-
-    if (existing) {
-      if (existing.state !== session.state) {
-        this.logger.info("store", "Session state changed", {
-          event: "session.state_changed",
-          sessionId: session.id,
-          previousState: existing.state,
-          state: session.state,
-          tool: session.tool,
-        });
-      } else {
-        this.logger.debug("store", "Session updated", { event: "session.updated", sessionId: session.id, state: session.state });
-      }
-      this.state = {
-        ...this.state,
-        sessions: this.state.sessions.map((s) => (s.id === session.id ? session : s)),
-        refreshedAt: Date.now(),
-      };
-      this.emit("store:event", { type: "session:updated", session } satisfies StoreEvent);
-    } else {
-      if (!session.stateChangedAt) {
-        session = { ...session, stateChangedAt: Date.now() };
-      }
-      if (session.state === "working" && !session.lastWorkingChangedAt) {
-        session = { ...session, lastWorkingChangedAt: session.stateChangedAt };
-      }
-      this.logger.info("store", "Session added", { event: "session.added", sessionId: session.id, tool: session.tool, state: session.state });
-      this.state = {
-        ...this.state,
-        sessions: [...this.state.sessions, session],
-        refreshedAt: Date.now(),
-      };
-      this.emit("store:event", { type: "session:added", session } satisfies StoreEvent);
-    }
-
-    // Track lastChildActiveAt on parent when a child session transitions
-    // away from "working" or "waiting-input" and no other children are active.
-    if (session.parentSessionId && existing && (existing.state === "working" || existing.state === "waiting-input") && existing.state !== session.state) {
-      const anyOtherActiveChildren = this.state.sessions.some(
-        (s) => s.parentSessionId === session.parentSessionId
-          && s.id !== session.id
-          && (s.state === "working" || s.state === "waiting-input"),
-      );
-      if (!anyOtherActiveChildren) {
-        const parent = this.state.sessions.find((s) => s.id === session.parentSessionId);
-        if (parent) {
-          let updatedParent: SessionModel;
-          if (this.suppressedIdle.has(parent.id)) {
-            this.suppressedIdle.delete(parent.id);
-            updatedParent = {
-              ...parent,
-              state: "idle" as SessionModel["state"],
-              stateChangedAt: Date.now(),
-              stableForMs: 0,
-              lastChildActiveAt: Date.now(),
-            };
-            this.logger.info("store", "Session state changed", {
-              event: "session.state_changed",
-              sessionId: parent.id,
-              previousState: parent.state,
-              state: "idle",
-              tool: parent.tool,
-            });
-          } else {
-            updatedParent = { ...parent, lastChildActiveAt: Date.now() };
-          }
-          this.state = {
-            ...this.state,
-            sessions: this.state.sessions.map((s) => s.id === parent.id ? updatedParent : s),
-            refreshedAt: Date.now(),
-          };
-          this.emit("store:event", { type: "session:updated", session: updatedParent } satisfies StoreEvent);
-        }
-      }
-    }
-  }
-
-  /** Remove a session by id */
-  removeSession(sessionId: string): void {
-    const session = this.state.sessions.find((s) => s.id === sessionId);
-    if (!session) {
-      return;
-    }
-
-    const parentId = session.parentSessionId;
-
-    this.logger.info("store", "Session removed", { event: "session.removed", sessionId });
-    this.state = {
-      ...this.state,
-      sessions: this.state.sessions.filter((s) => s.id !== sessionId),
-      refreshedAt: Date.now(),
-    };
-    this.emit("store:event", { type: "session:removed", sessionId } satisfies StoreEvent);
-
-    this.suppressedIdle.delete(sessionId);
-
-    if (parentId && this.suppressedIdle.has(parentId)) {
-      const anyOtherActiveChildren = this.state.sessions.some(
-        (s) => s.parentSessionId === parentId && (s.state === "working" || s.state === "waiting-input"),
-      );
-      if (!anyOtherActiveChildren) {
-        this.suppressedIdle.delete(parentId);
-        const parent = this.state.sessions.find((s) => s.id === parentId);
-        if (parent) {
-          const updatedParent: SessionModel = {
-            ...parent,
-            state: "idle" as SessionModel["state"],
-            stateChangedAt: Date.now(),
-            stableForMs: 0,
-          };
-          this.state = {
-            ...this.state,
-            sessions: this.state.sessions.map((s) => s.id === parentId ? updatedParent : s),
-            refreshedAt: Date.now(),
-          };
-          this.logger.info("store", "Session state changed", {
-            event: "session.state_changed",
-            sessionId: parentId,
-            previousState: parent.state,
-            state: "idle",
-            tool: parent.tool,
-          });
-          this.emit("store:event", { type: "session:updated", session: updatedParent } satisfies StoreEvent);
-        }
-      }
-    }
-  }
-
-  /**
-   * Remove tmux enrichment from any sessions currently bound to a pane, except
-   * for an optional winning session that should retain the binding.
-   */
-  clearTmuxBindingForPane(paneId: string, exceptSessionId?: string): void {
-    let changed = false;
-    const sessions = this.state.sessions.map((session) => {
-      const boundPaneId = session.legacyPaneId ?? session.tmux?.pane;
-      if (boundPaneId !== paneId || session.id === exceptSessionId) {
-        return session;
-      }
-
-      if (
-        session.detectionSource !== "opencode-sdk"
-        && session.detectionSource !== "opencode-hook"
-        && session.detectionSource !== "opencode-db"
-        && session.detectionSource !== "claude-hook"
-        && session.detectionSource !== "claude-transcript"
-        && session.detectionSource !== "codex-hook"
-        && session.detectionSource !== "codex-transcript"
-      ) {
-        return session;
-      }
-
-      changed = true;
-      return {
-        ...session,
-        source: "standalone" as const,
-        tmux: undefined,
-        legacyPaneId: undefined,
-        processTree: undefined,
-        processChain: undefined,
-        sample: undefined,
-        stableForMs: undefined,
-        panePid: undefined,
-        tty: undefined,
-        paneTitle: undefined,
-        currentCommand: undefined,
-      };
-    });
-
-    if (!changed) {
-      return;
-    }
-
-    this.state = {
-      ...this.state,
-      sessions,
-      refreshedAt: Date.now(),
-    };
-  }
-
-  /** Update usage state and emit event */
-  setUsage(usage: import("../usage/types").UsageState): void {
-    this.state = { ...this.state, usage };
-    this.emit("store:event", { type: "usage:updated", usage } satisfies StoreEvent);
-  }
-
-  /** Update tmux session list */
-  setTmuxSessions(sessions: SessionInfo[]): void {
-    this.state = { ...this.state, tmuxSessions: sessions };
-  }
-
-  /**
-   * Snapshot of process data currently held by the process collector, if any.
-   * Used by other collectors as a fallback when platform tools (pgrep, lsof)
-   * are unavailable.
-   */
-  private processCollector?: { processes: { pid: number; command: string }[] };
-
-  registerProcessCollector(collector: { processes: { pid: number; command: string }[] }): void {
-    this.processCollector = collector;
-  }
-
-  getCollectorProcessSnapshot(): { pid: number; command: string }[] {
-    return this.processCollector?.processes ?? [];
-  }
-
-  /** Update collector status */
-  setCollectorStatus(name: string, status: Partial<CollectorStatus>): void {
-    this.state = {
-      ...this.state,
-      collectorStatus: {
-        ...this.state.collectorStatus,
-        [name]: {
-          ...{ name, running: false, lastRunAt: 0 },
-          ...this.state.collectorStatus[name],
-          ...status,
-        },
-      },
-    };
-  }
-
-  /** Emit a store error event */
-  reportError(source: string, message: string): void {
-    this.logger.warn("store", "Collector error", { event: "collector.error", collector: source, errorMessage: message });
-    this.emit("store:event", { type: "error", source, message } satisfies StoreEvent);
-  }
-
-  // ── SDK PID registry ───────────────────────────────────────────────────────
-
-  /** Register a known SDK process PID (used for PID-ancestry dedup) */
-  registerSdkPid(pid: number, instanceUrl: string): void {
-    this.sdkPids.set(pid, instanceUrl);
-  }
-
-  /** Unregister a SDK process PID */
-  unregisterSdkPid(pid: number): void {
-    this.sdkPids.delete(pid);
-  }
-
-  /** Get the current set of known SDK process PIDs */
-  getSdkPids(): ReadonlyMap<number, string> {
-    return this.sdkPids;
-  }
-
-  // ── Local-command exclusion registry ──────────────────────────────────────
-
-  /** Mark a session as a deliberately-excluded local-command (batch) transcript */
-  markLocalCommand(sessionId: string): void {
-    this.localCommandIds.set(sessionId, Date.now());
-  }
-
-  /** Returns true when the session was excluded as a local-command transcript */
-  isLocalCommand(sessionId: string): boolean {
-    return this.localCommandIds.has(sessionId);
-  }
-
-  /** Apply bounded retention to inactive sessions and local-command markers. */
-  applyRetention(retention: RetentionConfig, now = Date.now()): void {
-    this.pruneLocalCommandIds(retention, now);
-
-    const active = (session: SessionModel) => session.state === "working" || session.state === "waiting-input";
-    const maxAgeMs = retention.standaloneMaxAgeHours > 0
-      ? retention.standaloneMaxAgeHours * 60 * 60 * 1000
-      : 0;
-    const removeIds = new Set<string>();
-
-    if (maxAgeMs > 0) {
-      for (const session of this.state.sessions) {
-        if (active(session)) continue;
-        if (session.source !== "standalone") continue;
-        if (now - session.lastActivity > maxAgeMs) {
-          removeIds.add(session.id);
-        }
-      }
-    }
-
-    const maxSessions = retention.maxSessions;
-    if (maxSessions > 0) {
-      const survivors = this.state.sessions.filter((session) => !removeIds.has(session.id));
-      const overflow = survivors.length - maxSessions;
-      if (overflow > 0) {
-        const candidates = survivors
-          .filter((session) => !active(session))
-          .sort((a, b) => a.lastActivity - b.lastActivity);
-        for (const session of candidates.slice(0, overflow)) {
-          removeIds.add(session.id);
-        }
-      }
-    }
-
-    if (removeIds.size === 0) return;
-
-    for (const id of removeIds) {
-      this.suppressedIdle.delete(id);
-    }
-
-    this.state = {
-      ...this.state,
-      sessions: this.state.sessions.filter((session) => !removeIds.has(session.id)),
-      refreshedAt: now,
-    };
-    for (const id of removeIds) {
-      this.logger.info("store", "Session pruned by retention", { event: "retention.pruned", sessionId: id });
-      this.emit("store:event", { type: "session:removed", sessionId: id } satisfies StoreEvent);
-    }
-    this.emit("store:event", { type: "state:refreshed", timestamp: now } satisfies StoreEvent);
-  }
-
-  private pruneLocalCommandIds(retention: RetentionConfig, now: number): void {
-    const ttlMs = retention.localCommandTtlHours * 60 * 60 * 1000;
-    for (const [sessionId, markedAt] of this.localCommandIds) {
-      if (now - markedAt > ttlMs) {
-        this.localCommandIds.delete(sessionId);
-      }
-    }
-  }
-
-  /** Rebuild childSessionIds on parent sessions that have children */
-  syncChildSessionIds(): void {
-    const sessions = this.state.sessions;
-    const childMap = new Map<string, string[]>();
-    for (const s of sessions) {
-      if (!s.parentSessionId) continue;
-      const siblings = childMap.get(s.parentSessionId) ?? [];
-      if (!siblings.includes(s.id)) siblings.push(s.id);
-      childMap.set(s.parentSessionId, siblings);
-    }
-
-    for (const [parentId, childIds] of childMap) {
-      const parent = this.getSession(parentId);
-      if (!parent) continue;
-
-      const sorted = [...childIds].sort();
-      const existing = [...(parent.childSessionIds ?? [])].sort();
-      if (JSON.stringify(sorted) !== JSON.stringify(existing)) {
-        this.upsertSession({ ...parent, childSessionIds: sorted });
-      }
-    }
-  }
-
-  // ── Typed event helper ─────────────────────────────────────────────────────
-
-  onEvent(listener: (event: StoreEvent) => void): () => void {
-    this.on("store:event", listener);
-    return () => this.off("store:event", listener);
-  }
-}