argsbarg 3.3.14 → 3.4.1

package/src/hidden-mcpb.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { cliPresentationRoot, cliParseRoot } from "./builtins/presentation.ts";
+import { exportPresentationBuiltins } from "./builtins/export.ts";
+import { cliHelpRender } from "./help.ts";
+import { cliSchemaExport } from "./schema.ts";
+import { collectMcpTools } from "./mcp/tools.ts";
+import { defaultMcpBundlePaths, generateMcpManifest, packMcpBundle } from "./mcp/bundle.ts";
+import { CliOptionKind, type CliProgram } from "./types.ts";
+
+const hiddenFixture: CliProgram = {
+  key: "myapp",
+  version: "1.0.0",
+  description: "Hidden demo.",
+  mcpServer: { enabled: true },
+  commands: [
+    {
+      key: "public",
+      description: "Visible command.",
+      handler: () => {},
+    },
+    {
+      key: "secret",
+      hidden: true,
+      description: "Hidden command.",
+      handler: () => {},
+    },
+    {
+      key: "flags",
+      description: "Command with hidden option.",
+      options: [
+        {
+          name: "visible",
+          description: "Shown in help.",
+          kind: CliOptionKind.Presence,
+        },
+        {
+          name: "secret-flag",
+          hidden: true,
+          description: "Hidden option.",
+          kind: CliOptionKind.Presence,
+        },
+      ],
+      handler: () => {},
+    },
+  ],
+};
+
+describe("hidden commands and options", () => {
+  test("parse root includes hidden commands", () => {
+    const parse = cliParseRoot(hiddenFixture);
+    expect(parse.commands?.map((c) => c.key)).toContain("secret");
+  });
+
+  test("presentation root omits hidden commands", () => {
+    const presentation = cliPresentationRoot(hiddenFixture);
+    const keys = presentation.commands?.map((c) => c.key) ?? [];
+    expect(keys).toContain("public");
+    expect(keys).not.toContain("secret");
+  });
+
+  test("root help omits hidden commands", () => {
+    const help = cliHelpRender(cliParseRoot(hiddenFixture), [], false);
+    expect(help).toContain("public");
+    expect(help).not.toContain("secret");
+  });
+
+  test("hidden command -h still works", () => {
+    const help = cliHelpRender(cliParseRoot(hiddenFixture), ["secret"], false);
+    expect(help).toContain("Hidden command.");
+  });
+
+  test("help omits hidden options", () => {
+    const help = cliHelpRender(cliParseRoot(hiddenFixture), ["flags"], false);
+    expect(help).toContain("--visible");
+    expect(help).not.toContain("secret-flag");
+  });
+
+  test("schema export omits hidden nodes and options", () => {
+    const schema = cliSchemaExport(hiddenFixture);
+    const keys = schema.commands?.map((c) => c.key) ?? [];
+    expect(keys).toContain("public");
+    expect(keys).not.toContain("secret");
+    const flags = schema.commands?.find((c) => c.key === "flags");
+    expect(flags?.options?.map((o) => o.name)).toEqual(["visible"]);
+  });
+
+  test("MCP tools omit hidden commands", () => {
+    const tools = collectMcpTools(hiddenFixture);
+    expect(tools.map((t) => t.name)).toEqual(["public", "flags"]);
+  });
+});
+
+describe("mcp router", () => {
+  test("presentation exposes mcp bundle but not hidden serve", () => {
+    const builtins = exportPresentationBuiltins(hiddenFixture);
+    const mcp = builtins.find((b) => b.key === "mcp");
+    expect(mcp).toBeDefined();
+    expect(mcp?.commands?.map((c) => c.key)).toEqual(["bundle"]);
+    expect(mcp?.fallbackCommand).toBe("serve");
+  });
+
+  test("mcp help lists bundle", () => {
+    const help = cliHelpRender(cliParseRoot(hiddenFixture), ["mcp"], false);
+    expect(help).toContain("bundle");
+    expect(help).not.toMatch(/│ serve\s/);
+  });
+});
+
+describe("mcp bundle", () => {
+  test("generateMcpManifest uses mcpServerId and binary entry", () => {
+    const manifest = generateMcpManifest(hiddenFixture, "myapp");
+    expect(manifest.name).toBe("myapp");
+    expect(manifest.manifest_version).toBe("0.3");
+    expect((manifest.server as { type: string }).type).toBe("binary");
+    expect((manifest.server as { entry_point: string }).entry_point).toBe("myapp");
+    const mcpConfig = (manifest.server as { mcp_config: { command: string; args: string[] } }).mcp_config;
+    expect(mcpConfig.command).toBe("${__dirname}/myapp");
+    expect(mcpConfig.args).toEqual(["mcp"]);
+    expect((manifest.compatibility as { platforms: string[] }).platforms).toEqual(["darwin"]);
+  });
+
+  test("defaultMcpBundlePaths", () => {
+    const cwd = "/tmp/work";
+    const paths = defaultMcpBundlePaths(hiddenFixture, cwd);
+    expect(paths.binaryPath).toBe(join(cwd, "dist", "myapp"));
+    expect(paths.outPath).toBe(join(cwd, "dist", "myapp.mcpb"));
+  });
+
+  test("packMcpBundle writes zip with manifest and binary on darwin", () => {
+    if (process.platform !== "darwin") {
+      return;
+    }
+    const work = mkdtempSync(join(tmpdir(), "mcpb-test-"));
+    try {
+      const dist = join(work, "dist");
+      mkdirSync(dist, { recursive: true });
+      const binaryPath = join(dist, "myapp");
+      writeFileSync(binaryPath, "#!/bin/sh\necho hi\n", { mode: 0o755 });
+
+      const outPath = packMcpBundle(hiddenFixture, { cwd: work });
+      expect(outPath).toBe(join(dist, "myapp.mcpb"));
+
+      const zip = readFileSync(outPath);
+      expect(zip.length).toBeGreaterThan(0);
+      expect(zip.indexOf(Buffer.from("manifest.json"))).toBeGreaterThanOrEqual(0);
+      expect(zip.indexOf(Buffer.from("myapp"))).toBeGreaterThanOrEqual(0);
+    } finally {
+      rmSync(work, { recursive: true, force: true });
+    }
+  });
+});

