@amoree-code/ocean 0.0.0-stage → 1.2.0

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

@@ -0,0 +1,54 @@
+import { searchHistory } from "../../application/pull/history-index.js";
+import { lastPullRecord, pull } from "../../application/pull/pull.js";
+const usage = "Usage: ocean pull [--yes] [--daily] | search [words…] [--project <id>] [--client <id>] [--limit N] [--json] | report";
+// `ocean pull` (T-305): everything every AI client holds, into Ocean and sorted by project —
+// memory and instruction files as review candidates, claude.ai exports from ~/Downloads, and a
+// searchable index of every conversation. A dry run until --yes; `--daily` skips when the last
+// pull is under a day old. `report` prints the last run's record.
+export async function runPullCommand(args) {
+    const flags = ["--client", "--project", "--limit"];
+    const value = (flag) => {
+        const index = args.indexOf(flag);
+        return index >= 0 ? args[index + 1] : undefined;
+    };
+    if (args[0] === "search") {
+        const words = args
+            .slice(1)
+            .filter((arg, index, all) => !arg.startsWith("--") && !flags.includes(all[index - 1] ?? ""));
+        if (!words.length && !value("--project") && !value("--client"))
+            throw new Error(usage);
+        const limit = Number(value("--limit") ?? 20);
+        const hits = await searchHistory(words.join(" "), {
+            client: value("--client"),
+            project: value("--project"),
+            limit: Number.isFinite(limit) && limit > 0 ? limit : 20,
+        });
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(hits, null, 2));
+            return;
+        }
+        for (const hit of hits)
+            console.log(`${hit.date}  ${hit.project.padEnd(16)} ${hit.client.padEnd(14)} ${hit.title || "(untitled)"}\n            ${hit.file}`);
+        if (!hits.length)
+            console.error("No conversation matches.");
+        return;
+    }
+    if (args[0] === "report") {
+        const record = await lastPullRecord();
+        if (!record)
+            console.error("No pull has run with --yes yet.");
+        else
+            console.log(JSON.stringify(record, null, 2));
+        return;
+    }
+    if (args.some((arg) => !["--yes", "--daily"].includes(arg)))
+        throw new Error(usage);
+    const result = await pull({
+        apply: args.includes("--yes"),
+        daily: args.includes("--daily"),
+    });
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.applied && !result.skipped)
+        console.error("Dry run: pass --yes to propose the new memory as candidates and write the history index; review with `ocean memory review list --project <id>`.");
+}
+//# sourceMappingURL=pull-command.js.map

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

