argsbarg 3.6.4 → 4.0.0

package/src/mcp/server.ts

@@ -3,8 +3,9 @@ This module implements the MCP JSON-RPC server over stdio: initialize, tools,
 resources, and ping. Responses are newline-delimited JSON on stdout only.
 */
 
-import { cliInvoke } from "../invoke.ts";
-import type { CliProgram } from "../types.ts";
+import type { Cli } from "../cli.ts";
+import { bootstrapAppConfig } from "../config/bootstrap.ts";
+import { formatMcpMissingConfigMessage, missingRequiredConfig } from "../config/resolve.ts";
 import { buildToolCallSuccess } from "./result.ts";
 import {
   allMcpResources,
@@ -41,7 +42,8 @@ function writeError(id: string | number | null | undefined, code: number, messag
 }
 
 /** Handles one NDJSON request line. */
-async function handleRequestLine(root: CliProgram, line: string): Promise<void> {
+async function handleRequestLine(cli: Cli, line: string): Promise<void> {
+  const root = cli.program;
   let req: JsonRpcRequest;
   try {
     req = JSON.parse(line) as JsonRpcRequest;
@@ -121,13 +123,19 @@ async function handleRequestLine(root: CliProgram, line: string): Promise<void>
         writeError(id, -32602, `Unknown tool: ${name}`);
         return;
       }
-      const missingEnv = (tool.leaf.mcpTool?.requiresEnv ?? []).filter((k) => !process.env[k]);
-      if (missingEnv.length > 0) {
+      const { resolved } = bootstrapAppConfig(root, { validateFile: false });
+      const missingConfig = missingRequiredConfig(root, resolved);
+      if (missingConfig.length > 0) {
         writeResponse({
           jsonrpc: "2.0",
           id,
           result: {
-            content: [{ type: "text", text: `Missing required env: ${missingEnv.join(", ")}` }],
+            content: [
+              {
+                type: "text",
+                text: formatMcpMissingConfigMessage(root, missingConfig),
+              },
+            ],
             isError: true,
           },
         });
@@ -145,7 +153,7 @@ async function handleRequestLine(root: CliProgram, line: string): Promise<void>
         });
         return;
       }
-      const invokeResult = await cliInvoke(root, argvResult);
+      const invokeResult = await cli.invoke(argvResult);
       if (invokeResult.kind === "ok" && invokeResult.exitCode === 0) {
         writeResponse({
           jsonrpc: "2.0",
@@ -222,7 +230,7 @@ async function handleRequestLine(root: CliProgram, line: string): Promise<void>
 }
 
 /** Runs the MCP NDJSON read loop on stdin until EOF. */
-export async function mcpServeStdioLoop(root: CliProgram): Promise<void> {
+export async function mcpServeStdioLoop(cli: Cli): Promise<void> {
   let buffer = "";
   for await (const chunk of Bun.stdin.stream()) {
     buffer += new TextDecoder().decode(chunk);
@@ -234,12 +242,12 @@ export async function mcpServeStdioLoop(root: CliProgram): Promise<void> {
         nl = buffer.indexOf("\n");
         continue;
       }
-      await handleRequestLine(root, line);
+      await handleRequestLine(cli, line);
       nl = buffer.indexOf("\n");
     }
   }
   const trailing = buffer.trim();
   if (trailing.length > 0) {
-    await handleRequestLine(root, trailing);
+    await handleRequestLine(cli, trailing);
   }
 }

package/src/mcp/tools.ts

@@ -1,6 +1,6 @@
 /*
 This module maps CliProgram leaf nodes to MCP tool definitions and converts
-flat JSON tool arguments into argv for cliInvoke.
+flat JSON tool arguments into argv for Cli.invoke.
 */
 
 import { cliResolveNotes } from "../help.ts";
@@ -168,17 +168,13 @@ function buildInputSchema(
   return schema;
 }
 
-/** Resolves MCP tool description with optional override, requiresEnv suffix, and leaf notes. */
+/** Resolves MCP tool description with optional override and leaf notes. */
 function resolveToolDescription(root: CliProgram, path: string[], leaf: CliLeaf): string {
   let desc: string;
   if (leaf.mcpTool?.description) {
     desc = leaf.mcpTool.description;
   } else {
     desc = mcpToolDescription(path, root.key, leaf.description);
-    const env = leaf.mcpTool?.requiresEnv;
-    if (env && env.length > 0) {
-      desc += ` [requires env: ${env.join(", ")}]`;
-    }
   }
   const notes = (leaf.notes ?? "").trim();
   if (notes.length > 0) {
@@ -277,7 +273,7 @@ export function resolveMcpSchemaUri(root: CliProgram): string {
   return defaultMcpSchemaUri(mcpServerId(root));
 }
 
-/** Converts flat MCP tool arguments to argv for cliInvoke. */
+/** Converts flat MCP tool arguments to argv for Cli.invoke. */
 export function mcpToolCallToArgv(
   root: CliProgram,
   tool: McpToolDef,

package/src/mcp/zip.ts

@@ -0,0 +1,82 @@
+/*
+Minimal ZIP writer (store method, no compression) for MCPB and Claude plugin bundles.
+*/
+
+/** CRC-32 for ZIP local headers. */
+function crc32(data: Buffer): number {
+  let crc = 0xffffffff;
+  for (let i = 0; i < data.length; i++) {
+    const byte = data[i];
+    if (byte === undefined) {
+      continue;
+    }
+    crc ^= byte;
+    for (let j = 0; j < 8; j++) {
+      crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+    }
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+/** Writes a minimal ZIP (store, no compression) with one or more files. */
+export function zipStore(files: { name: string; data: Buffer }[]): Buffer {
+  const parts: Buffer[] = [];
+  const central: Buffer[] = [];
+  let offset = 0;
+
+  for (const file of files) {
+    const nameBuf = Buffer.from(file.name, "utf8");
+    const crc = crc32(file.data);
+    const local = Buffer.alloc(30 + nameBuf.length);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(0, 6);
+    local.writeUInt16LE(0, 8);
+    local.writeUInt16LE(0, 10);
+    local.writeUInt16LE(0, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(file.data.length, 18);
+    local.writeUInt32LE(file.data.length, 22);
+    local.writeUInt32LE(nameBuf.length, 26);
+    local.writeUInt16LE(0, 28);
+    nameBuf.copy(local, 30);
+
+    const centralHdr = Buffer.alloc(46 + nameBuf.length);
+    centralHdr.writeUInt32LE(0x02014b50, 0);
+    centralHdr.writeUInt16LE(20, 4);
+    centralHdr.writeUInt16LE(20, 6);
+    centralHdr.writeUInt16LE(0, 8);
+    centralHdr.writeUInt16LE(0, 10);
+    centralHdr.writeUInt16LE(0, 12);
+    centralHdr.writeUInt16LE(0, 14);
+    centralHdr.writeUInt32LE(crc, 16);
+    centralHdr.writeUInt32LE(file.data.length, 20);
+    centralHdr.writeUInt32LE(file.data.length, 24);
+    centralHdr.writeUInt32LE(nameBuf.length, 28);
+    centralHdr.writeUInt16LE(0, 30);
+    centralHdr.writeUInt16LE(0, 32);
+    centralHdr.writeUInt16LE(0, 34);
+    centralHdr.writeUInt16LE(0, 36);
+    centralHdr.writeUInt32LE(0, 38);
+    centralHdr.writeUInt32LE(offset, 42);
+    nameBuf.copy(centralHdr, 46);
+
+    parts.push(local, file.data);
+    central.push(centralHdr);
+    offset += local.length + file.data.length;
+  }
+
+  const centralStart = offset;
+  const centralBuf = Buffer.concat(central);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(0, 4);
+  end.writeUInt16LE(0, 6);
+  end.writeUInt16LE(files.length, 8);
+  end.writeUInt16LE(files.length, 10);
+  end.writeUInt32LE(centralBuf.length, 12);
+  end.writeUInt32LE(centralStart, 16);
+  end.writeUInt16LE(0, 20);
+
+  return Buffer.concat([...parts, centralBuf, end]);
+}

package/src/mcp.integration.test.ts

@@ -0,0 +1,502 @@
+/*
+Domain-specific regression tests (split from index.test.ts).
+*/
+
+import { expect, test } from "bun:test";
+import { join } from "node:path";
+import { $ } from "bun";
+import type { CliProgram } from "./index.ts";
+import { buildToolCallSuccess } from "./mcp/result.ts";
+import {
+  collectMcpTools,
+  mcpToolCallToArgv,
+  mcpToolDescription,
+  sanitizeToolSegment,
+} from "./mcp/tools.ts";
+import { cliSchemaExport } from "./schema.ts";
+import { mcpRequest, nestedMcpFixture, testProgram } from "./test-fixtures.ts";
+import { cliValidateProgram } from "./validate.ts";
+
+test("sanitizeToolSegment normalizes dotted app keys", () => {
+  expect(sanitizeToolSegment("minimal.ts")).toBe("minimal_ts");
+});
+
+test("mcpToolDescription formats CLI path and root-leaf prefix", () => {
+  expect(mcpToolDescription(["stat", "owner", "lookup"], "nested.ts", "Resolve owner info.")).toBe(
+    "stat owner lookup — Resolve owner info.",
+  );
+  expect(mcpToolDescription(["read"], "nested.ts", "Print files.")).toBe("read — Print files.");
+  expect(mcpToolDescription([], "helloapp", "Tiny demo.")).toBe("helloapp — Tiny demo.");
+});
+
+test("collectMcpTools lists user leaf commands only", () => {
+  const tools = collectMcpTools(nestedMcpFixture);
+  const names = tools.map((t) => t.name);
+  expect(names).toContain("stat_owner_lookup");
+  expect(names).toContain("read");
+  expect(names).not.toContain("hidden");
+  expect(names).not.toContain("install");
+  expect(names).not.toContain("mcp");
+  expect(names).not.toContain("completion");
+  const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
+  expect(lookup.description).toBe("stat owner lookup — Resolve owner info.");
+});
+
+test("collectMcpTools appends leaf notes to MCP tool description", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Notes demo.",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        notes: "Use `--json` for structured output.",
+        handler: () => {},
+      },
+    ],
+  });
+  const tools = collectMcpTools(root);
+  expect(tools[0]?.description).toBe("run — Run.\n\nUse `--json` for structured output.");
+});
+
+test("collectMcpTools appends notes after mcpTool.description override", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Notes demo.",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        notes: "Operational hint.",
+        mcpTool: { description: "Custom MCP text." },
+        handler: () => {},
+      },
+    ],
+  });
+  const tools = collectMcpTools(root);
+  expect(tools[0]?.description).toBe("Custom MCP text.\n\nOperational hint.");
+});
+
+test("collectMcpTools resolves {argsbarg:program} in appended notes", () => {
+  const root = testProgram({
+    key: "myapp",
+    version: "1.0.0",
+    description: "Notes demo.",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        notes: "See `{argsbarg:program} docs api`.",
+        handler: () => {},
+      },
+    ],
+  });
+  const tools = collectMcpTools(root);
+  expect(tools[0]?.description).toContain("See `myapp docs api`.");
+});
+
+test("cliSchemaExport includes leaf outputSchema", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Schema export demo.",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        outputSchema: {
+          type: "object",
+          properties: { ok: { type: "boolean" } },
+        },
+        handler: () => {},
+      },
+    ],
+  });
+  const schema = cliSchemaExport(root);
+  expect(schema.commands?.[0]?.outputSchema).toEqual({
+    type: "object",
+    properties: { ok: { type: "boolean" } },
+  });
+});
+
+test("cliSchemaExport accepts legacy mcpTool.outputSchema", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Schema export demo.",
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        mcpTool: {
+          outputSchema: { type: "object", properties: { id: { type: "string" } } },
+        },
+        handler: () => {},
+      },
+    ],
+  });
+  expect(cliSchemaExport(root).commands?.[0]?.outputSchema).toEqual({
+    type: "object",
+    properties: { id: { type: "string" } },
+  });
+});
+
+test("outputSchema must be a JSON Schema object", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Bad output schema.",
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        outputSchema: [] as unknown as Record<string, unknown>,
+        handler: () => {},
+      },
+    ],
+  });
+  expect(() => cliValidateProgram(root)).toThrow(/outputSchema must be a JSON Schema object/);
+});
+
+test("outputSchema cannot be set on both leaf and mcpTool", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Duplicate output schema.",
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        outputSchema: { type: "object" },
+        mcpTool: { outputSchema: { type: "object" } },
+        handler: () => {},
+      },
+    ],
+  });
+  expect(() => cliValidateProgram(root)).toThrow(/Set outputSchema on the leaf only/);
+});
+
+test("collectMcpTools merges parent options into inputSchema", () => {
+  const tools = collectMcpTools(nestedMcpFixture);
+  const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
+  const schema = lookup.inputSchema as { properties: Record<string, unknown>; required?: string[] };
+  expect(schema.properties.json).toBeDefined();
+  expect(schema.required).toContain("path");
+});
+
+test("collectMcpTools includes outputSchema when set on leaf", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Output schema demo.",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "run",
+        description: "Run with JSON output.",
+        outputSchema: {
+          type: "object",
+          properties: { ok: { type: "boolean" } },
+          required: ["ok"],
+        },
+        handler: () => {},
+      },
+    ],
+  });
+  const tools = collectMcpTools(root);
+  expect(tools).toHaveLength(1);
+  expect(tools[0]?.outputSchema).toEqual({
+    type: "object",
+    properties: { ok: { type: "boolean" } },
+    required: ["ok"],
+  });
+});
+
+test("collectMcpTools omits outputSchema when leaf has none", () => {
+  const tools = collectMcpTools(nestedMcpFixture);
+  const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
+  expect(lookup.outputSchema).toBeUndefined();
+});
+
+test("mcpToolCallToArgv builds nested lookup argv", () => {
+  const tools = collectMcpTools(nestedMcpFixture);
+  const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
+  const argv = mcpToolCallToArgv(nestedMcpFixture, lookup, {
+    "user-name": "alice",
+    path: "./x",
+    json: true,
+  });
+  expect(argv).toEqual(["stat", "owner", "lookup", "--json", "--user-name", "alice", "./x"]);
+});
+
+test("mcpToolCallToArgv expands varargs positionals", () => {
+  const tools = collectMcpTools(nestedMcpFixture);
+  const read = tools.find((t) => t.name === "read")!;
+  const argv = mcpToolCallToArgv(nestedMcpFixture, read, { files: ["a", "b"] });
+  expect(argv).toEqual(["read", "a", "b"]);
+});
+
+test("reserved command name install is rejected", () => {
+  const root = testProgram({
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "install",
+        description: "bad",
+        handler: () => {},
+      },
+    ],
+  });
+  expect(() => cliValidateProgram(root)).toThrow(/Reserved command name: install/);
+});
+
+test("top-level command name mcp is allowed without mcpServer", () => {
+  const root = testProgram({
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "mcp",
+        description: "user command",
+        handler: () => {},
+      },
+    ],
+  });
+  expect(() => cliValidateProgram(root)).not.toThrow();
+});
+
+test("top-level command name mcp is rejected when mcpServer is enabled", () => {
+  const root = testProgram({
+    key: "app",
+    description: "",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "mcp",
+        description: "user command",
+        handler: () => {},
+      },
+    ],
+  });
+  expect(() => cliValidateProgram(root)).toThrow(/Reserved command name: mcp/);
+});
+
+test("mcpServer on non-root node is rejected", () => {
+  const root = {
+    key: "app",
+    version: "0.0.0",
+    description: "",
+    commands: [
+      {
+        key: "x",
+        description: "cmd",
+        mcpServer: { enabled: true },
+        handler: () => {},
+      },
+    ],
+  } as unknown as CliProgram;
+  expect(() => cliValidateProgram(root)).toThrow(/mcpServer is only supported on the program root/);
+});
+
+test("mcpTool on root is rejected", () => {
+  const root = testProgram({
+    key: "app",
+    description: "",
+    mcpTool: { enabled: false },
+    handler: () => {},
+  });
+  expect(() => cliValidateProgram(root)).toThrow(/mcpTool is only supported on leaf commands/);
+});
+
+test("mcpTool on routing node is rejected", () => {
+  const root = testProgram({
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "group",
+        description: "group",
+        mcpTool: { enabled: false },
+        commands: [
+          {
+            key: "leaf",
+            description: "leaf",
+            handler: () => {},
+          },
+        ],
+      },
+    ],
+  });
+  expect(() => cliValidateProgram(root)).toThrow(/mcpTool is only supported on leaf commands/);
+});
+
+test("buildToolCallSuccess returns stdout only", () => {
+  const result = buildToolCallSuccess("hello\n", "");
+  expect(result.isError).toBe(false);
+  expect(result.content).toEqual([{ type: "text", text: "hello\n" }]);
+  expect(result.structuredContent).toBeUndefined();
+});
+
+test("buildToolCallSuccess adds stderr as second content block", () => {
+  const result = buildToolCallSuccess("out\n", "warn\n");
+  expect(result.content).toEqual([
+    { type: "text", text: "out\n" },
+    { type: "text", text: "warn" },
+  ]);
+  expect(result.structuredContent).toBeUndefined();
+});
+
+test("buildToolCallSuccess stderr-only still includes stdout slot", () => {
+  const result = buildToolCallSuccess("", "warn\n");
+  expect(result.content).toEqual([
+    { type: "text", text: "" },
+    { type: "text", text: "warn" },
+  ]);
+});
+
+test("buildToolCallSuccess parses JSON structuredContent", () => {
+  const result = buildToolCallSuccess('{"a":1}\n', "");
+  expect(result.structuredContent).toEqual({ a: 1 });
+  expect(result.content[0]?.text).toBe('{"a":1}\n');
+});
+
+test("buildToolCallSuccess skips structuredContent for plain text", () => {
+  const result = buildToolCallSuccess("lookup user=x\n", "");
+  expect(result.structuredContent).toBeUndefined();
+});
+
+test("buildToolCallSuccess parses JSON primitives", () => {
+  const result = buildToolCallSuccess("true\n", "");
+  expect(result.structuredContent).toBe(true);
+});
+
+test("MCP initialize returns tools and resources capabilities", async () => {
+  const responses = await mcpRequest([{ jsonrpc: "2.0", id: 1, method: "initialize", params: {} }]);
+  const res = responses.get(1) as { result: { capabilities: Record<string, unknown> } };
+  expect(res.result.capabilities.tools).toBeDefined();
+  expect(res.result.capabilities.resources).toBeDefined();
+});
+
+test("MCP tools/list includes stat_owner_lookup", async () => {
+  const responses = await mcpRequest([{ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} }]);
+  const res = responses.get(2) as {
+    result: { tools: { name: string; inputSchema: { required?: string[] } }[] };
+  };
+  const lookup = res.result.tools.find((t) => t.name === "stat_owner_lookup");
+  expect(lookup).toBeDefined();
+  expect(lookup?.inputSchema.required).toContain("path");
+});
+
+test("MCP resources/read returns schema JSON", async () => {
+  const responses = await mcpRequest([
+    { jsonrpc: "2.0", id: 3, method: "resources/read", params: { uri: "nested_ts://schema" } },
+  ]);
+  const res = responses.get(3) as { result: { contents: { text: string }[] } };
+  const schema = JSON.parse(res.result.contents[0]?.text);
+  expect(schema.key).toBe("nested.ts");
+});
+
+test("MCP tools/call runs stat_owner_lookup", async () => {
+  const readme = join(import.meta.dir, "..", "README.md");
+  const responses = await mcpRequest([
+    {
+      jsonrpc: "2.0",
+      id: 4,
+      method: "tools/call",
+      params: {
+        name: "stat_owner_lookup",
+        arguments: { path: readme, "user-name": "test" },
+      },
+    },
+  ]);
+  const res = responses.get(4) as { result: { content: { text: string }[]; isError: boolean } };
+  expect(res.result.isError).toBe(false);
+  expect(res.result.content[0]?.text).toContain("lookup user=test");
+});
+
+test("MCP tools/call returns structuredContent for JSON stdout", async () => {
+  const readme = join(import.meta.dir, "..", "README.md");
+  const responses = await mcpRequest([
+    {
+      jsonrpc: "2.0",
+      id: 6,
+      method: "tools/call",
+      params: {
+        name: "stat_owner_lookup",
+        arguments: { path: readme, "user-name": "test", json: true },
+      },
+    },
+  ]);
+  const res = responses.get(6) as {
+    result: {
+      content: { text: string }[];
+      structuredContent?: { user: string; path: string };
+      isError: boolean;
+    };
+  };
+  expect(res.result.isError).toBe(false);
+  expect(res.result.structuredContent).toEqual({ user: "test", path: readme });
+  expect(JSON.parse(res.result.content[0]?.text.trim())).toEqual({ user: "test", path: readme });
+});
+
+test("MCP tools/call errors on missing required positional", async () => {
+  const responses = await mcpRequest([
+    {
+      jsonrpc: "2.0",
+      id: 5,
+      method: "tools/call",
+      params: { name: "stat_owner_lookup", arguments: { "user-name": "test" } },
+    },
+  ]);
+  const res = responses.get(5) as { result: { isError: boolean; content: { text: string }[] } };
+  expect(res.result.isError).toBe(true);
+  expect(res.result.content[0]?.text).toContain("Missing argument: path");
+});
+
+test("MCP ping returns empty result", async () => {
+  const responses = await mcpRequest([{ jsonrpc: "2.0", id: 99, method: "ping", params: {} }]);
+  const res = responses.get(99) as { result: Record<string, never> };
+  expect(res.result).toEqual({});
+});
+
+test("minimal.ts mcp without opt-in fails", async () => {
+  const { stderr, exitCode } = await $`bun run examples/minimal.ts mcp`.nothrow().quiet();
+  expect(exitCode).toBe(1);
+  expect(stderr.toString()).toContain("MCP is not enabled");
+});
+
+test("MCP resources/list includes custom resource", async () => {
+  const responses = await mcpRequest(
+    [{ jsonrpc: "2.0", id: 10, method: "resources/list", params: {} }],
+    { script: "examples/mcp-test.ts" },
+  );
+  const res = responses.get(10) as { result: { resources: { uri: string }[] } };
+  const uris = res.result.resources.map((r) => r.uri);
+  expect(uris).toContain("mcp_test://schema");
+  expect(uris).toContain("test://hello");
+});
+
+test("MCP resources/read returns custom resource body", async () => {
+  const responses = await mcpRequest(
+    [{ jsonrpc: "2.0", id: 11, method: "resources/read", params: { uri: "test://hello" } }],
+    { script: "examples/mcp-test.ts" },
+  );
+  const res = responses.get(11) as { result: { contents: { text: string }[] } };
+  expect(res.result.contents[0]?.text).toBe("hello resource");
+});
+
+test("MCP resources/read unknown URI returns error", async () => {
+  const responses = await mcpRequest(
+    [{ jsonrpc: "2.0", id: 12, method: "resources/read", params: { uri: "missing://nope" } }],
+    { script: "examples/mcp-test.ts" },
+  );
+  const res = responses.get(12) as { error: { code: number } };
+  expect(res.error.code).toBe(-32602);
+});