package/src/hidden.ts

@@ -0,0 +1,32 @@
+/*
+Filters hidden commands and options from presentation surfaces (help, schema, completions).
+Parsing still uses the full tree via cliParseRoot.
+*/
+
+import type { CliNode, CliOption, CliRouter } from "./types.ts";
+import { isCliLeaf, isCliRouter } from "./types.ts";
+
+/** Options visible in help, schema, completions, and MCP tool schemas. */
+export function visibleOptions(options: CliOption[] | undefined): CliOption[] {
+  return (options ?? []).filter((o) => !o.hidden);
+}
+
+/** Strips hidden commands and options from one node for presentation export. */
+export function presentationNode(node: CliNode): CliNode | null {
+  if (node.hidden) {
+    return null;
+  }
+  const options = visibleOptions(node.options);
+  if (isCliRouter(node)) {
+    const commands = node.commands
+      .map((ch) => presentationNode(ch))
+      .filter((ch): ch is CliNode => ch !== null);
+    return { ...node, options, commands };
+  }
+  return { ...node, options };
+}
+
+/** Subcommands visible in help listings (parent may be any node in the parse tree). */
+export function visibleSubcommands(cmds: CliNode[]): CliNode[] {
+  return cmds.filter((c) => !c.hidden);
+}

package/src/index.test.ts

@@ -26,7 +26,7 @@ import { buildToolCallSuccess } from "./mcp/result.ts";
 import { generateSkillBundle } from "./skill/generate.ts";
 import { cliSkillInstall } from "./skill/install.ts";
 import { ParseKind, parse, postParseValidate } from "./parse.ts";
-import { cliSchemaJson } from "./schema.ts";
+import { cliSchemaExport, cliSchemaJson } from "./schema.ts";
 import { cliValidateProgram } from "./validate.ts";
 import { expect, test } from "bun:test";
 
