@smithers-orchestrator/cli 0.16.0

package/src/chat.js

@@ -0,0 +1,226 @@
+import { formatTimestamp } from "./format.js";
+
+/** @typedef {import("./ChatAttemptMeta.ts").ChatAttemptMeta} ChatAttemptMeta */
+/** @typedef {import("./ChatAttemptRow.ts").ChatAttemptRow} ChatAttemptRow */
+/** @typedef {import("./ChatOutputEvent.ts").ChatOutputEvent} ChatOutputEvent */
+/** @typedef {import("./ParsedNodeOutputEvent.ts").ParsedNodeOutputEvent} ParsedNodeOutputEvent */
+
+/**
+ * @param {string | null} [metaJson]
+ * @returns {ChatAttemptMeta}
+ */
+export function parseChatAttemptMeta(metaJson) {
+    if (!metaJson)
+        return {};
+    try {
+        const parsed = JSON.parse(metaJson);
+        if (!parsed || typeof parsed !== "object")
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * @param {Pick<ChatAttemptRow, "nodeId" | "iteration" | "attempt">} attempt
+ */
+export function chatAttemptKey(attempt) {
+    return `${attempt.nodeId}:${attempt.iteration}:${attempt.attempt}`;
+}
+/**
+ * @param {ChatOutputEvent} event
+ * @returns {ParsedNodeOutputEvent | null}
+ */
+export function parseNodeOutputEvent(event) {
+    if (event.type !== "NodeOutput")
+        return null;
+    try {
+        const payload = JSON.parse(event.payloadJson);
+        if (!payload || typeof payload !== "object")
+            return null;
+        const text = typeof payload.text === "string" ? payload.text : "";
+        const stream = payload.stream === "stderr" ? "stderr" : "stdout";
+        if (!text)
+            return null;
+        return {
+            seq: event.seq,
+            timestampMs: event.timestampMs,
+            nodeId: String(payload.nodeId ?? ""),
+            iteration: Number(payload.iteration ?? 0),
+            attempt: Number(payload.attempt ?? 1),
+            stream,
+            text,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * @param {ChatOutputEvent} event
+ * @returns {ParsedNodeOutputEvent | null}
+ */
+export function parseAgentEvent(event) {
+    if (event.type !== "AgentEvent")
+        return null;
+    try {
+        const payload = JSON.parse(event.payloadJson);
+        if (!payload || typeof payload !== "object")
+            return null;
+        const agentEvent = payload.event;
+        if (!agentEvent || typeof agentEvent !== "object")
+            return null;
+        const nodeId = String(payload.nodeId ?? "");
+        const iteration = Number(payload.iteration ?? 0);
+        const attempt = Number(payload.attempt ?? 1);
+        if (agentEvent.type === "action") {
+            const action = agentEvent.action;
+            const phase = agentEvent.phase ?? "";
+            const kind = action?.kind ?? "unknown";
+            const title = action?.title ?? "";
+            const message = agentEvent.message ?? "";
+            const detail = action?.detail ?? {};
+            let text = "";
+            if (kind === "tool" || kind === "command") {
+                if (phase === "started") {
+                    const input = detail.input ? JSON.stringify(detail.input) : "";
+                    text = `[tool] ${title}${input ? `: ${truncate(input, 200)}` : ""}`;
+                }
+                else if (phase === "completed") {
+                    const output = detail.output ? String(detail.output) : message;
+                    text = `[tool] ${title} → ${truncate(output || "done", 200)}`;
+                }
+                else {
+                    return null;
+                }
+            }
+            else if (kind === "file_change") {
+                const changes = detail.changes;
+                if (Array.isArray(changes)) {
+                    text = `[file_change] ${changes.map((c) => `${c.type ?? "change"}: ${c.file ?? c.path ?? "?"}`).join(", ")}`;
+                }
+                else {
+                    text = `[file_change] ${title || message || "files changed"}`;
+                }
+            }
+            else if (kind === "reasoning") {
+                if (!message)
+                    return null;
+                text = `[reasoning] ${truncate(message, 300)}`;
+            }
+            else if (kind === "note" && agentEvent.entryType === "thought") {
+                if (!message)
+                    return null;
+                text = `[thought] ${truncate(message, 300)}`;
+            }
+            else if (kind === "web_search") {
+                text = `[web_search] ${title || message || "searching"}`;
+            }
+            else {
+                // Skip other action kinds (turn, todo_list, generic notes)
+                return null;
+            }
+            if (!text)
+                return null;
+            return {
+                seq: event.seq,
+                timestampMs: event.timestampMs,
+                nodeId,
+                iteration,
+                attempt,
+                stream: "stdout",
+                text,
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * @param {string} str
+ * @param {number} max
+ */
+function truncate(str, max) {
+    if (str.length <= max) return str;
+    return str.slice(0, max) + "…";
+}
+/**
+ * @param {ChatAttemptRow} attempt
+ * @param {ReadonlySet<string>} outputAttemptKeys
+ * @returns {boolean}
+ */
+export function isAgentAttempt(attempt, outputAttemptKeys) {
+    const meta = parseChatAttemptMeta(attempt.metaJson);
+    if (meta.kind === "agent")
+        return true;
+    if (attempt.responseText?.trim())
+        return true;
+    return outputAttemptKeys.has(chatAttemptKey(attempt));
+}
+/**
+ * @param {ChatAttemptRow[]} attempts
+ * @param {ReadonlySet<string>} outputAttemptKeys
+ * @param {boolean} includeAll
+ * @returns {ChatAttemptRow[]}
+ */
+export function selectChatAttempts(attempts, outputAttemptKeys, includeAll) {
+    const agentAttempts = attempts
+        .filter((attempt) => isAgentAttempt(attempt, outputAttemptKeys))
+        .sort((a, b) => {
+        if (a.startedAtMs !== b.startedAtMs)
+            return a.startedAtMs - b.startedAtMs;
+        if (a.nodeId !== b.nodeId)
+            return a.nodeId.localeCompare(b.nodeId);
+        if (a.iteration !== b.iteration)
+            return a.iteration - b.iteration;
+        return a.attempt - b.attempt;
+    });
+    if (includeAll)
+        return agentAttempts;
+    const latest = agentAttempts[agentAttempts.length - 1];
+    return latest ? [latest] : [];
+}
+/**
+ * @param {ChatAttemptRow} attempt
+ * @returns {string}
+ */
+export function formatChatAttemptHeader(attempt) {
+    const meta = parseChatAttemptMeta(attempt.metaJson);
+    const title = meta.label?.trim() || attempt.nodeId;
+    const agentBits = [meta.agentId, meta.agentModel].filter(Boolean).join(" · ");
+    const parts = [
+        title,
+        `attempt ${attempt.attempt}`,
+        attempt.iteration > 0 ? `iteration ${attempt.iteration}` : null,
+        attempt.state,
+        agentBits || null,
+    ].filter(Boolean);
+    return `=== ${parts.join(" · ")} ===`;
+}
+/**
+ * @param {{ baseMs: number; timestampMs: number; role: "user" | "assistant" | "stderr"; attempt: Pick<ChatAttemptRow, "nodeId" | "iteration" | "attempt">; text: string; }} options
+ * @returns {string}
+ */
+export function formatChatBlock(options) {
+    const { baseMs, timestampMs, role, attempt, text } = options;
+    const ts = formatTimestamp(baseMs, timestampMs);
+    const ref = `${attempt.nodeId}#${attempt.attempt}${attempt.iteration > 0 ? `.${attempt.iteration}` : ""}`;
+    const body = text.replace(/\s+$/, "");
+    const prefix = `[${ts}] ${role} ${ref}`;
+    if (!body.includes("\n")) {
+        return `${prefix}: ${body}`;
+    }
+    return `${prefix}:\n${indentBlock(body)}`;
+}
+/**
+ * @param {string} text
+ */
+function indentBlock(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => `  ${line}`)
+        .join("\n");
+}

package/src/diff.js

@@ -0,0 +1,221 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./DiffBundleLike.ts").DiffBundleLike} DiffBundleLike */
+/** @typedef {import("./RunDiffCommandInput.ts").RunDiffCommandInput} RunDiffCommandInput */
+/** @typedef {import("./RunDiffCommandResult.ts").RunDiffCommandResult} RunDiffCommandResult */
+// @smithers-type-exports-end
+
+import pc from "picocolors";
+import { getNodeDiffRoute } from "@smithers-orchestrator/server/gatewayRoutes/getNodeDiff";
+import { EXIT_OK, EXIT_SERVER_ERROR } from "./util/exitCodes.js";
+import { formatCliErrorForStderr, getCliErrorMapping } from "./util/errorMessage.js";
+
+/** @param {boolean} color */
+function colors(color) {
+    return color ? pc.createColors(true) : pc.createColors(false);
+}
+
+// ANSI CSI sequences: `ESC [ ... letter`. Strip covers colors (m), cursor
+// moves, etc. Only used when the caller disables color so that existing
+// escapes from upstream (jj, git) do not leak into non-TTY pipes.
+const ANSI_ESCAPE_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function stripAnsi(value) {
+    return value.replace(ANSI_ESCAPE_REGEX, "");
+}
+
+/**
+ * @param {string} diffText
+ * @param {boolean} useColor
+ * @returns {string}
+ */
+function colorizePatch(diffText, useColor) {
+    // Finding #6: when color is disabled (explicit --color never or non-TTY),
+    // also strip any ANSI escapes the upstream VCS layer may have embedded
+    // in patch text. Without this, piping to `less` or capturing to a file
+    // leaks raw CSI codes. Color is only added here when useColor is true.
+    if (!useColor) return stripAnsi(diffText);
+    const c = colors(true);
+    const lines = diffText.split("\n");
+    const out = [];
+    for (const line of lines) {
+        if (line.startsWith("+++") || line.startsWith("---")) {
+            out.push(c.bold(line));
+        } else if (line.startsWith("+")) {
+            out.push(c.green(line));
+        } else if (line.startsWith("-")) {
+            out.push(c.red(line));
+        } else if (line.startsWith("@@")) {
+            out.push(c.cyan(line));
+        } else if (line.startsWith("diff ") || line.startsWith("index ")) {
+            out.push(c.dim(line));
+        } else {
+            out.push(line);
+        }
+    }
+    return out.join("\n");
+}
+
+/**
+ * @param {DiffBundleLike} bundle
+ * @param {{ color?: boolean }} [options]
+ * @returns {string}
+ */
+export function renderUnifiedDiff(bundle, options) {
+    const useColor = Boolean(options?.color);
+    if (!bundle || !Array.isArray(bundle.patches) || bundle.patches.length === 0) {
+        return "(no changes)";
+    }
+    return bundle.patches
+        .map((patch) => colorizePatch(String(patch.diff ?? ""), useColor))
+        .join("\n");
+}
+
+/**
+ * Streaming per-line count of +/- markers in a unified diff. Counts
+ * content lines only (skips "+++ "/"--- " file headers). Scans via
+ * indexOf to avoid a giant split() allocation on large diffs.
+ *
+ * @param {string} diffText
+ * @returns {{ added: number; removed: number }}
+ */
+function countDiffLines(diffText) {
+    let added = 0;
+    let removed = 0;
+    let cursor = 0;
+    while (cursor < diffText.length) {
+        const nl = diffText.indexOf("\n", cursor);
+        const end = nl === -1 ? diffText.length : nl;
+        const ch = diffText.charCodeAt(cursor);
+        if (ch === 43 /* + */ && !(diffText.charCodeAt(cursor + 1) === 43 && diffText.charCodeAt(cursor + 2) === 43)) {
+            added++;
+        }
+        else if (ch === 45 /* - */ && !(diffText.charCodeAt(cursor + 1) === 45 && diffText.charCodeAt(cursor + 2) === 45)) {
+            removed++;
+        }
+        cursor = end + 1;
+    }
+    return { added, removed };
+}
+
+/**
+ * Render a stat summary. Accepts either:
+ * - a server-side `summary` response ({ filesChanged, added, removed, files })
+ * - or a legacy `DiffBundle` (computes summary on the fly, streaming
+ *   through patches so no intermediate array of full patch text is held).
+ *
+ * @param {DiffBundleLike | { summary: { filesChanged: number; added: number; removed: number; files: Array<{ path: string; added: number; removed: number }> } }} input
+ * @returns {string}
+ */
+export function renderDiffStat(input) {
+    const summary = summaryFromInput(input);
+    if (summary.filesChanged === 0) {
+        return " 0 files changed";
+    }
+    /** @type {string[]} */
+    const lines = [];
+    for (const file of summary.files) {
+        const added = file.added;
+        const removed = file.removed;
+        lines.push(` ${file.path} | ${added + removed} ${"+".repeat(Math.min(added, 20))}${"-".repeat(Math.min(removed, 20))}`);
+    }
+    lines.push(` ${summary.filesChanged} file${summary.filesChanged === 1 ? "" : "s"} changed, ${summary.added} insertion${summary.added === 1 ? "" : "s"}(+), ${summary.removed} deletion${summary.removed === 1 ? "" : "s"}(-)`);
+    return lines.join("\n");
+}
+
+/**
+ * @param {any} input
+ * @returns {{ filesChanged: number; added: number; removed: number; files: Array<{ path: string; added: number; removed: number }> }}
+ */
+function summaryFromInput(input) {
+    if (input && input.summary && typeof input.summary === "object") {
+        const s = input.summary;
+        return {
+            filesChanged: Number(s.filesChanged ?? 0),
+            added: Number(s.added ?? 0),
+            removed: Number(s.removed ?? 0),
+            files: Array.isArray(s.files) ? s.files : [],
+        };
+    }
+    if (!input || !Array.isArray(input.patches) || input.patches.length === 0) {
+        return { filesChanged: 0, added: 0, removed: 0, files: [] };
+    }
+    const files = [];
+    let totalAdded = 0;
+    let totalRemoved = 0;
+    for (const patch of input.patches) {
+        const { added, removed } = countDiffLines(String(patch.diff ?? ""));
+        totalAdded += added;
+        totalRemoved += removed;
+        files.push({ path: String(patch.path ?? ""), added, removed });
+    }
+    return { filesChanged: files.length, added: totalAdded, removed: totalRemoved, files };
+}
+
+/**
+ * @param {SmithersDb} adapter
+ * @param {string} runId
+ * @param {string} nodeId
+ * @returns {Promise<number | null>}
+ */
+async function resolveLatestIteration(adapter, runId, nodeId) {
+    try {
+        const iterations = await adapter.listNodeIterations(runId, nodeId);
+        if (!Array.isArray(iterations) || iterations.length === 0) return null;
+        return iterations.reduce((max, row) => {
+            const it = typeof row?.iteration === "number" ? row.iteration : 0;
+            return it > max ? it : max;
+        }, 0);
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * @param {RunDiffCommandInput} input
+ * @returns {Promise<RunDiffCommandResult>}
+ */
+export async function runDiffOnce(input) {
+    let iteration = input.iteration;
+    if (typeof iteration !== "number") {
+        const latest = await resolveLatestIteration(input.adapter, input.runId, input.nodeId);
+        iteration = latest ?? 0;
+    }
+    const result = await getNodeDiffRoute({
+        runId: input.runId,
+        nodeId: input.nodeId,
+        iteration,
+        async resolveRun(runId) {
+            if (runId !== input.runId) return null;
+            const run = await input.adapter.getRun(runId);
+            if (!run) return null;
+            return { adapter: input.adapter };
+        },
+        // Finding #5: stat mode asks the route for a summary only so very
+        // large diffs (>50MB) still return without hitting DiffTooLarge.
+        ...(input.stat ? { stat: true } : undefined),
+    });
+    if (!result.ok) {
+        input.stderr.write(`${formatCliErrorForStderr(result.error.code, result.error.message)}\n`);
+        const mapping = getCliErrorMapping(result.error.code, result.error.message);
+        return { exitCode: mapping.exitCode };
+    }
+    const payload = result.payload;
+    if (input.json) {
+        // Ticket 0014: --json emits the raw bundle (or summary when stat).
+        input.stdout.write(`${JSON.stringify(payload)}\n`);
+        return { exitCode: EXIT_OK };
+    }
+    if (input.stat) {
+        input.stdout.write(`${renderDiffStat(payload)}\n`);
+        return { exitCode: EXIT_OK };
+    }
+    input.stdout.write(`${renderUnifiedDiff(payload, { color: input.color })}\n`);
+    return { exitCode: EXIT_OK };
+}
+
+// ensure EXIT_SERVER_ERROR is considered used by linters / tree-shakers.
+void EXIT_SERVER_ERROR;

package/src/event-categories.js

@@ -0,0 +1,141 @@
+
+/** @typedef {import("./EventCategory.ts").EventCategory} EventCategory */
+/** @typedef {import("./SmithersEventType.ts").SmithersEventType} SmithersEventType */
+const EVENT_CATEGORY_BY_TYPE = {
+    SupervisorStarted: "supervisor",
+    SupervisorPollCompleted: "supervisor",
+    RunAutoResumed: "run",
+    RunAutoResumeSkipped: "run",
+    RunStarted: "run",
+    RunStatusChanged: "run",
+    RunFinished: "run",
+    RunFailed: "run",
+    RunCancelled: "run",
+    RunContinuedAsNew: "run",
+    RunHijackRequested: "run",
+    RunHijacked: "run",
+    SandboxCreated: "sandbox",
+    SandboxShipped: "sandbox",
+    SandboxHeartbeat: "sandbox",
+    SandboxBundleReceived: "sandbox",
+    SandboxCompleted: "sandbox",
+    SandboxFailed: "sandbox",
+    SandboxDiffReviewRequested: "sandbox",
+    SandboxDiffAccepted: "sandbox",
+    SandboxDiffRejected: "sandbox",
+    FrameCommitted: "frame",
+    NodePending: "node",
+    NodeStarted: "node",
+    TaskHeartbeat: "node",
+    TaskHeartbeatTimeout: "node",
+    NodeFinished: "node",
+    NodeFailed: "node",
+    NodeCancelled: "node",
+    NodeSkipped: "node",
+    NodeRetrying: "node",
+    NodeWaitingApproval: "node",
+    NodeWaitingTimer: "node",
+    ApprovalRequested: "approval",
+    ApprovalGranted: "approval",
+    ApprovalAutoApproved: "approval",
+    ApprovalDenied: "approval",
+    ToolCallStarted: "tool-call",
+    ToolCallFinished: "tool-call",
+    NodeOutput: "output",
+    AgentEvent: "agent",
+    RetryTaskStarted: "run",
+    RetryTaskFinished: "run",
+    RevertStarted: "revert",
+    RevertFinished: "revert",
+    TimeTravelStarted: "revert",
+    TimeTravelFinished: "revert",
+    WorkflowReloadDetected: "workflow",
+    WorkflowReloaded: "workflow",
+    WorkflowReloadFailed: "workflow",
+    WorkflowReloadUnsafe: "workflow",
+    ScorerStarted: "scorer",
+    ScorerFinished: "scorer",
+    ScorerFailed: "scorer",
+    TokenUsageReported: "token",
+    SnapshotCaptured: "snapshot",
+    RunForked: "run",
+    ReplayStarted: "run",
+    MemoryFactSet: "memory",
+    MemoryRecalled: "memory",
+    MemoryMessageSaved: "memory",
+    OpenApiToolCalled: "openapi",
+    TimerCreated: "timer",
+    TimerFired: "timer",
+    TimerCancelled: "timer",
+};
+const CATEGORY_ALIASES = {
+    agent: "agent",
+    approval: "approval",
+    approvals: "approval",
+    frame: "frame",
+    memory: "memory",
+    node: "node",
+    openapi: "openapi",
+    output: "output",
+    revert: "revert",
+    run: "run",
+    sandbox: "sandbox",
+    scorer: "scorer",
+    snapshot: "snapshot",
+    supervisor: "supervisor",
+    timer: "timer",
+    token: "token",
+    tool: "tool-call",
+    toolcall: "tool-call",
+    "tool-call": "tool-call",
+    "tool_call": "tool-call",
+    workflow: "workflow",
+    reload: "workflow",
+};
+const EVENT_TYPES_BY_CATEGORY = Object.entries(EVENT_CATEGORY_BY_TYPE).reduce((acc, [type, category]) => {
+    if (!acc[category])
+        acc[category] = [];
+    acc[category].push(type);
+    return acc;
+}, {
+    agent: [],
+    approval: [],
+    frame: [],
+    memory: [],
+    node: [],
+    openapi: [],
+    output: [],
+    revert: [],
+    run: [],
+    sandbox: [],
+    scorer: [],
+    snapshot: [],
+    supervisor: [],
+    timer: [],
+    token: [],
+    "tool-call": [],
+    workflow: [],
+});
+export const EVENT_CATEGORY_VALUES = Object.keys(EVENT_TYPES_BY_CATEGORY);
+/**
+ * @param {string} raw
+ * @returns {EventCategory | null}
+ */
+export function normalizeEventCategory(raw) {
+    const key = raw.trim().toLowerCase();
+    return CATEGORY_ALIASES[key] ?? null;
+}
+/**
+ * @param {string} type
+ * @returns {EventCategory | null}
+ */
+export function eventCategoryForType(type) {
+    return EVENT_CATEGORY_BY_TYPE[type] ?? null;
+}
+/**
+ * @param {EventCategory} category
+ * @returns {readonly SmithersEventType[]}
+ */
+export function eventTypesForCategory(category) {
+    return EVENT_TYPES_BY_CATEGORY[category];
+}

package/src/find-db.js

@@ -0,0 +1,93 @@
+import { resolve, dirname } from "node:path";
+import { existsSync } from "node:fs";
+import { SmithersDb } from "@smithers-orchestrator/db/adapter";
+import { ensureSmithersTables } from "@smithers-orchestrator/db/ensure";
+import { SmithersError } from "@smithers-orchestrator/errors";
+/** @typedef {import("./FindDbWaitOptions.ts").FindDbWaitOptions} FindDbWaitOptions */
+
+/**
+ * Walk from `from` (default: cwd) upward looking for smithers.db.
+ * Returns the absolute path to the database file.
+ *
+ * @param {string} [from]
+ * @returns {string}
+ */
+export function findSmithersDb(from) {
+    let dir = resolve(from ?? process.cwd());
+    const root = resolve("/");
+    while (true) {
+        const candidate = resolve(dir, "smithers.db");
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir || dir === root) {
+            throw new SmithersError("CLI_DB_NOT_FOUND", "No smithers.db found. Run this command from a directory containing a smithers.db, or use 'smithers up <workflow>' to start a run first.");
+        }
+        dir = parent;
+    }
+}
+/**
+ * @param {number} ms
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * @param {string} [from]
+ * @param {FindDbWaitOptions} [opts]
+ * @returns {Promise<string>}
+ */
+export async function waitForSmithersDb(from, opts = {}) {
+    const timeoutMs = Math.max(0, opts.timeoutMs ?? 0);
+    const intervalMs = Math.max(1, opts.intervalMs ?? 100);
+    const startedAt = Date.now();
+    while (true) {
+        try {
+            return findSmithersDb(from);
+        }
+        catch (err) {
+            if (!(err instanceof SmithersError) || err.code !== "CLI_DB_NOT_FOUND") {
+                throw err;
+            }
+            const elapsedMs = Date.now() - startedAt;
+            if (elapsedMs >= timeoutMs) {
+                throw err;
+            }
+            await sleep(Math.min(intervalMs, timeoutMs - elapsedMs));
+        }
+    }
+}
+/**
+ * Open a smithers.db file and return a SmithersDb adapter with cleanup function.
+ *
+ * @param {string} dbPath
+ * @returns {Promise<{ adapter: SmithersDb; cleanup: () => void }>}
+ */
+export async function openSmithersDb(dbPath) {
+    const { Database } = await import("bun:sqlite");
+    const { drizzle } = await import("drizzle-orm/bun-sqlite");
+    const sqlite = new Database(dbPath);
+    const db = drizzle(sqlite);
+    ensureSmithersTables(db);
+    return {
+        adapter: new SmithersDb(db),
+        cleanup: () => {
+            try {
+                sqlite.close();
+            }
+            catch { }
+        },
+    };
+}
+/**
+ * Find and open the nearest smithers.db.
+ *
+ * @param {string} [from]
+ * @param {FindDbWaitOptions} [opts]
+ * @returns {Promise<{ adapter: SmithersDb; dbPath: string; cleanup: () => void }>}
+ */
+export async function findAndOpenDb(from, opts) {
+    const dbPath = await waitForSmithersDb(from, opts);
+    const { adapter, cleanup } = await openSmithersDb(dbPath);
+    return { adapter, dbPath, cleanup };
+}