@amoree-code/ocean 0.0.0-stage → 1.2.0

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

@@ -0,0 +1,317 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { bootstrapEnvironment, buildOceanBootstrap, } from "@ocean/context/context/resource-injection.js";
+import { profileIdentity, } from "@ocean/core/domain/profiles/profile.js";
+import { validateRunContract } from "@ocean/core/domain/runs/run-contract.js";
+import { validateSessionEntryContract } from "@ocean/core/domain/sessions/entry-contract.js";
+import { oceanEnvPair } from "@ocean/core/shared/paths.js";
+import { projectRules, resolveProject, } from "@ocean/core/shared/project-resolution.js";
+import { boundProjectManifest } from "@ocean/loop/hooks/session-start-hook.js";
+import { openSessionStore } from "@ocean/loop/infrastructure/persistence/session-store.js";
+import { authorizeRun } from "@ocean/loop/runs/run-authorization.js";
+import { finalizeSession } from "@ocean/loop/sessions/session-closeout.js";
+import { authAdapter, authLogin, authStatus, } from "../../application/auth/auth-orchestrator.js";
+import { defaultAuthDeps } from "../../composition/runtime.js";
+import { redactRuntimeText } from "../../infrastructure/observability/runtime-logger.js";
+import { runInteractive, runPassthrough, } from "../../infrastructure/process/interactive-process.js";
+import { findProvider, resolveOriginalExecutable, validateExplicitExecutable, } from "../../infrastructure/providers/provider-registry.js";
+async function rulesCount(project) {
+    const { manifest } = await boundProjectManifest(project);
+    try {
+        return manifest ? projectRules(manifest).length : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+export async function intercept(command, args, options = {}) {
+    const provider = findProvider(command);
+    if (provider.enabled === false || isUtilityInvocation(provider.id, args)) {
+        const executable = options.originalExecutable
+            ? validateExplicitExecutable(options.originalExecutable)
+            : resolveOriginalExecutable(provider.command);
+        const result = await runPassthrough({
+            command: executable,
+            args,
+            cwd: path.resolve(process.cwd()),
+            env: oceanEnvPair("INTERCEPTED", "1"),
+        });
+        return result.exitCode;
+    }
+    const entryPoint = options.entryPoint ??
+        (options.originalExecutable ? "desktop-wrapper" : "terminal-shim");
+    const controlLevel = options.controlLevel ??
+        (options.originalExecutable ? "managed-partial" : "observed");
+    const inputCapture = options.originalExecutable ? "none" : "bounded-terminal";
+    const sessionId = randomUUID();
+    const profile = interceptedProfile(provider.id);
+    const store = await openSessionStore();
+    const workingDirectory = path.resolve(process.cwd());
+    const projectResolution = await resolveProject(workingDirectory);
+    // The env bootstrap carries only the rules count; the rules themselves reach the client
+    // through its own session-start hook.
+    const bootstrap = buildOceanBootstrap(projectResolution, {
+        rules: await rulesCount(projectResolution),
+    });
+    const runId = randomUUID();
+    const contract = validateRunContract({
+        runId,
+        sessionId,
+        profile: profile.name,
+        workingDirectory,
+        allowedTools: [provider.command],
+        deniedTools: [],
+        stopConditions: ["provider-process-exits"],
+        approval: { required: false, approved: true },
+        budget: {
+            timeoutMs: 24 * 60 * 60 * 1000,
+            maxAttempts: 1,
+            maxOutputBytes: 64_000,
+        },
+    });
+    store.create({
+        sessionId,
+        title: options.title ?? `${provider.id} session`,
+        taskId: options.taskId ?? null,
+        handoffId: options.handoffId ?? null,
+        provider: provider.id,
+        providerSessionId: null,
+        parentSessionId: null,
+        profile: profile.name,
+        profileIdentity: profileIdentity(profile),
+        workingDirectory,
+        resumeData: null,
+        projectId: projectResolution.status === "bound" ? projectResolution.projectId : null,
+    });
+    store.appendEvent(sessionId, "session_entry_contract", JSON.stringify(validateSessionEntryContract({
+        entryPoint,
+        controlLevel,
+        inputCapture,
+        contextTransport: options.originalExecutable
+            ? "desktop-passthrough"
+            : bootstrap.manifest.transport,
+        policyEnforcement: "shim-lifecycle-and-provider-owned-policy",
+        promotion: "explicit-review",
+        resume: provider.id === "claude"
+            ? "provider-owned-if-exposed"
+            : "unsupported",
+    })));
+    store.appendEvent(sessionId, "intercept_requested", JSON.stringify({
+        runId,
+        command: provider.command,
+        args: args.map(redactRuntimeText),
+    }));
+    if (options.handoffId)
+        store.appendEvent(sessionId, "handoff_bound", JSON.stringify({
+            handoffId: options.handoffId,
+            taskId: options.taskId ?? null,
+        }));
+    store.appendEvent(sessionId, "project_resolved", JSON.stringify({ workingDirectory, ...projectResolution }));
+    store.appendEvent(sessionId, "ocean_bootstrap", JSON.stringify({
+        provider: provider.id,
+        ...bootstrap.manifest,
+    }));
+    try {
+        store.updateStatus(sessionId, "running");
+        authorizeRun(store, contract);
+        const executable = options.originalExecutable
+            ? validateExplicitExecutable(options.originalExecutable)
+            : resolveOriginalExecutable(provider.command);
+        const authState = await authStatus(provider.id, defaultAuthDeps);
+        store.appendEvent(sessionId, "auth_state", JSON.stringify({ provider: provider.id, state: authState }));
+        if (authState === "login_required") {
+            store.appendEvent(sessionId, "auth_login_started", JSON.stringify({ provider: provider.id }));
+            const verifiedState = await authLogin(provider.id, defaultAuthDeps);
+            store.appendEvent(sessionId, "auth_state", JSON.stringify({ provider: provider.id, state: verifiedState }));
+            if (verifiedState !== "authenticated") {
+                store.updateStatus(sessionId, "failed");
+                store.appendEvent(sessionId, "evidence", JSON.stringify({
+                    sessionId,
+                    type: "auth",
+                    source: "ocean-interceptor",
+                    result: "blocked_by_client_authentication",
+                    criterion: "provider login did not verify successfully",
+                }));
+                await finalizeSession(store, sessionId, { exitCode: 1 });
+                return 1;
+            }
+        }
+        store.appendEvent(sessionId, "provider_resolved", JSON.stringify({ executable, runtime: "direct" }));
+        const processRequest = {
+            command: provider.command,
+            args,
+            cwd: workingDirectory,
+            environment: {
+                ...oceanEnvPair("INTERCEPTED", "1"),
+                ...bootstrapEnvironment(bootstrap),
+            },
+        };
+        const runProvider = async (signal) => await (options.originalExecutable ? runPassthrough : runInteractive)({
+            command: executable,
+            args,
+            cwd: workingDirectory,
+            env: processRequest.environment,
+            signal,
+            onData: (data) => store.appendEvent(sessionId, "provider_output", redactRuntimeText(data)),
+            onInput: (data) => store.appendEvent(sessionId, "terminal_input", redactRuntimeText(data)),
+        });
+        const abortController = new AbortController();
+        let terminationSignal;
+        const onTermination = (signal) => {
+            terminationSignal = signal;
+            abortController.abort();
+        };
+        process.once("SIGINT", onTermination);
+        process.once("SIGTERM", onTermination);
+        let result;
+        try {
+            result = await runProvider(abortController.signal);
+        }
+        finally {
+            process.off("SIGINT", onTermination);
+            process.off("SIGTERM", onTermination);
+        }
+        const exitCode = terminationSignal
+            ? terminationSignal === "SIGINT"
+                ? 130
+                : 143
+            : result.exitCode;
+        let evidence = classifyProviderResult(exitCode, result.output);
+        if (evidence.result === "blocked_by_client_authentication" &&
+            authAdapter(provider.id)) {
+            store.appendEvent(sessionId, "auth_recovery_started", JSON.stringify({ provider: provider.id, reason: evidence.criterion }));
+            const recoveredState = await authLogin(provider.id, defaultAuthDeps);
+            store.appendEvent(sessionId, "auth_state", JSON.stringify({
+                provider: provider.id,
+                state: recoveredState,
+                phase: "recovery",
+            }));
+            if (recoveredState === "authenticated") {
+                store.appendEvent(sessionId, "run_resumed", JSON.stringify({
+                    provider: provider.id,
+                    reason: "authentication verified",
+                }));
+                result = await runProvider(new AbortController().signal);
+                if (result.output)
+                    store.appendEvent(sessionId, "provider_output", redactRuntimeText(result.output));
+                evidence = classifyProviderResult(result.exitCode, result.output);
+            }
+        }
+        const finalExitCode = terminationSignal ? exitCode : result.exitCode;
+        const status = finalExitCode === 0 ? "completed" : "failed";
+        store.updateStatus(sessionId, status);
+        store.appendEvent(sessionId, "process_exit", JSON.stringify({
+            exitCode: finalExitCode,
+            signal: terminationSignal ?? null,
+        }));
+        if (evidence.result === "blocked_by_client_authentication") {
+            store.appendEvent(sessionId, "provider_blocked", JSON.stringify({ reason: evidence.criterion }));
+        }
+        store.appendEvent(sessionId, "evidence", JSON.stringify({
+            sessionId,
+            type: "provider_exit",
+            source: "ocean-interceptor",
+            result: evidence.result,
+            criterion: evidence.criterion,
+        }));
+        store.scanCaptureItems(sessionId);
+        await finalizeSession(store, sessionId, {
+            exitCode: finalExitCode,
+            nextAction: terminationSignal
+                ? `Session ended by ${terminationSignal}.`
+                : undefined,
+        });
+        return finalExitCode;
+    }
+    catch (error) {
+        store.updateStatus(sessionId, "failed");
+        store.appendEvent(sessionId, "error", redactRuntimeText(error instanceof Error ? error.message : String(error)));
+        await finalizeSession(store, sessionId, { exitCode: 1 });
+        throw error;
+    }
+    finally {
+        store.close();
+    }
+}
+const UTILITY_FLAGS = new Set(["--help", "-h", "--version", "-v", "-V"]);
+// Management subcommands that never start a working session. `attach` and
+// `ultrareview` are excluded on purpose: both are real work.
+const UTILITY_SUBCOMMANDS = {
+    claude: new Set([
+        "agents",
+        "auth",
+        "auto-mode",
+        "doctor",
+        "gateway",
+        "import",
+        "install",
+        "logs",
+        "mcp",
+        "plugin",
+        "plugins",
+        "project",
+        "respawn",
+        "rm",
+        "setup-token",
+        "stop",
+        "kill",
+        "update",
+        "upgrade",
+    ]),
+};
+/**
+ * True when an invocation is a lookup or management command (a version check,
+ * `claude agents --json` polled by a desktop client, `claude mcp list`) rather
+ * than a working session. These run straight through without a session record,
+ * which otherwise floods the store with hundreds of empty summaries a day.
+ */
+export function isUtilityInvocation(providerId, args) {
+    const first = args[0];
+    if (first === undefined)
+        return false;
+    if (args.length === 1 && UTILITY_FLAGS.has(first))
+        return true;
+    return UTILITY_SUBCOMMANDS[providerId]?.has(first) ?? false;
+}
+function classifyProviderResult(exitCode, output) {
+    if (exitCode === 0)
+        return {
+            result: "proven",
+            criterion: "intercepted provider process exits successfully",
+        };
+    if (/401\s+Unauthorized|missing bearer|not logged in|sign in to use/i.test(output)) {
+        return {
+            result: "blocked_by_client_authentication",
+            criterion: "provider authentication is required",
+        };
+    }
+    return {
+        result: "not_proven",
+        criterion: "intercepted provider process exits successfully",
+    };
+}
+function interceptedProfile(provider) {
+    return {
+        schemaVersion: 1,
+        name: `intercepted:${provider}`,
+        description: "Ocean transparent CLI interception profile",
+        version: "1.0.0",
+        provider: provider,
+        model: "provider-managed",
+        role: "intercepted worker",
+        skills: [],
+        allowedPaths: ["."],
+        allowedCommands: [],
+        writePolicy: "none",
+        contextSources: [],
+        clients: {
+            [provider]: { enabled: true, capabilities: [], limitations: [] },
+        },
+        defaultClient: provider,
+        memory: { enabled: true, scope: "profile" },
+        verification: { commands: [] },
+        contextCompression: "none",
+        instructions: "",
+    };
+}
+//# sourceMappingURL=intercept-command.js.map

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

@@ -0,0 +1,27 @@
+import { oceanRoot } from "@ocean/core/shared/paths.js";
+import { applyLayout, rollbackLayout, } from "../../application/layout/layout-apply.js";
+import { planLayout } from "../../application/layout/layout-plan.js";
+const USAGE = "Usage: ocean layout plan | apply --yes | rollback --yes";
+export async function runLayoutCommand(args) {
+    // Built and rehearsed for the macOS/Linux workspace (HOME-relative pointers, POSIX symlinks and
+    // modes); on Windows the home folder, links and permissions behave differently and are untested.
+    if (process.platform === "win32")
+        throw new Error("ocean layout supports macOS and Linux only.");
+    const action = args[0] ?? "plan";
+    const confirmed = args.includes("--yes");
+    const print = (value) => console.log(JSON.stringify(value, null, 2));
+    if (action === "plan")
+        return print(await planLayout(oceanRoot()));
+    if (action !== "apply" && action !== "rollback")
+        throw new Error(USAGE);
+    // Both write outside the workspace (client config, shell files), so neither runs by accident.
+    if (!confirmed) {
+        print(await planLayout(oceanRoot()));
+        throw new Error(`ocean layout ${action} changes files outside the workspace; review the plan above, then re-run with --yes.`);
+    }
+    if (action === "apply")
+        print(await applyLayout(oceanRoot()));
+    else
+        print(await rollbackLayout(oceanRoot()));
+}
+//# sourceMappingURL=layout-command.js.map

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

@@ -0,0 +1,52 @@
+import { createDefaultMarketplace, marketplacePaths, } from "@ocean/market/install/default-marketplace.js";
+import { runInstalledMcp } from "@ocean/market/mcp/mcp-runner.js";
+const usage = "Usage: ocean market list|install <name> [--version <v>]|update <name>|uninstall <name>|exec <name> [--index <file>]... [--yes] [--accept-flagged]";
+function flagValues(args, flag) {
+    return args.flatMap((arg, index) => arg === flag && args[index + 1] ? [args[index + 1]] : []);
+}
+export async function runMarketCommand(action, args) {
+    const approved = args.includes("--yes");
+    const marketplace = createDefaultMarketplace({
+        indexFiles: flagValues(args, "--index"),
+        acceptFlagged: args.includes("--accept-flagged"),
+        // Non-interactive: permissions are granted only by an explicit --yes, and are always shown.
+        consent: async (manifest) => {
+            console.error(`${manifest.name}@${manifest.version} requests permissions: ${JSON.stringify(manifest.permissions)}`);
+            if (!approved)
+                console.error("Re-run with --yes to grant them.");
+            return approved;
+        },
+    });
+    const name = args.find((arg, index) => !arg.startsWith("--") &&
+        !["--index", "--version"].includes(args[index - 1]));
+    if (action === "list") {
+        const installed = await marketplace.installed();
+        console.log(JSON.stringify(Object.entries(installed).map(([id, entry]) => ({
+            name: id,
+            kind: entry.manifest.kind,
+            version: entry.manifest.version,
+            sha256: entry.manifest.integrity.sha256,
+            installedAt: entry.installedAt,
+        })), null, 2));
+        return;
+    }
+    if (action === "exec" && name) {
+        const paths = marketplacePaths();
+        process.exitCode = await runInstalledMcp(name, {
+            serversRoot: paths.mcpServers,
+            stateRoot: paths.mcpState,
+        });
+        return;
+    }
+    if (!name || !["install", "update", "uninstall"].includes(action))
+        throw new Error(usage);
+    if (action === "install")
+        console.log(JSON.stringify(await marketplace.install(name, flagValues(args, "--version")[0]), null, 2));
+    else if (action === "update")
+        console.log(JSON.stringify(await marketplace.update(name), null, 2));
+    else {
+        await marketplace.uninstall(name);
+        console.log(JSON.stringify({ name, status: "uninstalled" }, null, 2));
+    }
+}
+//# sourceMappingURL=market-command.js.map

package/dist/interfaces/cli/mcp-gateway-command.js

@@ -0,0 +1,30 @@
+import { marketplacePaths } from "@ocean/market/install/default-marketplace.js";
+import { gatewayMembers, McpGateway, serveMcpGateway, } from "@ocean/market/mcp/mcp-gateway.js";
+import { McpClient } from "@ocean/services/infrastructure/mcp/mcp-client.js";
+import { oceanVersion } from "../../version.js";
+// `ocean mcp gateway`: one stdio MCP endpoint for every registered server. Logs go to stderr,
+// which MCP clients keep as the server's log.
+export async function runMcpGatewayCommand() {
+    const log = (line) => console.error(`ocean mcp gateway: ${line}`);
+    const paths = marketplacePaths();
+    const { members, skipped } = await gatewayMembers({
+        serversRoot: paths.mcpServers,
+        stateRoot: paths.mcpState,
+    });
+    for (const skip of skipped)
+        log(`${skip.capability} not routed: ${skip.reason}`);
+    const gateway = new McpGateway(members, {
+        client: (member) => new McpClient({
+            command: member.command,
+            args: member.args,
+            cwd: member.cwd,
+            env: member.env,
+            inheritEnv: member.inheritEnv,
+            stderrLabel: `ocean mcp gateway [${member.capability}]`,
+        }),
+        version: await oceanVersion(),
+        log,
+    });
+    await serveMcpGateway(gateway);
+}
+//# sourceMappingURL=mcp-gateway-command.js.map