@scrylog/cli 0.1.0

package/src/daemon/collectors/opencode/discovery.ts

@@ -0,0 +1,257 @@
+import { existsSync, readdirSync, readFileSync, readlinkSync } from "node:fs";
+import type { ProcessInfo } from "../../../shared/types";
+import { maybeRunCommand } from "../../../shared/utils";
+import { IS_LINUX, IS_WINDOWS } from "../../../shared/platform";
+import type { Logger } from "../../../shared/logger";
+import { parseWindowsProcesses } from "../process";
+
+const OPENCODE_DEFAULT_PORT = 4096;
+
+/**
+ * Subcommands of opencode that are NOT local servers.
+ * Processes running these should not be matched as opencode server instances.
+ */
+const OPENCODE_NON_SERVER_SUBCOMMANDS = /^(attach|check)\b/i;
+
+/**
+ * Returns true if the command string represents an opencode executable invocation
+ * (not opencode as an argument to another process, or opencode as a directory component).
+ *
+ * Valid executable forms:
+ *   - `opencode [args]`              — bare name, first token
+ *   - `/path/to/opencode [args]`     — absolute path, first token
+ *   - `node /path/to/opencode [args]` — Node.js runner
+ *   - `bun /path/to/opencode [args]`  — Bun runner
+ *
+ * Rejected forms:
+ *   - `tmux new-session ... opencode` — opencode is an argument to tmux
+ *   - `/Users/x/.opencode/node_modules/.../binary` — opencode is a directory in the path
+ */
+function isOpencodeExecutable(command: string): boolean {
+  const tokens = command.trim().split(/\s+/);
+  const first = tokens[0] ?? "";
+  const second = tokens[1] ?? "";
+
+  // First token ends with /opencode or IS opencode (bare name)
+  if (/(?:^|[\\/])opencode(?:\.exe)?$/i.test(first)) return true;
+
+  // Interpreter (node/bun) with second token being the opencode script
+  if (/^(node|bun)(?:\.exe)?$/i.test(first) && /(?:^|[\\/])opencode(?:\.exe)?$/i.test(second)) return true;
+
+  return false;
+}
+
+/**
+ * Given a process command string, attempt to extract the OpenCode HTTP URL.
+ * Matches:
+ *   - `opencode serve [--port N] [--hostname H]`
+ *   - `opencode [--port N]` (TUI mode with explicit port)
+ *   - `opencode` (TUI mode, no args — assumes default port 4096 on localhost)
+ * Returns undefined if the command is not an OpenCode server process.
+ */
+export function parseOpencodeUrl(command: string): string | undefined {
+  if (!isOpencodeExecutable(command)) return undefined;
+
+  // Extract the subcommand/args portion (everything after the executable token)
+  const tokens = command.trim().split(/\s+/);
+  const isInterpreted = /^(node|bun)(?:\.exe)?$/i.test(tokens[0] ?? "");
+  const args = tokens.slice(isInterpreted ? 2 : 1).join(" ");
+
+  // Client-only subcommands — not a local server
+  if (OPENCODE_NON_SERVER_SUBCOMMANDS.test(args.trim())) return undefined;
+
+  const portMatch = command.match(/--port[=\s]+(\d+)/);
+  const hostMatch = command.match(/--hostname[=\s]+(\S+)/);
+  const port = portMatch ? Number.parseInt(portMatch[1] ?? "", 10) : OPENCODE_DEFAULT_PORT;
+  const rawHost = hostMatch ? (hostMatch[1] ?? "127.0.0.1") : "127.0.0.1";
+  const host = rawHost === "0.0.0.0" ? "127.0.0.1" : rawHost;
+  return `http://${host}:${port}`;
+}
+
+/**
+ * Returns true if the command explicitly specifies a --port argument.
+ * Used to decide whether lsof-based port discovery is needed.
+ */
+export function hasExplicitPort(command: string): boolean {
+  return /--port[=\s]+\d+/.test(command);
+}
+
+/**
+ * Use `lsof` to find the TCP port an opencode process is listening on.
+ * Runs `lsof -nP -p <pid>` and looks for a LISTEN TCP entry.
+ * Returns the port number, or undefined if none found.
+ *
+ * This is needed when opencode is started without `--port` (TUI mode),
+ * in which case it binds to a random ephemeral port.
+ */
+export function discoverListeningPort(pid: number, timeoutMs?: number): number | undefined {
+  const lsofResult = maybeRunCommand(["lsof", "-nP", "-p", String(pid)], timeoutMs);
+  if (lsofResult.ok) {
+    for (const line of lsofResult.output.split(/\r?\n/)) {
+      // Match lines like: opencode 12345 user  10u  IPv4 ...  TCP 127.0.0.1:59871 (LISTEN)
+      const m = line.match(/TCP\s+[\w.*]+:(\d+)\s+\(LISTEN\)/i);
+      if (m) {
+        const port = Number.parseInt(m[1] ?? "", 10);
+        if (Number.isFinite(port) && port > 0) return port;
+      }
+    }
+  }
+
+  // Fallback for minimal Linux containers/WSL without lsof: read /proc/<pid>/net/tcp
+  if (IS_LINUX) {
+    return discoverListeningPortFromProc(pid);
+  }
+
+  return undefined;
+}
+
+export function parseProcNetTcpListeningPorts(content: string, socketInodes: ReadonlySet<string>): number[] {
+  const ports: number[] = [];
+
+  for (const line of content.split(/\r?\n/).filter(Boolean).slice(1)) {
+    // Columns: sl local_address rem_address st tx_queue:rx_queue tr:tm->when retrnsmt uid timeout inode
+    const cols = line.trim().split(/\s+/);
+    const local = cols[1];
+    const st = cols[3];
+    const inode = cols[9];
+    if (st !== "0A" || !local || !inode || !socketInodes.has(inode)) continue;
+
+    const portHex = local.split(":")[1];
+    if (!portHex) continue;
+    const port = Number.parseInt(portHex, 16);
+    if (Number.isFinite(port) && port > 0) ports.push(port);
+  }
+
+  return ports;
+}
+
+function discoverListeningPortFromProc(pid: number): number | undefined {
+  const fdDir = `/proc/${pid}/fd`;
+  if (!existsSync(fdDir)) return undefined;
+
+  try {
+    const socketInodes = new Set<string>();
+    for (const fd of readdirSync(fdDir)) {
+      try {
+        const target = readlinkSync(`${fdDir}/${fd}`);
+        const match = target.match(/^socket:\[(\d+)\]$/);
+        if (match?.[1]) socketInodes.add(match[1]);
+      } catch {
+        // Ignore fds that disappear while scanning.
+      }
+    }
+    if (socketInodes.size === 0) return undefined;
+
+    for (const procPath of [`/proc/${pid}/net/tcp`, `/proc/${pid}/net/tcp6`]) {
+      if (!existsSync(procPath)) continue;
+      const ports = parseProcNetTcpListeningPorts(readFileSync(procPath, "utf8"), socketInodes);
+      if (ports.length > 0) return ports[0];
+    }
+  } catch {
+    // Ignore permission/read errors.
+  }
+
+  return undefined;
+}
+
+/**
+ * Scan a process tree (list of descendants of a pane's root PID) looking for
+ * an OpenCode server process. Returns the pid and derived HTTP URL if found.
+ *
+ * NOTE: opencode runs as a child of the shell (panePid), so we scan
+ * descendants — not ancestors — of the pane root.
+ */
+export function findOpencodeInTree(
+  processTree: ProcessInfo[],
+): { pid: number; url: string } | undefined {
+  for (const p of processTree) {
+    const url = parseOpencodeUrl(p.command);
+    if (url !== undefined) return { pid: p.pid, url };
+  }
+  return undefined;
+}
+
+// ── Auto-discovery ────────────────────────────────────────────────────────────
+
+export interface DiscoveredInstance {
+  url: string;
+  pid?: number;
+}
+
+// Cache pid → discovered port to avoid repeated lsof calls each discovery cycle.
+// Entries are kept until the process disappears (instance teardown clears them).
+const pidPortCache = new Map<number, number>();
+
+export function discoverInstances(logger: Logger, timeoutMs?: number): DiscoveredInstance[] {
+  const instances: DiscoveredInstance[] = [];
+
+  // Scan for opencode processes and try to extract port from args
+  const result = IS_WINDOWS
+    ? maybeRunCommand(["wmic", "process", "get", "ProcessId,ParentProcessId,CommandLine", "/format:csv"], timeoutMs)
+    : maybeRunCommand(["ps", "-ax", "-o", "pid=,command="], timeoutMs);
+  if (result.ok) {
+    const processes = IS_WINDOWS
+      ? parseWindowsProcesses(result.output)
+      : result.output.split(/\r?\n/).filter(Boolean).map((line) => {
+        const match = line.match(/^\s*(\d+)\s+(.*)$/);
+        if (!match) return null;
+        return { pid: Number.parseInt(match[1] ?? "", 10), command: match[2] ?? "" };
+      }).filter((p): p is { pid: number; command: string } => Boolean(p));
+    logger.debug("opencode", "Process scan for autodiscover", { totalLines: processes.length });
+
+    for (const { pid, command } of processes) {
+      if (!Number.isFinite(pid) || pid <= 0) continue;
+
+      const url = parseOpencodeUrl(command);
+      if (!url) continue;
+
+      // If no explicit --port in the command, the opencode TUI binds to a random
+      // port. Use lsof to find the actual listening port and override the default.
+      let resolvedUrl = url;
+      if (!hasExplicitPort(command)) {
+        const cached = pidPortCache.get(pid);
+        if (cached !== undefined) {
+          resolvedUrl = `http://127.0.0.1:${cached}`;
+          logger.debug("opencode", "Using cached port for opencode TUI", { pid, port: cached });
+        } else {
+          const discovered = discoverListeningPort(pid, timeoutMs);
+          if (discovered !== undefined) {
+            pidPortCache.set(pid, discovered);
+            resolvedUrl = `http://127.0.0.1:${discovered}`;
+            logger.debug("opencode", "Discovered port via lsof for opencode TUI", { pid, port: discovered });
+          } else {
+            logger.debug("opencode", "No listening port found via lsof for opencode TUI — skipping (not yet bound or hooks mode)", { pid });
+            continue;
+          }
+        }
+      }
+
+      logger.debug("opencode", "Found opencode process", { pid, url: resolvedUrl, command: command.slice(0, 80) });
+      instances.push({ url: resolvedUrl, pid });
+    }
+  } else {
+    logger.warn("opencode", "Process scan failed", { error: result.error });
+  }
+
+  // Always probe default port if no instances found via process scan
+  if (instances.length === 0) {
+    const fallbackUrl = `http://localhost:4096`;
+    logger.debug("opencode", "No opencode processes found via scan — probing default port", { url: fallbackUrl });
+    instances.push({ url: fallbackUrl });
+  }
+
+  // De-duplicate by URL
+  const seen = new Set<string>();
+  const deduped = instances.filter((inst) => {
+    if (seen.has(inst.url)) return false;
+    seen.add(inst.url);
+    return true;
+  });
+
+  logger.debug("opencode", "Autodiscover result", { count: deduped.length, urls: deduped.map((i) => i.url) });
+  return deduped;
+}
+
+export function clearPidPortCache(pid: number): void {
+  pidPortCache.delete(pid);
+}

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

