@scrylog/cli 0.1.0

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

@@ -0,0 +1,241 @@
+import type { SessionModel, TmuxPaneRecord, PaneSample } from "../../../shared/types";
+import type { OpenCodeConfig } from "../../../shared/config";
+import type { DaemonStore } from "../../store";
+import { classifyPane } from "../../../legacy/classifier";
+import { parseOpencodeUrl } from "../opencode/discovery";
+
+export function isOpenCodeManagedSession(session: SessionModel): boolean {
+  return session.detectionSource === "opencode-sdk"
+    || session.detectionSource === "opencode-hook"
+    || session.detectionSource === "opencode-db";
+}
+
+export function isClaudeManagedSession(session: SessionModel): boolean {
+  return session.tool === "claude" && (
+    session.detectionSource === "claude-transcript" ||
+    session.detectionSource === "claude-hook"
+  );
+}
+
+export function isCodexManagedSession(session: SessionModel): boolean {
+  return session.tool === "codex" && (
+    session.detectionSource === "codex-transcript" ||
+    session.detectionSource === "codex-hook"
+  );
+}
+
+export function clearStaleClaudeTmuxBindings(store: DaemonStore, livePaneIds: ReadonlySet<string>): void {
+  const current = store.getSessions();
+  for (const session of current) {
+    const paneId = session.legacyPaneId ?? session.tmux?.pane;
+    if (!isClaudeManagedSession(session) || !paneId) continue;
+    if (!livePaneIds.has(paneId)) {
+      store.clearTmuxBindingForPane(paneId);
+    }
+  }
+}
+
+export function clearStaleCodexTmuxBindings(store: DaemonStore, livePaneIds: ReadonlySet<string>): void {
+  const current = store.getSessions();
+  for (const session of current) {
+    const paneId = session.legacyPaneId ?? session.tmux?.pane;
+    if (!isCodexManagedSession(session) || !paneId) continue;
+    if (!livePaneIds.has(paneId)) {
+      store.clearTmuxBindingForPane(paneId);
+    }
+  }
+}
+
+/**
+ * Compute stableForMs for a managed session (Claude/OpenCode) being enriched
+ * with tmux context.  The pane classifier's stableForMs tracks how long the
+ * *pane* has been in the same heuristic state, which is unrelated to when the
+ * managed session's state last changed (that's driven by hooks/SDK).
+ * Using the pane value would make the timer jump to minutes the moment tmux
+ * polls, even if the session state just changed moments ago.
+ */
+export function managedStableForMs(session: SessionModel): number {
+  const since = session.stateChangedAt ?? session.lastActivity;
+  if (!since) return 0;
+  return Math.max(0, Date.now() - since);
+}
+
+export function detectClaudePermissionPrompt(sample: PaneSample | null): { state: SessionModel["state"]; hasAttention: boolean; summary: string } | null {
+  if (!sample) return null;
+  const text = sample.lines.join("\n");
+  if (!/Do you want to proceed\?/i.test(text)) return null;
+  return {
+    state: "waiting-input",
+    hasAttention: true,
+    summary: "Do you want to proceed?",
+  };
+}
+
+export function isClaudePaneCandidate(
+  processTree: Array<{ command: string; comm: string }>,
+  currentCommand: string,
+): boolean {
+  const combined = `${currentCommand} ${processTree.map((p) => `${p.comm} ${p.command}`).join(" ")}`;
+  // Match 'claude' binary but not 'claude-code' or other unrelated uses
+  return /(?:^|\s|\/)(claude)(?:\s|$)/i.test(combined);
+}
+
+export function isCodexPaneCandidate(
+  processTree: Array<{ command: string; comm: string }>,
+  currentCommand: string,
+): boolean {
+  const combined = `${currentCommand} ${processTree.map((p) => `${p.comm} ${p.command}`).join(" ")}`;
+  return /(?:^|\s|\/)(codex)(?:\s|$)/i.test(combined);
+}
+
+export function detectCodexPermissionPrompt(sample: PaneSample | null): { state: SessionModel["state"]; hasAttention: boolean; summary: string } | null {
+  if (!sample) return null;
+  const text = sample.lines.join("\n");
+
+  // Codex permission prompts for tool execution approval
+  const permMatch = text.match(/approve(?:d)?\s+(?:codex\s+)?to\s+run\s+(\S+)/i)
+    ?? text.match(/Allow\s+(?:this\s+)?(?:command|action|tool)\??/i)
+    ?? text.match(/\[Y\]es\/\[N\]o/i);
+  if (permMatch) {
+    return {
+      state: "waiting-input",
+      hasAttention: true,
+      summary: "Permission request",
+    };
+  }
+
+  // Codex agent asking a question (bullet-point lines ending in ?)
+  const questionLines = sample.lines.filter((line) => /^\s*•\s.*\?\s*$/.test(line));
+  if (questionLines.length > 0) {
+    const last = questionLines[questionLines.length - 1]!.replace(/^\s*•\s*/, "").trim();
+    return {
+      state: "waiting-input",
+      hasAttention: true,
+      summary: last.slice(0, 120) || "Waiting for input",
+    };
+  }
+
+  const nonEmpty = sample.lines.filter((l) => l.trim().length > 0);
+  const lastNonEmpty = nonEmpty[nonEmpty.length - 1];
+
+  // Prompt cursor, optionally with a prefilled confirmation question.
+  const promptMatch = lastNonEmpty?.match(/^\s*›\s*(.*)$/);
+  if (promptMatch) {
+    const promptText = (promptMatch[1] ?? "").trim();
+    if (promptText.length > 0 && /\?\s*$/.test(promptText)) {
+      return {
+        state: "waiting-input",
+        hasAttention: true,
+        summary: promptText.slice(0, 120),
+      };
+    }
+  }
+
+  return null;
+}
+
+export function clearStaleOpenCodeTmuxBindings(store: DaemonStore, livePaneIds: ReadonlySet<string>): void {
+  const current = store.getSessions();
+  for (const session of current) {
+    const paneId = session.legacyPaneId ?? session.tmux?.pane;
+    if (!isOpenCodeManagedSession(session) || !paneId) {
+      continue;
+    }
+
+    if (!livePaneIds.has(paneId)) {
+      store.clearTmuxBindingForPane(paneId);
+    }
+  }
+}
+
+export function isOpenCodePaneCandidate(
+  pane: TmuxPaneRecord,
+  processTree: Array<{ command: string }>,
+  classifiedTool?: string,
+): boolean {
+  return Boolean(
+    pane.opencodeSession ||
+    classifiedTool === "opencode" ||
+    processTree.some((process) => parseOpencodeUrl(process.command) !== undefined) ||
+    isAttachClientPane(processTree),
+  );
+}
+
+export function isAttachClientPane(processTree: Array<{ command: string }>): boolean {
+  return processTree.some(
+    (process) =>
+      /(?:^|\s)(?:opencode|node\s+.*\/opencode|bun\s+.*\/opencode)\s+attach\b/i.test(process.command) ||
+      /\bbun\s+run\s+src\/oc\/index\.ts\b/i.test(process.command) ||
+      /(?:^|\s)(?:oc|[^\s]*\/oc)(?:\s|$)/i.test(process.command),
+  );
+}
+
+export function shouldHideOpenCodePane(
+  opencode: OpenCodeConfig,
+  pane: TmuxPaneRecord,
+  processTree: Array<{ command: string }>,
+  classifiedTool?: string,
+): boolean {
+  if (opencode.mode !== "sse") {
+    return false;
+  }
+
+  return isOpenCodePaneCandidate(pane, processTree, classifiedTool);
+}
+
+export function looksLikeAgent(processTree: Array<{ command: string; comm: string }>, currentCommand: string): boolean {
+  const combined = `${currentCommand} ${processTree.map((p) => `${p.comm} ${p.command}`).join(" ")}`;
+  return /(opencode|codex|copilotcli|copilot|claude)/i.test(combined);
+}
+
+/**
+ * Converts a classified pane record into a SessionModel.
+ * Panes that are already covered by SDK collectors (opencode/claude) will
+ * be marked with legacyPaneId so those collectors can take precedence.
+ */
+export function paneModelToSession(pane: ReturnType<typeof classifyPane>["pane"]): SessionModel {
+  const tool = pane.tool === "opencode" ? "opencode"
+    : pane.tool === "claude" ? "claude"
+    : pane.tool === "codex" ? "codex"
+    : pane.tool === "copilotcli" ? "copilotcli"
+    : pane.tool === "shell" ? "shell"
+    : "unknown";
+
+  const state = pane.state === "working" ? "working"
+    : pane.state === "idle" ? "idle"
+    : pane.state === "waiting-input" ? "waiting-input"
+    : pane.state === "shell" ? "shell"
+    : "unknown";
+  const claudePrompt = tool === "claude" ? detectClaudePermissionPrompt(pane.sample) : null;
+  const codexPrompt = tool === "codex" ? detectCodexPermissionPrompt(pane.sample) : null;
+
+  return {
+    id: `tmux:${pane.paneId}`,
+    source: "tmux",
+    tool,
+    state: codexPrompt?.state ?? claudePrompt?.state ?? state,
+    project: pane.project,
+    tmux: {
+      session: pane.sessionName,
+      window: String(pane.windowIndex),
+      pane: pane.paneId,
+    },
+    summary: codexPrompt?.summary ?? claudePrompt?.summary ?? pane.summary,
+    lastActivity: pane.lastChangedAt,
+    detectionSource: "fallback-detection",
+    legacyPaneId: pane.paneId,
+    // Extended fields
+    processTree: pane.processTree,
+    processChain: pane.processChain,
+    sample: pane.sample,
+    toolReasons: pane.toolReasons,
+    stateReasons: pane.stateReasons,
+    stableForMs: pane.stableForMs,
+    hasAttention: codexPrompt?.hasAttention ?? claudePrompt?.hasAttention ?? pane.hasAttention,
+    currentCommand: pane.currentCommand,
+    currentPath: pane.currentPath,
+    panePid: pane.panePid,
+    tty: pane.tty,
+    paneTitle: pane.title,
+  };
+}

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

