argsbarg 6.1.1 → 6.1.3

package/src/{api.integration.test.ts → test/integration/http.test.ts}

@@ -5,18 +5,21 @@ HTTP API integration tests: routes, tool invocation, CORS, OpenAPI, and validati
 import { describe, expect, test } from "bun:test";
 import { join } from "node:path";
 import { $ } from "bun";
-import { generateOpenApi } from "./api/openapi.ts";
-import { API_CORS_HEADERS } from "./api/result.ts";
-import { handleApiRequest } from "./api/server.ts";
-import { Cli, CliContext, type CliContext as CliContextType, CliOptionKind, cliErrWithHelp } from "./index.ts";
-import { nestedMcpFixture, testProgram } from "./test-fixtures.ts";
-import { cliValidateProgram } from "./validate.ts";
+import { cliValidateProgram } from "~/core/validate.ts";
+import { generateOpenApi } from "~/http/openapi.ts";
+import { API_CORS_HEADERS } from "~/http/result.ts";
+import { handleApiRequest } from "~/http/server.ts";
+import { Cli, CliContext, type CliContext as CliContextType, CliOptionKind, cliErrWithHelp } from "~/index";
+import { LogEmitter } from "~/log/emitter.ts";
+import { createServerRuntime } from "~/server/context.ts";
+import { resolveHttpServeConfig } from "~/server/overrides.ts";
+import { nestedMcpFixture, testProgram } from "~/test/fixtures.ts";
 
 /** Program with HTTP API enabled and handlers that return values. */
 function nestedApiFixture() {
   return testProgram({
     ...nestedMcpFixture,
-    apiServer: { enabled: true },
+    httpServer: { enabled: true },
     commands: [
       {
         key: "stat",
@@ -80,7 +83,7 @@ function nestedApiFixture() {
       {
         key: "pdf",
         description: "Return a minimal PDF.",
-        apiResponse: { contentType: "application/pdf" },
+        http: { successContentType: "application/pdf" },
         handler: (ctx: CliContextType) => {
           ctx.respond({
             body: new Uint8Array([0x25, 0x50, 0x44, 0x46, 0x2d, 0x31, 0x2e, 0x34]),
@@ -91,7 +94,7 @@ function nestedApiFixture() {
       {
         key: "html",
         description: "Return HTML.",
-        apiResponse: { contentType: "text/html; charset=utf-8" },
+        http: { successContentType: "text/html; charset=utf-8" },
         handler: (ctx: CliContextType) => {
           ctx.respond({
             body: "<!DOCTYPE html><html><body>hi</body></html>",
@@ -109,42 +112,57 @@ function nestedApiFixture() {
 }
 
 /** Sends one HTTP request through the in-process API handler. */
-async function apiRequest(program: ReturnType<typeof nestedApiFixture>, request: Request) {
+async function apiRequest(
+  program: ReturnType<typeof nestedApiFixture>,
+  request: Request,
+  opts?: { withServer?: boolean },
+) {
   const cli = new Cli(program);
-  return handleApiRequest(cli, request);
+  if (opts?.withServer) {
+    const resolved = resolveHttpServeConfig(program);
+    cli.server = {
+      runtime: createServerRuntime(program, "http"),
+      emitter: new LogEmitter({
+        program,
+        resolved: { ...resolved.log, access: false },
+      }),
+      http: resolved,
+    };
+  }
+  return handleApiRequest(cli, request, cli.server?.http);
 }
 
-describe("apiServer validation", () => {
-  test("rejects empty apiServer", () => {
+describe("httpServer validation", () => {
+  test("rejects empty httpServer", () => {
     const root = testProgram({
       key: "app",
       description: "",
-      apiServer: {} as { enabled: boolean },
+      httpServer: {} as { enabled: boolean },
       handler: () => {},
     });
-    expect(() => cliValidateProgram(root)).toThrow(/apiServer requires enabled: true/);
+    expect(() => cliValidateProgram(root)).toThrow(/httpServer requires enabled: true/);
   });
 
-  test("rejects top-level command name api when apiServer enabled", () => {
+  test("rejects top-level command name http when httpServer enabled", () => {
     const root = testProgram({
       key: "app",
       description: "",
-      apiServer: { enabled: true },
-      commands: [{ key: "api", description: "user", handler: () => {} }],
+      httpServer: { enabled: true },
+      commands: [{ key: "http", description: "user", handler: () => {} }],
     });
-    expect(() => cliValidateProgram(root)).toThrow(/Reserved command name: api/);
+    expect(() => cliValidateProgram(root)).toThrow(/Reserved command name: http/);
   });
 
-  test("allows top-level command name api without apiServer", () => {
+  test("allows top-level command name http without httpServer", () => {
     const root = testProgram({
       key: "app",
       description: "",
-      commands: [{ key: "api", description: "user", handler: () => {} }],
+      commands: [{ key: "http", description: "user", handler: () => {} }],
     });
     expect(() => cliValidateProgram(root)).not.toThrow();
   });
 
-  test("rejects apiServer on non-root node", () => {
+  test("rejects httpServer on non-root node", () => {
     const root = {
       key: "app",
       version: "0.0.0",
@@ -153,12 +171,12 @@ describe("apiServer validation", () => {
         {
           key: "x",
           description: "cmd",
-          apiServer: { enabled: true },
+          httpServer: { enabled: true },
           handler: () => {},
         },
       ],
-    } as unknown as import("./types.ts").CliProgram;
-    expect(() => cliValidateProgram(root)).toThrow(/apiServer is only supported on the program root/);
+    } as unknown as import("~/core/types.ts").CliProgram;
+    expect(() => cliValidateProgram(root)).toThrow(/httpServer is only supported on the program root/);
   });
 });
 
@@ -166,6 +184,94 @@ describe("HTTP API routes", () => {
   const program = nestedApiFixture();
   cliValidateProgram(program);
 
+  test("GET /health/live returns ok", async () => {
+    const res = await apiRequest(program, new Request("http://127.0.0.1/health/live"));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ ok: true });
+  });
+
+  test("GET /health/ready returns ok when healthy", async () => {
+    const res = await apiRequest(program, new Request("http://127.0.0.1/health/ready"), { withServer: true });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { ok: boolean; checks: Record<string, { ok: boolean }> };
+    expect(body.ok).toBe(true);
+    expect(body.checks.config_file.ok).toBe(true);
+    expect(body.checks.config_required.ok).toBe(true);
+  });
+
+  test("GET /health/ready returns 503 when custom readiness fails", async () => {
+    const failProgram = testProgram({
+      key: "app",
+      description: "Test",
+      version: "1.0.0",
+      httpServer: { enabled: true },
+      readiness: () => false,
+      handler: () => ({ ok: true }),
+    });
+    cliValidateProgram(failProgram);
+    const res = await apiRequest(failProgram, new Request("http://127.0.0.1/health/ready"), { withServer: true });
+    expect(res.status).toBe(503);
+    const body = (await res.json()) as { ok: boolean; checks: { custom: { ok: boolean } } };
+    expect(body.ok).toBe(false);
+    expect(body.checks.custom.ok).toBe(false);
+  });
+
+  test("POST /api returns 500 for non-Error throw", async () => {
+    const throwProgram = testProgram({
+      key: "app",
+      description: "Test",
+      httpServer: { enabled: true },
+      commands: [
+        {
+          key: "boom",
+          description: "Throws non-Error",
+          handler: () => {
+            throw "unexpected";
+          },
+        },
+      ],
+    });
+    cliValidateProgram(throwProgram);
+    const res = await apiRequest(
+      throwProgram,
+      new Request("http://127.0.0.1/api/boom", { method: "POST", body: "{}" }),
+    );
+    expect(res.status).toBe(500);
+  });
+
+  test("POST /api obscures unexpected errors when configured", async () => {
+    const throwProgram = testProgram({
+      key: "app",
+      description: "Test",
+      httpServer: { enabled: true, errors: { obscureUnexpected: true } },
+      commands: [
+        {
+          key: "boom",
+          description: "Throws non-Error",
+          handler: () => {
+            throw "secret";
+          },
+        },
+      ],
+    });
+    cliValidateProgram(throwProgram);
+    const cli = new Cli(throwProgram);
+    const resolved = resolveHttpServeConfig(throwProgram);
+    cli.server = {
+      runtime: createServerRuntime(throwProgram, "http"),
+      emitter: new LogEmitter({ program: throwProgram, resolved: { ...resolved.log, access: false } }),
+      http: resolved,
+    };
+    const res = await handleApiRequest(
+      cli,
+      new Request("http://127.0.0.1/api/boom", { method: "POST", body: "{}" }),
+      resolved,
+    );
+    expect(res.status).toBe(500);
+    const body = (await res.json()) as { error: string };
+    expect(body.error).toBe("An unexpected error occurred.");
+  });
+
   test("GET /health includes CORS headers", async () => {
     const res = await apiRequest(program, new Request("http://127.0.0.1/health"));
     expect(res.status).toBe(200);
@@ -174,46 +280,43 @@ describe("HTTP API routes", () => {
   });
 
   test("OPTIONS returns 204 with CORS headers", async () => {
-    const res = await apiRequest(
-      program,
-      new Request("http://127.0.0.1/tools/stat-owner-lookup", { method: "OPTIONS" }),
-    );
+    const res = await apiRequest(program, new Request("http://127.0.0.1/api/stat/owner/lookup", { method: "OPTIONS" }));
     expect(res.status).toBe(204);
     expect(res.headers.get("access-control-allow-origin")).toBe("*");
     expect(res.headers.get("access-control-allow-methods")).toContain("POST");
   });
 
-  test("POST /tools/:name returns raw JSON body", async () => {
-    const readme = join(import.meta.dir, "..", "README.md");
+  test("POST /api/... returns raw JSON body with 201", async () => {
+    const readme = join(import.meta.dir, "..", "..", "..", "README.md");
     const res = await apiRequest(
       program,
-      new Request("http://127.0.0.1/tools/stat-owner-lookup", {
+      new Request("http://127.0.0.1/api/stat/owner/lookup", {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ "user-name": "alice", path: readme, json: true }),
       }),
     );
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(201);
     expect(res.headers.get("content-type")).toContain("application/json");
     expect(await res.json()).toEqual({ user: "alice", path: readme });
   });
 
-  test("POST /tools/:name returns raw text body", async () => {
-    const readme = join(import.meta.dir, "..", "README.md");
+  test("POST /api/... returns raw text body with 201", async () => {
+    const readme = join(import.meta.dir, "..", "..", "..", "README.md");
     const res = await apiRequest(
       program,
-      new Request("http://127.0.0.1/tools/stat-owner-lookup", {
+      new Request("http://127.0.0.1/api/stat/owner/lookup", {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ "user-name": "alice", path: readme }),
       }),
     );
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(201);
     const text = await res.text();
     expect(text).toContain("lookup user=alice");
   });
 
-  test("POST /tools returns 405", async () => {
+  test("POST /tools returns 404 (legacy path removed)", async () => {
     const res = await apiRequest(
       program,
       new Request("http://127.0.0.1/tools", {
@@ -222,41 +325,41 @@ describe("HTTP API routes", () => {
         body: "{}",
       }),
     );
-    expect(res.status).toBe(405);
+    expect(res.status).toBe(404);
   });
 
-  test("POST /tools/:name returns PDF bytes", async () => {
+  test("POST /api/pdf returns PDF bytes with 201", async () => {
     const res = await apiRequest(
       program,
-      new Request("http://127.0.0.1/tools/pdf", {
+      new Request("http://127.0.0.1/api/pdf", {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: "{}",
       }),
     );
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(201);
     expect(res.headers.get("content-type")).toBe("application/pdf");
     const bytes = new Uint8Array(await res.arrayBuffer());
     expect(String.fromCharCode(...bytes.slice(0, 4))).toBe("%PDF");
   });
 
-  test("POST /tools/:name returns HTML", async () => {
+  test("POST /api/html returns HTML with 201", async () => {
     const res = await apiRequest(
       program,
-      new Request("http://127.0.0.1/tools/html", {
+      new Request("http://127.0.0.1/api/html", {
         method: "POST",
         body: "{}",
       }),
     );
-    expect(res.status).toBe(200);
+    expect(res.status).toBe(201);
     expect(res.headers.get("content-type")).toContain("text/html");
     expect(await res.text()).toContain("<!DOCTYPE html>");
   });
 
-  test("POST /tools/:name returns 500 when handler has no response", async () => {
+  test("POST /api/silent returns 500 when handler has no response", async () => {
     const res = await apiRequest(
       program,
-      new Request("http://127.0.0.1/tools/silent", {
+      new Request("http://127.0.0.1/api/silent", {
         method: "POST",
         body: "{}",
       }),
@@ -266,10 +369,10 @@ describe("HTTP API routes", () => {
     expect(body.error).toContain("ctx.respond()");
   });
 
-  test("POST /tools returns 404 for unknown tool", async () => {
+  test("POST /api returns 404 for unknown route", async () => {
     const res = await apiRequest(
       program,
-      new Request("http://127.0.0.1/tools/missing_tool", {
+      new Request("http://127.0.0.1/api/missing_tool", {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: "{}",
@@ -278,10 +381,10 @@ describe("HTTP API routes", () => {
     expect(res.status).toBe(404);
   });
 
-  test("POST /tools returns 400 for bad args", async () => {
+  test("POST /api returns 400 for bad args", async () => {
     const res = await apiRequest(
       program,
-      new Request("http://127.0.0.1/tools/stat-owner-lookup", {
+      new Request("http://127.0.0.1/api/stat/owner/lookup", {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ "user-name": "alice" }),
@@ -294,11 +397,11 @@ describe("HTTP API routes", () => {
     expect(body.error).not.toContain("\u001B[");
   });
 
-  test("POST /tools/:name returns plain JSON validation errors", async () => {
+  test("POST /api/... returns plain JSON validation errors", async () => {
     const failProgram = testProgram({
       key: "app",
       description: "Test app",
-      apiServer: { enabled: true },
+      httpServer: { enabled: true },
       commands: [
         {
           key: "fail",
@@ -312,7 +415,7 @@ describe("HTTP API routes", () => {
     cliValidateProgram(failProgram);
     const res = await apiRequest(
       failProgram,
-      new Request("http://127.0.0.1/tools/fail", {
+      new Request("http://127.0.0.1/api/fail", {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: "{}",
@@ -323,12 +426,12 @@ describe("HTTP API routes", () => {
     expect(body).toEqual({ error: "bad input" });
   });
 
-  test("GET /openapi.json lists tool paths", async () => {
+  test("GET /openapi.json lists REST paths", async () => {
     const res = await apiRequest(program, new Request("http://127.0.0.1/openapi.json"));
     expect(res.status).toBe(200);
     const doc = (await res.json()) as { openapi: string; paths: Record<string, unknown> };
     expect(doc.openapi).toBe("3.1.0");
-    expect(doc.paths["/tools/stat-owner-lookup"]).toBeDefined();
+    expect(doc.paths["/api/stat/owner/lookup"]).toBeDefined();
   });
 
   test("GET /openapi-browser returns Scalar HTML", async () => {
@@ -345,9 +448,9 @@ describe("HTTP API routes", () => {
 test("generateOpenApi maps binary content types", () => {
   const program = nestedApiFixture();
   const doc = generateOpenApi(program) as {
-    paths: Record<string, { post: { responses: { "200": { content: Record<string, unknown> } } } }>;
+    paths: Record<string, { post: { responses: { "201": { content: Record<string, unknown> } } } }>;
   };
-  const pdf = doc.paths["/tools/pdf"]?.post.responses["200"].content["application/pdf"] as {
+  const pdf = doc.paths["/api/pdf"]?.post.responses["201"].content["application/pdf"] as {
     schema: { format: string };
   };
   expect(pdf.schema.format).toBe("binary");
@@ -357,7 +460,7 @@ test("generateOpenApi dereferences nested inputSchema definitions", () => {
   const program = testProgram({
     key: "app",
     description: "Test app",
-    apiServer: { enabled: true },
+    httpServer: { enabled: true },
     commands: [
       {
         key: "render",
@@ -394,7 +497,7 @@ test("generateOpenApi dereferences nested inputSchema definitions", () => {
       }
     >;
   };
-  const schema = doc.paths["/tools/render"]?.post.requestBody.content["application/json; charset=utf-8"].schema;
+  const schema = doc.paths["/api/render"]?.post.requestBody.content["application/json; charset=utf-8"].schema;
   expect(schema.properties.invoice).toEqual({
     type: "object",
     properties: { id: { type: "string" } },
@@ -408,7 +511,7 @@ test("ctx.respond throws when called twice", () => {
     description: "",
     handler: () => {},
   });
-  const context = new CliContext("app", [], [], {}, program, "api");
+  const context = new CliContext("app", [], [], {}, program, "http");
   context.respond({ body: { ok: true } });
   expect(() => context.respond({ body: { ok: true } })).toThrow(/already called/);
 });
@@ -417,7 +520,7 @@ test("API_CORS_HEADERS are wide open", () => {
   expect(API_CORS_HEADERS["access-control-allow-origin"]).toBe("*");
 });
 
-test("ctx.invocation is api via Cli.invoke", async () => {
+test("ctx.invocation is http via Cli.invoke", async () => {
   let seen = "";
   const root = testProgram({
     key: "app",
@@ -428,14 +531,14 @@ test("ctx.invocation is api via Cli.invoke", async () => {
     },
   });
   cliValidateProgram(root);
-  const result = await new Cli(root).invoke([], { invocation: "api" });
+  const result = await new Cli(root).invoke([], { invocation: "http" });
   expect(result.kind).toBe("ok");
-  expect(seen).toBe("api");
-  expect(result.response?.body).toEqual({ invocation: "api" });
+  expect(seen).toBe("http");
+  expect(result.response?.body).toEqual({ invocation: "http" });
 });
 
-test("minimal.ts api without opt-in fails", async () => {
-  const { stderr, exitCode } = await $`bun run examples/minimal.ts api`.nothrow().quiet();
+test("minimal.ts http without opt-in fails", async () => {
+  const { stderr, exitCode } = await $`bun run examples/minimal.ts http`.nothrow().quiet();
   expect(exitCode).toBe(1);
   expect(stderr.toString()).toContain("HTTP API is not available");
 });

package/src/{mcp.integration.test.ts → test/integration/mcp.test.ts}

@@ -5,19 +5,18 @@ 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 { buildToolCallSuccessFromResponse } from "./mcp/result.ts";
+import { cliSchemaExport } from "~/core/schema.ts";
+import { cliValidateProgram } from "~/core/validate.ts";
+import type { CliProgram } from "~/index";
+import { buildToolCallSuccessFromResponse } from "~/mcp/result.ts";
 import {
-  apiToolName,
   collectMcpTools,
   mcpToolCallToArgv,
   mcpToolDescription,
   mcpToolName,
   sanitizeToolSegment,
-} from "./mcp/tools.ts";
-import { cliSchemaExport } from "./schema.ts";
-import { mcpRequest, nestedMcpFixture, testProgram } from "./test-fixtures.ts";
-import { cliValidateProgram } from "./validate.ts";
+} from "~/mcp/tools.ts";
+import { mcpRequest, nestedMcpFixture, testProgram } from "~/test/fixtures.ts";
 
 test("sanitizeToolSegment normalizes dotted app keys", () => {
   expect(sanitizeToolSegment("minimal.ts")).toBe("minimal_ts");
@@ -31,10 +30,8 @@ test("mcpToolDescription formats CLI path and root-leaf prefix", () => {
   expect(mcpToolDescription([], "helloapp", "Tiny demo.")).toBe("helloapp — Tiny demo.");
 });
 
-test("apiToolName hyphen-joins path; mcpToolName sanitizes to underscores", () => {
-  expect(apiToolName(nestedMcpFixture, ["stat", "owner", "lookup"])).toBe("stat-owner-lookup");
+test("mcpToolName sanitizes path segments to underscores", () => {
   expect(mcpToolName(nestedMcpFixture, ["stat", "owner", "lookup"])).toBe("stat_owner_lookup");
-  expect(apiToolName(nestedMcpFixture, ["render-invoice"])).toBe("render-invoice");
   expect(mcpToolName(nestedMcpFixture, ["render-invoice"])).toBe("render_invoice");
 });
 
@@ -43,7 +40,6 @@ test("collectMcpTools lists user leaf commands only", () => {
   const names = tools.map((t) => t.name);
   expect(names).toContain("stat_owner_lookup");
   const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
-  expect(lookup.apiName).toBe("stat-owner-lookup");
   expect(lookup.description).toBe("stat owner lookup — Resolve owner info.");
   expect(names).toContain("read");
   expect(names).not.toContain("hidden");
@@ -104,13 +100,13 @@ test("collectMcpTools resolves {argsbarg:program} in appended notes", () => {
       {
         key: "run",
         description: "Run.",
-        notes: "See `{argsbarg:program} docs api`.",
+        notes: "See `{argsbarg:program} docs cli`.",
         handler: () => {},
       },
     ],
   });
   const tools = collectMcpTools(root);
-  expect(tools[0]?.description).toContain("See `myapp docs api`.");
+  expect(tools[0]?.description).toContain("See `myapp docs cli`.");
 });
 
 /** CliSchemaExport includes leaf outputSchema. */
@@ -139,29 +135,6 @@ test("cliSchemaExport includes leaf outputSchema", () => {
   });
 });
 
-/** CliSchemaExport accepts legacy mcpTool.outputSchema. */
-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" } },
-  });
-});
-
 /** Tests that outputSchema must be a JSON Schema object. */
 test("outputSchema must be a JSON Schema object", () => {
   const root = testProgram({
@@ -180,25 +153,6 @@ test("outputSchema must be a JSON Schema object", () => {
   expect(() => cliValidateProgram(root)).toThrow(/outputSchema must be a JSON Schema object/);
 });
 
-/** Tests that outputSchema cannot be set on both leaf and mcpTool. */
-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")!;
@@ -419,7 +373,7 @@ test("MCP resources/read returns schema JSON", async () => {
 
 /** MCP tools/call runs stat_owner_lookup. */
 test("MCP tools/call runs stat_owner_lookup", async () => {
-  const readme = join(import.meta.dir, "..", "README.md");
+  const readme = join(import.meta.dir, "..", "..", "..", "README.md");
   const responses = await mcpRequest([
     {
       jsonrpc: "2.0",
@@ -440,7 +394,7 @@ test("MCP tools/call runs stat_owner_lookup", async () => {
 
 /** MCP tools/call returns structuredContent for JSON stdout. */
 test("MCP tools/call returns structuredContent for JSON stdout", async () => {
-  const readme = join(import.meta.dir, "..", "README.md");
+  const readme = join(import.meta.dir, "..", "..", "..", "README.md");
   const responses = await mcpRequest([
     {
       jsonrpc: "2.0",