@goke/mcp 0.0.8 → 0.0.9

package/README.md

@@ -62,60 +62,114 @@ notion-mcp-cli notion-retrieve-page --page_id "abc123"
 notion-mcp-cli notion-list-users
 ```
 
-## Turn a goke CLI into an MCP server
+## Expose a CLI as an MCP server
 
-`addCliToolsToMcp()` does the inverse mapping: every CLI command becomes an MCP tool.
-
-- Command description → MCP tool description
-- Option schema (Zod or any Standard Schema library) → MCP `inputSchema` JSON Schema
-- Command names are sanitized into valid MCP tool names (invalid characters become `_`)
-- Composable with existing MCP tools already registered on the same server
-
-### With low-level `Server`
+`createMcpAction()` turns your entire CLI into a stdio MCP server with one line. Every CLI command becomes an MCP tool automatically. The command you attach it to is excluded from the tool list.
 
 ```ts
 import { goke } from "goke"
 import { z } from "zod"
-import { Server } from "@modelcontextprotocol/sdk/server/index.js"
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
-import { addCliToolsToMcp } from "@goke/mcp"
+import { createMcpAction } from "@goke/mcp"
 
 const cli = goke("my-cli")
 
 cli
-  .command("notion search", "Search Notion pages")
+  .command("search", "Search pages")
   .option("--query <query>", z.string().describe("Search query"))
-  .action((options) => ({ query: options.query }))
+  .option("--limit [limit]", z.number().default(10).describe("Max results"))
+  .action((options) => {
+    return { results: findPages(options.query, options.limit) }
+  })
+
+cli
+  .command("deploy <env>", "Deploy to environment")
+  .option("--dry-run", z.boolean().default(false).describe("Simulate"))
+  .action((env, options) => {
+    return options.dryRun ? `would deploy to ${env}` : deploy(env)
+  })
+
+// Add MCP support — runs a stdio MCP server when the user invokes `my-cli mcp`
+cli.command("mcp", "Start MCP server over stdio")
+  .action(createMcpAction({ cli }))
+
+cli.help()
+cli.parse()
+```
+
+Now users can use your CLI directly **or** connect it as an MCP server:
+
+```bash
+# Use as a normal CLI
+my-cli search --query "meeting notes"
+my-cli deploy staging --dry-run
+
+# Use as an MCP server (e.g. from Claude Desktop, Cursor, etc.)
+my-cli mcp
+```
+
+When running as MCP, the server exposes `search` and `deploy` as tools. The `mcp` command itself is excluded. Options with Zod schemas (or any Standard Schema) become typed `inputSchema` properties in the MCP tool definition.
+
+### Installing the MCP server in clients
+
+Users can install your CLI as an MCP server in any client using [`@playwriter/install-mcp`](https://github.com/nicepkg/install-mcp) — a cross-platform tool that handles config file locations for every major MCP client:
+
+```bash
+# Install in Claude Desktop
+npx @playwriter/install-mcp my-cli --client claude-desktop
+
+# Install in Cursor
+npx @playwriter/install-mcp my-cli --client cursor
+
+# Install in VS Code
+npx @playwriter/install-mcp my-cli --client vscode
+```
+
+This works with any client: `claude-desktop`, `cursor`, `vscode`, `windsurf`, `claude-code`, `opencode`, `zed`, `goose`, `cline`, `codex`, `gemini-cli`, and [more](https://github.com/supermemoryai/install-mcp#supported-clients). If the command needs custom arguments, pass the full command string:
+
+```bash
+npx @playwriter/install-mcp 'npx my-cli mcp' --client cursor
+```
+
+`createMcpAction` accepts the same filtering options as `addCliToolsToMcp`:
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `cli` | `Goke` | **required** | The CLI instance to expose |
+| `commandFilter` | `(name) => boolean` | — | Additional filter (MCP command is always excluded) |
+| `sanitizeToolName` | `(name) => string` | — | Custom tool name sanitizer |
+| `serverName` | `string` | CLI name | MCP server name |
+| `serverVersion` | `string` | `'1.0.0'` | MCP server version |
+| `createTransport` | `() => Transport` | stdio | Custom transport factory |
+
+### Advanced: `addCliToolsToMcp`
+
+For more control (composing with existing MCP tools, using a custom server), use `addCliToolsToMcp()` directly:
+
+```ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js"
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+import { addCliToolsToMcp } from "@goke/mcp"
 
 const server = new Server(
   { name: "my-cli-mcp", version: "1.0.0" },
   { capabilities: {} },
 )
 
+// Mount CLI commands as tools alongside your own
 addCliToolsToMcp({ cli, server })
 
 const transport = new StdioServerTransport()
 await server.connect(transport)
 ```
 
-Run it with Node:
-
-```bash
-node dist/server.js
-```
-
-### With high-level `McpServer`
+Also works with the high-level `McpServer`:
 
 ```ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
