@goke/mcp 0.1.0 → 0.1.2

package/README.md

@@ -95,6 +95,7 @@ const cli = goke("my-cli")
 cli
   .command("search", "Search pages")
   .option("--query <query>", z.string().describe("Search query"))
+  .required()
   .option("--limit [limit]", z.number().default(10).describe("Max results"))
   .action((options) => {
     return { results: findPages(options.query, options.limit) }
@@ -129,6 +130,8 @@ 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.
 
+**`inputSchema.required` is not the CLI `<value>` syntax.** `--query <query>` means the flag needs a value if it is present. The flag itself is still optional unless you chain `.required()`. Required **positionals** like `<env>` always go in `required`. `.required()` flags go in `required` too.
+
 ### 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:
@@ -194,13 +197,15 @@ addCliToolsToMcp({ cli, server: mcp })
 
 ## Multi-tenant remote MCP over HTTP
 
-When you expose a cli as a **remote** MCP (over `StreamableHTTPServerTransport`, SSE, or any other network transport), one server process handles many concurrent users. Each tool call must run against that user's own filesystem, working directory, environment, and stdin — otherwise tenants see each other's state and stdio writes trample the JSON-RPC channel.
+When you expose a cli as a **remote** MCP over HTTP, one process handles many concurrent users. Each request must run against that user's own filesystem, working directory, environment, and stdin — otherwise tenants see each other's state and stdio writes trample the JSON-RPC channel.
+
+Do **not** keep MCP session IDs. Streamable HTTP can run **stateless**: `sessionIdGenerator: undefined`. Each POST builds a fresh `Server` and transport, then closes them. That works on Cloudflare Workers and any other isolate that does not keep process memory.
 
 The recipe is:
 
 1. Define the cli **once**.
-2. On every HTTP POST, **clone** the cli with per-tenant `{ cwd, env, fs, stdin }` from the request auth (header, cookie, JWT). Mount it on a fresh `Server` via `addCliToolsToMcp({ cli: tenantClone, server })`.
-3. Inside command actions, always use the **injected** `ctx` (`ctx.fs`, `ctx.process.cwd`, `ctx.process.env`, `ctx.console.log`) instead of the Node globals. `@goke/mcp` wires each tool call into the tenant's cloned context, but only code that goes through `ctx` participates in that isolation.
+2. On **every POST**, resolve the tenant from the request (JWT, cookie, header), **clone** the cli with `{ cwd, env, fs }`, and mount it on a fresh `Server` via `addCliToolsToMcp({ cli: tenantClone, server })`.
+3. Inside command actions, always use the **injected** `ctx` — `ctx.fs`, `ctx.process.cwd`, `ctx.process.env`, `ctx.console.log` — instead of the Node globals. `@goke/mcp` wires each tool call into the tenant's cloned context, but only code that goes through `ctx` participates in that isolation.
 
 ### Write commands against `ctx`
 
@@ -235,7 +240,31 @@ cli
 
 The MCP SDK ships `WebStandardStreamableHTTPServerTransport`, which accepts a Web-Standard `Request` and returns a `Response`. That one shape plugs directly into **any** web framework that speaks web-standard: [Spiceflow](https://github.com/remorses/spiceflow), Cloudflare Workers, Deno, Bun, Next.js route handlers, SvelteKit endpoints, or a raw `fetch`-based handler. No Express, no `node:http` wiring, no framework lock-in.
 
-Do **not** keep a `Map` of transports keyed by `Mcp-Session-Id`. Tenant state lives in durable storage. Each POST clones the cli from the request auth.
+Pass `sessionIdGenerator: undefined` so the transport does not emit or expect `mcp-session-id`. Do not store transports in a `Map`. JSON-RPC `initialize`, `tools/list`, and `tools/call` are separate POSTs. Each one clones the cli from the request's tenant identity.
+
+This is MCP SDK v1 Streamable HTTP **without optional transport sessions** (protocol revisions through `2025-11-25`). It is not the later `2026-07-28` protocol, which drops `initialize`. Session IDs are optional in `2025-11-25`. Stateless servers omit them.
+
+The Streamable HTTP spec requires **Origin** checks on every request (DNS rebinding). Reject a present, disallowed `Origin` with **403**. Missing `Origin` is normal for non-browser MCP clients.
+
+```
+POST /mcp  (JWT / x-tenant-id)
+        │
+        v
+resolveTenant(id) ──> baseCli.clone({ cwd, env, fs })
+                           │
+                           v
+                    fresh Server + transport
+                    sessionIdGenerator: undefined
+                           │
+                           v
+addCliToolsToMcp ──> handleRequest
+                           │
+                           v
+                        Response
+                           │
+                           v
+             close transport + server ──> nothing stored
+```
 
 You build one `handleMcpRequest(request: Request): Promise<Response>` function and mount it wherever you route HTTP:
 
@@ -251,12 +280,20 @@ declare function resolveTenant(tenantId: string): {
   fs: GokeFs
 }
 
+declare function isAllowedOrigin(origin: string): boolean
+
 export async function handleMcpRequest(request: Request): Promise<Response> {
-  let parsedBody: unknown
-  if (request.method === "POST") {
-    parsedBody = await request.clone().json().catch(() => undefined)
+  const origin = request.headers.get("origin")
+  if (origin && !isAllowedOrigin(origin)) {
+    return new Response(null, { status: 403 })
+  }
+
+  if (request.method !== "POST") {
+    return new Response(null, { status: 405, headers: { Allow: "POST" } })
   }
 
+  const parsedBody = await request.clone().json().catch(() => undefined)
+
   const tenantId = request.headers.get("x-tenant-id")
   if (!tenantId) return new Response("missing x-tenant-id", { status: 401 })
   const tenant = resolveTenant(tenantId)
@@ -277,7 +314,6 @@ export async function handleMcpRequest(request: Request): Promise<Response> {
     sessionIdGenerator: undefined,
     enableJsonResponse: true,
   })
-
   await mcpServer.connect(transport)
   try {
     return await transport.handleRequest(request, { parsedBody })
@@ -320,7 +356,7 @@ export async function POST(request: Request) {
 
 **Key guarantees**
 
-- Every tool call on a request runs against `tenantCli`'s `cwd` / `env` / `fs`, not the base cli's and not another tenant's.
+- Every request runs against `tenantCli`'s `cwd` / `env` / `fs` — not the base cli's and not another tenant's.
 - `ctx.console.log` / `ctx.console.error` / `ctx.process.stdout.write` / `ctx.process.stderr.write` are captured into the `CallToolResult.content`. They never reach the host process stdio, so they can't corrupt the JSON-RPC channel or leak between users.
 - `ctx.process.exit(code)` throws `GokeProcessExit` instead of killing the server. The tool call resolves as `{ isError: code !== 0, content: [captured output] }` and the next request keeps running.
 - Actions that `throw` are caught and returned as `{ isError: true, content: [message, stderr] }`.
@@ -336,7 +372,7 @@ Only code that flows through `ctx` participates in the isolation. The following
 
 Port those to `ctx.fs`, `ctx.console`, `ctx.process.*` and you're multi-tenant-safe.
 
-For a runnable end-to-end example (including two concurrent in-memory-fs tenants writing separate files), see [`src/__test__/http-multi-tenant.test.ts`](./src/__test__/http-multi-tenant.test.ts).
+For a runnable end-to-end example (including two concurrent in-memory-fs tenants writing separate files, with a new server per POST), see [`src/__test__/http-multi-tenant.test.ts`](./src/__test__/http-multi-tenant.test.ts).
 
 ### Lower-level primitive: `cli.createExecutionContext(override)`
 

package/dist/__test__/add-cli-tools-to-mcp.test.js

@@ -15,6 +15,7 @@ function createCli() {
     cli
         .command("say hi", "Say hello")
         .option("--name <name>", z.string().describe("Person to greet"))
+        .required()
         .option("--caps", z.boolean().default(false).describe("Uppercase output"))
         .action((options) => {
         const message = `Hello ${options.name}!`;
@@ -178,11 +179,7 @@ describe("addCliToolsToMcp", () => {
                 "type": "number",
                 "description": "Right operand"
               }
-            },
-            "required": [
-              "left",
-              "right"
-            ]
+            }
           }
         },
         {
@@ -224,10 +221,7 @@ describe("addCliToolsToMcp", () => {
                 "type": "boolean",
                 "description": "Dry run flag"
               }
-            },
-            "required": [
-              "title"
-            ]
+            }
           }
         }
       ]"
@@ -280,11 +274,7 @@ describe("addCliToolsToMcp", () => {
                 "type": "number",
                 "description": "Right operand"
               }
-            },
-            "required": [
-              "left",
-              "right"
-            ]
+            }
           }
         },
         {
@@ -326,10 +316,7 @@ describe("addCliToolsToMcp", () => {
                 "type": "boolean",
                 "description": "Dry run flag"
               }
-            },
-            "required": [
-              "title"
-            ]
+            }
           }
         }
       ]"

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

