@scrylog/cli 0.3.0 → 0.3.1

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

@@ -1,128 +0,0 @@
-import { listSessions } from "@joeldmtz/prtl-core";
-import type { ListSessionsOptions, PrtlListResult } from "@joeldmtz/prtl-core";
-import type { ScrylogConfig } from "../../../shared/config";
-import type { SessionModel } from "../../../shared/types";
-import type { Logger } from "../../../shared/logger";
-import { NOOP_LOGGER } from "../../../shared/logger";
-import type { Collector } from "../../scheduler";
-import type { DaemonStore } from "../../store";
-import type { GitCollector } from "../git";
-import { herdrPaneToSession } from "./normalization";
-
-type HerdrList = (options?: ListSessionsOptions) => Promise<PrtlListResult>;
-
-export class HerdrCollector implements Collector {
-  name = "herdr";
-  private timer: ReturnType<typeof setInterval> | null = null;
-  private inFlight = false;
-  private generation = 0;
-  private logger: Logger = NOOP_LOGGER;
-
-  constructor(
-    private readonly gitCollector: GitCollector,
-    private readonly list: HerdrList = listSessions,
-  ) {}
-
-  start(store: DaemonStore, config: ScrylogConfig, logger: Logger): void {
-    this.logger = logger;
-    const generation = ++this.generation;
-    const run = () => void this.collect(store, config.daemon.commandTimeoutMs, generation);
-    logger.info("herdr", "Collector started", { event: "collector.started", collector: this.name, intervalMs: config.daemon.pollIntervalMs });
-    run();
-    this.timer = setInterval(run, config.daemon.pollIntervalMs);
-  }
-
-  stop(): void {
-    this.generation += 1;
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    this.logger.info("herdr", "Collector stopped", { event: "collector.stopped", collector: this.name });
-  }
-
-  async collect(store: DaemonStore, timeoutMs: number, generation = this.generation): Promise<void> {
-    if (this.inFlight) {
-      this.logger.debug("herdr", "Skipping overlapping poll", { event: "collector.poll_skipped", collector: this.name });
-      return;
-    }
-
-    this.inFlight = true;
-    const startedAt = Date.now();
-    try {
-      const result = await this.list({ provider: "herdr", timeoutMs });
-      if (generation !== this.generation) return;
-      const provider = result.metadata.providers.herdr;
-      const liveHerdrIds = new Set<string>();
-
-      if (provider?.available) {
-        for (const pane of result.items.filter((item) => item.provider === "herdr")) {
-          const path = pane.foregroundCwd ?? pane.cwd;
-          const session = herdrPaneToSession(pane, path ? this.gitCollector.resolve(path) : undefined);
-          liveHerdrIds.add(session.id);
-          const existing = store.getSession(session.id);
-          if (existing && existing.detectionSource !== "herdr") {
-            if (existing.source !== "tmux") {
-              store.upsertSession({
-                ...existing,
-                source: "herdr",
-                herdr: session.herdr,
-                project: session.project ?? existing.project,
-                currentPath: existing.currentPath ?? session.currentPath,
-                currentCommand: session.currentCommand,
-                paneTitle: session.paneTitle,
-              });
-            }
-          } else {
-            // herdr-native sessions: prtl-core refreshes metadata.collectedAt on
-            // every collection, so a pane doing nothing would report a fresh
-            // lastActivity each poll and constantly reorder idle groups. Only
-            // real changes (state, agent status, summary) count as activity.
-            const previous = existing?.detectionSource === "herdr" ? existing : undefined;
-            const activityChanged = Boolean(
-              previous
-              && (previous.state !== session.state
-                || previous.herdr?.agentStatus !== session.herdr?.agentStatus
-                || previous.summary !== session.summary),
-            );
-            const merged: SessionModel = previous && !activityChanged
-              ? { ...session, lastActivity: previous.lastActivity }
-              : { ...session, lastActivity: Date.now() };
-            store.upsertSession(merged);
-          }
-        }
-
-        for (const session of store.getSessions()) {
-          if (session.source !== "herdr" || liveHerdrIds.has(session.id)) continue;
-          if (session.detectionSource === "herdr") {
-            store.removeSession(session.id);
-          } else {
-            store.clearHerdrBinding(session.id);
-          }
-        }
-      }
-
-      const errors = provider?.errors?.map((error) => `${error.source}: ${error.message}`) ?? [];
-      const lastError = provider?.available ? undefined : (provider?.reason ?? errors.at(-1) ?? "herdr_unavailable");
-      store.setCollectorStatus(this.name, {
-        running: true,
-        lastRunAt: Date.now(),
-        lastDurationMs: Date.now() - startedAt,
-        lastError,
-      });
-      this.logger.debug("herdr", "Collection completed", {
-        event: "collector.poll_completed",
-        collector: this.name,
-        available: provider?.available ?? false,
-        panes: liveHerdrIds.size,
-      });
-    } catch (error) {
-      if (generation !== this.generation) return;
-      const message = error instanceof Error ? error.message : String(error);
-      store.setCollectorStatus(this.name, { running: true, lastRunAt: Date.now(), lastDurationMs: Date.now() - startedAt, lastError: message });
-      this.logger.warn("herdr", "Collection failed", { event: "collector.poll_failed", collector: this.name, errorMessage: message });
-    } finally {
-      this.inFlight = false;
-    }
-  }
-}

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

