@amoree-code/ocean 0.0.0-stage → 1.2.0

package/dist/infrastructure/providers/providers.js

@@ -0,0 +1,134 @@
+import path from "node:path";
+import { runHeadless } from "../process/cli-process.js";
+import { explicitModel, runClaudeSdk } from "./claude-sdk.js";
+import { resolveOriginalExecutable } from "./provider-registry.js";
+// One flag per directory; never variadic, so the next argument cannot be swallowed.
+function repeatFlag(flag, values) {
+    return (values ?? []).flatMap((value) => [flag, value]);
+}
+// The model is enforced with each client's own flag, never only described in the prompt.
+// Flags verified against each installed CLI's --help on 2026-10-13.
+function modelFlag(flag, model) {
+    const chosen = explicitModel(model);
+    return chosen ? [flag, chosen] : [];
+}
+export const providerAdapterRegistry = {
+    // Claude runs through the Claude Agent SDK, which builds Claude Code's flags itself
+    // (claudeSdkOptions: resume, model, read-only, read grant).
+    claude: {
+        provider: "claude",
+        capabilities: ["headless", "resume", "read-only"],
+        run: runClaudeSdk,
+    },
+    codex: {
+        provider: "codex",
+        capabilities: ["headless", "read-only"],
+        readOnlyArgs: ["--sandbox", "read-only"],
+        build: (request) => [
+            "exec",
+            ...modelFlag("--model", request.model),
+            ...(request.readOnly ? ["--sandbox", "read-only"] : []),
+            "--json",
+            "--skip-git-repo-check",
+            request.prompt,
+        ],
+    },
+    gemini: {
+        provider: "gemini",
+        capabilities: ["headless", "read-only"],
+        readOnlyArgs: ["--approval-mode=plan"],
+        build: (request) => [
+            ...modelFlag("--model", request.model),
+            ...(request.readOnly ? ["--approval-mode=plan"] : []),
+            ...repeatFlag("--include-directories", request.readDirectories),
+            "--prompt",
+            request.prompt,
+            "--output-format",
+            "stream-json",
+        ],
+    },
+    antigravity: {
+        provider: "antigravity",
+        capabilities: ["headless", "read-only"],
+        readOnlyArgs: ["--mode", "plan", "--sandbox"],
+        build: (request) => [
+            ...modelFlag("--model", request.model),
+            ...(request.readOnly ? ["--mode", "plan", "--sandbox"] : []),
+            "--print",
+            request.prompt,
+            "--output-format",
+            "stream-json",
+        ],
+    },
+    hermes: {
+        provider: "hermes",
+        capabilities: ["headless"],
+        build: (request) => [
+            ...modelFlag("-m", request.model),
+            "-z",
+            request.prompt,
+        ],
+    },
+    kilo: {
+        provider: "kilo",
+        capabilities: ["headless"],
+        build: (request) => [
+            "run",
+            ...modelFlag("--model", request.model),
+            "--auto",
+            request.prompt,
+        ],
+    },
+    kimi: {
+        provider: "kimi",
+        capabilities: ["headless", "read-only"],
+        readOnlyArgs: ["--plan"],
+        build: (request) => [
+            ...modelFlag("--model", request.model),
+            ...(request.readOnly ? ["--plan"] : []),
+            "--prompt",
+            request.prompt,
+            "--print",
+            "--output-format",
+            "stream-json",
+        ],
+    },
+};
+export function buildProviderInvocation(request) {
+    const command = request.provider === "antigravity" ? "agy" : request.provider;
+    const adapter = providerAdapterRegistry[request.provider];
+    if (!adapter.build)
+        throw new Error(`${request.provider} runs through its SDK, not a CLI invocation`);
+    if (request.readOnly)
+        assertProviderSupportsReadOnly(request.provider);
+    const args = adapter.build(request);
+    return { command, args };
+}
+export function assertProviderSupportsReadOnly(provider) {
+    if (!providerAdapterRegistry[provider].capabilities.includes("read-only"))
+        throw new Error(`Provider cannot enforce read-only execution: ${provider}`);
+}
+export function runProvider(request) {
+    const sdkRun = providerAdapterRegistry[request.provider].run;
+    if (sdkRun)
+        return sdkRun(request);
+    const { command, args } = buildProviderInvocation(request);
+    return runHeadless({
+        command: resolveOriginalExecutable(command),
+        args,
+        cwd: path.resolve(request.cwd),
+        // Built fresh for every run: the plan's variables override any inherited value of the
+        // same name, and nothing is written back to this process's environment.
+        env: {
+            ...request.env,
+            ...(request.provider === "hermes" && request.clientHome
+                ? { HERMES_HOME: request.clientHome }
+                : {}),
+        },
+        timeoutMs: request.timeoutMs,
+        maxOutputBytes: request.maxOutputBytes,
+        onEvent: request.onEvent,
+        onSpawn: request.onSpawn,
+    });
+}
+//# sourceMappingURL=providers.js.map