@@ -29,7 +29,9 @@ describe("createMcpAction", () => {
         cli
             .command("add", "Add numbers")
             .option("--a <a>", z.number().describe("First"))
+            .required()
             .option("--b <b>", z.number().describe("Second"))
+            .required()
             .action((options) => ({ sum: options.a + options.b }));
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
         cli.command("mcp", "Start MCP server").action(createMcpAction({
@@ -186,7 +188,7 @@ describe("createMcpAction", () => {
             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"]);
+            expect(searchTool.inputSchema.required).toBeUndefined();
             const deployTool = tools.tools.find((t) => t.name === "deploy");
             expect(deployTool.inputSchema.properties).toHaveProperty("env");
             expect(deployTool.inputSchema.properties).toHaveProperty("dryRun");
@@ -229,6 +231,122 @@ describe("createMcpAction", () => {
             await client.close();
         }
     });
+    it("keeps --flag <value> in properties but not in required", async () => {
+        const cli = goke("strada");
+        cli
+            .command("projects create <slug>", "Create a project")
+            .option("--traces-days <days>", z.string().optional().describe("Traces retention days"))
+            .option("--logs-days <days>", z.string().optional().describe("Logs retention days"))
+            .option("--errors-days <days>", z.string().optional().describe("Errors retention days"))
+            .option("--metrics-days <days>", z.string().optional().describe("Metrics retention days"))
+            .option("--all-days <days>", z.string().optional().describe("Retention for all signals"))
+            .action((slug, options) => ({ slug, ...options }));
+        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();
+            const createTool = tools.tools.find((t) => t.name === "projects_create");
+            expect(createTool.inputSchema.properties).toHaveProperty("slug");
+            expect(createTool.inputSchema.properties).toHaveProperty("tracesDays");
+            expect(createTool.inputSchema.properties).toHaveProperty("logsDays");
+            expect(createTool.inputSchema.properties).toHaveProperty("allDays");
+            expect(createTool.inputSchema.required).toEqual(["slug"]);
+            const result = await client.callTool({
+                name: "projects_create",
+                arguments: { slug: "my-app" },
+            });
+            expect(firstTextContent(result)).toBe('{\n  "slug": "my-app"\n}');
+            await expect(client.callTool({
+                name: "projects_create",
+                arguments: {},
+            })).rejects.toThrow("Missing required argument: slug");
+        }
+        finally {
+            await client.close();
+        }
+    });
+    it("puts .required() --flag <value> in inputSchema.required", async () => {
+        const cli = goke("checks");
+        cli
+            .command("checks create", "Create a check")
+            .option("--url <url>", z.string().describe("URL to check"))
+            .required()
+            .option("--name <name>", z.string().describe("Check name"))
+            .required()
+            .option("--timeout [ms]", z.number().optional().describe("Timeout"))
+            .action((options) => options);
+        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();
+            const createTool = tools.tools.find((t) => t.name === "checks_create");
+            expect(createTool.inputSchema.properties).toHaveProperty("url");
+            expect(createTool.inputSchema.properties).toHaveProperty("name");
+            expect(createTool.inputSchema.properties).toHaveProperty("timeout");
+            expect(createTool.inputSchema.required).toEqual(["url", "name"]);
+            const result = await client.callTool({
+                name: "checks_create",
+                arguments: { url: "https://example.com", name: "home" },
+            });
+            expect(firstTextContent(result)).toContain("https://example.com");
+            await expect(client.callTool({
+                name: "checks_create",
+                arguments: { name: "home" },
+            })).rejects.toThrow("Missing required argument: url");
+        }
+        finally {
+            await client.close();
+        }
+    });
+    it("does not put wrapJsonSchema flags in required", async () => {
+        const cli = goke("wrapped");
+        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) => options);
+        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();
+            const setTool = tools.tools.find((t) => t.name === "config_set");
+            expect(setTool.inputSchema.properties).toHaveProperty("key");
+            expect(setTool.inputSchema.properties).toHaveProperty("value");
+            expect(setTool.inputSchema.required).toBeUndefined();
+            const result = await client.callTool({
+                name: "config_set",
+                arguments: {},
+            });
+            expect(firstTextContent(result)).toBe("{}");
+        }
+        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();

package/dist/__test__/http-multi-tenant.test.d.ts

@@ -1,10 +1,11 @@
 /**
  * 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). Isolation comes from the
- * `x-tenant-id` header on each POST, not from `Mcp-Session-Id`.
+ * Proves that one goke cli exposed over stateless MCP streamable HTTP
+ * can serve multiple concurrent users with fully isolated state
+ * (in-memory fs + cwd + env) — no shared host process stdio, no
+ * cross-tenant leaks, no mcp-session-id map. Isolation comes from
+ * the `x-tenant-id` header on each POST, not from `Mcp-Session-Id`.
  *
  * Wiring choices worth calling out:
  *
@@ -14,12 +15,15 @@
  *     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 HTTP POST gets a fresh transport with
- *     `sessionIdGenerator: undefined` and a cli **clone** via
+ *   - `sessionIdGenerator: undefined` is stateless mode. The
+ *     transport does not emit or expect `mcp-session-id`. Each
+ *     POST builds a fresh Server + transport, then closes them.
+ *   - `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 request 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

package/dist/__test__/http-multi-tenant.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-multi-tenant.test.d.ts","sourceRoot":"","sources":["../../src/__test__/http-multi-tenant.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG"}
+{"version":3,"file":"http-multi-tenant.test.d.ts","sourceRoot":"","sources":["../../src/__test__/http-multi-tenant.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG"}

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

@@ -1,10 +1,11 @@
 /**
  * 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). Isolation comes from the
- * `x-tenant-id` header on each POST, not from `Mcp-Session-Id`.
+ * Proves that one goke cli exposed over stateless MCP streamable HTTP
+ * can serve multiple concurrent users with fully isolated state
+ * (in-memory fs + cwd + env) — no shared host process stdio, no
+ * cross-tenant leaks, no mcp-session-id map. Isolation comes from
+ * the `x-tenant-id` header on each POST, not from `Mcp-Session-Id`.
  *
  * Wiring choices worth calling out:
  *
@@ -14,12 +15,15 @@
  *     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 HTTP POST gets a fresh transport with
- *     `sessionIdGenerator: undefined` and a cli **clone** via
+ *   - `sessionIdGenerator: undefined` is stateless mode. The
+ *     transport does not emit or expect `mcp-session-id`. Each
+ *     POST builds a fresh Server + transport, then closes them.
+ *   - `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 request 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
@@ -86,6 +90,7 @@ function buildBaseCli() {
     cli
         .command("save <filename>", "Save content to a file in the tenant workspace")
         .option("--content <content>", z.string().describe("File content"))
+        .required()
         .action(async (filename, options, ctx) => {
         const full = path.posix.join(ctx.process.cwd, filename);
         await ctx.fs.writeFile(full, options.content);
@@ -101,9 +106,10 @@ function buildBaseCli() {
     return cli;
 }
 /**
- * Build a `FetchLike` that serves MCP streamable-HTTP traffic with a
- * fresh transport + cli clone on every POST. Tenant identity comes
- * from `x-tenant-id`. There is no `mcp-session-id` map.
+ * Build a `FetchLike` that handles each MCP POST with a fresh
+ * `WebStandardStreamableHTTPServerTransport` and cli clone.
+ * Tenant identity comes from `x-tenant-id` on every request.
+ * Nothing is keyed by `mcp-session-id`.
  */
 function createMultiTenantFetch(options) {
     const { baseCli, resolveTenant } = options;
@@ -115,17 +121,15 @@ function createMultiTenantFetch(options) {
         if (sessionHeader) {
             sessionHeaders.push(sessionHeader);
         }
-        // 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 });
+        const origin = headers.get("origin");
+        if (origin && origin !== "http://in-memory-mcp.test") {
+            return new Response(null, { status: 403 });
+        }
+        if (method !== "POST") {
+            return new Response(null, { status: 405, headers: { Allow: "POST" } });
         }
-        // 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) {
+        if (init?.body != null) {
             const rawBody = init.body;
             const bodyText = typeof rawBody === "string"
                 ? rawBody
@@ -155,10 +159,13 @@ function createMultiTenantFetch(options) {
             enableJsonResponse: true,
         });
         await mcpServer.connect(transport);
-        const response = await transport.handleRequest(request, { parsedBody });
-        await transport.close();
-        await mcpServer.close();
-        return response;
+        try {
+            return await transport.handleRequest(request, { parsedBody });
+        }
+        finally {
+            await transport.close();
+            await mcpServer.close();
+        }
     };
     return { fetch: customFetch, sessionHeaders };
 }
@@ -186,8 +193,6 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
                 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, {
@@ -213,15 +218,10 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
         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 request clones the cli with that tenant's
-            // cwd + fs, the writes land in separate Maps.
             const aliceSave = await aliceClient.callTool({
                 name: "save",
                 arguments: { filename: "notes.txt", content: "alice-secret" },
@@ -234,7 +234,6 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
             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" },
@@ -247,8 +246,6 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
             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"]);
@@ -277,4 +274,22 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
             await bobClient.close();
         }
     });
+    it("rejects a present Origin that is not allowed", async () => {
+        const { fetch } = createMultiTenantFetch({
+            baseCli: buildBaseCli(),
+            resolveTenant: () => {
+                throw new Error("tenant must not be resolved for a forbidden origin");
+            },
+        });
+        const response = await fetch("http://in-memory-mcp.test/mcp", {
+            method: "POST",
+            headers: {
+                origin: "https://evil.example",
+                "x-tenant-id": "tenant-a",
+                "content-type": "application/json",
+            },
+            body: "{}",
+        });
+        expect(response.status).toBe(403);
+    });
 });

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,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"}
+{"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;AAyFd,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;AAufD,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

@@ -359,10 +359,12 @@ function createBinding(cli, command, toolName) {
             requiredNames.push(arg.value);
         }
     }
+    // `--days <days>` means "value required if the flag is present". The flag
+    // itself is required only when `.required()` set `flagRequired`.
     for (const option of options) {
         const normalized = normalizeOptionSchema(option);
         properties[option.name] = normalized.schema;
-        if (option.required) {
+        if (option.flagRequired && option.default === undefined) {
             requiredNames.push(option.name);
         }
         optionBindings.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goke/mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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.15.1"
+    "goke": "^6.17.0"
   },
   "scripts": {
     "clean": "rm -rf dist",

package/src/__test__/add-cli-tools-to-mcp.test.ts

@@ -18,6 +18,7 @@ function createCli() {
   cli
     .command("say hi", "Say hello")
     .option("--name <name>", z.string().describe("Person to greet"))
+    .required()
     .option("--caps", z.boolean().default(false).describe("Uppercase output"))
     .action((options) => {
       const message = `Hello ${options.name}!`;
@@ -219,11 +220,7 @@ describe("addCliToolsToMcp", () => {
                 "type": "number",
                 "description": "Right operand"
               }
-            },
-            "required": [
-              "left",
-              "right"
-            ]
+            }
           }
         },
         {
@@ -265,10 +262,7 @@ describe("addCliToolsToMcp", () => {
                 "type": "boolean",
                 "description": "Dry run flag"
               }
-            },
-            "required": [
-              "title"
-            ]
+            }
           }
         }
       ]"
