@scrylog/cli 0.3.0 → 0.3.2

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

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

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

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

@@ -1,294 +0,0 @@
-/**
- * OpenCode SQLite Collector
- *
- * Reads session metadata from the OpenCode SQLite database and enriches
- * existing sessions in the store. Runs every 30 seconds.
- *
- * Priority rules:
- * - Preserves state from native collectors; a matching herdr placeholder is claimed as idle.
- * - 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";
-}
-
-export function claimHerdrSessionForOpenCodeDb(existing: SessionModel, sessionId: string): SessionModel {
-  if (existing.detectionSource !== "herdr") return existing;
-  return {
-    ...existing,
-    state: "idle",
-    detectionSource: "opencode-db",
-    opencode: existing.opencode ?? { sessionId, instanceUrl: "" },
-  };
-}
-
-// ── 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) {
-          const replacingHerdr = existing.detectionSource === "herdr";
-          const owned = claimHerdrSessionForOpenCodeDb(existing, row.id);
-          // 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(
-            owned,
-            effectiveParentSessionId ? store.getSession(effectiveParentSessionId) : undefined,
-            config,
-            now,
-          );
-
-          if (replacingHerdr || needsUpdate || (targetState !== undefined && targetState !== existing.state)) {
-            const project = row.directory
-              ? (this.gitCollector?.resolve(row.directory) ?? existing.project)
-              : existing.project;
-            const merged: SessionModel = {
-              ...owned,
-              state: targetState ?? owned.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
-      }
-    }
-  }
-}