@@ -0,0 +1,4 @@
+export { TmuxCollector } from "./collector";
+export { clearStaleClaudeTmuxBindings, clearStaleCodexTmuxBindings, clearStaleOpenCodeTmuxBindings, isAttachClientPane, shouldHideOpenCodePane, looksLikeAgent } from "./enrichment";
+export { collectTmuxState, parseSessions, parsePanes, capturePane } from "./parse";
+export type { TmuxCollectionResult } from "./parse";

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

@@ -0,0 +1,128 @@
+import type { PaneSample, SessionInfo, TmuxPaneRecord } from "../../../shared/types";
+import { compactWhitespace, maybeRunCommand, parseIntSafe, pickMeaningfulTail, stripAnsiAndUi } from "../../../shared/utils";
+
+export const PANE_FORMAT = [
+  "#{session_name}",
+  "#{window_index}",
+  "#{window_name}",
+  "#{pane_index}",
+  "#{pane_id}",
+  "#{pane_pid}",
+  "#{pane_current_command}",
+  "#{pane_current_path}",
+  "#{pane_active}",
+  "#{pane_tty}",
+  "#{pane_title}",
+  "#{pane_width}",
+  "#{pane_height}",
+  "#{@opencode-session}",
+  "#{@claude-session}",
+  "#{@codex-session}",
+].join("\t");
+
+export const SESSION_FORMAT = ["#{session_name}", "#{session_attached}", "#{session_windows}"].join("\t");
+
+export interface TmuxCollectionResult {
+  sessions: SessionInfo[];
+  panes: TmuxPaneRecord[];
+  errors: string[];
+}
+
+export function collectTmuxState(timeoutMs?: number): TmuxCollectionResult {
+  const sessionResult = maybeRunCommand(["tmux", "list-sessions", "-F", SESSION_FORMAT], timeoutMs);
+  if (!sessionResult.ok) {
+    if (
+      sessionResult.error.includes("failed to connect to server") ||
+      sessionResult.error.includes("no server running")
+    ) {
+      return { sessions: [], panes: [], errors: [] };
+    }
+    return { sessions: [], panes: [], errors: [sessionResult.error] };
+  }
+
+  const paneResult = maybeRunCommand(["tmux", "list-panes", "-a", "-F", PANE_FORMAT], timeoutMs);
+  const sessions = parseSessions(sessionResult.output);
+
+  if (!paneResult.ok) {
+    return { sessions, panes: [], errors: [paneResult.error] };
+  }
+
+  return { sessions, panes: parsePanes(paneResult.output), errors: [] };
+}
+
+export function capturePane(paneId: string, lines: number, timeoutMs?: number): PaneSample | null {
+  const result = maybeRunCommand(["tmux", "capture-pane", "-p", "-t", paneId, "-S", `-${lines}`], timeoutMs);
+  if (!result.ok) {
+    return null;
+  }
+
+  const allLines = result.output.split(/\r?\n/).map((line: string) => line.replace(/\t/g, "    "));
+  const cleanLines = allLines.filter(
+    (line: string, index: number, arr: string[]) => !(index === arr.length - 1 && line === ""),
+  );
+
+  return {
+    paneId,
+    lines: cleanLines,
+    preview: pickMeaningfulTail(cleanLines, compactWhitespace(stripAnsiAndUi(cleanLines.slice(-3).join(" ")))),
+  };
+}
+
+export function parseSessions(output: string): SessionInfo[] {
+  return output
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      const [name, attached, windows] = line.split("\t");
+      return {
+        name: name ?? "",
+        attached: attached === "1",
+        windows: parseIntSafe(windows ?? ""),
+      };
+    });
+}
+
+export function parsePanes(output: string): TmuxPaneRecord[] {
+  return output
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      const [
+        sessionName,
+        windowIndex,
+        windowName,
+        paneIndex,
+        paneId,
+        panePid,
+        currentCommand,
+        currentPath,
+        active,
+        tty,
+        title,
+        width,
+        height,
+        opencodeSession,
+        claudeSession,
+        codexSession,
+      ] = line.split("\t");
+
+      return {
+        sessionName: sessionName ?? "",
+        windowIndex: parseIntSafe(windowIndex ?? ""),
+        windowName: windowName ?? "",
+        paneIndex: parseIntSafe(paneIndex ?? ""),
+        paneId: paneId ?? "",
+        panePid: parseIntSafe(panePid ?? ""),
+        currentCommand: currentCommand ?? "",
+        currentPath: currentPath ?? "",
+        active: active === "1",
+        tty: tty ?? "",
+        title: title ?? "",
+        width: parseIntSafe(width ?? ""),
+        height: parseIntSafe(height ?? ""),
+        opencodeSession: opencodeSession || undefined,
+        claudeSession: claudeSession || undefined,
+        codexSession: codexSession || undefined,
+      } satisfies TmuxPaneRecord;
+    });
+}

