@goke/mcp 0.0.9 → 0.0.10

package/dist/__test__/http-multi-tenant.test.js

@@ -0,0 +1,309 @@
+/**
+ * Multi-tenant remote-MCP test.
+ *
+ * Proves that one goke cli exposed over the MCP streamable-HTTP
+ * transport can serve multiple concurrent users with fully isolated
+ * state (in-memory fs + cwd + env) — no shared host process stdio,
+ * no cross-tenant leaks.
+ *
+ * Wiring choices worth calling out:
+ *
+ *   - `WebStandardStreamableHTTPServerTransport` from the MCP SDK
+ *     accepts a Web-Standard `Request` and returns a `Response`.
+ *     That means we can drive it **in-process** through the client
+ *     transport's `fetch` hook without ever binding a TCP socket
+ *     or spinning up `node:http` / Express. Same wire protocol,
+ *     zero sockets.
+ *   - `enableJsonResponse: true` switches the transport off SSE and
+ *     into pure request/response JSON. GET SSE opens are answered
+ *     with `405`, which the client treats as "server does not offer
+ *     SSE" and moves on (see `_startOrAuthSse` in the SDK client).
+ *   - Each session gets its own cli **clone** via
+ *     `baseCli.clone({ cwd, env, fs })`. The clone inherits the
+ *     command tree but owns its own `{ cwd, env, fs }`, which is
+ *     what `runCliTool` forwards into every action through
+ *     `ctx.process.*` / `ctx.fs`.
+ */
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server as McpLowLevelServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { goke } from "goke";
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { addCliToolsToMcp } from "../cli-to-mcp.js";
+// ─── Minimal in-memory fs ─────────────────────────────────────────
+/**
+ * Dead-simple `GokeFs` backed by a `Map<string, string>`.
+ *
+ * Implements only the methods the cli commands in this test
+ * actually call (`writeFile`, `readFile`, `mkdir`). Every other
+ * method throws so accidental real-fs usage would fail loudly.
+ */
+const notImplemented = (name) => () => {
+    throw new Error(`InMemoryFs.${name} not implemented for this test`);
+};
+class InMemoryFs {
+    files = new Map();
+    writeFile = async (filePath, data) => {
+        const key = String(filePath);
+        const text = typeof data === "string"
+            ? data
+            : new TextDecoder("utf-8").decode(data);
+        this.files.set(key, text);
+    };
+    readFile = async (filePath) => {
+        const key = String(filePath);
+        const content = this.files.get(key);
+        if (content === undefined) {
+            throw new Error(`ENOENT: ${key}`);
+        }
+        return content;
+    };
+    mkdir = async () => undefined;
+    appendFile = notImplemented("appendFile");
+    chmod = notImplemented("chmod");
+    copyFile = notImplemented("copyFile");
+    link = notImplemented("link");
+    readlink = notImplemented("readlink");
+    realpath = notImplemented("realpath");
+    rename = notImplemented("rename");
+    rm = notImplemented("rm");
+    symlink = notImplemented("symlink");
+    utimes = notImplemented("utimes");
+}
+// ─── Shared cli definition ────────────────────────────────────────
+/**
+ * One cli definition, reused across tenants. Commands read / write
+ * through `ctx.fs` and resolve paths against `ctx.process.cwd`, so
+ * the *same* code runs per tenant but talks to a tenant-specific
+ * filesystem when invoked via the session-scoped clone below.
+ */
+function buildBaseCli() {
+    const cli = goke("notes-app");
+    cli
+        .command("save <filename>", "Save content to a file in the tenant workspace")
+        .option("--content <content>", z.string().describe("File content"))
+        .action(async (filename, options, ctx) => {
+        const full = path.posix.join(ctx.process.cwd, filename);
+        await ctx.fs.writeFile(full, options.content);
+        return { saved: full, tenant: ctx.process.env.TENANT_ID };
+    });
+    cli
+        .command("load <filename>", "Read a file from the tenant workspace")
+        .action(async (filename, _options, ctx) => {
+        const full = path.posix.join(ctx.process.cwd, filename);
+        const text = await ctx.fs.readFile(full, "utf8");
+        return { path: full, text, tenant: ctx.process.env.TENANT_ID };
+    });
+    return cli;
+}
+/**
+ * Build a `FetchLike` that routes MCP streamable-HTTP traffic into
+ * in-process session-scoped `WebStandardStreamableHTTPServerTransport`
+ * instances. One transport + one cli clone per session. Each session
+ * is keyed by `mcp-session-id`; initialization requests pick a tenant
+ * via the `x-tenant-id` header.
+ *
+ * Returns both the custom fetch and the transports map so tests can
+ * inspect session state if needed.
+ */
+function createMultiTenantFetch(options) {
+    const { baseCli, resolveTenant } = options;
+    const transports = new Map();
+    const customFetch = async (url, init) => {
+        const method = (init?.method ?? "GET").toUpperCase();
+        const headers = new Headers(init?.headers);
+        // Pure request/response mode: tell the client there's no SSE
+        // available on GET. `_startOrAuthSse` in the SDK client treats
+        // 405 as "server does not offer SSE" and moves on gracefully.
+        if (method === "GET") {
+            return new Response(null, { status: 405 });
+        }
+        // Parse POST body once and hand it to the transport via
+        // `parsedBody` in `HandleRequestOptions` so we don't have to
+        // worry about Request body streams being single-use.
+        let parsedBody = undefined;
+        if (method === "POST" && init?.body != null) {
+            const rawBody = init.body;
+            const bodyText = typeof rawBody === "string"
+                ? rawBody
+                : await new Response(rawBody).text();
+            if (bodyText) {
+                parsedBody = JSON.parse(bodyText);
+            }
+        }
+        // Rebuild a plain Request with the same method + headers. The
+        // transport reads accept/content-type from here and uses
+        // `parsedBody` for the actual JSON-RPC payload.
+        const request = new Request(url.toString(), {
+            method,
+            headers,
+        });
+        const sessionId = headers.get("mcp-session-id");
+        // Existing session: route to its transport.
+        if (sessionId && transports.has(sessionId)) {
+            return transports.get(sessionId).handleRequest(request, { parsedBody });
+        }
+        // New session: must be an initialize POST.
+        if (method !== "POST" || !isInitializeRequest(parsedBody)) {
+            return new Response(JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code: -32000, message: "Bad Request: No valid session ID provided" },
+                id: null,
+            }), { status: 400, headers: { "content-type": "application/json" } });
+        }
+        // Resolve the tenant from the custom header, build a cli clone
+        // with its cwd/env/fs, and spin up a session-scoped MCP server.
+        const tenantId = headers.get("x-tenant-id");
+        if (!tenantId) {
+            return new Response("missing x-tenant-id header", { status: 401 });
+        }
+        const tenant = resolveTenant(tenantId);
+        const tenantCli = baseCli.clone({
+            cwd: tenant.cwd,
+            env: { ...tenant.env, TENANT_ID: tenantId },
+            fs: tenant.fs,
+        });
+        const mcpServer = new McpLowLevelServer({ name: "notes-app-mcp", version: "1.0.0" }, { capabilities: {} });
+        addCliToolsToMcp({ cli: tenantCli, server: mcpServer });
+        const transport = new WebStandardStreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            // Pure request/response — no SSE streaming to clean up.
+            enableJsonResponse: true,
+            onsessioninitialized: (sid) => {
+                transports.set(sid, transport);
+            },
+            onsessionclosed: (sid) => {
+                transports.delete(sid);
+            },
+        });
+        transport.onclose = () => {
+            const sid = transport.sessionId;
+            if (sid) {
+                transports.delete(sid);
+            }
+        };
+        await mcpServer.connect(transport);
+        return transport.handleRequest(request, { parsedBody });
+    };
+    return { fetch: customFetch, transports };
+}
+// ─── Tests ────────────────────────────────────────────────────────
+describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () => {
+    function setupScenario() {
+        const baseCli = buildBaseCli();
+        const tenants = new Map();
+        tenants.set("tenant-a", {
+            cwd: "/workspace-a",
+            env: { ROLE: "writer" },
+            fs: new InMemoryFs(),
+        });
+        tenants.set("tenant-b", {
+            cwd: "/workspace-b",
+            env: { ROLE: "reader" },
+            fs: new InMemoryFs(),
+        });
+        const { fetch: tenantFetch } = createMultiTenantFetch({
+            baseCli,
+            resolveTenant: (id) => {
+                const tenant = tenants.get(id);
+                if (!tenant)
+                    throw new Error(`unknown tenant ${id}`);
+                return tenant;
+            },
+        });
+        // The URL is a placeholder — the in-process fetch never looks
+        // at the host, just the method/headers/body.
+        const endpoint = new URL("http://in-memory-mcp.test/mcp");
+        async function connectTenant(tenantId) {
+            const transport = new StreamableHTTPClientTransport(endpoint, {
+                fetch: tenantFetch,
+                requestInit: {
+                    headers: {
+                        "x-tenant-id": tenantId,
+                    },
+                },
+            });
+            const client = new Client({ name: `${tenantId}-client`, version: "1.0.0" }, { capabilities: {} });
+            await client.connect(transport);
+            return client;
+        }
+        return { tenants, connectTenant };
+    }
+    function firstTextBlock(result) {
+        const content = result.content ?? [];
+        return content.find((block) => block.type === "text")?.text ?? "";
+    }
+    it("routes each session to its own cli clone with tenant-specific cwd/env/fs", async () => {
+        const { tenants, connectTenant } = setupScenario();
+        const aliceClient = await connectTenant("tenant-a");
+        const bobClient = await connectTenant("tenant-b");
+        try {
+            // Each client sees the same tool catalog — it comes from the
+            // shared cli definition.
+            const aliceTools = (await aliceClient.listTools()).tools.map((t) => t.name).sort();
+            const bobTools = (await bobClient.listTools()).tools.map((t) => t.name).sort();
+            expect(aliceTools).toEqual(["load", "save"]);
+            expect(bobTools).toEqual(["load", "save"]);
+            // Both tenants write a file called `notes.txt` with different
+            // content. Since each session uses its own cli clone (with
+            // its own cwd + fs), the writes land in separate Maps.
+            const aliceSave = await aliceClient.callTool({
+                name: "save",
+                arguments: { filename: "notes.txt", content: "alice-secret" },
+            });
+            const bobSave = await bobClient.callTool({
+                name: "save",
+                arguments: { filename: "notes.txt", content: "bob-secret" },
+            });
+            expect(firstTextBlock(aliceSave)).toContain("/workspace-a/notes.txt");
+            expect(firstTextBlock(aliceSave)).toContain("tenant-a");
+            expect(firstTextBlock(bobSave)).toContain("/workspace-b/notes.txt");
+            expect(firstTextBlock(bobSave)).toContain("tenant-b");
+            // Each tenant reads back what it wrote.
+            const aliceLoad = await aliceClient.callTool({
+                name: "load",
+                arguments: { filename: "notes.txt" },
+            });
+            const bobLoad = await bobClient.callTool({
+                name: "load",
+                arguments: { filename: "notes.txt" },
+            });
+            expect(firstTextBlock(aliceLoad)).toContain("alice-secret");
+            expect(firstTextBlock(aliceLoad)).not.toContain("bob-secret");
+            expect(firstTextBlock(bobLoad)).toContain("bob-secret");
+            expect(firstTextBlock(bobLoad)).not.toContain("alice-secret");
+            // Sanity check: the underlying in-memory maps really are
+            // disjoint. Tenant A's fs only has tenant A's file.
+            const tenantAFs = tenants.get("tenant-a").fs;
+            const tenantBFs = tenants.get("tenant-b").fs;
+            expect([...tenantAFs.files.keys()]).toEqual(["/workspace-a/notes.txt"]);
+            expect([...tenantBFs.files.keys()]).toEqual(["/workspace-b/notes.txt"]);
+            expect(tenantAFs.files.get("/workspace-a/notes.txt")).toBe("alice-secret");
+            expect(tenantBFs.files.get("/workspace-b/notes.txt")).toBe("bob-secret");
+        }
+        finally {
+            await aliceClient.close();
+            await bobClient.close();
+        }
+    });
+    it("raises a tool error when a tenant reads a file it never wrote", async () => {
+        const { connectTenant } = setupScenario();
+        const bobClient = await connectTenant("tenant-b");
+        try {
+            const result = await bobClient.callTool({
+                name: "load",
+                arguments: { filename: "does-not-exist.txt" },
+            });
+            expect(result.isError).toBe(true);
+            expect(firstTextBlock(result)).toMatch(/ENOENT/);
+        }
+        finally {
+            await bobClient.close();
+        }
+    });
+});