@@ -0,0 +1,5 @@
+export { OpenCodeCollector } from "./collector";
+export { parseOpencodeUrl, hasExplicitPort, discoverListeningPort, findOpencodeInTree, discoverInstances, clearPidPortCache } from "./discovery";
+export { mapSessionStatus, buildSessionModel } from "./session-builder";
+export type { DiscoveredInstance } from "./discovery";
+export type { InstanceState } from "./session-builder";

package/src/daemon/collectors/opencode/session-builder.ts

@@ -0,0 +1,59 @@
+import type { SessionModel, SessionState } from "../../../shared/types";
+import type { Session, SessionStatus } from "@opencode-ai/sdk";
+import type { GitCollector } from "../git";
+
+export interface InstanceState {
+  url: string;
+  pid?: number;
+  sessions: Map<string, SessionModel>;
+  status: Map<string, SessionStatus>;
+  /** sessionId → set of pending permissionRequest IDs */
+  pendingPermissions: Map<string, Set<string>>;
+  /** sessionId → set of pending question IDs */
+  pendingQuestions: Map<string, Set<string>>;
+  sseAbort?: AbortController;
+  pollTimer?: ReturnType<typeof setInterval>;
+  polling?: boolean;
+  skippedPolls?: number;
+}
+
+export function mapSessionStatus(status: SessionStatus): SessionState {
+  if (status.type === "busy") return "working";
+  if (status.type === "idle") return "idle";
+  if (status.type === "retry") return "working";
+  return "idle";
+}
+
+export function buildSessionModel(
+  session: Session,
+  status: SessionStatus,
+  instanceUrl: string,
+  pendingPermissions: Map<string, Set<string>>,
+  pendingQuestions: Map<string, Set<string>>,
+  gitCollector?: GitCollector,
+): SessionModel {
+  const hasPendingPermission = (pendingPermissions.get(session.id)?.size ?? 0) > 0;
+  const hasPendingQuestion = (pendingQuestions.get(session.id)?.size ?? 0) > 0;
+  const hasAttention = hasPendingPermission || hasPendingQuestion;
+  const state: SessionState = hasAttention ? "waiting-input" : mapSessionStatus(status);
+  const currentPath = session.directory || undefined;
+  const project = currentPath ? gitCollector?.resolve(currentPath) : undefined;
+
+  return {
+    id: `opencode:${session.id}`,
+    source: "standalone",
+    tool: "opencode",
+    state,
+    summary: session.title || "OpenCode session",
+    lastActivity: session.time.updated,
+    hasAttention,
+    opencode: {
+      sessionId: session.id,
+      instanceUrl,
+    },
+    detectionSource: "opencode-sdk",
+    currentPath,
+    project,
+    parentSessionId: session.parentID ? `opencode:${session.parentID}` : undefined,
+  };
+}

