@scrylog/cli 0.3.0 → 0.3.2

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

@@ -1,242 +0,0 @@
-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),
-      windowName: pane.windowName,
-      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

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

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

@@ -1,259 +0,0 @@
-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 { keychainCoordinator } from "../../usage/resolvers/keychain-coordinator";
-import type { DaemonStore } from "../store";
-import type { Collector } from "../scheduler";
-
-interface UsageResolverSet {
-  claudeProvider: ClaudeUsageProvider;
-  codexProvider: CodexUsageProvider;
-  opencodeGoProvider: OpenCodeGoUsageProvider;
-}
-
-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;
-  private pollController?: AbortController;
-  private resolverSet?: UsageResolverSet;
-
-  async start(store: DaemonStore, config: ScrylogConfig, logger: Logger): Promise<void> {
-    this.store = store;
-    this.config = config;
-    this.logger = logger;
-    keychainCoordinator.configure({
-      allowPrompts: () => config.usage.auth.allowKeychainPrompts,
-      onFailure: (failure) =>
-        logger.warn("usage", "Keychain read failed", {
-          event: "keychain_read_failed",
-          code: failure.code,
-          service: failure.service,
-          account: failure.account ?? null,
-          cooldownUntil: failure.cooldownUntil ? new Date(failure.cooldownUntil).toISOString() : null,
-        }),
-    });
-
-    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.pollController?.abort();
-    // Drop resolver/provider instances so a later start() rebuilds them from
-    // the current configuration instead of reusing stale constructor args.
-    this.resolverSet = 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 pollController = new AbortController();
-    this.pollController = pollController;
-    const startedAt = Date.now();
-    try {
-      await this.poll(pollController.signal);
-      store.setCollectorStatus(this.name, { lastDurationMs: Date.now() - startedAt, skippedPolls: this.skippedPolls, errorCount: this.errorCount });
-    } catch (error) {
-      if (!pollController.signal.aborted) {
-        this.errorCount += 1;
-        this.logger?.warn("usage", "Poll failed", {
-          event: "collector.poll_failed",
-          collector: this.name,
-          errorMessage: error instanceof Error ? error.message : String(error),
-        });
-      }
-    } finally {
-      if (this.pollController === pollController) this.pollController = undefined;
-      this.polling = false;
-    }
-  }
-
-  private async poll(signal: AbortSignal): Promise<void> {
-    const store = this.store!;
-    const config = this.config!;
-    const logger = this.logger!;
-
-    const resolvers = this.ensureResolvers(config);
-    const providers: UsageProviderEntry[] = [];
-    const attemptedAt = Date.now();
-
-    for (const providerName of config.usage.providers) {
-      if (providerName === "claude") {
-        try {
-          const result = await withAbort((requestSignal) => resolvers.claudeProvider.fetch({ signal: requestSignal }), config.daemon.networkTimeoutMs, "Claude usage fetch timed out", signal);
-          providers.push(result.entry);
-        } catch (err) {
-          if (signal.aborted) throw 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") {
-        try {
-          const result = await withAbort((requestSignal) => resolvers.codexProvider.fetch({ signal: requestSignal }), config.daemon.networkTimeoutMs, "Codex usage fetch timed out", signal);
-          providers.push(result.entry);
-        } catch (err) {
-          if (signal.aborted) throw 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") {
-        try {
-          const result = await withAbort((requestSignal) => resolvers.opencodeGoProvider.fetch({ signal: requestSignal }), config.daemon.networkTimeoutMs, "OpenCode Go usage fetch timed out", signal);
-          providers.push(result.entry);
-        } catch (err) {
-          if (signal.aborted) throw 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 });
-  }
-
-  /**
-   * Resolvers and providers are created once per collector lifetime so
-   * resolved credentials stay cached across polls instead of re-reading
-   * credential sources on every cycle.
-   */
-  private ensureResolvers(config: ScrylogConfig): UsageResolverSet {
-    if (!this.resolverSet) {
-      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,
-      );
-
-      this.resolverSet = {
-        claudeProvider: new ClaudeUsageProvider(planner, oauthResolver, webResolver, cliResolver),
-        codexProvider: new CodexUsageProvider(
-          new CodexAuthResolver(config.usage.codex.chatgptBaseUrl),
-          config.usage.codex.dataSource,
-        ),
-        opencodeGoProvider: new OpenCodeGoUsageProvider(
-          new OpenCodeGoWebResolver(),
-          config.usage.opencodeGo.serverFnId,
-        ),
-      };
-    }
-    return this.resolverSet;
-  }
-}
-
-export function withAbort<T>(
-  run: (signal: AbortSignal) => Promise<T>,
-  timeoutMs: number,
-  message: string,
-  parentSignal?: AbortSignal,
-): Promise<T> {
-  const controller = new AbortController();
-  if (parentSignal?.aborted) {
-    controller.abort();
-    return Promise.reject(new Error("Usage poll cancelled"));
-  }
-  return new Promise<T>((resolve, reject) => {
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    const cleanup = () => {
-      if (timer) clearTimeout(timer);
-      parentSignal?.removeEventListener("abort", onParentAbort);
-    };
-    const onParentAbort = () => {
-      controller.abort();
-      reject(new Error("Usage poll cancelled"));
-    };
-    parentSignal?.addEventListener("abort", onParentAbort, { once: true });
-    // Register the deadline before starting the request so the first
-    // synchronous step is already bounded.
-    timer = setTimeout(() => {
-      controller.abort();
-      reject(new Error(message));
-    }, timeoutMs);
-
-    let promise: Promise<T>;
-    try {
-      promise = run(controller.signal);
-    } catch (error) {
-      cleanup();
-      reject(error instanceof Error ? error : new Error(String(error)));
-      return;
-    }
-    promise.then(
-      (value) => {
-        cleanup();
-        resolve(value);
-      },
-      (error) => {
-        cleanup();
-        reject(error);
-      },
-    );
-  });
-}