@@ -325,11 +319,7 @@ describe("addCliToolsToMcp", () => {
                 "type": "number",
                 "description": "Right operand"
               }
-            },
-            "required": [
-              "left",
-              "right"
-            ]
+            }
           }
         },
         {
@@ -371,10 +361,7 @@ describe("addCliToolsToMcp", () => {
                 "type": "boolean",
                 "description": "Dry run flag"
               }
-            },
-            "required": [
-              "title"
-            ]
+            }
           }
         }
       ]"

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

@@ -35,7 +35,9 @@ describe("createMcpAction", () => {
     cli
       .command("add", "Add numbers")
       .option("--a <a>", z.number().describe("First"))
+      .required()
       .option("--b <b>", z.number().describe("Second"))
+      .required()
       .action((options) => ({ sum: options.a + options.b }));
 
     const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
@@ -238,7 +240,7 @@ describe("createMcpAction", () => {
       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"]);
+      expect(searchTool.inputSchema.required).toBeUndefined();
 
       const deployTool = tools.tools.find((t) => t.name === "deploy")!;
       expect(deployTool.inputSchema.properties).toHaveProperty("env");
@@ -292,6 +294,155 @@ describe("createMcpAction", () => {
     }
   });
 
+  it("keeps --flag <value> in properties but not in required", async () => {
+    const cli = goke("strada");
+
+    cli
+      .command("projects create <slug>", "Create a project")
+      .option("--traces-days <days>", z.string().optional().describe("Traces retention days"))
+      .option("--logs-days <days>", z.string().optional().describe("Logs retention days"))
+      .option("--errors-days <days>", z.string().optional().describe("Errors retention days"))
+      .option("--metrics-days <days>", z.string().optional().describe("Metrics retention days"))
+      .option("--all-days <days>", z.string().optional().describe("Retention for all signals"))
+      .action((slug, options) => ({ slug, ...options }));
+
+    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();
+      const createTool = tools.tools.find((t) => t.name === "projects_create")!;
+      expect(createTool.inputSchema.properties).toHaveProperty("slug");
+      expect(createTool.inputSchema.properties).toHaveProperty("tracesDays");
+      expect(createTool.inputSchema.properties).toHaveProperty("logsDays");
+      expect(createTool.inputSchema.properties).toHaveProperty("allDays");
+      expect(createTool.inputSchema.required).toEqual(["slug"]);
+
+      const result = await client.callTool({
+        name: "projects_create",
+        arguments: { slug: "my-app" },
+      });
+      expect(firstTextContent(result)).toBe('{\n  "slug": "my-app"\n}');
+
+      await expect(
+        client.callTool({
+          name: "projects_create",
+          arguments: {},
+        }),
+      ).rejects.toThrow("Missing required argument: slug");
+    } finally {
+      await client.close();
+    }
+  });
+
+  it("puts .required() --flag <value> in inputSchema.required", async () => {
+    const cli = goke("checks");
+
+    cli
+      .command("checks create", "Create a check")
+      .option("--url <url>", z.string().describe("URL to check"))
+      .required()
+      .option("--name <name>", z.string().describe("Check name"))
+      .required()
+      .option("--timeout [ms]", z.number().optional().describe("Timeout"))
+      .action((options) => options);
+
+    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();
+      const createTool = tools.tools.find((t) => t.name === "checks_create")!;
+      expect(createTool.inputSchema.properties).toHaveProperty("url");
+      expect(createTool.inputSchema.properties).toHaveProperty("name");
+      expect(createTool.inputSchema.properties).toHaveProperty("timeout");
+      expect(createTool.inputSchema.required).toEqual(["url", "name"]);
+
+      const result = await client.callTool({
+        name: "checks_create",
+        arguments: { url: "https://example.com", name: "home" },
+      });
+      expect(firstTextContent(result)).toContain("https://example.com");
+
+      await expect(
+        client.callTool({
+          name: "checks_create",
+          arguments: { name: "home" },
+        }),
+      ).rejects.toThrow("Missing required argument: url");
+    } finally {
+      await client.close();
+    }
+  });
+
+  it("does not put wrapJsonSchema flags in required", async () => {
+    const cli = goke("wrapped");
+
+    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) => options);
+
+    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();
+      const setTool = tools.tools.find((t) => t.name === "config_set")!;
+      expect(setTool.inputSchema.properties).toHaveProperty("key");
+      expect(setTool.inputSchema.properties).toHaveProperty("value");
+      expect(setTool.inputSchema.required).toBeUndefined();
+
+      const result = await client.callTool({
+        name: "config_set",
+        arguments: {},
+      });
+      expect(firstTextContent(result)).toBe("{}");
+    } finally {
+      await client.close();
+    }
+  });
+
   it("returns empty tool list when only the mcp command exists", async () => {
     const cli = goke("empty-app");
 

package/src/__test__/http-multi-tenant.test.ts

@@ -1,10 +1,11 @@
 /**
  * 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). Isolation comes from the
- * `x-tenant-id` header on each POST, not from `Mcp-Session-Id`.
+ * Proves that one goke cli exposed over stateless MCP streamable HTTP
+ * can serve multiple concurrent users with fully isolated state
+ * (in-memory fs + cwd + env) — no shared host process stdio, no
+ * cross-tenant leaks, no mcp-session-id map. Isolation comes from
+ * the `x-tenant-id` header on each POST, not from `Mcp-Session-Id`.
  *
  * Wiring choices worth calling out:
  *
@@ -14,12 +15,15 @@
  *     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 HTTP POST gets a fresh transport with
- *     `sessionIdGenerator: undefined` and a cli **clone** via
+ *   - `sessionIdGenerator: undefined` is stateless mode. The
+ *     transport does not emit or expect `mcp-session-id`. Each
+ *     POST builds a fresh Server + transport, then closes them.
+ *   - `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 request 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
@@ -100,6 +104,7 @@ function buildBaseCli(): Goke {
   cli
     .command("save <filename>", "Save content to a file in the tenant workspace")
     .option("--content <content>", z.string().describe("File content"))
+    .required()
     .action(async (filename: string, options: { content: string }, ctx) => {
       const full = path.posix.join(ctx.process.cwd, filename);
       await ctx.fs.writeFile(full, options.content);
@@ -120,8 +125,8 @@ function buildBaseCli(): Goke {
 // ─── In-process multi-tenant fetch ────────────────────────────────
 
 /**
- * Per-tenant state resolved from the `x-tenant-id` header on each
- * request. Each tenant gets its own cwd, env, and in-memory fs.
+ * Per-tenant state resolved from the `x-tenant-id` header on every
+ * POST. Each tenant gets its own cwd, env, and in-memory fs.
  */
 interface TenantState {
   cwd: string;
@@ -130,9 +135,10 @@ interface TenantState {
 }
 
 /**
- * Build a `FetchLike` that serves MCP streamable-HTTP traffic with a
- * fresh transport + cli clone on every POST. Tenant identity comes
- * from `x-tenant-id`. There is no `mcp-session-id` map.
+ * Build a `FetchLike` that handles each MCP POST with a fresh
+ * `WebStandardStreamableHTTPServerTransport` and cli clone.
+ * Tenant identity comes from `x-tenant-id` on every request.
+ * Nothing is keyed by `mcp-session-id`.
  */
 function createMultiTenantFetch(options: {
   baseCli: Goke;
@@ -152,18 +158,17 @@ function createMultiTenantFetch(options: {
       sessionHeaders.push(sessionHeader);
     }
 
-    // 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 });
+    const origin = headers.get("origin");
+    if (origin && origin !== "http://in-memory-mcp.test") {
+      return new Response(null, { status: 403 });
+    }
+
+    if (method !== "POST") {
+      return new Response(null, { status: 405, headers: { Allow: "POST" } });
     }
 
-    // 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: unknown = undefined;
-    if (method === "POST" && init?.body != null) {
+    if (init?.body != null) {
       const rawBody = init.body;
       const bodyText = typeof rawBody === "string"
         ? rawBody
@@ -202,10 +207,12 @@ function createMultiTenantFetch(options: {
     });
 
     await mcpServer.connect(transport);
-    const response = await transport.handleRequest(request, { parsedBody });
-    await transport.close();
-    await mcpServer.close();
-    return response;
+    try {
+      return await transport.handleRequest(request, { parsedBody });
+    } finally {
+      await transport.close();
+      await mcpServer.close();
+    }
   };
 
   return { fetch: customFetch, sessionHeaders };
@@ -237,8 +244,6 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
       },
     });
 
-    // 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: string): Promise<Client> {
@@ -273,16 +278,11 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
     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 request clones the cli with that tenant's
-      // cwd + fs, the writes land in separate Maps.
       const aliceSave = await aliceClient.callTool({
         name: "save",
         arguments: { filename: "notes.txt", content: "alice-secret" },
@@ -297,7 +297,6 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
       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" },
@@ -312,8 +311,6 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
       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"]);
@@ -342,4 +339,25 @@ describe("remote MCP over streamable HTTP with multi-tenant in-memory fs", () =>
       await bobClient.close();
     }
   });
+
+  it("rejects a present Origin that is not allowed", async () => {
+    const { fetch } = createMultiTenantFetch({
+      baseCli: buildBaseCli(),
+      resolveTenant: () => {
+        throw new Error("tenant must not be resolved for a forbidden origin");
+      },
+    });
+
+    const response = await fetch("http://in-memory-mcp.test/mcp", {
+      method: "POST",
+      headers: {
+        origin: "https://evil.example",
+        "x-tenant-id": "tenant-a",
+        "content-type": "application/json",
+      },
+      body: "{}",
+    });
+
+    expect(response.status).toBe(403);
+  });
 });

package/src/cli-to-mcp.ts

@@ -40,6 +40,7 @@ interface OptionLike {
   description: string;
   default?: unknown;
   required?: boolean;
+  flagRequired?: boolean;
   isBoolean?: boolean;
   schema?: StandardJSONSchemaV1;
 }
@@ -503,11 +504,13 @@ function createBinding(cli: Goke, command: Command, toolName: string): CliToolBi
     }
   }
 
+  // `--days <days>` means "value required if the flag is present". The flag
+  // itself is required only when `.required()` set `flagRequired`.
   for (const option of options) {
     const normalized = normalizeOptionSchema(option);
     properties[option.name] = normalized.schema;
 
-    if (option.required) {
+    if (option.flagRequired && option.default === undefined) {
       requiredNames.push(option.name);
     }