@amoree-code/ocean 0.0.0-stage → 1.2.0

package/dist/interfaces/cli/browser-command.js

@@ -0,0 +1,119 @@
+import { openSessionStore } from "@ocean/loop/infrastructure/persistence/session-store.js";
+import { BrowserService, } from "@ocean/services/browser/browser-service.js";
+import { BrowserSessionManager, browserDownloadsPath, } from "@ocean/services/browser/browser-session.js";
+import { BrowserTaskRunner } from "@ocean/services/browser/browser-task-runner.js";
+import { PlaywrightBrowserProvider } from "../../infrastructure/providers/playwright-browser-provider.js";
+export async function runBrowserCommand(action, args) {
+    const store = await openSessionStore();
+    const manager = new BrowserSessionManager(store, new BrowserService(new PlaywrightBrowserProvider()));
+    const runner = new BrowserTaskRunner(manager);
+    try {
+        if (action === "detect")
+            return print(await manager.detect());
+        if (action === "open") {
+            const profile = flag(args, "--profile") ?? "default";
+            const portText = flag(args, "--port");
+            const port = portText === undefined ? undefined : Number(portText);
+            if (port !== undefined &&
+                (!Number.isInteger(port) || port <= 0 || port > 65_535))
+                throw new Error("Browser port must be an integer between 1 and 65535.");
+            return print(await manager.open(profile, port));
+        }
+        if (action === "show")
+            return print(manager.show(required(args, 0, "session-id")));
+        if (action === "events")
+            return print(manager.events(required(args, 0, "session-id")));
+        if (action === "close")
+            return print(await manager.close(required(args, 0, "session-id")));
+        if (action === "approve")
+            return print(await manager.approve(required(args, 0, "session-id")));
+        const sessionId = required(args, 0, "session-id");
+        if (action === "navigate")
+            return print(await manager.navigate(sessionId, required(args, 1, "url"), args.includes("--approve"), numberFlag(args, "--timeout")));
+        if (action === "read")
+            return print(await manager.read(sessionId));
+        if (action === "observe")
+            return print(await manager.observe(sessionId));
+        if (action === "extract")
+            return print(await manager.extract(sessionId, required(args, 1, "selector"), flag(args, "--attribute") ?? null));
+        if (action === "click")
+            return print(await manager.click(sessionId, required(args, 1, "selector"), parseExpectation(args), numberFlag(args, "--timeout")));
+        if (action === "type")
+            return print(await manager.type(sessionId, required(args, 1, "selector"), required(args, 2, "text"), !args.includes("--no-clear")));
+        if (action === "select")
+            return print(await manager.select(sessionId, required(args, 1, "selector"), required(args, 2, "value")));
+        if (action === "replace-text")
+            return print(await manager.replaceText(sessionId, required(args, 1, "selector"), required(args, 2, "old-text"), required(args, 3, "new-text"), numberFlag(args, "--occurrence")));
+        if (action === "scroll")
+            return print(await manager.scroll(sessionId, numberFlag(args, "--delta") ?? Number(args[1] ?? "600")));
+        if (action === "wait")
+            return print(await manager.wait(sessionId, {
+                selector: flag(args, "--selector"),
+                urlContains: flag(args, "--url-contains"),
+                timeoutMs: numberFlag(args, "--timeout"),
+            }));
+        if (action === "upload") {
+            const selector = required(args, 1, "selector");
+            const paths = args.slice(2).filter((value) => !value.startsWith("--"));
+            if (!paths.length)
+                throw new Error("Usage: ocean browser upload <session-id> <selector> <path>... --approve");
+            return print(await manager.upload(sessionId, selector, paths, args.includes("--approve")));
+        }
+        if (action === "download") {
+            const selector = required(args, 1, "selector");
+            const destination = flag(args, "--destination") ?? browserDownloadsPath(sessionId);
+            return print(await manager.download(sessionId, selector, destination, args.includes("--approve"), numberFlag(args, "--timeout")));
+        }
+        if (action === "submit")
+            return print(await manager.submit(sessionId, required(args, 1, "selector"), args.includes("--approve"), numberFlag(args, "--timeout")));
+        if (action === "run") {
+            const taskPath = required(args, 1, "task-file");
+            const task = await BrowserTaskRunner.fromFile(taskPath);
+            return print(await runner.run(sessionId, task, args.includes("--approve")));
+        }
+        usage();
+        process.exitCode = 1;
+    }
+    finally {
+        store.close();
+    }
+}
+function parseExpectation(args) {
+    const value = flag(args, "--expect");
+    if (value === "navigates" || value === "stays")
+        return { kind: value };
+    if (value?.startsWith("count:")) {
+        const separator = value.lastIndexOf(":");
+        const selector = value.slice("count:".length, separator);
+        const expected = Number(value.slice(separator + 1));
+        if (selector && Number.isInteger(expected) && expected >= 0)
+            return { kind: "selector-count", selector, expected };
+    }
+    throw new Error("Click requires --expect navigates|stays|count:<selector>:<expected>");
+}
+function flag(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function numberFlag(args, name) {
+    const value = flag(args, name);
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        throw new Error(`${name} must be a positive number.`);
+    return parsed;
+}
+function required(args, index, name) {
+    const value = args[index];
+    if (!value || value.startsWith("--"))
+        throw new Error(`Usage error: missing ${name}.`);
+    return value;
+}
+function print(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function usage() {
+    console.error("Usage: ocean browser detect|open|show|events|close|approve|navigate|read|observe|extract|click|type|replace-text|select|scroll|wait|upload|download|submit|run");
+}
+//# sourceMappingURL=browser-command.js.map

package/dist/interfaces/cli/capture-command.js

@@ -0,0 +1,125 @@
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { syncCaptureInbox } from "@ocean/brain/capture/inbox-sync.js";
+import { syncMemoryIndexes } from "@ocean/brain/memory/index-sync.js";
+import { validateSessionEntryContract } from "@ocean/core/domain/sessions/entry-contract.js";
+import { localDate } from "@ocean/core/shared/local-date.js";
+import { KNOWLEDGE_DIR, oceanPath, oceanRoot, PERSONAL_DIR, PROJECTS_DIR, WORKSPACE_PROJECT_ID, } from "@ocean/core/shared/paths.js";
+import { openSessionStore } from "@ocean/loop/infrastructure/persistence/session-store.js";
+import { sessionProjectId } from "@ocean/loop/sessions/session-projects.js";
+import { redactRuntimeText } from "../../infrastructure/observability/runtime-logger.js";
+export async function runCaptureCommand(action, args) {
+    const store = await openSessionStore();
+    try {
+        if (action === "add") {
+            const content = redactRuntimeText(args.join(" ").trim());
+            if (!content)
+                throw new Error("Usage: ocean capture add <idea>");
+            const sessionId = randomUUID();
+            store.create({
+                sessionId,
+                provider: "manual",
+                providerSessionId: null,
+                parentSessionId: null,
+                profile: "manual-capture",
+                profileIdentity: "",
+                workingDirectory: oceanRoot(),
+                projectId: await sessionProjectId(oceanRoot()),
+                resumeData: null,
+            });
+            store.appendEvent(sessionId, "session_entry_contract", JSON.stringify(validateSessionEntryContract({
+                entryPoint: "ocean-run",
+                controlLevel: "full-head",
+                inputCapture: "semantic",
+                contextTransport: "manual-capture",
+                policyEnforcement: "explicit-capture-operation",
+                promotion: "explicit-review",
+                resume: "unsupported",
+            })));
+            store.updateStatus(sessionId, "running");
+            store.appendEvent(sessionId, "user_input", content);
+            store.updateStatus(sessionId, "completed");
+            store.scanCaptureItems(sessionId);
+            await syncCaptureInbox(store);
+            const [item] = store
+                .listCaptureItems("new")
+                .filter((candidate) => candidate.sessionId === sessionId);
+            if (!item)
+                throw new Error("Capture item was not created");
+            console.log(JSON.stringify({ captureId: item.captureId, sessionId, status: "new" }));
+            return;
+        }
+        if (action === "scan") {
+            const sessionId = args[0];
+            const scanned = store.scanCaptureItems(sessionId);
+            await syncCaptureInbox(store);
+            console.log(JSON.stringify({ scanned }));
+            return;
+        }
+        if (action === "list") {
+            console.log(JSON.stringify(store.listCaptureItems(args[0] ?? "new"), null, 2));
+            return;
+        }
+        if (action === "promote" || action === "discard") {
+            const captureId = Number(args[0]);
+            if (!Number.isInteger(captureId))
+                throw new Error(`Usage: ocean capture ${action} <capture-id> [target]`);
+            if (action === "promote") {
+                const item = store.getCaptureItem(captureId);
+                if (!item)
+                    throw new Error(`Capture item not found: ${captureId}`);
+                await promote(item, args[1]);
+            }
+            store.updateCaptureStatus(captureId, action === "promote" ? "promoted" : "discarded", args[1]);
+            await syncCaptureInbox(store);
+            console.log(JSON.stringify({
+                captureId,
+                status: action === "promote" ? "promoted" : "discarded",
+                target: args[1] ?? null,
+            }));
+            return;
+        }
+        console.error("Usage: ocean capture add <idea>|scan [session-id]|list [status]|promote <id> <target>|discard <id>");
+        process.exitCode = 1;
+    }
+    finally {
+        store.close();
+    }
+}
+async function promote(item, target = "knowledge/results") {
+    if (target.startsWith("memory/")) {
+        const relative = target.slice("memory/".length);
+        if (!relative.endsWith(".md") || relative.includes(".."))
+            throw new Error("Memory target must be an existing canonical .md file.");
+        const file = path.resolve(oceanPath(PERSONAL_DIR), relative);
+        const memoryRoot = path.resolve(oceanPath(PERSONAL_DIR)) + path.sep;
+        if (!file.startsWith(memoryRoot))
+            throw new Error(`Memory target must stay inside ${PERSONAL_DIR}.`);
+        const header = `\n\n## Captured note — ${localDate()}\n\n${item.content.trim()}\n\n_Source: session-capture-${item.captureId}; review status: unverified._\n`;
+        await appendFile(file, header);
+        await syncMemoryIndexes(true);
+        return;
+    }
+    if (target === "memory") {
+        throw new Error("Use an explicit canonical file, for example memory/goals.md.");
+    }
+    if (target === "backlog") {
+        await appendFile(oceanPath(PROJECTS_DIR, "backlog.md"), `\n- [TODO] (P2) ${WORKSPACE_PROJECT_ID} — ${item.content.replace(/\s+/g, " ").trim()}  {${localDate()}}\n`);
+        return;
+    }
+    const match = target.match(/^knowledge\/(architecture|decisions|discoveries|failures|research|results|solutions|references)$/);
+    if (!match)
+        throw new Error("Target must be knowledge/<kind>, memory/<file>.md, or backlog.");
+    const safe = item.content
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "")
+        .slice(0, 60);
+    const slug = safe || `capture-${item.captureId}`;
+    const file = path.join(oceanPath(KNOWLEDGE_DIR, match[1], `${slug}-${item.captureId}.md`));
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, `---\nname: ${slug}-${item.captureId}\ndescription: Candidate promoted from a reviewed session input\nmetadata:\n  type: ${match[1] === "results" ? "task-result" : match[1].slice(0, -1)}\n  domain: ${match[1]}\n  status: current\n  verification: unverified\n  source: session-capture-${item.captureId}\n---\n\n${item.content.trim()}\n`);
+    await syncMemoryIndexes(true);
+}
+//# sourceMappingURL=capture-command.js.map

