argsbarg 6.1.2 → 6.1.3

package/src/skill/generate.ts

@@ -2,17 +2,17 @@
 This module generates Agent Skills content (SKILL.md + reference.md) from a CLI schema.
 */
 
-import { defaultConfigEntryTitle } from "../config/entry.ts";
-import { generateApiGuide } from "../docs/api-guide.ts";
+import { defaultConfigEntryTitle } from "~/config/entry.ts";
+import { collectOptionDefs } from "~/core/parse.ts";
+import { CliOptionKind, type CliProgram } from "~/core/types.ts";
+import { generateCliGuide } from "~/docs/cli-guide.ts";
 import {
   collectMcpTools,
   type McpToolDef,
   mcpServerId,
   resolveMcpSchemaUri,
   sanitizeToolSegment,
-} from "../mcp/tools.ts";
-import { collectOptionDefs } from "../parse.ts";
-import { CliOptionKind, type CliProgram } from "../types.ts";
+} from "~/mcp/tools.ts";
 import type { SkillTarget } from "./naming.ts";
 import { skillDirNameForTarget, skillFrontmatterName } from "./naming.ts";
 
@@ -149,7 +149,7 @@ function buildSkillMd(root: CliProgram, target: SkillTarget, dirName: string): s
     "",
     "## Reference",
     "",
-    `For full detail, open \`reference.md\` in this skill directory (same as \`${root.key} docs api\`).`,
+    `For full detail, open \`reference.md\` in this skill directory (same as \`${root.key} docs cli\`).`,
     "",
   );
 
@@ -190,9 +190,9 @@ function buildSkillMd(root: CliProgram, target: SkillTarget, dirName: string): s
   return lines.join("\n");
 }
 
-/** Builds reference.md with the full `docs api` markdown guide. */
+/** Builds reference.md with the compact `docs cli` markdown guide. */
 function buildReferenceMd(root: CliProgram): string {
-  return generateApiGuide(root);
+  return generateCliGuide(root, { compact: true });
 }
 
 /** Builds MCP routing SKILL.md for Claude Code plugin zips. */

package/src/skill/hint.ts

@@ -1,4 +1,4 @@
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 
 /** YAML frontmatter block at the start of SKILL.md. */
 export const MARKDOWN_FRONTMATTER_RE = /^---\r?\n[\s\S]*?\r?\n---\r?\n/;

package/src/skill/install.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { userHome } from "../paths/host.ts";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
+import { userHome } from "~/paths/host.ts";
 import { generateSkillBundle, type SkillTarget } from "./generate.ts";
 import { applySkillInstallHints } from "./hint.ts";
 

package/src/skill/naming.ts

@@ -1,7 +1,7 @@
 /** Agent skill install targets. */
 export type SkillTarget = "cursor" | "claude" | "codex" | "opencode" | "openclaw";
 
-import { sanitizeToolSegment } from "../mcp/tools.ts";
+import { sanitizeToolSegment } from "~/mcp/tools.ts";
 
 /** Kebab-case skill folder + frontmatter name for agents that require hyphen slugs. */
 export function skillSlug(programKey: string): string {

package/src/{test-fixtures.ts → test/fixtures.ts}

@@ -1,5 +1,5 @@
-import type { CliProgram } from "./types.ts";
-import { CliFallbackMode, CliOptionKind } from "./types.ts";
+import type { CliProgram } from "~/core/types.ts";
+import { CliFallbackMode, CliOptionKind } from "~/core/types.ts";
 
 export function testProgram(prog: Record<string, unknown> & { key: string; description: string }): CliProgram {
   return { version: "0.0.0", ...prog } as CliProgram;
@@ -166,6 +166,7 @@ export function nestedDocsFallbackFixture(): CliProgram {
   return testProgram({
     key: "app",
     description: "",
+    docs: { enabled: false },
     commands: [
       {
         key: "docs",

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

@@ -6,9 +6,9 @@ import { expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import { bootstrapAppConfig } from "./config/bootstrap.ts";
-import { resolveAppConfigPath } from "./config/file.ts";
-import { mcpRequest, testProgram } from "./test-fixtures.ts";
+import { bootstrapAppConfig } from "~/config/bootstrap.ts";
+import { resolveAppConfigPath } from "~/config/file.ts";
+import { mcpRequest, testProgram } from "~/test/fixtures.ts";
 
 /** Tests that bootstrapAppConfig prefers host env over config file. */
 test("bootstrapAppConfig prefers host env over config file", () => {
@@ -124,13 +124,13 @@ test("MCP config file loads and exports vars for tool handlers", async () => {
   rmSync(dir, { recursive: true, force: true });
 });
 
-/** Cli.run docs api skips required appConfig exit. */
-test("Cli.run docs api skips required appConfig exit", async () => {
+/** Cli.run docs cli skips required appConfig exit. */
+test("Cli.run docs cli skips required appConfig exit", async () => {
   const dir = mkdtempSync(join(tmpdir(), "argsbarg-docs-skip-"));
   const configFile = join(dir, ".local", "lib", "docs_skip_test", "config");
   mkdirSync(dirname(configFile), { recursive: true });
   writeFileSync(configFile, "{}\n");
-  const entry = join(import.meta.dir, "index.ts");
+  const entry = join(import.meta.dir, "..", "..", "index.ts");
   const mainPath = join(dir, "run-docs.ts");
   writeFileSync(
     mainPath,
@@ -139,7 +139,7 @@ const program = {
   key: "docs-skip-test",
   version: "1.0.0",
   description: "test",
-  docs: { enabled: true, topics: { readme: { text: "# readme\\n" } } },
+  docs: { topics: { readme: { text: "# readme\\n" } } },
   appConfig: {
     entries: { token: { description: "Token.", env: "DOCS_SKIP_RUN_TOKEN" } },
   },
@@ -151,7 +151,7 @@ await new Cli(program).run(process.argv.slice(2));
   const env = { ...process.env, HOME: dir } as Record<string, string | undefined>;
   delete env.DOCS_SKIP_RUN_TOKEN;
   try {
-    const proc = Bun.spawn(["bun", "run", mainPath, "docs", "api"], {
+    const proc = Bun.spawn(["bun", "run", mainPath, "docs", "cli"], {
       stdout: "pipe",
       stderr: "pipe",
       env,

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");
 });