@@ -0,0 +1,143 @@
+import { chmod, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { registryFile } from "@ocean/core/shared/fs-utils.js";
+import { DAILY_DIR, INBOX_DIR, KNOWLEDGE_DIR, liveEngineEntry, oceanPath, oceanRoot, PERSONAL_DIR, projectDir, REGISTRY_DIR, SYSTEM_DIR, TEMPLATES_DIR, WORKSPACE_PROJECT_ID, } from "@ocean/core/shared/paths.js";
+import { connectObsidianVault } from "@ocean/services/obsidian/vault-discovery.js";
+import { seedWorkspaceTemplate } from "../../application/layout/workspace-template.js";
+import { installShellIntegration, syncProviderWrappers, } from "../../infrastructure/wrappers/wrapper-manager.js";
+const personalDirectories = [
+    PERSONAL_DIR,
+    KNOWLEDGE_DIR,
+    DAILY_DIR,
+    INBOX_DIR,
+    TEMPLATES_DIR,
+];
+const REGISTRY_FILES = [
+    "providers.json",
+    "installations.json",
+    "project-bindings.json",
+];
+const stateDirectories = [
+    `${SYSTEM_DIR}/config/startup`,
+    `${SYSTEM_DIR}/profiles`,
+    `${SYSTEM_DIR}/sessions`,
+    REGISTRY_DIR,
+    `${SYSTEM_DIR}/integrations`,
+    `${SYSTEM_DIR}/archive`,
+    `${SYSTEM_DIR}/runtime/shims`,
+    `${SYSTEM_DIR}/runtime/temporary`,
+];
+async function ensureFile(file, contents) {
+    try {
+        await writeFile(file, contents, { flag: "wx" });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+}
+async function restrictDirectories(directory) {
+    await chmod(directory, 0o700);
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        if (entry.isDirectory())
+            await restrictDirectories(path.join(directory, entry.name));
+    }
+}
+async function installMacStartup() {
+    const launchAgents = path.join(os.homedir(), "Library", "LaunchAgents");
+    const label = "com.ocean.runtime";
+    const plist = path.join(launchAgents, `${label}.plist`);
+    const node = process.execPath;
+    const entry = liveEngineEntry();
+    const contents = `<?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>${node}</string><string>${entry}</string><string>service</string></array>
+<key>WorkingDirectory</key><string>${oceanRoot()}</string>
+<key>RunAtLoad</key><true/>
+<key>KeepAlive</key><true/>
+</dict></plist>
+`;
+    await mkdir(launchAgents, { recursive: true });
+    await writeFile(plist, contents);
+}
+async function installLinuxStartup() {
+    const systemdUser = path.join(os.homedir(), ".config", "systemd", "user");
+    const unit = path.join(systemdUser, "ocean.service");
+    const contents = `[Unit]
+Description=Ocean local runtime
+
+[Service]
+Type=simple
+WorkingDirectory=${oceanRoot()}
+ExecStart=${process.execPath} ${liveEngineEntry()} service
+Restart=on-failure
+
+[Install]
+WantedBy=default.target
+`;
+    await mkdir(systemdUser, { recursive: true });
+    await writeFile(unit, contents);
+}
+async function installWindowsStartup() {
+    const startup = path.join(process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+    const launcher = path.join(startup, "ocean.cmd");
+    const contents = `@echo off\ncd /d "${oceanRoot()}"\n"${process.execPath}" "${liveEngineEntry()}" service\n`;
+    await mkdir(startup, { recursive: true });
+    await writeFile(launcher, contents);
+}
+export const SETUP_USAGE = "Usage: ocean setup [--obsidian <vault-path>] [--read-write]";
+// `setup` writes shims, the shell profile and the startup entry, so anything it does not
+// understand — `--help` included — must stop it before it writes (T-307).
+export function parseSetupArgs(args) {
+    const options = { obsidianMode: "read-only" };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--help" || arg === "-h" || arg === "help")
+            return { kind: "help" };
+        if (arg === "--read-write")
+            options.obsidianMode = "read-write";
+        else if (arg === "--obsidian") {
+            const value = args[index + 1];
+            if (!value || value.startsWith("-"))
+                return { kind: "error", message: "--obsidian needs a vault path" };
+            options.obsidianPath = value;
+            index += 1;
+        }
+        else
+            return { kind: "error", message: `Unknown setup argument: ${arg}` };
+    }
+    return { kind: "run", options };
+}
+export async function setup(options = {}) {
+    await Promise.all([...personalDirectories, `${projectDir(WORKSPACE_PROJECT_ID)}/tasks`].map((directory) => mkdir(oceanPath(directory), { recursive: true })));
+    // T-296: charter, policies, templates and indexes for a new workspace; existing files are kept.
+    await seedWorkspaceTemplate();
+    for (const file of REGISTRY_FILES)
+        registryFile(file);
+    await Promise.all(stateDirectories.map((directory) => mkdir(oceanPath(directory), { recursive: true })));
+    await ensureFile(oceanPath(PERSONAL_DIR, "MEMORY.md"), "# Memory\n\n## Records (generated)\n");
+    await ensureFile(oceanPath(KNOWLEDGE_DIR, "KNOWLEDGE.md"), "# Knowledge\n\n## Records (generated)\n");
+    await ensureFile(oceanPath(SYSTEM_DIR, "profiles", "default.json"), await readFile(new URL("../../../templates/profiles/default.json", import.meta.url), "utf8"));
+    // T-245: the runtime config names the default profile, so `ocean run` without --profile
+    // no longer depends on the historical fallback. An existing file is never replaced.
+    await ensureFile(oceanPath(SYSTEM_DIR, "config", "runtime.json"), `${JSON.stringify({ schemaVersion: 1, defaultProfile: "default" }, null, 2)}\n`);
+    await ensureFile(oceanPath(SYSTEM_DIR, "config", "startup", "STARTUP.md"), "# Ocean startup\n\nManaged by `ocean setup`.\n");
+    await syncProviderWrappers();
+    const shellProfile = await installShellIntegration();
+    if (process.platform === "darwin")
+        await installMacStartup();
+    if (process.platform === "linux")
+        await installLinuxStartup();
+    if (process.platform === "win32")
+        await installWindowsStartup();
+    await restrictDirectories(oceanPath(SYSTEM_DIR));
+    if (options.obsidianPath) {
+        const result = await connectObsidianVault(options.obsidianPath, options.obsidianMode ?? "read-only");
+        console.log(`Obsidian connected: ${result.vaultPath} (${result.noteCount} Markdown notes)`);
+    }
+    console.log(`Ocean setup complete: ${oceanRoot()} (AI CLI interception enabled in ${shellProfile})`);
+}
+//# sourceMappingURL=setup-command.js.map

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

@@ -0,0 +1,249 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { enginePath, oceanPath, projectDir, resolveWithin, WORKSPACE_PROJECT_ID, } from "@ocean/core/shared/paths.js";
+import { folderProject, projectsWithTasks, } from "@ocean/core/shared/project-resolution.js";
+import { resolveTaskReference } from "@ocean/core/shared/task-reference.js";
+import { archiveDoneTasks, completeTask, } from "@ocean/loop/tasks/archive-tasks.js";
+import { checkpointTask } from "@ocean/loop/tasks/checkpoint-task.js";
+import { claimTask, releaseTask } from "@ocean/loop/tasks/claim-task.js";
+import { listTasks, listTasksForFolder, } from "@ocean/loop/tasks/list-tasks.js";
+import { newTask } from "@ocean/loop/tasks/new-task.js";
+import { renumberTasks } from "@ocean/loop/tasks/renumber-tasks.js";
+import { verificationReadiness } from "@ocean/loop/tasks/verification-readiness.js";
+import { verifyTask } from "@ocean/loop/tasks/verify-task.js";
+const execFile = promisify(execFileCallback);
+// Re-exported for existing importers (daily/context commands, tests). The
+// implementation and the MCP server both live in the application layer now.
+export { listTasks };
+// The live task an id-based action works on (resolution rules: resolveTaskReference). The
+// action uses the location's own id and project, never the id as typed.
+async function liveTask(id, explicitProject, cwdProject) {
+    const location = await resolveTaskReference(id, {
+        projectId: explicitProject ?? cwdProject ?? undefined,
+        explicit: Boolean(explicitProject),
+    });
+    if (location.archived)
+        throw new Error(`${location.id} is archived`);
+    return {
+        owner: location.projectId,
+        id: location.id,
+        root: resolveWithin(oceanPath(projectDir(location.projectId)), "tasks"),
+    };
+}
+// `ocean tasks list --pretty`: one aligned row per task, for a person rather than a tool.
+function taskTable(tasks) {
+    if (!tasks.length)
+        return "No tasks.\n";
+    const rows = [
+        ["PROJECT", "ID", "STATE", "TITLE"],
+        ...tasks.map((task) => [task.project, task.id, task.state, task.title]),
+    ];
+    const widths = [0, 1, 2].map((column) => Math.max(...rows.map((row) => row[column].length)));
+    return rows
+        .map((row) => row
+        .map((cell, column) => column < 3 ? cell.padEnd(widths[column]) : cell)
+        .join("  ")
+        .trimEnd())
+        .join("\n")
+        .concat("\n");
+}
+export async function runTasksCommand(action, args) {
+    const projectIndex = args.indexOf("--project");
+    const explicitProject = projectIndex >= 0 ? args[projectIndex + 1] : undefined;
+    if (projectIndex >= 0 && !explicitProject)
+        throw new Error("--project requires a project id");
+    // Without --project, the tasks are the folder's project's (T-256): the cwd decides, and only a
+    // folder that is no project falls back to the workspace project.
+    const cwdProject = explicitProject
+        ? null
+        : await folderProject(process.cwd());
+    const projectId = explicitProject ?? cwdProject ?? WORKSPACE_PROJECT_ID;
+    if (action === "list") {
+        const state = args.find((arg, index) => !arg.startsWith("--") &&
+            (projectIndex < 0 || index !== projectIndex + 1));
+        const found = await listTasksForFolder({
+            cwd: process.cwd(),
+            project: explicitProject,
+            state,
+        });
+        if (found.note)
+            console.error(found.note);
+        if (args.includes("--pretty"))
+            process.stdout.write(taskTable(found.tasks));
+        else
+            console.log(JSON.stringify(found.tasks, null, 2));
+        return;
+    }
+    if (action === "new") {
+        const title = args.find((arg, index) => !arg.startsWith("--") &&
+            (projectIndex < 0 || index !== projectIndex + 1));
+        const created = await newTask(projectId, title ?? "");
+        console.log(JSON.stringify({
+            id: created.id,
+            project: projectId,
+            file: path.relative(oceanPath(), created.file),
+        }));
+        return;
+    }
+    if (action === "doctor") {
+        // `--all`: every project with tasks, so a clean cwd project never hides another's drift.
+        const projects = args.includes("--all")
+            ? await projectsWithTasks()
+            : [projectId];
+        for (const project of projects) {
+            const label = projects.length > 1 ? `${project}: ` : "";
+            try {
+                const result = await execFile(process.execPath, [
+                    enginePath("scripts", "validate-tasks.mjs"),
+                    resolveWithin(oceanPath(projectDir(project)), "tasks"),
+                ]);
+                process.stdout.write(`${label}${result.stdout}`);
+            }
+            catch (error) {
+                const failure = error;
+                if (failure.stdout)
+                    process.stdout.write(`${label}${failure.stdout}`);
+                if (failure.stderr)
+                    process.stderr.write(`${label}${failure.stderr}`);
+                process.exitCode = 1;
+            }
+        }
+        return;
+    }
+    if (action === "index") {
+        const tasks = await listTasks(undefined, projectId);
+        const body = [
+            "# Tasks",
+            "",
+            "<!-- Generated by `ocean tasks index --write`. Do not edit by hand. -->",
+            "",
+            "| ID | State | Title | Goal |",
+            "|---|---|---|---|",
+            ...tasks.map((task) => `| ${task.id} | ${task.state} | ${task.title.replaceAll("|", "\\|")} | ${task.goal.replaceAll("|", "\\|")} |`),
+            "",
+        ].join("\n");
+        const target = resolveWithin(oceanPath(projectDir(projectId)), "index.md");
+        if (args.includes("--write")) {
+            await writeFile(target, body, "utf8");
+            console.log(`wrote ${path.relative(oceanPath(), target)}`);
+        }
+        else
+            process.stdout.write(body);
+        return;
+    }
+    if (action === "checkpoint") {
+        const id = args.find((arg) => !arg.startsWith("--"));
+        const noteIndex = args.indexOf("--note");
+        const nextIndex = args.indexOf("--next");
+        if (!id || noteIndex < 0 || !args[noteIndex + 1])
+            throw new Error("Usage: ocean tasks checkpoint <id> --note <text> [--next <text>] [--project <id>]");
+        const task = await liveTask(id, explicitProject, cwdProject);
+        const result = await checkpointTask(task.id, task.root, {
+            note: args[noteIndex + 1],
+            next: nextIndex >= 0 ? args[nextIndex + 1] : undefined,
+        });
+        // Advisory: say now if `tasks complete` will not be able to verify this task (T-291).
+        // The checkpoint is already written: a failed check is one more warning, never an error.
+        const verification = await verificationReadiness(task.id, task.root).catch((error) => ({
+            ready: false,
+            warnings: [
+                `could not check: ${error instanceof Error ? error.message : String(error)}`,
+            ],
+        }));
+        console.log(JSON.stringify({ ...result, project: task.owner, verification }, null, 2));
+        if (!verification.ready)
+            console.error(`warning: ${task.id} verification: ${verification.warnings.join("; ")}`);
+        return;
+    }
+    if (action === "verify") {
+        const id = args.find((arg) => !arg.startsWith("--"));
+        if (!id) {
+            console.error("Usage: ocean tasks verify <id> [--project <id>]");
+            process.exitCode = 1;
+            return;
+        }
+        const task = await liveTask(id, explicitProject, cwdProject);
+        const outcome = await verifyTask(task.id, task.root);
+        console.log(JSON.stringify(outcome, null, 2));
+        if (!outcome.passed)
+            process.exitCode = 1;
+        return;
+    }
+    if (action === "complete") {
+        const id = args[0];
+        if (!id) {
+            console.error("Usage: ocean tasks complete <id>");
+            process.exitCode = 1;
+            return;
+        }
+        if (args.includes("--no-verify")) {
+            console.error("Task completion verification cannot be skipped.");
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const task = await liveTask(id, explicitProject, cwdProject);
+            console.log(JSON.stringify(await completeTask(task.id, task.root), null, 2));
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (action === "claim" || action === "release") {
+        const id = args[0];
+        const flag = (name) => {
+            const at = args.indexOf(name);
+            return at >= 0 ? args[at + 1] : undefined;
+        };
+        const by = flag("--by");
+        if (!id || id.startsWith("--") || (action === "claim" && !by)) {
+            console.error("Usage: ocean tasks claim <id> --by <name> [--paths a,b] [--force] [--project <id>] | ocean tasks release <id> [--by <name>] [--force]");
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const task = await liveTask(id, explicitProject, cwdProject);
+            const force = args.includes("--force");
+            const result = action === "claim"
+                ? await claimTask(task.id, task.root, {
+                    by: by,
+                    paths: flag("--paths")?.split(",").filter(Boolean),
+                    force,
+                })
+                : await releaseTask(task.id, task.root, { by, force });
+            console.log(JSON.stringify({ ...result, project: task.owner }, null, 2));
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (action === "renumber") {
+        const prefixIndex = args.indexOf("--prefix");
+        const prefix = prefixIndex >= 0 ? args[prefixIndex + 1] : undefined;
+        if (!explicitProject || !prefix)
+            throw new Error("Usage: ocean tasks renumber --project <id> --prefix <PREFIX> [--write]");
+        console.log(JSON.stringify(await renumberTasks({
+            project: explicitProject,
+            prefix,
+            write: args.includes("--write"),
+        }), null, 2));
+        return;
+    }
+    if (action !== "archive") {
+        console.error("Usage: ocean tasks list [state] [--project <id>] [--pretty]|new <title> [--project <id>]|doctor [--all]|index [--write]|checkpoint <id> --note <text> [--next <text>]|verify <id>|complete <id>|claim <id> --by <name> [--paths a,b] [--force]|release <id> [--by <name>] [--force]|archive [--apply|--auto]|renumber --project <id> --prefix <PREFIX> [--write]");
+        process.exitCode = 1;
+        return;
+    }
+    const apply = args.includes("--apply") || args.includes("--auto");
+    const result = await archiveDoneTasks(resolveWithin(oceanPath(projectDir(projectId)), "tasks"), apply);
+    console.log(JSON.stringify({ dryRun: !apply, ...result }, null, 2));
+    if (apply && result.skipped.length)
+        process.exitCode = 1;
+}
+//# sourceMappingURL=tasks-command.js.map

package/dist/main.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import "./engine-root.js";
+import "./node-warnings.js";
+// Loaded dynamically so node-warnings.js is in place first: static imports would load
+// node:sqlite, and print its warning, before any module body runs.
+const { commandRegistry } = await import("./interfaces/cli/command-registry.js");
+const { renderCommandHelp, renderHelp, wantsCommandHelp } = await import("./interfaces/cli/help-command.js");
+const { onboard } = await import("./interfaces/cli/onboard-command.js");
+const { oceanVersion } = await import("./version.js");
+const command = process.argv[2] === "--yes" ? undefined : process.argv[2];
+if (command === "--version" || command === "-v") {
+    console.log(await oceanVersion());
+}
+else if (command === "--help" || command === "-h") {
+    console.log(renderHelp());
+}
+else if (!command) {
+    await onboard({ yes: process.argv.includes("--yes") });
+}
+else {
+    // Own keys only: `ocean toString` must not find Object.prototype.toString.
+    const handler = Object.hasOwn(commandRegistry, command)
+        ? commandRegistry[command]
+        : undefined;
+    // `--help` never runs a command: several write files or start onboarding before they look at
+    // their arguments. setup keeps its own help (it shares SETUP_USAGE).
+    if (handler &&
+        command !== "setup" &&
+        wantsCommandHelp(process.argv.slice(3))) {
+        console.log(renderCommandHelp(command));
+    }
+    else if (handler) {
+        // A failed command prints one line; OCEAN_DEBUG=1 keeps the stack for debugging.
+        try {
+            await handler();
+        }
+        catch (error) {
+            if (process.env.OCEAN_DEBUG === "1" || !(error instanceof Error))
+                throw error;
+            console.error(`Error: ${error.message}`);
+            process.exitCode = 1;
+        }
+    }
+    else {
+        console.error(`Unknown command: ${command}`);
+        process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=main.js.map

package/dist/node-warnings.js

@@ -0,0 +1,17 @@
+// Node prints "ExperimentalWarning: SQLite is an experimental feature" on every run that loads
+// node:sqlite, which the session store and brain index always do. Drop that one warning and
+// pass every other through. main.ts imports this before it loads anything that reaches
+// node:sqlite; a static import chain would load the builtin before this filter is installed.
+const emitWarning = process.emitWarning;
+process.emitWarning = function (warning, ...rest) {
+    const options = rest[0];
+    const type = typeof options === "string"
+        ? options
+        : options?.type;
+    const message = typeof warning === "string" ? warning : warning.message;
+    if (type === "ExperimentalWarning" && message.startsWith("SQLite"))
+        return;
+    emitWarning.call(this, warning, ...rest);
+};
+export {};
+//# sourceMappingURL=node-warnings.js.map

package/dist/version.js

@@ -0,0 +1,8 @@
+import { readFile } from "node:fs/promises";
+export async function oceanVersion() {
+    const manifest = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+    if (typeof manifest.version !== "string" || !manifest.version.trim())
+        throw new Error("package.json must declare a non-empty version");
+    return manifest.version;
+}
+//# sourceMappingURL=version.js.map

package/market/mcp/chrome-devtools/ocean.capability.json

@@ -0,0 +1,28 @@
+{
+  "kind": "mcp",
+  "name": "dev.ocean/chrome-devtools",
+  "description": "Control the owner's real, signed-in Chrome through Chrome DevTools MCP: tabs, navigation, clicks, forms, screenshots, console and network errors. Reads every open tab and acts inside any signed-in session of the attached profile, for every client that uses the Ocean gateway. The filesystem permission is declared for consent but not enforced at runtime, and the npm package is pinned by version, not by digest.",
+  "permissions": {
+    "filesystem": { "read": ["~/Library/Application Support/Google/Chrome"] },
+    "network": ["registry.npmjs.org", "localhost", "127.0.0.1"],
+    "exec": ["npx"]
+  },
+  "server": {
+    "name": "dev.ocean/chrome-devtools",
+    "description": "Chrome DevTools MCP attached to the owner's running Chrome. Usage statistics and CrUX lookups are off, so page URLs stay on this machine.",
+    "packages": [
+      {
+        "registryType": "npm",
+        "identifier": "chrome-devtools-mcp",
+        "version": "1.12.0",
+        "transport": { "type": "stdio" },
+        "packageArguments": [
+          { "type": "positional", "value": "--autoConnect" },
+          { "type": "positional", "value": "--no-usage-statistics" },
+          { "type": "positional", "value": "--no-performance-crux" }
+        ]
+      }
+    ],
+    "_meta": { "dev.ocean": { "clientKey": "chrome-devtools" } }
+  }
+}

package/market/mcp/gateway/ocean.capability.json

@@ -0,0 +1,21 @@
+{
+  "kind": "mcp",
+  "name": "dev.ocean/mcp-gateway",
+  "description": "One MCP endpoint for every registered server: Ocean's own and those installed from the marketplace.",
+  "server": {
+    "name": "dev.ocean/mcp-gateway",
+    "description": "Lists and routes the tools of every registered MCP server behind one stdio endpoint.",
+    "packages": [
+      {
+        "registryType": "ocean-engine",
+        "identifier": "ocean",
+        "transport": { "type": "stdio" },
+        "packageArguments": [
+          { "type": "positional", "value": "mcp" },
+          { "type": "positional", "value": "gateway" }
+        ]
+      }
+    ],
+    "_meta": { "dev.ocean": { "clientKey": "ocean-gateway" } }
+  }
+}

package/market/mcp/obsidian/ocean.capability.json

@@ -0,0 +1,21 @@
+{
+  "kind": "mcp",
+  "name": "dev.ocean/obsidian",
+  "description": "Ocean's Obsidian vault bridge over MCP.",
+  "server": {
+    "name": "dev.ocean/obsidian",
+    "description": "Read and sync an Obsidian vault through Ocean.",
+    "packages": [
+      {
+        "registryType": "ocean-engine",
+        "identifier": "ocean",
+        "transport": { "type": "stdio" },
+        "packageArguments": [
+          { "type": "positional", "value": "obsidian" },
+          { "type": "positional", "value": "mcp" }
+        ]
+      }
+    ],
+    "_meta": { "dev.ocean": { "clientKey": "ocean-obsidian" } }
+  }
+}

package/market/mcp/ocean/ocean.capability.json

@@ -0,0 +1,21 @@
+{
+  "kind": "mcp",
+  "name": "dev.ocean/ocean",
+  "description": "Ocean's own MCP server: workspace status, tasks, handoffs, sessions and the brain.",
+  "server": {
+    "name": "dev.ocean/ocean",
+    "description": "Ocean workspace, tasks, sessions and brain over MCP.",
+    "packages": [
+      {
+        "registryType": "ocean-engine",
+        "identifier": "ocean",
+        "transport": { "type": "stdio" },
+        "packageArguments": [
+          { "type": "positional", "value": "mcp" },
+          { "type": "positional", "value": "serve" }
+        ]
+      }
+    ],
+    "_meta": { "dev.ocean": { "clientKey": "ocean" } }
+  }
+}

package/market/mcp/playwright/ocean.capability.json

@@ -0,0 +1,23 @@
+{
+  "kind": "mcp",
+  "name": "com.microsoft/playwright-mcp",
+  "description": "Playwright browser automation through the browser extension.",
+  "permissions": {
+    "network": ["registry.npmjs.org", "localhost", "127.0.0.1"],
+    "exec": ["npx"]
+  },
+  "server": {
+    "name": "com.microsoft/playwright-mcp",
+    "description": "Browser automation with Playwright.",
+    "packages": [
+      {
+        "registryType": "npm",
+        "identifier": "@playwright/mcp",
+        "version": "0.0.84",
+        "transport": { "type": "stdio" },
+        "packageArguments": [{ "type": "positional", "value": "--extension" }]
+      }
+    ],
+    "_meta": { "dev.ocean": { "clientKey": "playwright" } }
+  }
+}