@@ -1,2 +0,0 @@
-export { HerdrCollector } from "./collector";
-export { herdrPaneToSession, herdrSessionId, herdrState, herdrSummary, herdrTool } from "./normalization";

package/src/daemon/collectors/herdr/normalization.ts

@@ -1,111 +0,0 @@
-import type { PrtlPane } from "@joeldmtz/prtl-core";
-import type { ProjectInfo, SessionModel, SessionState, SessionTool } from "../../../shared/types";
-
-const SESSION_TOOLS = new Set<SessionTool>(["opencode", "claude", "codex"]);
-
-function normalizeAgentName(value: string): string {
-  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
-}
-
-export function herdrTool(pane: PrtlPane): SessionTool {
-  const candidates = [pane.agent?.session?.agent, pane.agent?.name, pane.agent?.session?.source?.split(":").at(-1)];
-  for (const candidate of candidates) {
-    if (!candidate) continue;
-    const normalized = normalizeAgentName(candidate);
-    if (normalized === "opencode") return "opencode";
-    if (normalized === "claude" || normalized === "claudecode") return "claude";
-    if (normalized === "codex" || normalized === "codexcli") return "codex";
-    if (normalized === "copilot" || normalized === "copilotcli" || normalized === "githubcopilot") return "copilotcli";
-  }
-  if (!pane.agent && pane.command) return "shell";
-  return "unknown";
-}
-
-export function herdrState(pane: PrtlPane, tool = herdrTool(pane)): SessionState {
-  if (!pane.agent) return tool === "shell" ? "shell" : "unknown";
-  switch (pane.agent.status?.toLowerCase()) {
-    case "working": return "working";
-    case "idle":
-    case "done": return "idle";
-    case "blocked": return "waiting-input";
-    default: return "unknown";
-  }
-}
-
-export function herdrSessionId(pane: PrtlPane, tool = herdrTool(pane)): string {
-  const agentSessionId = pane.agent?.sessionId ?? pane.agent?.session?.value;
-  return agentSessionId && SESSION_TOOLS.has(tool)
-    ? `${tool}:${agentSessionId}`
-    : `herdr:${pane.id}`;
-}
-
-export function herdrSummary(pane: PrtlPane): string {
-  const statusLabel = pane.agent?.status ? pane.stateLabels?.[pane.agent.status] : undefined;
-  return pane.customStatus
-    ?? statusLabel
-    ?? pane.title
-    ?? pane.terminalTitleStripped
-    ?? pane.displayAgent
-    ?? pane.command
-    ?? pane.agent?.name
-    ?? pane.tab
-    ?? pane.workspace
-    ?? "Herdr pane";
-}
-
-/**
- * Explicit pane name only. prtl-core's `pane.name` falls back to the agent
- * name when the pane has no label; in that case the pane is unnamed and the
- * label logic must fall back to the tab name instead. The raw herdr record
- * carries the original pane fields, which is the only way to distinguish an
- * explicit name from prtl-core's agent-derived fallback.
- */
-export function herdrPaneName(pane: PrtlPane): string | undefined {
-  const raw = (pane.metadata?.raw as { pane?: { title?: unknown; label?: unknown; name?: unknown } } | undefined)?.pane;
-  if (raw) {
-    const explicit = [raw.name, raw.title, raw.label].find(
-      (value) => typeof value === "string" && value.trim().length > 0,
-    );
-    return typeof explicit === "string" ? explicit.trim() : undefined;
-  }
-  // No raw record to discriminate: only trust an explicitly-typed PrtlPane
-  // name field (raw pane title/title/label from the provider), never render
-  // the agent-derived fallback as a pane name.
-  return pane.title?.trim() || undefined;
-}
-
-export function herdrPaneToSession(pane: PrtlPane, project?: ProjectInfo): SessionModel {
-  const tool = herdrTool(pane);
-  const state = herdrState(pane, tool);
-  const agentSessionId = pane.agent?.sessionId ?? pane.agent?.session?.value;
-  const collectedAt = Date.parse(pane.metadata.collectedAt);
-  return {
-    id: herdrSessionId(pane, tool),
-    source: "herdr",
-    tool,
-    state,
-    project,
-    summary: herdrSummary(pane),
-    lastActivity: Number.isFinite(collectedAt) ? collectedAt : Date.now(),
-    hasAttention: state === "waiting-input",
-    activeTool: pane.agent?.name,
-    detectionSource: "herdr",
-    currentCommand: pane.command,
-    currentPath: pane.foregroundCwd ?? pane.cwd,
-    paneTitle: pane.title,
-    herdr: {
-      paneId: pane.id,
-      terminalId: pane.terminalId,
-      workspaceId: pane.workspaceId,
-      workspace: pane.workspace,
-      tabId: pane.tabId,
-      tab: pane.tab,
-      name: herdrPaneName(pane),
-      focused: pane.focused,
-      providerSource: pane.metadata.source,
-      agent: pane.agent?.name,
-      agentStatus: pane.agent?.status,
-      agentSessionId,
-    },
-  };
-}