@@ -853,6 +853,146 @@ test("collectMcpTools lists user leaf commands only", () => {
   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")!;
@@ -861,6 +1001,40 @@ test("collectMcpTools merges parent options into inputSchema", () => {
   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")!;

package/src/index.ts

@@ -18,6 +18,7 @@ export type {
   CliInvocation,
   CliMcpResource,
   CliMcpServerConfig,
+  CliMcpBundleConfig,
   CliMcpToolConfig,
   CliInstallConfig,
   CliUpdateArtifact,
@@ -45,3 +46,5 @@ export {
   parseReleaseTag,
 } from "./install/gh-release-update.ts";
 export type { GhReleaseUpdateConfig, GhVersionCheckConfig } from "./install/gh-release-update.ts";
+export { generateMcpManifest, packMcpBundle, defaultMcpBundlePaths } from "./mcp/bundle.ts";
+export type { McpBundlePaths, PackMcpBundleOpts } from "./mcp/bundle.ts";

package/src/invoke.ts

@@ -6,7 +6,7 @@ process.exit so MCP tool calls can run handlers repeatedly.
 
 import { CliContext } from "./context.ts";
 import { builtinInterceptRoot, dispatchBuiltin } from "./builtins/dispatch.ts";
-import { cliPresentationRoot } from "./builtins/presentation.ts";
+import { cliParseRoot, cliPresentationRoot } from "./builtins/presentation.ts";
 import { parse, postParseValidate, ParseKind } from "./parse.ts";
 import { type CliNode, type CliProgram, type CliRouter, isCliLeaf, isCliRouter } from "./types.ts";
 import { format } from "node:util";
@@ -65,7 +65,7 @@ export async function cliInvoke(root: CliProgram, argv: string[]): Promise<CliIn
       isLeafCompletionIntercept = intercept.isLeafCompletionIntercept;
     }
   } else {
-    parseRoot = cliPresentationRoot(root);
+    parseRoot = cliParseRoot(root);
   }
 
   let pr = parse(parseRoot, argv);

package/src/mcp/bundle.ts

@@ -0,0 +1,251 @@
+/*
+Packs a CLI program into an MCP Bundle (`.mcpb`) for Claude Desktop.
+macOS-only v1: expects `dist/<program.key>` as the compiled binary input.
+*/
+
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { collectMcpTools, mcpServerId } from "./tools.ts";
+import type { CliMcpBundleConfig, CliProgram } from "../types.ts";
+
+const MANIFEST_VERSION = "0.3";
+const DIST_DIR = "dist";
+
+/** Resolved paths for `mcp bundle`. */
+export interface McpBundlePaths {
+  binaryPath: string;
+  outPath: string;
+  binaryName: string;
+}
+
+/** Default `dist/<key>` binary and `dist/<key>.mcpb` output under cwd. */
+export function defaultMcpBundlePaths(program: CliProgram, cwd = process.cwd()): McpBundlePaths {
+  const binaryName = program.key;
+  const dist = join(cwd, DIST_DIR);
+  return {
+    binaryName,
+    binaryPath: join(dist, binaryName),
+    outPath: join(dist, `${binaryName}.mcpb`),
+  };
+}
+
+/** Collects unique env var names from MCP tool `requiresEnv` for manifest `user_config`. */
+function collectUserConfigEnvVars(program: CliProgram): string[] {
+  const names = new Set<string>();
+  for (const tool of collectMcpTools(program)) {
+    for (const env of tool.leaf.mcpTool?.requiresEnv ?? []) {
+      if (env.length > 0) {
+        names.add(env);
+      }
+    }
+  }
+  return [...names].sort();
+}
+
+/** Builds manifest `user_config` entries for required environment variables. */
+function buildUserConfig(program: CliProgram): Record<string, unknown> | undefined {
+  const envVars = collectUserConfigEnvVars(program);
+  if (envVars.length === 0) {
+    return undefined;
+  }
+  const out: Record<string, unknown> = {};
+  for (const name of envVars) {
+    const key = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "") || "env_var";
+    out[key] = {
+      type: "string",
+      title: name,
+      description: `Value for environment variable ${name}`,
+      sensitive: /key|token|secret|password/i.test(name),
+      required: true,
+    };
+  }
+  return out;
+}
+
+/** Default author when `mcpServer.bundle.author` is unset. */
+function defaultAuthor(bundle?: CliMcpBundleConfig): { name: string; email?: string; url?: string } {
+  return bundle?.author ?? { name: "Unknown" };
+}
+
+/** Generates MCPB `manifest.json` object from program schema and MCP tools. */
+export function generateMcpManifest(program: CliProgram, binaryName: string): Record<string, unknown> {
+  const bundle = program.mcpServer?.bundle;
+  const tools = collectMcpTools(program).map((t) => ({
+    name: t.name,
+    description: t.description.split("\n")[0] ?? t.description,
+  }));
+
+  const manifest: Record<string, unknown> = {
+    manifest_version: MANIFEST_VERSION,
+    name: mcpServerId(program),
+    version: program.version,
+    description: program.description,
+    author: defaultAuthor(bundle),
+    server: {
+      type: "binary",
+      entry_point: binaryName,
+      mcp_config: {
+        command: `\${__dirname}/${binaryName}`,
+        args: ["mcp"],
+      },
+    },
+    tools,
+    tools_generated: false,
+    compatibility: {
+      claude_desktop: ">=0.10.0",
+      platforms: ["darwin"],
+    },
+  };
+
+  const longDescription = bundle?.longDescription ?? program.description;
+  if (longDescription !== program.description) {
+    manifest.long_description = longDescription;
+  }
+
+  const userConfig = buildUserConfig(program);
+  if (userConfig) {
+    manifest.user_config = userConfig;
+  }
+
+  if (bundle?.icon) {
+    manifest.icon = basename(bundle.icon);
+  }
+
+  return manifest;
+}
+
+/** CRC-32 table for ZIP local headers (store method). */
+function crc32(data: Buffer): number {
+  let crc = 0xffffffff;
+  for (let i = 0; i < data.length; i++) {
+    crc ^= data[i]!;
+    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. */
+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]);
+}
+
+export interface PackMcpBundleOpts {
+  cwd?: string;
+  binaryPath?: string;
+  outPath?: string;
+}
+
+/**
+ * Stages manifest + binary (+ optional icon) and writes a `.mcpb` ZIP.
+ * macOS-only v1; requires the compiled binary to exist.
+ */
+export function packMcpBundle(program: CliProgram, opts: PackMcpBundleOpts = {}): string {
+  if (process.platform !== "darwin") {
+    throw new Error("mcp bundle is macOS-only in this release. Build the bundle on darwin.");
+  }
+
+  const cwd = opts.cwd ?? process.cwd();
+  const defaults = defaultMcpBundlePaths(program, cwd);
+  const binaryPath = resolve(cwd, opts.binaryPath ?? defaults.binaryPath);
+  const outPath = resolve(cwd, opts.outPath ?? defaults.outPath);
+  const binaryName = basename(binaryPath);
+
+  if (!existsSync(binaryPath)) {
+    throw new Error(`Binary not found: ${binaryPath}. Build with compile first (expected dist/${program.key}).`);
+  }
+
+  const staging = mkdtempSync(join(tmpdir(), "mcpb-"));
+  try {
+    const stagedBinary = join(staging, binaryName);
+    cpSync(binaryPath, stagedBinary, { mode: 0o755 });
+
+    const manifest = generateMcpManifest(program, binaryName);
+    const files: { name: string; data: Buffer }[] = [
+      { name: "manifest.json", data: Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8") },
+      { name: binaryName, data: readFileSync(stagedBinary) },
+    ];
+
+    const iconRel = program.mcpServer?.bundle?.icon;
+    if (iconRel) {
+      const iconSrc = resolve(cwd, iconRel);
+      if (!existsSync(iconSrc)) {
+        throw new Error(`Bundle icon not found: ${iconRel}`);
+      }
+      const iconName = basename(iconRel);
+      files.push({ name: iconName, data: readFileSync(iconSrc) });
+    }
+
+    mkdirSync(join(outPath, ".."), { recursive: true });
+    writeFileSync(outPath, zipStore(files));
+    return outPath;
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}
+
+/** Runs `mcp bundle`: writes `dist/<key>.mcpb` and prints the path on stdout. */
+export function runMcpBundle(program: CliProgram): void {
+  const outPath = packMcpBundle(program);
+  process.stdout.write(`${outPath}\n`);
+}

package/src/mcp/server.ts

@@ -95,6 +95,7 @@ async function handleRequestLine(root: CliProgram, line: string): Promise<void>
         name: t.name,
         description: t.description,
         inputSchema: t.inputSchema,
+        ...(t.outputSchema === undefined ? {} : { outputSchema: t.outputSchema }),
       }));
       writeResponse({ jsonrpc: "2.0", id, result: { tools } });
       return;