package/src/daemon/collectors/opencode-db.ts

@@ -0,0 +1,282 @@
+/**
+ * OpenCode SQLite Collector
+ *
+ * Reads session metadata from the OpenCode SQLite database and enriches
+ * existing sessions in the store. Runs every 30 seconds.
+ *
+ * Priority rules:
+ * - NEVER overwrites `state` — only metadata fields are written.
+ * - If a session already exists (from SSE/webhook), merges title/directory/lastActivity.
+ * - If a session does NOT exist yet, adds it with state="idle" and detectionSource="opencode-db".
+ */
+
+import { Database } from "bun:sqlite";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import type { ScrylogConfig } from "../../shared/config";
+import type { SessionModel } from "../../shared/types";
+import type { DaemonStore } from "../store";
+import type { Collector } from "../scheduler";
+import type { Logger } from "../../shared/logger";
+import { NOOP_LOGGER } from "../../shared/logger";
+import type { GitCollector } from "./git";
+
+const POLL_INTERVAL_MS = 30_000;
+const CHILD_ACTIVITY_WINDOW_MS = 90_000;
+
+export function inferChildSessionState(
+  session: Pick<SessionModel, "detectionSource" | "parentSessionId" | "lastActivity">,
+  parent: Pick<SessionModel, "state"> | undefined,
+  config: Pick<ScrylogConfig, "opencode">,
+  now: number,
+): SessionModel["state"] | undefined {
+  if (config.opencode.mode !== "hooks") return undefined;
+  if (session.detectionSource !== "opencode-db") return undefined;
+  if (!session.parentSessionId) return undefined;
+  if (parent?.state !== "working" && parent?.state !== "waiting-input") return "idle";
+  if (now - session.lastActivity > CHILD_ACTIVITY_WINDOW_MS) return "idle";
+  return "working";
+}
+
+// ── DB path resolution ────────────────────────────────────────────────────────
+
+/**
+ * Returns an ordered list of candidate DB paths for the current platform.
+ * The first path that exists on disk should be used.
+ *
+ * Priority:
+ *  1. OPENCODE_DATA_DIR env var (explicit override, always first)
+ *  2. Platform-specific primary path
+ *  3. Platform-specific fallback path(s)
+ */
+export function resolveDbCandidates(
+  platform: string = process.platform,
+  env: Record<string, string | undefined> = process.env,
+): string[] {
+  const home = homedir();
+
+  if (env["OPENCODE_DATA_DIR"]) {
+    return [join(env["OPENCODE_DATA_DIR"], "opencode.db")];
+  }
+
+  if (platform === "win32") {
+    const appData = env["APPDATA"] ?? join(home, "AppData", "Roaming");
+    return [
+      join(appData, "opencode", "opencode.db"),
+      join(home, "AppData", "Roaming", "opencode", "opencode.db"),
+    ];
+  }
+
+  if (platform === "darwin") {
+    return [
+      // XDG path — used by current OpenCode releases on macOS
+      join(home, ".local", "share", "opencode", "opencode.db"),
+      // Native macOS path — fallback for builds that follow Apple conventions
+      join(home, "Library", "Application Support", "opencode", "opencode.db"),
+    ];
+  }
+
+  // Linux and other Unix-like systems
+  return [
+    join(home, ".local", "share", "opencode", "opencode.db"),
+    join(home, ".config", "opencode", "opencode.db"),
+  ];
+}
+
+/**
+ * Returns the first candidate path that exists on disk, or null if none found.
+ */
+function findDbPath(): { path: string; candidates: string[] } | null {
+  const candidates = resolveDbCandidates();
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return { path: candidate, candidates };
+  }
+  return null;
+}
+
+// ── DB row type ───────────────────────────────────────────────────────────────
+
+interface SessionRow {
+  id: string;
+  title: string | null;
+  directory: string | null;
+  time_created: number;
+  time_updated: number;
+  parent_id: string | null;
+}
+
+// ── Collector ─────────────────────────────────────────────────────────────────
+
+export class OpenCodeDbCollector implements Collector {
+  name = "opencode-db";
+  private store?: DaemonStore;
+  private config?: ScrylogConfig;
+  private logger: Logger = NOOP_LOGGER;
+  private timer?: ReturnType<typeof setInterval>;
+  private gitCollector?: GitCollector;
+  private polling = false;
+  private skippedPolls = 0;
+  private errorCount = 0;
+
+  constructor(gitCollector?: GitCollector) {
+    this.gitCollector = gitCollector;
+  }
+
+  async start(store: DaemonStore, config: ScrylogConfig, logger: Logger): Promise<void> {
+    this.store = store;
+    this.config = config;
+    this.logger = logger;
+
+    const found = findDbPath();
+    if (!found) {
+      const candidates = resolveDbCandidates();
+      logger.info("opencode-db", "Database not found — collector inactive", { event: "collector.unavailable", collector: this.name, candidates });
+      store.setCollectorStatus(this.name, {
+        running: false,
+        lastError: `DB not found. Tried: ${candidates.join(", ")}`,
+      });
+      return;
+    }
+
+    const { path: dbPath } = found;
+    logger.info("opencode-db", "Collector started", { event: "collector.started", collector: this.name, path: dbPath, intervalMs: POLL_INTERVAL_MS });
+    store.setCollectorStatus(this.name, { running: true, lastRunAt: Date.now() });
+
+    await this.safePoll(dbPath);
+    this.timer = setInterval(() => void this.safePoll(dbPath), POLL_INTERVAL_MS);
+  }
+
+  async stop(): Promise<void> {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+    this.logger.info("opencode-db", "Collector stopped", { event: "collector.stopped", collector: this.name });
+  }
+
+  // ── Internal ───────────────────────────────────────────────────────────────
+
+  private async safePoll(dbPath: string): Promise<void> {
+    const store = this.store!;
+    if (this.polling) {
+      this.skippedPolls += 1;
+      store.setCollectorStatus(this.name, { skippedPolls: this.skippedPolls });
+      this.logger.debug("opencode-db", "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(dbPath);
+      store.setCollectorStatus(this.name, { running: true, lastRunAt: Date.now(), lastDurationMs: Date.now() - startedAt, skippedPolls: this.skippedPolls, errorCount: this.errorCount });
+    } finally {
+      this.polling = false;
+    }
+  }
+
+  private async poll(dbPath: string): Promise<void> {
+    const store = this.store!;
+    const config = this.config!;
+    const now = Date.now();
+    let db: Database | undefined;
+    try {
+      // Open read-only (WAL-safe)
+      db = new Database(dbPath, { readonly: true });
+
+      const cutoff = config.retention.standaloneMaxAgeHours > 0
+        ? now - config.retention.standaloneMaxAgeHours * 60 * 60 * 1000
+        : 0;
+      const limit = Math.max(1, config.retention.maxSessions || 500);
+      const rows = db
+        .query<SessionRow, [number, number]>(
+          "SELECT id, title, directory, time_created, time_updated, parent_id FROM session WHERE time_archived IS NULL AND time_updated >= ? ORDER BY time_updated DESC LIMIT ?",
+        )
+        .all(cutoff, limit);
+
+      this.logger.debug("opencode-db", "Poll result", { event: "collector.poll_completed", collector: this.name, rows: rows.length });
+
+      for (const row of rows) {
+        const storeId = `opencode:${row.id}`;
+        const existing = store.getSession(storeId);
+
+        if (existing) {
+          // Merge-only: preserve state, just update metadata
+          const newParentSessionId = row.parent_id ? `opencode:${row.parent_id}` : undefined;
+          const effectiveParentSessionId = newParentSessionId ?? existing.parentSessionId;
+          const needsUpdate =
+            existing.summary !== (row.title || "OpenCode session") ||
+            existing.currentPath !== (row.directory ?? undefined) ||
+            existing.lastActivity !== row.time_updated ||
+            existing.parentSessionId !== newParentSessionId;
+          const targetState = inferChildSessionState(
+            existing,
+            effectiveParentSessionId ? store.getSession(effectiveParentSessionId) : undefined,
+            config,
+            now,
+          );
+
+          if (needsUpdate || (targetState !== undefined && targetState !== existing.state)) {
+            const project = row.directory
+              ? (this.gitCollector?.resolve(row.directory) ?? existing.project)
+              : existing.project;
+            const merged: SessionModel = {
+              ...existing,
+              state: targetState ?? existing.state,
+              summary: row.title || existing.summary,
+              currentPath: row.directory ?? existing.currentPath,
+              lastActivity: Math.max(existing.lastActivity, row.time_updated),
+              project: project ?? existing.project,
+              parentSessionId: effectiveParentSessionId,
+            };
+            store.upsertSession(merged);
+            this.logger.debug("opencode-db", "Enriched existing session", { id: storeId });
+          }
+        } else {
+          // Session not yet known — add with minimal state
+          const currentPath = row.directory ?? undefined;
+          const project = currentPath ? this.gitCollector?.resolve(currentPath) : undefined;
+          const parentSessionId = row.parent_id ? `opencode:${row.parent_id}` : undefined;
+          const inferredChildState = inferChildSessionState(
+            { detectionSource: "opencode-db", parentSessionId, lastActivity: row.time_updated },
+            parentSessionId ? store.getSession(parentSessionId) : undefined,
+            config,
+            now,
+          );
+          const newSession: SessionModel = {
+            id: storeId,
+            source: "standalone",
+            tool: "opencode",
+            state: inferredChildState ?? "idle",
+            summary: row.title || "OpenCode session",
+            lastActivity: row.time_updated,
+            detectionSource: "opencode-db",
+            currentPath,
+            project,
+            opencode: {
+              sessionId: row.id,
+              instanceUrl: "",
+            },
+            parentSessionId,
+          };
+          store.upsertSession(newSession);
+          this.logger.debug("opencode-db", "Added session from DB", { id: storeId, title: row.title });
+        }
+      }
+
+      // All status updates consolidated in safePoll()
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      this.errorCount += 1;
+      this.logger.warn("opencode-db", "Poll error", { event: "collector.poll_failed", collector: this.name, errorMessage: msg });
+      store.setCollectorStatus(this.name, { lastError: msg, errorCount: this.errorCount });
+    } finally {
+      try {
+        db?.close();
+      } catch {
+        // Ignore close errors
+      }
+    }
+  }
+}