package/src/daemon/collectors/opencode/README.md

@@ -1,106 +0,0 @@
-# OpenCode Collector
-
-Monitors OpenCode sessions by connecting to running OpenCode instances via the
-`@opencode-ai/sdk` HTTP client. Uses SSE live events as the primary transport
-with HTTP polling as a fallback.
-
-## Data Flow
-
-```
-                          config.opencode.instances[]
-                                   │
-                                   │
-         ┌─────────────────────────▼──────────────────────────┐
-         │                     discovery                      │
-         │   discoverInstances()  │  parseOpencodeUrl()       │
-         │   discoverListeningPort()  │  findOpencodeInTree() │
-         └─────────────────────────┬──────────────────────────┘
-                                   │  DiscoveredInstance[]
-                                   │
-                                   ▼
-  ┌──────────────────────────────────────────────────────────────────┐
-  │                         collector.ts                             │
-  │                                                                  │
-  │   ┌───────────────┐            ┌───────────────────────────┐   │
-  │   │  60s refresh()│            │  SSE event.subscribe()    │   │
-  │   │  discover +   │            │                           │   │
-  │   │  connectInstance() ┌─────►│  session.status           │   │
-  │   └───────┬───────┘    │       │  session.updated/created  │   │
-  │           │            │       │  permission.updated       │   │
-  │           │    ┌───────┴───────┤  permission.replied       │   │
-  │           │    │ poll fallback │  session.deleted          │   │
-  │           │    │ (10s)         │  session.error            │   │
-  │           │    └───────┬───────┘                           │   │
-  │           │            │                                   │   │
-  │           │            ▼                                   │   │
-  │           │    ┌─────────────────┐                         │   │
-  │           └───►│ session-builder │  buildSessionModel()    │   │
-  │                │                 │  mapSessionStatus()     │   │
-  │                └────────┬────────┘                         │   │
-  │                         │                                   │   │
-  │                         ▼                                   │   │
-  │              store.upsertSession()                            │   │
-  │              store.syncChildSessionIds()                      │   │
-  │              store.registerSdkPid()                         │   │
-  └──────────────────────────────────────────────────────────────────┘
-         │
-         ▼
-    DaemonStore ──► /api/events SSE ──► TUI
-```
-
-## Modules
-
-| File | Responsibility | Key Exports |
-|------|-------------|-------------|
-| `discovery.ts` | Auto-discover OpenCode processes via `ps`, resolve ephemeral ports with `lsof`, parse command-line URLs | `discoverInstances()`, `parseOpencodeUrl()`, `hasExplicitPort()`, `discoverListeningPort()`, `findOpencodeInTree()`, `clearPidPortCache()`, `DiscoveredInstance` |
-| `session-builder.ts` | Map SDK `Session` + `SessionStatus` → `SessionModel`; compute `state` and `hasAttention` from pending permissions/questions | `buildSessionModel()`, `mapSessionStatus()`, `InstanceState` |
-| `collector.ts` | Maintain instance connections; subscribe to SSE; handle reconnects and poll fallback; dispatch events to `session-builder` | `OpenCodeCollector` (implements `Collector`) |
-| `index.ts` | Public re-exports | `OpenCodeCollector`, discovery + session-builder functions |
-
-## State Mapping (`session-builder.ts`)
-
-| SDK `SessionStatus` | State | Attention |
-|---------------------|-------|-----------|
-| `busy` | `working` | `false` |
-| `idle` | `idle` | `false` |
-| `retry` | `working` | `false` |
-| *(any + pending permission/question)* | `waiting-input` | `true` |
-
-## Transports
-
-| Transport | Trigger | Events Handled |
-|-----------|---------|----------------|
-| **SSE** | Primary. Established on `connectInstance()`. | `session.status`, `session.updated`, `session.created`, `session.deleted`, `session.idle`, `session.error`, `permission.updated`, `permission.replied` |
-| **Poll** | Fallback. Triggered when SSE disconnects or `connectInstance()` fails. | Fetches full session list + status map every 10s. |
-
-The collector seeds pending permissions on initial connect by calling the
-(optional) `permission.list` SDK endpoint. This avoids stale "waiting-input"
-states before the first SSE event arrives.
-
-## Instance Lifecycle
-
-```
-  discovered  ──►  connectInstance()  ──►  subscribeSSE()
-       │                                          │
-       │                                          ▼ (on disconnect/error)
-       │                              startPollFallback() ──►  pollInstance()
-       │                                          │
-       │                                          ▼ (on re-connect)
-       │                              stop poll timer ──► subscribeSSE()
-       │                                          │
-       └──────────────────────────────────────────┘
-              teardownInstance() on instance gone
-```
-
-## Interactions
-
-| Component | How |
-|-----------|-----|
-| `GitCollector` | Resolves `session.directory` → `project` in `buildSessionModel()` |
-| `TmuxCollector` | Uses `parseOpencodeUrl()` to derive instance URLs from pane process trees; uses `store.registerSdkPid()` results for PID-ancestry matching |
-| `DaemonStore` | Upserts sessions; registers SDK PIDs for tmux deduplication; rebuilds parent→child links |
-| `Scheduler` | Calls `start()` → sets up `60s` discovery interval |
-
-## Detection Source Produced
-
-- `"opencode-sdk"` — session discovered and maintained via `@opencode-ai/sdk` HTTP/SSE