package/dist/cli-to-mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-to-mcp.d.ts","sourceRoot":"","sources":["../src/cli-to-mcp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAS/E,OAAO,EAAmD,KAAK,IAAI,EAA6B,MAAM,MAAM,CAAC;AAwD7G,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,IAAI,CAAC;IACV,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,aAAa,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;IACjD,gBAAgB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC;CACpD;AA4XD,MAAM,WAAW,sBAAsB;IACrC,mEAAmE;IACnE,GAAG,EAAE,IAAI,CAAC;IACV,iGAAiG;IACjG,aAAa,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;IACjD,iCAAiC;IACjC,gBAAgB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC;IACnD,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iFAAiF;IACjF,eAAe,CAAC,EAAE,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CACxD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAsClG;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI,CAyCvE"}
+{"version":3,"file":"cli-to-mcp.d.ts","sourceRoot":"","sources":["../src/cli-to-mcp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAS/E,OAAO,EAKL,KAAK,IAAI,EAIV,MAAM,MAAM,CAAC;AAwFd,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,IAAI,CAAC;IACV,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,aAAa,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;IACjD,gBAAgB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC;CACpD;AAqfD,MAAM,WAAW,sBAAsB;IACrC,mEAAmE;IACnE,GAAG,EAAE,IAAI,CAAC;IACV,iGAAiG;IACjG,aAAa,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;IACjD,iCAAiC;IACjC,gBAAgB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC;IACnD,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iFAAiF;IACjF,eAAe,CAAC,EAAE,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CACxD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAsClG;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI,CAyCvE"}

package/dist/cli-to-mcp.js

@@ -5,8 +5,19 @@
  * or a high-level McpServer by mounting tools/list + tools/call handlers.
  */
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
-import { coerceBySchema, extractJsonSchema } from "goke";
+import { coerceBySchema, extractJsonSchema, GokeProcessExit, } from "goke";
 const CLI_TO_MCP_STATE = Symbol.for("@goke/mcp/cli-to-mcp-state");
+function createTextCaptureStream() {
+    const chunks = [];
+    return {
+        get text() {
+            return chunks.join("");
+        },
+        write(data) {
+            chunks.push(data);
+        },
+    };
+}
 function isMountableCommand(command, commandFilter) {
     if (!command.commandAction) {
         return false;
@@ -167,6 +178,90 @@ function isToolNotFoundResult(result, toolName) {
     const text = String(textBlock?.text ?? "").toLowerCase();
     return text.includes("tool") && text.includes("not found") && text.includes(toolName.toLowerCase());
 }
+/**
+ * Build the same `GokeExecutionContext` an action would receive from
+ * `cli.parse()`, but with capture streams for stdout/stderr and an
+ * `exit` that throws `GokeProcessExit` instead of killing the host
+ * process.
+ *
+ * Capturing is required for the stdio MCP transport because the host
+ * `process.stdout` is the JSON-RPC channel — any write to it would
+ * corrupt the protocol. Capturing is also what lets us surface
+ * `ctx.console.log` output in the `CallToolResult.content`.
+ */
+function createCallToolExecutionContext(cli) {
+    const stdout = createTextCaptureStream();
+    const stderr = createTextCaptureStream();
+    const ctx = cli.createExecutionContext({
+        stdout,
+        stderr,
+        // Swallow the user-level exit: the outer createExecutionContext
+        // wrapper will still throw `GokeProcessExit` after this returns,
+        // which `runCliTool` catches and turns into a `CallToolResult`.
+        exit: () => { },
+    });
+    return { ctx, stdout, stderr };
+}
+/**
+ * Build a `CallToolResult` from an action's return value plus any
+ * text that was captured from the injected `ctx.console` /
+ * `ctx.process.stdout` / `ctx.process.stderr` streams.
+ *
+ * Precedence rules:
+ *   1. If the action returned a ready-made `CallToolResult` (object
+ *      with a `content` key), honor it as-is. Captured output is
+ *      ignored to give authors a fully manual escape hatch.
+ *   2. If anything was captured on stdout or stderr, emit one text
+ *      block per non-empty stream (stdout first, then stderr) and
+ *      append the stringified return value as a trailing block when
+ *      it is non-empty. This keeps warnings written via
+ *      `ctx.console.error` / `ctx.process.stderr.write` from being
+ *      silently dropped when the action also returns a value.
+ *   3. Otherwise fall back to the legacy behavior (stringify the
+ *      return value, empty string when `undefined`).
+ */
+function buildCallToolResult(returnValue, capturedStdout, capturedStderr) {
+    if (returnValue && typeof returnValue === "object" && "content" in returnValue) {
+        return returnValue;
+    }
+    if (capturedStdout || capturedStderr) {
+        const blocks = [];
+        if (capturedStdout) {
+            blocks.push({ type: "text", text: capturedStdout });
+        }
+        if (capturedStderr) {
+            blocks.push({ type: "text", text: capturedStderr });
+        }
+        const valueText = formatTextResult(returnValue);
+        if (valueText) {
+            blocks.push({ type: "text", text: valueText });
+        }
+        return { content: blocks };
+    }
+    return toCallToolResult(returnValue);
+}
+/**
+ * Build an error `CallToolResult` from captured output + the process
+ * exit code thrown by `ctx.process.exit(code)`. Mirrors the
+ * `{ stdout, stderr, exitCode }` shape just-bash produces, but in the
+ * MCP content-block format.
+ */
+function buildProcessExitResult(exitCode, capturedStdout, capturedStderr) {
+    const content = [];
+    if (capturedStdout) {
+        content.push({ type: "text", text: capturedStdout });
+    }
+    if (capturedStderr) {
+        content.push({ type: "text", text: capturedStderr });
+    }
+    if (content.length === 0) {
+        content.push({ type: "text", text: `Process exited with code ${exitCode}` });
+    }
+    return {
+        isError: exitCode !== 0,
+        content,
+    };
+}
 async function runCliTool(binding, argumentsObject) {
     for (const requiredName of binding.requiredNames) {
         if (getToolCallArguments(argumentsObject, requiredName) === undefined) {
@@ -212,19 +307,35 @@ async function runCliTool(binding, argumentsObject) {
     if (!action) {
         throw new McpError(ErrorCode.InvalidParams, `Command ${binding.command.name} has no action`);
     }
+    // Build the same execution context an action would see when invoked
+    // from the command line, but with capture streams + a no-op `exit`
+    // so tool calls can't corrupt the MCP transport or kill the host.
+    const { ctx, stdout, stderr } = createCallToolExecutionContext(binding.cli);
     try {
-        const result = await Promise.resolve(action(...positionalValues, optionsObject));
-        return toCallToolResult(result);
+        // Match `Goke#runMatchedCommand` by calling the action with the
+        // owning cli as `this`. Keeps behavior parity for JS authors who
+        // reference `this.name` / `this.options` from inside an action.
+        const result = await Promise.resolve(action.apply(binding.cli, [...positionalValues, optionsObject, ctx]));
+        return buildCallToolResult(result, stdout.text, stderr.text);
     }
     catch (error) {
+        if (error instanceof GokeProcessExit) {
+            return buildProcessExitResult(error.code, stdout.text, stderr.text);
+        }
         const message = error instanceof Error ? error.message : String(error);
+        const content = [
+            { type: "text", text: message },
+        ];
+        if (stderr.text) {
+            content.push({ type: "text", text: stderr.text });
+        }
         return {
             isError: true,
-            content: [{ type: "text", text: message }],
+            content,
         };
     }
 }
-function createBinding(command, toolName) {
+function createBinding(cli, command, toolName) {
     const positionalArgs = command.args;
     const options = command.options;
     const properties = {};
@@ -272,6 +383,7 @@ function createBinding(command, toolName) {
             inputSchema,
         },
         command,
+        cli,
         positionalArgs,
         options: optionBindings,
         requiredNames: Array.from(new Set(requiredNames)),
@@ -417,7 +529,7 @@ export function addCliToolsToMcp(options) {
         const baseToolName = defaultSanitizeToolName(sanitizeToolName(command.name));
         const toolName = uniqueToolName(baseToolName, usedNames);
         usedNames.add(toolName);
-        const binding = createBinding(command, toolName);
+        const binding = createBinding(cli, command, toolName);
         state.toolsByName.set(toolName, binding);
         state.commandToToolName.set(command.name, toolName);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goke/mcp",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "type": "module",
   "description": "Dynamically generate CLI commands from MCP server tools",
   "repository": {
@@ -51,7 +51,7 @@
     "@types/node": "^22.19.7",
     "vitest": "^3.1.0",
     "zod": "^4.3.6",
-    "goke": "^6.3.0"
+    "goke": "^6.8.0"
   },
   "scripts": {
     "clean": "rm -rf dist",