@amoree-code/ocean 0.0.0-stage → 1.2.0

package/node_modules/@ocean/services/dist/infrastructure/mcp/mcp-client.js

@@ -0,0 +1,162 @@
+import { spawn } from "node:child_process";
+import { actionFingerprint, mcpToolSchema, } from "@ocean/core/domain/mcp/mcp-contract.js";
+export class McpClient {
+    options;
+    child = null;
+    nextId = 1;
+    pending = new Map();
+    buffer = "";
+    tools = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async connect() {
+        this.child = spawn(this.options.command, this.options.args ?? [], {
+            cwd: this.options.cwd,
+            env: this.options.inheritEnv === false
+                ? (this.options.env ?? {})
+                : { ...process.env, ...this.options.env },
+            stdio: "pipe",
+        });
+        // An unread stderr pipe fills up and stalls the server.
+        const label = this.options.stderrLabel;
+        if (label) {
+            let pending = "";
+            this.child.stderr.setEncoding("utf8");
+            this.child.stderr.on("data", (chunk) => {
+                const lines = (pending + chunk).split("\n");
+                pending = lines.pop() ?? "";
+                for (const line of lines)
+                    process.stderr.write(`${label}: ${line}\n`);
+            });
+            this.child.stderr.on("end", () => {
+                if (pending)
+                    process.stderr.write(`${label}: ${pending}\n`);
+            });
+        }
+        else
+            this.child.stderr.resume();
+        this.child.stdout.setEncoding("utf8");
+        this.child.stdout.on("data", (chunk) => this.consume(chunk));
+        this.child.once("error", (error) => this.failPending(error));
+        this.child.once("close", () => this.failPending(new Error("MCP server stopped")));
+        await this.request("initialize", {
+            protocolVersion: "2025-06-18",
+            capabilities: {},
+            clientInfo: { name: "ocean", version: "0.3.2" },
+        });
+        this.notify("notifications/initialized", {});
+    }
+    async listTools() {
+        const result = (await this.request("tools/list", {}));
+        const tools = (result.tools ?? []).map((tool) => mcpToolSchema.parse(tool));
+        this.tools = new Map(tools.map((tool) => [tool.name, tool]));
+        return this.filterAllowed(tools);
+    }
+    async callTool(name, arguments_ = {}, approval = false) {
+        const tool = this.tools.get(name) ??
+            (await this.listTools()).find((candidate) => candidate.name === name);
+        if (!tool)
+            throw new Error(`MCP tool is not allowed or unavailable: ${name}`);
+        if (!this.isAllowed(name))
+            throw new Error(`MCP tool is not allowed: ${name}`);
+        if (tool.annotations?.readOnlyHint === false && !approval)
+            throw new Error(`MCP write requires explicit approval: ${name}`);
+        const args = tool.annotations?.readOnlyHint === false && approval
+            ? {
+                ...arguments_,
+                approval: {
+                    approved: true,
+                    fingerprint: actionFingerprint(name, arguments_),
+                },
+            }
+            : arguments_;
+        return this.request("tools/call", { name, arguments: args });
+    }
+    // For a proxy whose own client already gated the call: the arguments go to the server
+    // unchanged, so the server's own checks (such as an approval fingerprint) still decide.
+    async forwardToolCall(name, arguments_) {
+        if (!this.isAllowed(name))
+            throw new Error(`MCP tool is not allowed: ${name}`);
+        return this.request("tools/call", { name, arguments: arguments_ });
+    }
+    close() {
+        if (this.child) {
+            this.child.stdin.destroy();
+            this.child.stdout.destroy();
+            this.child.kill("SIGKILL");
+        }
+        this.child = null;
+    }
+    isAllowed(name) {
+        return (!this.options.allowedTools || this.options.allowedTools.includes(name));
+    }
+    filterAllowed(tools) {
+        return tools.filter((tool) => this.isAllowed(tool.name));
+    }
+    request(method, params) {
+        if (!this.child?.stdin.writable)
+            return Promise.reject(new Error("MCP client is not connected"));
+        const id = this.nextId++;
+        this.send({ jsonrpc: "2.0", id, method, params });
+        return new Promise((resolve, reject) => this.pending.set(id, { resolve, reject }));
+    }
+    notify(method, params) {
+        this.send({ jsonrpc: "2.0", method, params });
+    }
+    send(message) {
+        if (!this.child?.stdin.writable)
+            return;
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    consume(chunk) {
+        this.buffer += chunk;
+        while (true) {
+            const newline = this.buffer.indexOf("\n");
+            if (newline < 0)
+                return;
+            const line = this.buffer.slice(0, newline).trim();
+            this.buffer = this.buffer.slice(newline + 1);
+            if (!line)
+                continue;
+            // A stray log line on stdout is not a reason to drop the connection.
+            let response;
+            try {
+                response = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (response.id === undefined)
+                continue;
+            // A request from the server: answer `ping`, decline the rest (no client capabilities).
+            if (response.method !== undefined) {
+                this.send(response.method === "ping"
+                    ? { jsonrpc: "2.0", id: response.id, result: {} }
+                    : {
+                        jsonrpc: "2.0",
+                        id: response.id,
+                        error: {
+                            code: -32601,
+                            message: `Unsupported method: ${response.method}`,
+                        },
+                    });
+                continue;
+            }
+            const pending = this.pending.get(response.id);
+            if (!pending)
+                continue;
+            this.pending.delete(response.id);
+            if (response.error)
+                pending.reject(new Error(`MCP ${response.error.message ?? "request failed"}`));
+            else
+                pending.resolve(response.result);
+        }
+    }
+    failPending(error) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+    }
+}
+//# sourceMappingURL=mcp-client.js.map

package/node_modules/@ocean/services/dist/infrastructure/mcp/obsidian-server.js

@@ -0,0 +1,251 @@
+import { readdir, readFile } from "node:fs/promises";
+import { actionFingerprint, mcpApprovalSchema, } from "@ocean/core/domain/mcp/mcp-contract.js";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+import { listInboxCandidates, promoteInboxNote, } from "../../obsidian/inbox-promotion.js";
+import { discoverObsidianVault, loadObsidianConnection, validateObsidianVault, } from "../../obsidian/vault-discovery.js";
+import { syncObsidianVault } from "../../obsidian/vault-sync.js";
+import { resolveObsidianNotePath, writeObsidianNote, } from "../../obsidian/vault-writer.js";
+import { serverVersion } from "./server-version.js";
+import { McpToolRegistry } from "./tool-registry.js";
+const tools = new McpToolRegistry([
+    {
+        name: "obsidian_discover",
+        description: "List Obsidian Markdown notes and metadata issues.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "obsidian_sync",
+        description: "Compare the configured Obsidian vault with Ocean metadata state.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "obsidian_read",
+        description: "Read one validated Markdown note by relative path.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: "object",
+            properties: { path: { type: "string" } },
+            required: ["path"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "obsidian_inbox_list",
+        description: "List raw notes waiting in 00-Inbox.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "obsidian_conflicts_list",
+        description: "List Ocean-recorded Obsidian write conflicts without proposed note content.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "obsidian_write",
+        description: "Plan or apply a guarded Obsidian note write.",
+        annotations: { readOnlyHint: false },
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string" },
+                content: { type: "string" },
+                expectedSha256: { type: ["string", "null"] },
+                approved: { type: "boolean" },
+            },
+            required: ["path", "content", "approved"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "obsidian_inbox_promote",
+        description: "Plan or apply promotion of one inbox note into an approved vault area.",
+        annotations: { readOnlyHint: false },
+        inputSchema: {
+            type: "object",
+            properties: {
+                source: { type: "string" },
+                targetDirectory: { type: "string" },
+                approved: { type: "boolean" },
+            },
+            required: ["source", "targetDirectory", "approved"],
+            additionalProperties: false,
+        },
+    },
+]);
+function textResult(value) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(value) }],
+        structuredContent: value,
+    };
+}
+function requiredString(args, key) {
+    const value = args[key];
+    if (typeof value !== "string" || !value)
+        throw new Error(`${key} is required`);
+    return value;
+}
+function requiredText(args, key) {
+    const value = args[key];
+    if (typeof value !== "string")
+        throw new Error(`${key} is required`);
+    return value;
+}
+async function conflicts() {
+    const directory = oceanPath(SYSTEM_DIR, "integrations", "obsidian", "conflicts");
+    try {
+        return (await readdir(directory, { withFileTypes: true }))
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => ({ record: entry.name }));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+async function callTool(name, args, connection) {
+    await validateObsidianVault(connection);
+    if (name === "obsidian_discover") {
+        const result = await discoverObsidianVault(connection);
+        return {
+            noteCount: result.noteCount,
+            totalBytes: result.totalBytes,
+            notes: result.notes,
+            issues: result.issues,
+        };
+    }
+    if (name === "obsidian_sync")
+        return syncObsidianVault(connection);
+    if (name === "obsidian_read") {
+        const relative = requiredString(args, "path");
+        const file = resolveObsidianNotePath(connection.vaultPath, relative);
+        const content = await readFile(file, "utf8");
+        if (Buffer.byteLength(content) > 1_000_000)
+            throw new Error("Obsidian note exceeds 1000000 bytes");
+        return { path: relative, content };
+    }
+    if (name === "obsidian_inbox_list")
+        return listInboxCandidates(connection);
+    if (name === "obsidian_conflicts_list")
+        return conflicts();
+    if (name === "obsidian_write") {
+        const approval = mcpApprovalSchema.parse(args.approval);
+        const actionArgs = {
+            path: args.path,
+            content: args.content,
+            ...(args.expectedSha256 === undefined
+                ? {}
+                : { expectedSha256: args.expectedSha256 }),
+        };
+        if (approval.fingerprint !== actionFingerprint(name, actionArgs))
+            throw new Error("Obsidian write approval does not match the requested action");
+        return writeObsidianNote(connection, requiredString(args, "path"), requiredText(args, "content"), args.expectedSha256 === null || args.expectedSha256 === undefined
+            ? null
+            : requiredString(args, "expectedSha256"), true);
+    }
+    if (name === "obsidian_inbox_promote") {
+        const approval = mcpApprovalSchema.parse(args.approval);
+        const actionArgs = {
+            source: args.source,
+            targetDirectory: args.targetDirectory,
+        };
+        if (approval.fingerprint !== actionFingerprint(name, actionArgs))
+            throw new Error("Inbox promotion approval does not match the requested action");
+        return promoteInboxNote(connection, requiredString(args, "source"), requiredString(args, "targetDirectory"), true);
+    }
+    throw new Error(`Unknown MCP tool: ${name}`);
+}
+export async function handleObsidianMcpRequest(request, connection) {
+    if (request.method === "notifications/initialized")
+        return null;
+    if (request.method === "initialize")
+        return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: {
+                protocolVersion: "2025-06-18",
+                capabilities: { tools: {} },
+                serverInfo: { name: "ocean-obsidian", version: await serverVersion() },
+            },
+        };
+    if (request.method === "tools/list")
+        return { jsonrpc: "2.0", id: request.id, result: { tools: tools.list() } };
+    if (request.method !== "tools/call")
+        return {
+            jsonrpc: "2.0",
+            id: request.id,
+            error: {
+                code: -32601,
+                message: `Unsupported MCP method: ${request.method ?? ""}`,
+            },
+        };
+    const name = request.params?.name;
+    if (typeof name !== "string" || !tools.has(name))
+        return {
+            jsonrpc: "2.0",
+            id: request.id,
+            error: { code: -32602, message: "Unknown MCP tool" },
+        };
+    try {
+        return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: textResult(await callTool(name, (request.params?.arguments ?? {}), connection)),
+        };
+    }
+    catch (error) {
+        return {
+            jsonrpc: "2.0",
+            id: request.id,
+            error: {
+                code: -32000,
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+}
+export async function runObsidianMcpServer() {
+    const connection = await loadObsidianConnection();
+    let buffer = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", async (chunk) => {
+        buffer += chunk;
+        while (true) {
+            const newline = buffer.indexOf("\n");
+            if (newline < 0)
+                return;
+            const line = buffer.slice(0, newline).trim();
+            buffer = buffer.slice(newline + 1);
+            if (!line)
+                continue;
+            const request = JSON.parse(line);
+            const response = await handleObsidianMcpRequest(request, connection);
+            if (!response)
+                continue;
+            process.stdout.write(`${JSON.stringify(response)}\n`);
+        }
+    });
+    await new Promise((resolve) => {
+        process.stdin.once("end", resolve);
+    });
+}
+//# sourceMappingURL=obsidian-server.js.map