package/dist/interfaces/cli/client-test-command.js

@@ -0,0 +1,133 @@
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { buildOceanBootstrap } from "@ocean/context/context/resource-injection.js";
+import { enginePath, oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+import { resolveProject } from "@ocean/core/shared/project-resolution.js";
+import { claudeNativeHookStatus } from "@ocean/loop/hooks/session-start-hook.js";
+import { openSessionStore } from "@ocean/loop/infrastructure/persistence/session-store.js";
+import { findProvider, loadProviderRegistry, resolveOriginalExecutable, } from "../../infrastructure/providers/provider-registry.js";
+import { providerWrapperName, providerWrapperPath, shimDirectory, } from "../../infrastructure/wrappers/wrapper-manager.js";
+export async function runClientTestCommand(providerName, json = false) {
+    const cwd = path.resolve(process.cwd());
+    const project = await resolveProject(cwd);
+    const bootstrap = buildOceanBootstrap(project);
+    const providers = providerName
+        ? [findProvider(providerName)]
+        : loadProviderRegistry();
+    const store = await openSessionStore();
+    const reports = await Promise.all(providers.map((provider) => buildReport(provider, cwd, project, bootstrap, store)));
+    store.close();
+    if (json) {
+        console.log(JSON.stringify(providerName ? reports[0] : reports, null, 2));
+        return;
+    }
+    for (const report of reports)
+        printReport(report);
+}
+async function buildReport(provider, cwd, project, bootstrap, store) {
+    let executable = null;
+    try {
+        executable = resolveOriginalExecutable(provider.command);
+    }
+    catch {
+        /* Report missing provider below. */
+    }
+    const latest = store.list().find((session) => session.provider === provider.id) ?? null;
+    const events = latest ? store.listEvents(latest.sessionId) : [];
+    const entry = events.find((event) => event.type === "session_entry_contract");
+    const manifest = events.find((event) => event.type === "ocean_bootstrap");
+    const entryBoundary = provider.id === "claude"
+        ? await claudeEntryBoundaryStatus()
+        : {
+            kind: "wrapper-only",
+            detail: `No native hook is wired for this provider. A plain ${provider.command} runs natively; ${providerWrapperName(provider.command)} routes it through Ocean (ocean intercept --client).`,
+        };
+    return {
+        provider: provider.id,
+        routing: {
+            cwd,
+            command: provider.command,
+            shim: providerWrapperPath(provider.command),
+            shimDirectory: shimDirectory(),
+            nativeExecutable: executable,
+            oceanEngine: enginePath("dist", "main.js"),
+        },
+        project,
+        ocean: {
+            root: oceanPath(),
+            bootstrapBytes: bootstrap.manifest.bytes,
+            bootstrapTransport: bootstrap.manifest.transport,
+            sessionStore: oceanPath(SYSTEM_DIR, "sessions", "sessions.sqlite"),
+            runtimeLogs: oceanPath(SYSTEM_DIR, "runtime", "logs", "runtime.jsonl"),
+            sessionSummaries: oceanPath(SYSTEM_DIR, "sessions", "summaries"),
+        },
+        entryBoundary,
+        // The bootstrap is always delivered as an environment variable when launched through the
+        // Ocean shim; whether the provider itself reads it natively (a hook, a config convention)
+        // is unverified until that provider's own consumption is tested — never claimed PROVEN here.
+        transport: "NOT PROVEN: bootstrap-env (delivered as OCEAN_BOOTSTRAP; native provider consumption unverified)",
+        providerOwnedPaths: provider.id === "claude"
+            ? [
+                path.join(os.homedir(), ".claude"),
+                path.join(os.homedir(), ".claude", "CLAUDE.md"),
+                path.join(cwd, "CLAUDE.md"),
+                path.join(cwd, ".claude", "CLAUDE.md"),
+            ].map((file) => ({ path: file, exists: existsSync(file) }))
+            : [
+                {
+                    path: "provider-managed (not controlled by Ocean)",
+                    exists: null,
+                },
+            ],
+        latestSession: latest
+            ? {
+                sessionId: latest.sessionId,
+                status: latest.status,
+                entryContract: entry ? JSON.parse(entry.data) : null,
+                bootstrapManifest: manifest ? JSON.parse(manifest.data) : null,
+            }
+            : null,
+    };
+}
+async function claudeEntryBoundaryStatus() {
+    const hook = await claudeNativeHookStatus();
+    if (hook.registered) {
+        return {
+            kind: "native-hook-registered",
+            detail: `SessionStart hook is registered in ${hook.settingsPath} and points at ${hook.scriptPath}. Its actual invocation by a live Claude Code session is still unverified here — this only proves registration.`,
+        };
+    }
+    if (hook.scriptInstalled) {
+        return {
+            kind: "native-hook-available-not-registered",
+            detail: `Hook script exists at ${hook.scriptPath} but hooks.SessionStart in ${hook.settingsPath} does not reference it. Until it does, only ${providerWrapperName("claude")} routes Claude through Ocean.`,
+        };
+    }
+    return {
+        kind: "wrapper-only",
+        detail: `No native SessionStart hook script found. Only ${providerWrapperName("claude")} routes Claude through Ocean (ocean intercept --client claude).`,
+    };
+}
+function printReport(report) {
+    console.log(`Ocean client test: ${report.provider}`);
+    console.log(`cwd: ${report.routing.cwd}`);
+    console.log(`shim: ${report.routing.shim}`);
+    console.log(`native executable: ${report.routing.nativeExecutable ?? "NOT FOUND outside Ocean shims"}`);
+    console.log(`Ocean engine: ${report.routing.oceanEngine}`);
+    console.log(`project: ${report.project.status}${report.project.status === "bound" ? ` (${report.project.projectId}, confidence: ${report.project.confidence})` : ""}`);
+    console.log(`entry boundary: ${report.entryBoundary.kind} — ${report.entryBoundary.detail}`);
+    console.log(`Ocean bootstrap bytes: ${report.ocean.bootstrapBytes}`);
+    console.log(`Ocean saves sessions: ${report.ocean.sessionStore}`);
+    console.log(`Ocean saves runtime logs: ${report.ocean.runtimeLogs}`);
+    console.log(`Ocean saves summaries: ${report.ocean.sessionSummaries}`);
+    console.log(`transport: ${report.transport}`);
+    console.log("Provider-owned paths:");
+    for (const file of report.providerOwnedPaths)
+        console.log(`- ${file.exists === null ? "not controlled" : file.exists ? "present" : "absent"}: ${file.path}`);
+    if (report.latestSession)
+        console.log(`latest session: ${report.latestSession.sessionId} [${report.latestSession.status}] — inspect with: ocean session events ${report.latestSession.sessionId}`);
+    else
+        console.log("latest session: none");
+}
+//# sourceMappingURL=client-test-command.js.map

package/dist/interfaces/cli/clients-command.js

@@ -0,0 +1,129 @@
+import { readCallLedger, summarizeCallLedger, } from "@ocean/services/infrastructure/mcp/call-ledger.js";
+import { applyClients, attributeLedger, confirmClient, defaultClientEnv, planClients, recordVerification, repairClients, restoreClients, temporaryEntryProblem, verifyClient, } from "../../application/clients/clients.js";
+import { applyHooks, planHooks, restoreHooks, } from "../../application/clients/hooks.js";
+import { applyNative, planNative, restoreNative, } from "../../application/clients/native.js";
+import { applyOpencodePlugin, planOpencodePlugin, restoreOpencodePlugin, } from "../../application/clients/opencode-plugin.js";
+const usage = "Usage: ocean clients detect|plan [--json] | apply [--client <id>…] [--yes] | verify [<id>…] | confirm <id>… --label in-app|headless|connected|blocked [--via <evidence>] [--reason <why>] | ledger | repair | restore [--batch <id>]";
+// `ocean clients` (T-296 P2/P3b): every installed AI client's `ocean` MCP entry and, where the
+// client has a verified session-start event, Ocean's session hook. `apply` shows the plan until
+// --yes; `repair` only re-applies clients already approved; `restore` undoes an apply batch
+// (entries and hooks) from the journal.
+export async function runClientsCommand(args) {
+    const [action = "detect", ...rest] = args;
+    const json = rest.includes("--json");
+    const values = (flag) => rest.flatMap((arg, index) => (rest[index - 1] === flag ? [arg] : []));
+    let result;
+    if (action === "detect" || action === "plan") {
+        const plans = await planClients();
+        // `apply` refuses a temporary engine; the plan says so up front (T-300).
+        const problem = temporaryEntryProblem(defaultClientEnv().entry);
+        if (problem && action === "plan")
+            console.error(`Warning: apply would refuse this plan — ${problem}`);
+        if (!json) {
+            for (const plan of plans) {
+                if (action === "detect" && !plan.installed)
+                    continue;
+                const ops = plan.ops.map((op) => `${op.kind} ${op.key}`).join(", ");
+                console.log(`${plan.client.padEnd(15)} ${plan.status.padEnd(14)} ${plan.tier.padEnd(13)} ${plan.installed ? plan.evidence.join("; ") : "not installed"}${ops ? ` → ${ops}` : ""}${plan.reason ? ` (${plan.reason})` : ""}`);
+            }
+            if (action === "plan")
+                for (const native of await planNative())
+                    console.log(`${`${native.client} memory`.padEnd(15)} ${native.status.padEnd(14)} ${native.setting
+                        ? `${native.file} ${native.setting}`
+                        : (native.reason ?? "")}${native.setting && native.reason ? ` (${native.reason})` : ""}`);
+            if (action === "plan")
+                for (const hook of await planHooks())
+                    console.log(`${`${hook.client} hook`.padEnd(15)} ${hook.status.padEnd(14)} ${hook.file} ${hook.event}${hook.reason ? ` (${hook.reason})` : ""}${hook.snippet ? `; add ${hook.snippet}` : ""}`);
+            if (action === "plan")
+                for (const plugin of await planOpencodePlugin())
+                    console.log(`${"opencode hook".padEnd(15)} ${plugin.status.padEnd(14)} ${plugin.file} plugin${plugin.reason ? ` (${plugin.reason})` : ""}`);
+            return;
+        }
+        result =
+            action === "detect"
+                ? plans.filter((plan) => plan.installed)
+                : {
+                    clients: plans,
+                    hooks: await planHooks(),
+                    plugins: await planOpencodePlugin(),
+                    native: await planNative(),
+                };
+    }
+    else if (action === "apply") {
+        const clients = values("--client");
+        if (!rest.includes("--yes")) {
+            const pending = (await planClients()).filter((plan) => plan.status === "change" &&
+                (!clients.length || clients.includes(plan.client)));
+            const hooks = (await planHooks()).filter((hook) => hook.status === "change" &&
+                (!clients.length || clients.includes(hook.client)));
+            const native = (await planNative()).filter((plan) => plan.status === "change" &&
+                (!clients.length || clients.includes(plan.client)));
+            const plugins = (await planOpencodePlugin()).filter((plan) => plan.status === "change" &&
+                (!clients.length || clients.includes(plan.client)));
+            console.log(JSON.stringify({ dryRun: true, pending, hooks, plugins, native }, null, 2));
+            console.error("Dry run: pass --yes to write these client configs.");
+            return;
+        }
+        const selected = clients.length ? clients : undefined;
+        const applied = await applyClients({ clients: selected });
+        result = {
+            ...applied,
+            hooks: (await applyHooks({ clients: selected, batch: applied.batch }))
+                .results,
+            plugins: (await applyOpencodePlugin({ clients: selected, batch: applied.batch })).results,
+            native: (await applyNative({ clients: selected, batch: applied.batch }))
+                .results,
+        };
+    }
+    else if (action === "verify") {
+        const ids = rest.filter((arg) => !arg.startsWith("--"));
+        const targets = ids.length
+            ? ids
+            : (await planClients())
+                .filter((plan) => plan.installed && plan.status === "current")
+                .map((plan) => plan.client);
+        result = [];
+        for (const id of targets) {
+            const check = await verifyClient(id);
+            await recordVerification(id, check.ok);
+            result.push(check);
+        }
+    }
+    else if (action === "confirm") {
+        const flags = ["--label", "--via", "--reason"];
+        const ids = rest.filter((arg, index) => !arg.startsWith("--") && !flags.includes(rest[index - 1]));
+        const label = values("--label")[0];
+        if (!ids.length || !label)
+            throw new Error("Usage: ocean clients confirm <id>… --label in-app|headless|connected|blocked [--via <evidence>] [--reason <why>]");
+        for (const id of ids)
+            await confirmClient(id, {
+                label: label,
+                via: values("--via")[0],
+                reason: values("--reason")[0],
+            });
+        result = { confirmed: ids, label };
+    }
+    else if (action === "ledger")
+        // Which client called which Ocean tool, and when last — the in-app evidence (T-307).
+        result = attributeLedger(summarizeCallLedger(await readCallLedger()));
+    else if (action === "repair")
+        result = await repairClients();
+    else if (action === "restore") {
+        const restored = await restoreClients({ batch: values("--batch")[0] });
+        result = restored.batch
+            ? {
+                ...restored,
+                hooks: await restoreHooks({ batch: restored.batch }),
+                plugins: await restoreOpencodePlugin({ batch: restored.batch }),
+                native: await restoreNative({ batch: restored.batch }),
+            }
+            : restored;
+    }
+    else {
+        console.error(usage);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify(result, null, 2));
+}
+//# sourceMappingURL=clients-command.js.map