-import { addCliToolsToMcp } from "@goke/mcp"
 
 const mcp = new McpServer({ name: "my-cli-mcp", version: "1.0.0" })
+mcp.tool("custom-tool", "A tool defined directly", async () => ({ ... }))
 addCliToolsToMcp({ cli, server: mcp })
-
-const transport = new StdioServerTransport()
-await mcp.connect(transport)
 ```
 
 ## Full example (with config persistence)
@@ -220,13 +274,14 @@ Registers MCP tool commands on a goke CLI instance.
 ### Exports
 
 ```ts
-// Main function
+// MCP server → CLI (consume MCP tools as CLI commands)
 export { addMcpCommands } from '@goke/mcp'
-
-// Types
-export type { AddMcpCommandsOptions } from '@goke/mcp'
-export type { CachedMcpTools } from '@goke/mcp'
+export type { AddMcpCommandsOptions, CachedMcpTools } from '@goke/mcp'
 export type { McpOAuthConfig, McpOAuthState } from '@goke/mcp'
+
+// CLI → MCP server (expose CLI commands as MCP tools)
+export { createMcpAction, addCliToolsToMcp } from '@goke/mcp'
+export type { CreateMcpActionOptions, AddCliToolsToMcpOptions } from '@goke/mcp'
 ```
 
 ## OAuth flow

package/dist/__test__/create-mcp-action.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for createMcpAction — turning a CLI into a stdio MCP server.
+ *
+ * Uses InMemoryTransport (via createTransport option) to avoid actual stdio.
+ * Simulates the goke runtime by setting matchedCommandName before calling the action.
+ */
+export {};
+//# sourceMappingURL=create-mcp-action.test.d.ts.map

package/dist/__test__/create-mcp-action.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-mcp-action.test.d.ts","sourceRoot":"","sources":["../../src/__test__/create-mcp-action.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/__test__/create-mcp-action.test.js

@@ -0,0 +1,274 @@
+/**
+ * Tests for createMcpAction — turning a CLI into a stdio MCP server.
+ *
+ * Uses InMemoryTransport (via createTransport option) to avoid actual stdio.
+ * Simulates the goke runtime by setting matchedCommandName before calling the action.
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { goke, wrapJsonSchema } from "goke";
+import { z } from "zod";
+import { describe, expect, it } from "vitest";
+import { createMcpAction } from "../cli-to-mcp.js";
+function firstTextContent(result) {
+    const content = "content" in result ? result.content : [];
+    return content.find((entry) => entry.type === "text")?.text ?? "";
+}
+describe("createMcpAction", () => {
+    it("returns an action function", () => {
+        const cli = goke("test");
+        const action = createMcpAction({ cli });
+        expect(typeof action).toBe("function");
+    });
+    it("starts an MCP server exposing CLI commands, excluding the mcp command", async () => {
+        const cli = goke("test");
+        cli
+            .command("greet", "Say hello")
+            .option("--name <name>", z.string().describe("Person to greet"))
+            .action((options) => `Hello ${options.name}!`);
+        cli
+            .command("add", "Add numbers")
+            .option("--a <a>", z.number().describe("First"))
+            .option("--b <b>", z.number().describe("Second"))
+            .action((options) => ({ sum: options.a + options.b }));
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        cli.command("mcp", "Start MCP server").action(createMcpAction({
+            cli,
+            createTransport: () => serverTransport,
+        }));
+        // Simulate goke matching the "mcp" command (normally set by cli.parse())
+        cli.matchedCommandName = "mcp";
+        // Fire the action — starts the MCP server on the in-memory transport
+        const mcpCommand = cli.commands.find((c) => c.name === "mcp");
+        await mcpCommand.commandAction({});
+        const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+        await client.connect(clientTransport);
+        try {
+            const tools = await client.listTools();
+            const toolNames = tools.tools.map((t) => t.name).sort();
+            expect(toolNames).toEqual(["add", "greet"]);
+            const greetResult = await client.callTool({
+                name: "greet",
+                arguments: { name: "World" },
+            });
+            expect(firstTextContent(greetResult)).toBe("Hello World!");
+            const addResult = await client.callTool({
+                name: "add",
+                arguments: { a: 3, b: 7 },
+            });
+            expect(firstTextContent(addResult)).toBe('{\n  "sum": 10\n}');
+        }
+        finally {
+            await client.close();
+        }
+    });
+    it("composes user commandFilter with auto-exclusion", async () => {
+        const cli = goke("test");
+        cli.command("public-cmd", "Public command").action(() => "public");
+        cli.command("secret-cmd", "Secret command").action(() => "secret");
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        cli.command("mcp", "Start MCP server").action(createMcpAction({
+            cli,
+            commandFilter: (name) => name !== "secret-cmd",
+            createTransport: () => serverTransport,
+        }));
+        cli.matchedCommandName = "mcp";
+        const mcpCommand = cli.commands.find((c) => c.name === "mcp");
+        await mcpCommand.commandAction({});
+        const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+        await client.connect(clientTransport);
+        try {
+            const tools = await client.listTools();
+            const toolNames = tools.tools.map((t) => t.name).sort();
+            // Both "mcp" (auto-excluded) and "secret-cmd" (user filter) excluded
+            expect(toolNames).toEqual(["public-cmd"]);
+        }
+        finally {
+            await client.close();
+        }
+    });
+    it("works with multi-word command names", async () => {
+        const cli = goke("test");
+        cli
+            .command("db migrate", "Run migrations")
+            .action(() => "migrated");
+        cli
+            .command("db seed", "Seed database")
+            .action(() => "seeded");
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        cli.command("serve mcp", "Start MCP server").action(createMcpAction({
+            cli,
+            createTransport: () => serverTransport,
+        }));
+        cli.matchedCommandName = "serve mcp";
+        const mcpCommand = cli.commands.find((c) => c.name === "serve mcp");
+        await mcpCommand.commandAction({});
+        const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+        await client.connect(clientTransport);
+        try {
+            const tools = await client.listTools();
+            const toolNames = tools.tools.map((t) => t.name).sort();
+            expect(toolNames).toEqual(["db_migrate", "db_seed"]);
+            const migrateResult = await client.callTool({
+                name: "db_migrate",
+                arguments: {},
+            });
+            expect(firstTextContent(migrateResult)).toBe("migrated");
+        }
+        finally {
+            await client.close();
+        }
+    });
+    it("end-to-end: MCP client connects, discovers tools with schemas, calls tools, handles errors", async () => {
+        const cli = goke("my-app");
+        // String option command
+        cli
+            .command("search", "Search for items")
+            .option("--query <query>", z.string().describe("Search query"))
+            .option("--limit [limit]", z.number().default(10).describe("Max results"))
+            .action((options) => {
+            return { results: [`result for "${options.query}"`], limit: options.limit };
+        });
+        // Boolean flag + positional arg command
+        cli
+            .command("deploy <env>", "Deploy to environment")
+            .option("--dry-run", z.boolean().default(false).describe("Simulate deployment"))
+            .action((env, options) => {
+            return options.dryRun ? `dry-run deploy to ${env}` : `deployed to ${env}`;
+        });
+        // Command that returns a CallToolResult directly
+        cli
+            .command("status", "Get system status")
+            .action(() => ({
+            content: [{ type: "text", text: "all systems operational" }],
+        }));
+        // Command that throws an error (should be caught and returned as isError)
+        cli
+            .command("fail", "Always fails")
+            .action(() => {
+            throw new Error("something went wrong");
+        });
+        // Wrapped JSON schema command
+        cli
+            .command("config set", "Set a config value")
+            .option("--key <key>", wrapJsonSchema({ type: "string", description: "Config key" }))
+            .option("--value <value>", wrapJsonSchema({ type: "string", description: "Config value" }))
+            .action((options) => {
+            return `set ${options.key} = ${options.value}`;
+        });
+        // Commands without actions (should NOT appear as tools)
+        cli.command("no-action", "This has no action handler");
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        cli.command("mcp", "Start MCP server").action(createMcpAction({
+            cli,
+            serverName: "my-app-mcp",
+            serverVersion: "2.5.0",
+            createTransport: () => serverTransport,
+        }));
+        cli.matchedCommandName = "mcp";
+        const mcpCommand = cli.commands.find((c) => c.name === "mcp");
+        await mcpCommand.commandAction({});
+        const client = new Client({ name: "e2e-test-client", version: "1.0.0" }, { capabilities: {} });
+        await client.connect(clientTransport);
+        try {
+            // ── Server info ──
+            const serverInfo = client.getServerVersion();
+            expect(serverInfo).toMatchObject({ name: "my-app-mcp", version: "2.5.0" });
+            // ── Tool discovery ──
+            const tools = await client.listTools();
+            const toolNames = tools.tools.map((t) => t.name).sort();
+            // "mcp" auto-excluded, "no-action" has no handler → not mounted
+            expect(toolNames).toEqual(["config_set", "deploy", "fail", "search", "status"]);
+            // ── Verify schemas are propagated ──
+            const searchTool = tools.tools.find((t) => t.name === "search");
+            expect(searchTool.description).toBe("Search for items");
+            expect(searchTool.inputSchema.properties).toHaveProperty("query");
+            expect(searchTool.inputSchema.properties).toHaveProperty("limit");
+            expect(searchTool.inputSchema.required).toEqual(["query"]);
+            const deployTool = tools.tools.find((t) => t.name === "deploy");
+            expect(deployTool.inputSchema.properties).toHaveProperty("env");
+            expect(deployTool.inputSchema.properties).toHaveProperty("dryRun");
+            expect(deployTool.inputSchema.required).toEqual(["env"]);
+            // ── Call tool with schema-based options ──
+            const searchResult = await client.callTool({
+                name: "search",
+                arguments: { query: "hello", limit: 5 },
+            });
+            expect(firstTextContent(searchResult)).toBe('{\n  "results": [\n    "result for \\"hello\\""\n  ],\n  "limit": 5\n}');
+            // ── Call tool with positional args ──
+            const deployResult = await client.callTool({
+                name: "deploy",
+                arguments: { env: "production", dryRun: true },
+            });
+            expect(firstTextContent(deployResult)).toBe("dry-run deploy to production");
+            // ── Call tool that returns a raw CallToolResult ──
+            const statusResult = await client.callTool({
+                name: "status",
+                arguments: {},
+            });
+            expect(firstTextContent(statusResult)).toBe("all systems operational");
+            // ── Call tool that throws → error is caught and returned as isError ──
+            const failResult = await client.callTool({
+                name: "fail",
+                arguments: {},
+            });
+            expect(failResult.isError).toBe(true);
+            expect(firstTextContent(failResult)).toBe("something went wrong");
+            // ── Call tool with multi-word command name ──
+            const configResult = await client.callTool({
+                name: "config_set",
+                arguments: { key: "theme", value: "dark" },
+            });
+            expect(firstTextContent(configResult)).toBe("set theme = dark");
+            // ── Call nonexistent tool → MCP error ──
+            await expect(client.callTool({ name: "nonexistent", arguments: {} })).rejects.toThrow(/not found/i);
+        }
+        finally {
+            await client.close();
+        }
+    });
+    it("returns empty tool list when only the mcp command exists", async () => {
+        const cli = goke("empty-app");
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        cli.command("mcp", "Start MCP server").action(createMcpAction({
+            cli,
+            createTransport: () => serverTransport,
+        }));
+        cli.matchedCommandName = "mcp";
+        const mcpCommand = cli.commands.find((c) => c.name === "mcp");
+        await mcpCommand.commandAction({});
+        const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+        await client.connect(clientTransport);
+        try {
+            const tools = await client.listTools();
+            expect(tools.tools).toEqual([]);
+        }
+        finally {
+            await client.close();
+        }
+    });
+    it("exposes all commands when matchedCommandName is not set", async () => {
+        const cli = goke("test");
+        cli.command("ping", "Ping").action(() => "pong");
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        cli.command("mcp", "Start MCP server").action(createMcpAction({
+            cli,
+            createTransport: () => serverTransport,
+        }));
+        // Do NOT set matchedCommandName — simulates programmatic invocation
+        // without cli.parse(). All commands including "mcp" should be exposed.
+        const mcpCommand = cli.commands.find((c) => c.name === "mcp");
+        await mcpCommand.commandAction({});
+        const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+        await client.connect(clientTransport);
+        try {
+            const tools = await client.listTools();
+            const toolNames = tools.tools.map((t) => t.name).sort();
+            // Without matchedCommandName, auto-exclusion can't kick in
+            expect(toolNames).toEqual(["mcp", "ping"]);
+        }
+        finally {
+            await client.close();
+        }
+    });
+});

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

@@ -6,6 +6,7 @@
  */
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { type Goke } from "goke";
 export interface AddCliToolsToMcpOptions {
     cli: Goke;
@@ -13,5 +14,32 @@ export interface AddCliToolsToMcpOptions {
     commandFilter?: (commandName: string) => boolean;
     sanitizeToolName?: (commandName: string) => string;
 }
+export interface CreateMcpActionOptions {
+    /** The CLI instance whose commands will be exposed as MCP tools */
+    cli: Goke;
+    /** Additional filter for which commands to expose. The MCP command itself is always excluded. */
+    commandFilter?: (commandName: string) => boolean;
+    /** Custom tool name sanitizer */
+    sanitizeToolName?: (commandName: string) => string;
+    /** MCP server name. Defaults to the CLI name or 'cli-mcp-server' */
+    serverName?: string;
+    /** MCP server version. Defaults to '1.0.0' */
+    serverVersion?: string;
+    /** Custom transport factory. Defaults to StdioServerTransport (stdin/stdout). */
+    createTransport?: () => Transport | Promise<Transport>;
+}
+/**
+ * Create a goke action callback that starts an MCP server over stdio.
+ *
+ * Exposes all CLI commands as MCP tools, automatically excluding the
+ * command this action is attached to.
+ *
+ * @example
+ * ```ts
+ * cli.command('mcp', 'Start MCP server over stdio')
+ *   .action(createMcpAction({ cli }))
+ * ```
+ */
+export declare function createMcpAction(options: CreateMcpActionOptions): (...args: any[]) => Promise<void>;
 export declare function addCliToolsToMcp(options: AddCliToolsToMcpOptions): void;
 //# sourceMappingURL=cli-to-mcp.d.ts.map

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;AASxE,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,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,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"}

package/dist/cli-to-mcp.js

@@ -342,6 +342,50 @@ function getOrInstallState(server) {
     });
     return state;
 }
+/**
+ * Create a goke action callback that starts an MCP server over stdio.
+ *
+ * Exposes all CLI commands as MCP tools, automatically excluding the
+ * command this action is attached to.
+ *
+ * @example
+ * ```ts
+ * cli.command('mcp', 'Start MCP server over stdio')
+ *   .action(createMcpAction({ cli }))
+ * ```
+ */
+export function createMcpAction(options) {
+    const { cli, commandFilter: userFilter, sanitizeToolName, serverName, serverVersion, createTransport } = options;
+    return async () => {
+        // At call time, goke has already matched the command and set matchedCommandName.
+        // We use it to auto-exclude the MCP command itself from the tool list.
+        const mcpCommandName = cli.matchedCommandName;
+        const { Server: ServerClass } = await import("@modelcontextprotocol/sdk/server/index.js");
+        const server = new ServerClass({
+            name: serverName || cli.name || "cli-mcp-server",
+            version: serverVersion || "1.0.0",
+        }, { capabilities: {} });
+        addCliToolsToMcp({
+            cli,
+            server,
+            commandFilter: (name) => {
+                if (mcpCommandName && name === mcpCommandName)
+                    return false;
+                return userFilter ? userFilter(name) : true;
+            },
+            sanitizeToolName,
+        });
+        let transport;
+        if (createTransport) {
+            transport = await createTransport();
+        }
+        else {
+            const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+            transport = new StdioServerTransport();
+        }
+        await server.connect(transport);
+    };
+}
 export function addCliToolsToMcp(options) {
     const { cli, commandFilter, sanitizeToolName = defaultSanitizeToolName } = options;
     const server = resolveServer(options.server);

package/dist/index.d.ts

@@ -42,8 +42,8 @@
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { Goke } from "goke";
 import type { McpOAuthConfig } from "./types.js";
-export { addCliToolsToMcp } from "./cli-to-mcp.js";
-export type { AddCliToolsToMcpOptions } from "./cli-to-mcp.js";
+export { addCliToolsToMcp, createMcpAction } from "./cli-to-mcp.js";
+export type { AddCliToolsToMcpOptions, CreateMcpActionOptions } from "./cli-to-mcp.js";
 export type { Transport };
 export type { McpOAuthConfig, McpOAuthState } from "./types.js";
 export interface CachedMcpTools {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAKjC,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,YAAY,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,YAAY,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAG/D,YAAY,EAAE,SAAS,EAAE,CAAC;AAC1B,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhE,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC,CAAC;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,IAAI,CAAC;IACV;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAErC;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IAEvF;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,EAAE,cAAc,CAAC;IAEvB;;OAEG;IACH,SAAS,EAAE,MAAM,cAAc,GAAG,SAAS,CAAC;IAE5C;;OAEG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,KAAK,IAAI,CAAC;CACxD;AAmID;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyMlF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAKjC,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,YAAY,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACpE,YAAY,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAGvF,YAAY,EAAE,SAAS,EAAE,CAAC;AAC1B,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhE,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC,CAAC;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,IAAI,CAAC;IACV;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAErC;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IAEvF;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,EAAE,cAAc,CAAC;IAEvB;;OAEG;IACH,SAAS,EAAE,MAAM,cAAc,GAAG,SAAS,CAAC;IAE5C;;OAEG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,KAAK,IAAI,CAAC;CACxD;AAmID;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyMlF"}

package/dist/index.js

@@ -45,7 +45,7 @@ import { wrapJsonSchema } from "goke";
 import yaml from "js-yaml";
 import { FileOAuthProvider } from "./oauth-provider.js";
 import { startOAuthFlow, isAuthRequiredError } from "./auth.js";
-export { addCliToolsToMcp } from "./cli-to-mcp.js";
+export { addCliToolsToMcp, createMcpAction } from "./cli-to-mcp.js";
 const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
 /**
  * Check if a schema represents a complex type (object/array) for help text display.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goke/mcp",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "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.2.3"
+    "goke": "^6.3.0"
   },
   "scripts": {
     "clean": "rm -rf dist",

package/src/__test__/create-mcp-action.test.ts

@@ -0,0 +1,353 @@
+/**
+ * Tests for createMcpAction — turning a CLI into a stdio MCP server.
+ *
+ * Uses InMemoryTransport (via createTransport option) to avoid actual stdio.
+ * Simulates the goke runtime by setting matchedCommandName before calling the action.
+ */
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { goke, wrapJsonSchema } from "goke";
+import { z } from "zod";
+import { describe, expect, it } from "vitest";
+import { createMcpAction } from "../cli-to-mcp.js";
+
+function firstTextContent(result: Awaited<ReturnType<Client["callTool"]>>): string {
+  const content = "content" in result ? (result as { content: Array<{ type: string; text?: string }> }).content : [];
+  return content.find((entry) => entry.type === "text")?.text ?? "";
+}
+
+describe("createMcpAction", () => {
+  it("returns an action function", () => {
+    const cli = goke("test");
+    const action = createMcpAction({ cli });
+    expect(typeof action).toBe("function");
+  });
+
+  it("starts an MCP server exposing CLI commands, excluding the mcp command", async () => {
+    const cli = goke("test");
+
+    cli
+      .command("greet", "Say hello")
+      .option("--name <name>", z.string().describe("Person to greet"))
+      .action((options: { name: string }) => `Hello ${options.name}!`);
+
+    cli
+      .command("add", "Add numbers")
+      .option("--a <a>", z.number().describe("First"))
+      .option("--b <b>", z.number().describe("Second"))
+      .action((options: { a: number; b: number }) => ({ sum: options.a + options.b }));
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    cli.command("mcp", "Start MCP server").action(
+      createMcpAction({
+        cli,
+        createTransport: () => serverTransport,
+      }),
+    );
+
+    // Simulate goke matching the "mcp" command (normally set by cli.parse())
+    cli.matchedCommandName = "mcp";
+
+    // Fire the action — starts the MCP server on the in-memory transport
+    const mcpCommand = cli.commands.find((c) => c.name === "mcp")!;
+    await mcpCommand.commandAction!({});
+
+    const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+    await client.connect(clientTransport);
+
+    try {
+      const tools = await client.listTools();
+      const toolNames = tools.tools.map((t) => t.name).sort();
+      expect(toolNames).toEqual(["add", "greet"]);
+
+      const greetResult = await client.callTool({
+        name: "greet",
+        arguments: { name: "World" },
+      });
+      expect(firstTextContent(greetResult)).toBe("Hello World!");
+
+      const addResult = await client.callTool({
+        name: "add",
+        arguments: { a: 3, b: 7 },
+      });
+      expect(firstTextContent(addResult)).toBe('{\n  "sum": 10\n}');
+    } finally {
+      await client.close();
+    }
+  });
+
+  it("composes user commandFilter with auto-exclusion", async () => {
+    const cli = goke("test");
+
+    cli.command("public-cmd", "Public command").action(() => "public");
+    cli.command("secret-cmd", "Secret command").action(() => "secret");
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    cli.command("mcp", "Start MCP server").action(
+      createMcpAction({
+        cli,
+        commandFilter: (name) => name !== "secret-cmd",
+        createTransport: () => serverTransport,
+      }),
+    );
+
+    cli.matchedCommandName = "mcp";
+
+    const mcpCommand = cli.commands.find((c) => c.name === "mcp")!;
+    await mcpCommand.commandAction!({});
+
+    const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+    await client.connect(clientTransport);
+
+    try {
+      const tools = await client.listTools();
+      const toolNames = tools.tools.map((t) => t.name).sort();
+      // Both "mcp" (auto-excluded) and "secret-cmd" (user filter) excluded
+      expect(toolNames).toEqual(["public-cmd"]);
+    } finally {
+      await client.close();
+    }
+  });
+
+  it("works with multi-word command names", async () => {
+    const cli = goke("test");
+
+    cli
+      .command("db migrate", "Run migrations")
+      .action(() => "migrated");
+
+    cli
+      .command("db seed", "Seed database")
+      .action(() => "seeded");
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    cli.command("serve mcp", "Start MCP server").action(
+      createMcpAction({
+        cli,
+        createTransport: () => serverTransport,
+      }),
+    );
+
+    cli.matchedCommandName = "serve mcp";
+
+    const mcpCommand = cli.commands.find((c) => c.name === "serve mcp")!;
+    await mcpCommand.commandAction!({});
+
+    const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+    await client.connect(clientTransport);
+
+    try {
+      const tools = await client.listTools();
+      const toolNames = tools.tools.map((t) => t.name).sort();
+      expect(toolNames).toEqual(["db_migrate", "db_seed"]);
+
+      const migrateResult = await client.callTool({
+        name: "db_migrate",
+        arguments: {},
+      });
+      expect(firstTextContent(migrateResult)).toBe("migrated");
+    } finally {
+      await client.close();
+    }
+  });
+
+  it("end-to-end: MCP client connects, discovers tools with schemas, calls tools, handles errors", async () => {
+    const cli = goke("my-app");
+
+    // String option command
+    cli
+      .command("search", "Search for items")
+      .option("--query <query>", z.string().describe("Search query"))
+      .option("--limit [limit]", z.number().default(10).describe("Max results"))
+      .action((options: { query: string; limit: number }) => {
+        return { results: [`result for "${options.query}"`], limit: options.limit };
+      });
+
+    // Boolean flag + positional arg command
+    cli
+      .command("deploy <env>", "Deploy to environment")
+      .option("--dry-run", z.boolean().default(false).describe("Simulate deployment"))
+      .action((env: string, options: { dryRun: boolean }) => {
+        return options.dryRun ? `dry-run deploy to ${env}` : `deployed to ${env}`;
+      });
+
+    // Command that returns a CallToolResult directly
+    cli
+      .command("status", "Get system status")
+      .action(() => ({
+        content: [{ type: "text", text: "all systems operational" }],
+      }));
+
+    // Command that throws an error (should be caught and returned as isError)
+    cli
+      .command("fail", "Always fails")
+      .action(() => {
+        throw new Error("something went wrong");
+      });
+
+    // Wrapped JSON schema command
+    cli
+      .command("config set", "Set a config value")
+      .option("--key <key>", wrapJsonSchema({ type: "string", description: "Config key" }))
+      .option("--value <value>", wrapJsonSchema({ type: "string", description: "Config value" }))
+      .action((options: { key: string; value: string }) => {
+        return `set ${options.key} = ${options.value}`;
+      });
+
+    // Commands without actions (should NOT appear as tools)
+    cli.command("no-action", "This has no action handler");
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    cli.command("mcp", "Start MCP server").action(
+      createMcpAction({
+        cli,
+        serverName: "my-app-mcp",
+        serverVersion: "2.5.0",
+        createTransport: () => serverTransport,
+      }),
+    );
+
+    cli.matchedCommandName = "mcp";
+
+    const mcpCommand = cli.commands.find((c) => c.name === "mcp")!;
+    await mcpCommand.commandAction!({});
+
+    const client = new Client({ name: "e2e-test-client", version: "1.0.0" }, { capabilities: {} });
+    await client.connect(clientTransport);
+
+    try {
+      // ── Server info ──
+      const serverInfo = client.getServerVersion();
+      expect(serverInfo).toMatchObject({ name: "my-app-mcp", version: "2.5.0" });
+
+      // ── Tool discovery ──
+      const tools = await client.listTools();
+      const toolNames = tools.tools.map((t) => t.name).sort();
+      // "mcp" auto-excluded, "no-action" has no handler → not mounted
+      expect(toolNames).toEqual(["config_set", "deploy", "fail", "search", "status"]);
+
+      // ── Verify schemas are propagated ──
+      const searchTool = tools.tools.find((t) => t.name === "search")!;
+      expect(searchTool.description).toBe("Search for items");
+      expect(searchTool.inputSchema.properties).toHaveProperty("query");
+      expect(searchTool.inputSchema.properties).toHaveProperty("limit");
+      expect(searchTool.inputSchema.required).toEqual(["query"]);
+
+      const deployTool = tools.tools.find((t) => t.name === "deploy")!;
+      expect(deployTool.inputSchema.properties).toHaveProperty("env");
+      expect(deployTool.inputSchema.properties).toHaveProperty("dryRun");
+      expect(deployTool.inputSchema.required).toEqual(["env"]);
+
+      // ── Call tool with schema-based options ──
+      const searchResult = await client.callTool({
+        name: "search",
+        arguments: { query: "hello", limit: 5 },
+      });
+      expect(firstTextContent(searchResult)).toBe(
+        '{\n  "results": [\n    "result for \\"hello\\""\n  ],\n  "limit": 5\n}',
+      );
+
+      // ── Call tool with positional args ──
+      const deployResult = await client.callTool({
+        name: "deploy",
+        arguments: { env: "production", dryRun: true },
+      });
+      expect(firstTextContent(deployResult)).toBe("dry-run deploy to production");
+
+      // ── Call tool that returns a raw CallToolResult ──
+      const statusResult = await client.callTool({
+        name: "status",
+        arguments: {},
+      });
+      expect(firstTextContent(statusResult)).toBe("all systems operational");
+
+      // ── Call tool that throws → error is caught and returned as isError ──
+      const failResult = await client.callTool({
+        name: "fail",
+        arguments: {},
+      });
+      expect(failResult.isError).toBe(true);
+      expect(firstTextContent(failResult)).toBe("something went wrong");
+
+      // ── Call tool with multi-word command name ──
+      const configResult = await client.callTool({
+        name: "config_set",
+        arguments: { key: "theme", value: "dark" },
+      });
+      expect(firstTextContent(configResult)).toBe("set theme = dark");
+
+      // ── Call nonexistent tool → MCP error ──
+      await expect(
+        client.callTool({ name: "nonexistent", arguments: {} }),
+      ).rejects.toThrow(/not found/i);
+    } finally {
+      await client.close();
+    }
+  });
+
+  it("returns empty tool list when only the mcp command exists", async () => {
+    const cli = goke("empty-app");
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    cli.command("mcp", "Start MCP server").action(
+      createMcpAction({
+        cli,
+        createTransport: () => serverTransport,
+      }),
+    );
+
+    cli.matchedCommandName = "mcp";
+
+    const mcpCommand = cli.commands.find((c) => c.name === "mcp")!;
+    await mcpCommand.commandAction!({});
+
+    const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+    await client.connect(clientTransport);
+
+    try {
+      const tools = await client.listTools();
+      expect(tools.tools).toEqual([]);
+    } finally {
+      await client.close();
+    }
+  });
+
+  it("exposes all commands when matchedCommandName is not set", async () => {
+    const cli = goke("test");
+
+    cli.command("ping", "Ping").action(() => "pong");
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    cli.command("mcp", "Start MCP server").action(
+      createMcpAction({
+        cli,
+        createTransport: () => serverTransport,
+      }),
+    );
+
+    // Do NOT set matchedCommandName — simulates programmatic invocation
+    // without cli.parse(). All commands including "mcp" should be exposed.
+
+    const mcpCommand = cli.commands.find((c) => c.name === "mcp")!;
+    await mcpCommand.commandAction!({});
+
+    const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+    await client.connect(clientTransport);
+
+    try {
+      const tools = await client.listTools();
+      const toolNames = tools.tools.map((t) => t.name).sort();
+      // Without matchedCommandName, auto-exclusion can't kick in
+      expect(toolNames).toEqual(["mcp", "ping"]);
+    } finally {
+      await client.close();
+    }
+  });
+});

package/src/cli-to-mcp.ts

@@ -7,6 +7,7 @@
 
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import {
   CallToolRequestSchema,
   ErrorCode,
@@ -456,6 +457,73 @@ function getOrInstallState(server: Server): CliToMcpState {
   return state;
 }
 
+export interface CreateMcpActionOptions {
+  /** The CLI instance whose commands will be exposed as MCP tools */
+  cli: Goke;
+  /** Additional filter for which commands to expose. The MCP command itself is always excluded. */
+  commandFilter?: (commandName: string) => boolean;
+  /** Custom tool name sanitizer */
+  sanitizeToolName?: (commandName: string) => string;
+  /** MCP server name. Defaults to the CLI name or 'cli-mcp-server' */
+  serverName?: string;
+  /** MCP server version. Defaults to '1.0.0' */
+  serverVersion?: string;
+  /** Custom transport factory. Defaults to StdioServerTransport (stdin/stdout). */
+  createTransport?: () => Transport | Promise<Transport>;
+}
+
+/**
+ * Create a goke action callback that starts an MCP server over stdio.
+ *
+ * Exposes all CLI commands as MCP tools, automatically excluding the
+ * command this action is attached to.
+ *
+ * @example
+ * ```ts
+ * cli.command('mcp', 'Start MCP server over stdio')
+ *   .action(createMcpAction({ cli }))
+ * ```
+ */
+export function createMcpAction(options: CreateMcpActionOptions): (...args: any[]) => Promise<void> {
+  const { cli, commandFilter: userFilter, sanitizeToolName, serverName, serverVersion, createTransport } = options;
+
+  return async () => {
+    // At call time, goke has already matched the command and set matchedCommandName.
+    // We use it to auto-exclude the MCP command itself from the tool list.
+    const mcpCommandName = cli.matchedCommandName;
+
+    const { Server: ServerClass } = await import("@modelcontextprotocol/sdk/server/index.js");
+
+    const server = new ServerClass(
+      {
+        name: serverName || cli.name || "cli-mcp-server",
+        version: serverVersion || "1.0.0",
+      },
+      { capabilities: {} },
+    );
+
+    addCliToolsToMcp({
+      cli,
+      server,
+      commandFilter: (name) => {
+        if (mcpCommandName && name === mcpCommandName) return false;
+        return userFilter ? userFilter(name) : true;
+      },
+      sanitizeToolName,
+    });
+
+    let transport: Transport;
+    if (createTransport) {
+      transport = await createTransport();
+    } else {
+      const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+      transport = new StdioServerTransport();
+    }
+
+    await server.connect(transport);
+  };
+}
+
 export function addCliToolsToMcp(options: AddCliToolsToMcpOptions): void {
   const { cli, commandFilter, sanitizeToolName = defaultSanitizeToolName } = options;
   const server = resolveServer(options.server);

package/src/index.ts

@@ -49,8 +49,8 @@ import yaml from "js-yaml";
 import { FileOAuthProvider } from "./oauth-provider.js";
 import { startOAuthFlow, isAuthRequiredError } from "./auth.js";
 import type { McpOAuthConfig, McpOAuthState } from "./types.js";
-export { addCliToolsToMcp } from "./cli-to-mcp.js";
-export type { AddCliToolsToMcpOptions } from "./cli-to-mcp.js";
+export { addCliToolsToMcp, createMcpAction } from "./cli-to-mcp.js";
+export type { AddCliToolsToMcpOptions, CreateMcpActionOptions } from "./cli-to-mcp.js";
 
 // Public exports - only types that consumers need
 export type { Transport };