package/dist/infrastructure/wrappers/wrapper-manager.js

@@ -0,0 +1,374 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { access, chmod, mkdir, readdir, readFile, rm, writeFile, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { atomicWrite } from "@ocean/core/shared/fs-utils.js";
+import { liveEngineEntry, oceanEnv, oceanPath, SYSTEM_DIR, } from "@ocean/core/shared/paths.js";
+import { builtInProviderRecords, loadProviderRegistry, resolveOriginalExecutable, saveProviderRegistry, } from "../providers/provider-registry.js";
+const execFile = promisify(execFileCallback);
+const CLI_WRAPPER_NAMES = ["ocean"];
+const DESKTOP_WRAPPER_PROVIDERS = ["claude"];
+export function shimDirectory() {
+    return oceanPath(SYSTEM_DIR, "runtime", "shims");
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function wrapperPath(command) {
+    return process.platform === "win32"
+        ? path.join(shimDirectory(), `${command}.cmd`)
+        : path.join(shimDirectory(), command);
+}
+// A provider wrapper never takes the provider's own name: a same-name shim shadows the native
+// binary and its behaviour then depends on PATH order and on which shell is running (T-266).
+// Clients reach Ocean through their native hooks; `ocean-<command>` is the explicit way in.
+export function providerWrapperName(command) {
+    return `ocean-${command}`;
+}
+export function providerWrapperPath(command) {
+    return wrapperPath(providerWrapperName(command));
+}
+// Names Ocean may own in the shim directory; anything else there can shadow a real command.
+function isNamespacedShim(name) {
+    const base = name.replace(/\.cmd$/i, "");
+    return (CLI_WRAPPER_NAMES.includes(base) ||
+        base.startsWith("ocean-") ||
+        DESKTOP_WRAPPER_PROVIDERS.some((provider) => base === `${provider}-vscode`));
+}
+// Every provider wrapper Ocean has written (posix and .cmd) sets OCEAN_SHIM_DIR and calls
+// intercept; a user's own script that merely calls `ocean intercept` does not set the variable.
+function isOceanInterceptWrapper(contents) {
+    return (contents.includes("OCEAN_SHIM_DIR=") &&
+        contents.includes(" intercept --client "));
+}
+// The interpreter recorded at sync time, else `node` from PATH once that one is gone (an fnm/nvm
+// upgrade removes the old version's directory), else the usual install locations — an app started
+// from the Dock has a minimal PATH (T-307).
+function posixNode() {
+    return `node=${shellQuote(process.execPath)}\n[ -x "$node" ] || node=$(command -v node 2>/dev/null)\nfor candidate in /opt/homebrew/bin/node /usr/local/bin/node; do [ -x "$node" ] || node=$candidate; done\n`;
+}
+function windowsNode() {
+    return `set "node=${process.execPath}"\r\nif not exist "%node%" set "node=node"\r\n`;
+}
+export function desktopWrapperPath(provider = "claude") {
+    return wrapperPath(`${provider}-vscode`);
+}
+function wrapperContents(provider) {
+    const entry = shellQuote(liveEngineEntry());
+    if (process.platform === "win32") {
+        return `@echo off\r\nset "OCEAN_SHIM_DIR=${shimDirectory()}"\r\n${windowsNode()}"%node%" "${liveEngineEntry()}" intercept --client "${provider.id}" -- %*\r\n`;
+    }
+    return `#!/bin/sh\nexport OCEAN_SHIM_DIR=${shellQuote(shimDirectory())}\n${posixNode()}exec "$node" ${entry} intercept --client ${shellQuote(provider.id)} -- "$@"\n`;
+}
+function cliWrapperContents() {
+    if (process.platform === "win32") {
+        return `@echo off\r\n${windowsNode()}"%node%" "${liveEngineEntry()}" %*\r\n`;
+    }
+    return `#!/bin/sh\n${posixNode()}exec "$node" ${shellQuote(liveEngineEntry())} "$@"\n`;
+}
+function desktopWrapperContents(provider) {
+    if (process.platform === "win32") {
+        return `@echo off\r\nif "%~1"=="" exit /b 64\r\nset "native=%~1"\r\nshift\r\n${windowsNode()}"%node%" "${liveEngineEntry()}" intercept --client "${provider}" --executable "%native%" -- %*\r\n`;
+    }
+    return `#!/bin/sh
+if [ "$#" -lt 1 ]; then
+  echo "Ocean desktop wrapper requires the native ${provider} executable path" >&2
+  exit 64
+fi
+native="$1"
+shift
+${posixNode()}exec "$node" ${shellQuote(liveEngineEntry())} intercept --client ${shellQuote(provider)} --executable "$native" -- "$@"
+`;
+}
+export async function syncProviderWrappers() {
+    const providers = loadProviderRegistry();
+    await mkdir(shimDirectory(), { recursive: true });
+    for (const name of CLI_WRAPPER_NAMES) {
+        const cliWrapper = wrapperPath(name);
+        await writeFile(cliWrapper, cliWrapperContents());
+        if (process.platform !== "win32")
+            await chmod(cliWrapper, 0o755);
+    }
+    for (const provider of providers) {
+        const file = providerWrapperPath(provider.command);
+        await writeFile(file, wrapperContents(provider));
+        if (process.platform !== "win32")
+            await chmod(file, 0o755);
+    }
+    for (const provider of DESKTOP_WRAPPER_PROVIDERS) {
+        const desktopWrapper = desktopWrapperPath(provider);
+        await writeFile(desktopWrapper, desktopWrapperContents(provider));
+        if (process.platform !== "win32")
+            await chmod(desktopWrapper, 0o755);
+    }
+    await removeLegacyShims();
+    await saveProviderRegistry(providers);
+    return { providers, directory: shimDirectory() };
+}
+// Removes same-name shims left by earlier syncs, including ones for providers no longer
+// registered, but only files Ocean wrote: anything else is the user's, and doctor reports it.
+async function removeLegacyShims() {
+    for (const name of await readdir(shimDirectory())) {
+        if (name.startsWith(".") || isNamespacedShim(name))
+            continue;
+        await removeLegacyShim(path.join(shimDirectory(), name));
+    }
+}
+async function removeLegacyShim(file) {
+    let contents;
+    try {
+        contents = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    if (isOceanInterceptWrapper(contents))
+        await rm(file, { force: true });
+}
+export async function registerProvider(id, command = id) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(id) || !/^[a-zA-Z0-9._-]+$/.test(command)) {
+        throw new Error("Provider id and command may contain only letters, numbers, dot, underscore, and hyphen");
+    }
+    const providers = loadProviderRegistry().filter((provider) => provider.id !== id);
+    const provider = {
+        id,
+        command,
+        interactive: true,
+        headless: true,
+    };
+    await saveProviderRegistry([...providers, provider]);
+    await syncProviderWrappers();
+    return provider;
+}
+export async function setProviderEnabled(id, enabled) {
+    const providers = loadProviderRegistry();
+    const provider = providers.find((candidate) => candidate.id === id || candidate.command === id);
+    if (!provider)
+        throw new Error(`Provider is not registered: ${id}`);
+    const updated = { ...provider, enabled };
+    await saveProviderRegistry(providers.map((candidate) => candidate.id === provider.id ? updated : candidate));
+    return updated;
+}
+export async function removeProvider(id) {
+    const providers = loadProviderRegistry();
+    const provider = providers.find((candidate) => candidate.id === id || candidate.command === id);
+    if (!provider)
+        throw new Error(`Provider is not registered: ${id}`);
+    if (builtInProviderRecords().some((candidate) => candidate.id === provider.id)) {
+        throw new Error(`Built-in provider remains registered; use its package manager to remove: ${provider.id}`);
+    }
+    await rm(providerWrapperPath(provider.command), { force: true });
+    await removeLegacyShim(wrapperPath(provider.command));
+    await saveProviderRegistry(providers.filter((candidate) => candidate.id !== provider.id));
+    return provider;
+}
+export function shellKind(parentCommand, loginShell) {
+    const parent = path.basename(parentCommand.trim().split(/\s+/, 1)[0] ?? "");
+    if (parent === "fish")
+        return "fish";
+    if (["ash", "bash", "dash", "ksh", "sh", "zsh"].includes(parent))
+        return "posix";
+    return path.basename(loginShell) === "fish" ? "fish" : "posix";
+}
+async function currentShellName() {
+    if (process.platform === "win32")
+        return "powershell";
+    try {
+        const { stdout } = await execFile("ps", [
+            "-p",
+            String(process.ppid),
+            "-o",
+            "comm=",
+        ]);
+        const parent = path.basename(stdout.trim().split(/\s+/, 1)[0] ?? "");
+        if (["ash", "bash", "dash", "fish", "ksh", "sh", "zsh"].includes(parent))
+            return parent;
+    }
+    catch {
+        // Fall through to the configured login shell.
+    }
+    return path.basename(process.env.SHELL ?? "");
+}
+async function currentShellKind() {
+    return (await currentShellName()) === "fish" ? "fish" : "posix";
+}
+// Appended, once: the shim directory holds only Ocean's own names, so its PATH position no
+// longer decides anything, and re-sourcing a profile never grows PATH.
+export function shellPathLine(kind, directory) {
+    if (kind === "powershell")
+        return `if (-not (($env:Path -split ';') -contains "${directory}")) { $env:Path = "$env:Path;${directory}" }`;
+    const quoted = shellQuote(directory);
+    // --path edits $PATH itself; without it fish puts fish_user_paths in front of the system dirs.
+    if (kind === "fish")
+        return `fish_add_path --append --path ${quoted}`;
+    return `case ":$PATH:" in *:${quoted}:*) ;; *) export PATH="$PATH":${quoted} ;; esac`;
+}
+export async function installShellPath() {
+    const kind = process.platform === "win32" ? "powershell" : await currentShellKind();
+    return shellPathLine(kind, shimDirectory());
+}
+async function shellProfilePath() {
+    const home = os.homedir();
+    if (process.platform === "win32")
+        return (oceanEnv("SHELL_PROFILE") ??
+            path.join(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1"));
+    const profile = oceanEnv("SHELL_PROFILE");
+    if (profile)
+        return profile;
+    const shell = await currentShellName();
+    if (shell === "fish")
+        return path.join(home, ".config", "fish", "config.fish");
+    if (shell === "zsh")
+        return path.join(home, ".zshrc");
+    if (shell === "bash")
+        return path.join(home, ".bashrc");
+    return path.join(home, ".profile");
+}
+const BLOCK_BEGIN = /^# >>> (ocean) interception >>>$/;
+function withoutEol(line) {
+    return line.replace(/\r?\n$/, "");
+}
+// Removes every managed interception block and nothing else:
+// all other lines keep their exact bytes and line endings. Only the single blank separator the
+// installer puts above its block goes with it. A begin marker without a matching end marker is
+// left alone rather than guessed at.
+function stripInterceptionBlocks(text) {
+    const lines = text.split(/(?<=\n)/);
+    const kept = [];
+    // Once a name has no end marker after some position it has none after any later one, so
+    // repeated unterminated begin markers cost one scan, not one scan each.
+    const noEndFor = new Set();
+    for (let index = 0; index < lines.length; index += 1) {
+        const begin = BLOCK_BEGIN.exec(withoutEol(lines[index]));
+        if (begin && !noEndFor.has(begin[1])) {
+            const end = `# <<< ${begin[1]} interception <<<`;
+            const close = lines.findIndex((line, at) => at > index && withoutEol(line) === end);
+            if (close < 0)
+                noEndFor.add(begin[1]);
+            if (close >= 0) {
+                if (kept.length && withoutEol(kept[kept.length - 1]).trim() === "")
+                    kept.pop();
+                index = close;
+                continue;
+            }
+        }
+        kept.push(lines[index]);
+    }
+    return kept.join("");
+}
+export async function installShellIntegration() {
+    const file = await shellProfilePath();
+    let existing = "";
+    try {
+        existing = await readFile(file, "utf8");
+    }
+    catch {
+        /* new profile */
+    }
+    const line = await installShellPath();
+    const eol = existing.includes("\r\n") ? "\r\n" : "\n";
+    let rest = stripInterceptionBlocks(existing);
+    if (rest && !rest.endsWith("\n"))
+        rest += eol;
+    const block = `${["# >>> ocean interception >>>", line, "# <<< ocean interception <<<"].join(eol)}${eol}`;
+    await mkdir(path.dirname(file), { recursive: true });
+    await atomicWrite(file, rest ? `${rest}${eol}${block}` : block);
+    return file;
+}
+export async function wrapperDoctor(commandPath) {
+    const findings = [];
+    const providers = loadProviderRegistry();
+    for (const name of CLI_WRAPPER_NAMES) {
+        try {
+            const contents = await readFile(wrapperPath(name), "utf8");
+            if (!contents.includes(liveEngineEntry()))
+                findings.push(`${name}: CLI wrapper is stale or does not route through Ocean; run: ocean doctor --fix`);
+        }
+        catch {
+            findings.push(`${name}: CLI wrapper is missing at ${wrapperPath(name)}; run: ocean doctor --fix`);
+        }
+    }
+    for (const provider of providers) {
+        try {
+            const contents = await readFile(providerWrapperPath(provider.command), "utf8");
+            if (!contents.includes(`intercept --client '${provider.id}'`) &&
+                !contents.includes(`intercept --client "${provider.id}"`)) {
+                findings.push(`${provider.id}: wrapper is stale or does not route through Ocean`);
+            }
+        }
+        catch {
+            findings.push(`${provider.id}: wrapper is missing at ${providerWrapperPath(provider.command)}`);
+        }
+        try {
+            resolveOriginalExecutable(provider.command);
+        }
+        catch (error) {
+            findings.push(`${provider.id}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const currentPath = (process.env.PATH ?? "")
+        .split(path.delimiter)
+        .map((entry) => path.resolve(entry));
+    if (!currentPath.includes(path.resolve(shimDirectory())))
+        findings.push(`Ocean shim directory is not on PATH: ${shimDirectory()}`);
+    let names = [];
+    try {
+        names = await readdir(shimDirectory());
+    }
+    catch {
+        /* reported above as missing wrappers */
+    }
+    const strays = names.filter((entry) => !entry.startsWith(".") && !isNamespacedShim(entry));
+    for (const name of strays.sort())
+        findings.push(`${name}: ${path.join(shimDirectory(), name)} can shadow the native ${name} command; run: ocean client sync, or remove it if it is not Ocean's`);
+    const bypass = commandPath ? absolutePathBypassFinding(commandPath) : null;
+    if (bypass)
+        findings.push(bypass);
+    return findings;
+}
+export function absolutePathBypassFinding(commandPath) {
+    if (!path.isAbsolute(commandPath))
+        return null;
+    const resolved = path.resolve(commandPath);
+    if (resolved.startsWith(`${path.resolve(shimDirectory())}${path.sep}`))
+        return null;
+    const command = path.basename(resolved).replace(/\.(cmd|exe|bat)$/i, "");
+    const provider = loadProviderRegistry().find((candidate) => candidate.command === command);
+    // Running a provider natively is the normal route since T-266, but it reaches Ocean only
+    // through a registered native hook; say so instead of calling it a misuse.
+    if (provider)
+        return `NATIVE_ENTRY: ${provider.id} at ${resolved} reaches Ocean only through its native hook; ${providerWrapperName(provider.command)} routes it through Ocean`;
+    return `BYPASS_DETECTED: absolute path is outside Ocean and is not a registered provider: ${resolved}`;
+}
+export async function wrapperStatus() {
+    const providers = loadProviderRegistry();
+    return Promise.all(providers.map(async (provider) => {
+        let realExecutable = null;
+        try {
+            realExecutable = resolveOriginalExecutable(provider.command);
+        }
+        catch {
+            /* reported by doctor */
+        }
+        let installed = true;
+        try {
+            await access(providerWrapperPath(provider.command));
+        }
+        catch {
+            installed = false;
+        }
+        return {
+            ...provider,
+            enabled: provider.enabled !== false,
+            wrapper: providerWrapperPath(provider.command),
+            installed,
+            realExecutable,
+            entryPoint: "terminal-shim",
+            controlLevel: "observed",
+        };
+    }));
+}
+//# sourceMappingURL=wrapper-manager.js.map

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

@@ -0,0 +1,54 @@
+import { randomUUID } from "node:crypto";
+import { validateSessionEntryContract } from "@ocean/core/domain/sessions/entry-contract.js";
+import { openSessionStore } from "@ocean/loop/infrastructure/persistence/session-store.js";
+import { sessionProjectId } from "@ocean/loop/sessions/session-projects.js";
+import { authLogin, authStatus, } from "../../application/auth/auth-orchestrator.js";
+import { defaultAuthDeps } from "../../composition/runtime.js";
+export async function runAuthCommand(action, provider) {
+    if (!provider || !["status", "login"].includes(action)) {
+        console.error("Usage: ocean auth status|login <client>");
+        process.exitCode = 1;
+        return;
+    }
+    const store = await openSessionStore();
+    const sessionId = randomUUID();
+    store.create({
+        sessionId,
+        provider,
+        providerSessionId: null,
+        parentSessionId: null,
+        profile: `auth:${provider}`,
+        profileIdentity: "",
+        workingDirectory: process.cwd(),
+        projectId: await sessionProjectId(process.cwd()),
+        resumeData: null,
+    });
+    store.appendEvent(sessionId, "session_entry_contract", JSON.stringify(validateSessionEntryContract({
+        entryPoint: "ocean-run",
+        controlLevel: "full-head",
+        inputCapture: "none",
+        contextTransport: "provider-owned-auth",
+        policyEnforcement: "provider-owned-auth-boundary",
+        promotion: "explicit-review",
+        resume: "unsupported",
+    })));
+    store.updateStatus(sessionId, "running");
+    store.appendEvent(sessionId, "auth_started", JSON.stringify({ action, provider }));
+    const state = action === "status"
+        ? await authStatus(provider, defaultAuthDeps)
+        : await authLogin(provider, defaultAuthDeps);
+    store.appendEvent(sessionId, "auth_state", JSON.stringify({ state }));
+    store.appendEvent(sessionId, "evidence", JSON.stringify({
+        type: "auth",
+        result: state,
+        criterion: "provider-owned authentication state",
+    }));
+    store.updateStatus(sessionId, ["failed", "cancelled", "not_supported"].includes(state)
+        ? "failed"
+        : "completed");
+    store.close();
+    console.log(JSON.stringify({ provider, state, sessionId }));
+    if (state === "failed" || state === "not_supported")
+        process.exitCode = 1;
+}
+//# sourceMappingURL=auth-command.js.map

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

@@ -0,0 +1,93 @@
+import { execFile } from "node:child_process";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { liveEngineEntry, oceanRoot } from "@ocean/core/shared/paths.js";
+import { BrowserBridge, browserBridgeHealth, browserBridgePort, serveBrowserBridge, } from "@ocean/market/mcp/browser-bridge.js";
+import { McpClient } from "@ocean/services/infrastructure/mcp/mcp-client.js";
+import { oceanVersion } from "../../version.js";
+const LABEL = "com.ocean.browser-bridge";
+const run = promisify(execFile);
+// `ocean mcp browser-bridge`: the one loopback MCP endpoint in front of the owner's Chrome. Logs
+// go to stderr and never carry page content.
+export async function runBrowserBridgeCommand() {
+    const log = (line) => console.error(`ocean browser bridge: ${line}`);
+    const bridge = new BrowserBridge({
+        client: (member) => new McpClient({
+            command: member.command,
+            args: member.args,
+            cwd: member.cwd,
+            env: member.env,
+            inheritEnv: member.inheritEnv,
+        }),
+        version: await oceanVersion(),
+        log,
+    });
+    const port = browserBridgePort();
+    const server = await serveBrowserBridge(bridge, port, log);
+    log(`listening on 127.0.0.1:${port}`);
+    const stop = () => {
+        bridge.close();
+        server.close();
+        process.exit(0);
+    };
+    process.once("SIGTERM", stop);
+    process.once("SIGINT", stop);
+}
+function plistPath() {
+    return path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+function launchdDomain() {
+    return `gui/${process.getuid?.() ?? ""}`;
+}
+async function installService() {
+    const logs = path.join(os.homedir(), "Library", "Logs");
+    const file = plistPath();
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>Label</key><string>${LABEL}</string>
+<key>ProgramArguments</key><array><string>${process.execPath}</string><string>${liveEngineEntry()}</string><string>mcp</string><string>browser-bridge</string></array>
+<key>WorkingDirectory</key><string>${oceanRoot()}</string>
+<key>RunAtLoad</key><true/>
+<key>KeepAlive</key><true/>
+<key>StandardErrorPath</key><string>${path.join(logs, `${LABEL}.log`)}</string>
+</dict></plist>
+`);
+    await run("launchctl", ["bootout", `${launchdDomain()}/${LABEL}`]).catch(() => { });
+    await run("launchctl", ["bootstrap", launchdDomain(), file]);
+    console.log(`installed ${LABEL}: ${file}`);
+}
+async function uninstallService() {
+    await run("launchctl", ["bootout", `${launchdDomain()}/${LABEL}`]).catch(() => { });
+    await rm(plistPath(), { force: true });
+    console.log(`removed ${LABEL}`);
+}
+export async function runBrowserServiceCommand(action) {
+    if (process.platform !== "darwin") {
+        console.error("ocean mcp browser-service supports macOS only; run `ocean mcp browser-bridge` under your own service manager.");
+        process.exitCode = 1;
+    }
+    else if (action === "install")
+        await installService();
+    else if (action === "uninstall")
+        await uninstallService();
+    else {
+        console.error("Usage: ocean mcp browser-service install|uninstall");
+        process.exitCode = 1;
+    }
+}
+export async function browserBridgeFindings() {
+    const health = await browserBridgeHealth();
+    const finding = (severity, message) => [
+        { code: "BROWSER_BRIDGE", severity, message, fixable: false },
+    ];
+    if (!health)
+        return finding("WARN", "browser bridge is not reachable; start it with `ocean mcp browser-service install` (a sandboxed shell cannot reach loopback)");
+    return health.chromeDebuggingListening
+        ? finding("OK", "browser bridge is up and Chrome debugging is listening")
+        : finding("WARN", "browser bridge is up but Chrome is closed or chrome://inspect/#remote-debugging is off");
+}
+//# sourceMappingURL=browser-bridge-command.js.map