package/src/daemon/collectors/usage.ts

@@ -0,0 +1,193 @@
+import type { ScrylogConfig } from "../../shared/config";
+import type { Logger } from "../../shared/logger";
+import type { UsageState, UsageProviderEntry } from "../../usage/types";
+import { ClaudeSourcePlanner } from "../../usage/planner";
+import { ClaudeUsageProvider } from "../../usage/providers/claude";
+import { CodexUsageProvider } from "../../usage/providers/codex";
+import { OpenCodeGoUsageProvider } from "../../usage/providers/opencode-go";
+import { ClaudeAuthResolver } from "../../usage/resolvers/claude-auth";
+import { ClaudeWebResolver } from "../../usage/resolvers/claude-web";
+import { ClaudeCliResolver } from "../../usage/resolvers/claude-cli";
+import { CodexAuthResolver } from "../../usage/resolvers/codex-auth";
+import { OpenCodeGoWebResolver } from "../../usage/resolvers/opencode-go-web";
+import type { DaemonStore } from "../store";
+import type { Collector } from "../scheduler";
+
+export class UsageCollector implements Collector {
+  name = "usage";
+  private timer?: ReturnType<typeof setInterval>;
+  private store?: DaemonStore;
+  private config?: ScrylogConfig;
+  private logger?: Logger;
+  private polling = false;
+  private skippedPolls = 0;
+  private errorCount = 0;
+
+  async start(store: DaemonStore, config: ScrylogConfig, logger: Logger): Promise<void> {
+    this.store = store;
+    this.config = config;
+    this.logger = logger;
+
+    logger.info("usage", "Collector started", { event: "collector.started", collector: this.name, intervalMs: config.usage.pollIntervalMs, providers: config.usage.providers });
+
+    await this.safePoll();
+
+    this.timer = setInterval(() => void this.safePoll(), config.usage.pollIntervalMs);
+  }
+
+  async stop(): Promise<void> {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+    this.logger?.info("usage", "Collector stopped", { event: "collector.stopped", collector: this.name });
+  }
+
+  private async safePoll(): Promise<void> {
+    const store = this.store!;
+    if (this.polling) {
+      this.skippedPolls += 1;
+      store.setCollectorStatus(this.name, { skippedPolls: this.skippedPolls });
+      this.logger?.debug("usage", "Skipping overlapping poll", { event: "collector.poll_skipped", collector: this.name, skippedPolls: this.skippedPolls });
+      return;
+    }
+
+    this.polling = true;
+    const startedAt = Date.now();
+    try {
+      await this.poll();
+      store.setCollectorStatus(this.name, { lastDurationMs: Date.now() - startedAt, skippedPolls: this.skippedPolls, errorCount: this.errorCount });
+    } finally {
+      this.polling = false;
+    }
+  }
+
+  private async poll(): Promise<void> {
+    const store = this.store!;
+    const config = this.config!;
+    const logger = this.logger!;
+
+    const providers: UsageProviderEntry[] = [];
+    const attemptedAt = Date.now();
+
+    for (const providerName of config.usage.providers) {
+      if (providerName === "claude") {
+        const oauthResolver = new ClaudeAuthResolver();
+        const webResolver = new ClaudeWebResolver();
+        const cliResolver = new ClaudeCliResolver();
+        const planner = new ClaudeSourcePlanner(
+          {
+            dataSource: config.usage.claude.dataSource,
+            webExtrasEnabled: config.usage.claude.webExtrasEnabled,
+          },
+          oauthResolver,
+          webResolver,
+          cliResolver,
+        );
+
+        const decision = await planner.decide();
+        if (decision.primary === "auto") {
+          logger.debug("usage", "Claude not available on this machine, omitting from response", { event: "provider.unavailable", provider: "claude" });
+          continue;
+        }
+
+        const claudeProvider = new ClaudeUsageProvider(planner, oauthResolver, webResolver, cliResolver);
+        try {
+          const result = await withAbort((signal) => claudeProvider.fetch({ signal }), config.daemon.networkTimeoutMs, "Claude usage fetch timed out");
+          providers.push(result.entry);
+        } catch (err) {
+          this.errorCount += 1;
+          const message = err instanceof Error ? err.message : String(err);
+          logger.warn("usage", "Claude provider unexpected error", { event: "provider.fetch_failed", provider: "claude", errorMessage: message });
+          providers.push({
+            provider: "claude",
+            accountId: null,
+            available: true,
+            status: "error",
+            errors: [message],
+          });
+        }
+      } else if (providerName === "codex") {
+        const resolver = new CodexAuthResolver();
+
+        if (!(await resolver.isAvailable())) {
+          logger.debug("usage", "Codex not available on this machine, omitting from response", { event: "provider.unavailable", provider: "codex" });
+          continue;
+        }
+
+        const provider = new CodexUsageProvider(resolver);
+
+        try {
+          const result = await withAbort((signal) => provider.fetch({ signal }), config.daemon.networkTimeoutMs, "Codex usage fetch timed out");
+          providers.push(result.entry);
+        } catch (err) {
+          this.errorCount += 1;
+          const message = err instanceof Error ? err.message : String(err);
+          logger.warn("usage", "Codex provider unexpected error", { event: "provider.fetch_failed", provider: "codex", errorMessage: message });
+          providers.push({
+            provider: "codex",
+            accountId: null,
+            available: true,
+            status: "error",
+            errors: [message],
+          });
+        }
+      } else if (providerName === "opencode-go") {
+        const resolver = new OpenCodeGoWebResolver();
+
+        if (!(await resolver.isAvailable())) {
+          logger.debug("usage", "OpenCode Go not available on this machine, omitting from response", { event: "provider.unavailable", provider: "opencode-go" });
+          continue;
+        }
+
+        const provider = new OpenCodeGoUsageProvider(resolver, config.usage.opencodeGo.serverFnId);
+
+        try {
+          const result = await withAbort((signal) => provider.fetch({ signal }), config.daemon.networkTimeoutMs, "OpenCode Go usage fetch timed out");
+          providers.push(result.entry);
+        } catch (err) {
+          this.errorCount += 1;
+          const message = err instanceof Error ? err.message : String(err);
+          logger.warn("usage", "OpenCode Go provider unexpected error", { event: "provider.fetch_failed", provider: "opencode-go", errorMessage: message });
+          providers.push({
+            provider: "opencode-go",
+            accountId: null,
+            available: true,
+            status: "error",
+            errors: [message],
+          });
+        }
+      }
+    }
+
+    const state: UsageState = {
+      providers,
+      lastRefreshedAt: attemptedAt,
+    };
+
+    store.setUsage(state);
+    store.setCollectorStatus(this.name, { running: true, lastRunAt: attemptedAt, skippedPolls: this.skippedPolls, errorCount: this.errorCount });
+    logger.debug("usage", "Poll complete", { event: "collector.poll_completed", collector: this.name, providerCount: providers.length });
+  }
+}
+
+function withAbort<T>(run: (signal: AbortSignal) => Promise<T>, timeoutMs: number, message: string): Promise<T> {
+  const controller = new AbortController();
+  const promise = run(controller.signal);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error(message));
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      },
+    );
+  });
+}