argsbarg 1.4.3 → 2.0.0

package/src/install/plan.ts

@@ -0,0 +1,183 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CliProgram } from "../types.ts";
+import { installBinary } from "./binary.ts";
+import { installCompletions } from "./completions.ts";
+import { detectInstalledArtifacts } from "./detect-installed.ts";
+import { expectedMcpEntry, mergeMcpConfig } from "./mcp-config.ts";
+import { InstallPaths, userHome } from "./paths.ts";
+import { detectShells } from "./shell.ts";
+
+export interface InstallOpts {
+  all?: boolean;
+  bin?: boolean;
+  completions?: boolean;
+  skill?: boolean;
+  mcp?: boolean;
+  update?: boolean;
+  status?: boolean;
+  uninstall?: boolean;
+  yes?: boolean;
+  dry?: boolean;
+  json?: boolean;
+  quiet?: boolean;
+  prefix?: string;
+}
+
+export type InstallActionKind = "binary" | "completions" | "cursor-skill" | "claude-skill" | "cursor-mcp" | "claude-mcp";
+
+export interface InstallAction {
+  kind: InstallActionKind;
+  summary: string;
+  message: string;
+  run: () => string[];
+}
+
+function wantsBin(opts: InstallOpts): boolean {
+  return !!(opts.all || opts.bin || opts.update);
+}
+
+function wantsCompletions(opts: InstallOpts): boolean {
+  return !!(opts.all || opts.completions);
+}
+
+function wantsSkill(opts: InstallOpts): boolean {
+  return !!(opts.all || opts.skill);
+}
+
+function wantsMcp(opts: InstallOpts, root: CliProgram): boolean {
+  return !!(opts.all || opts.mcp) && root.mcpServer !== undefined;
+}
+
+/** Builds install actions for normal mode (--all / scoped targets). */
+export function buildInstallPlan(root: CliProgram, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
+  const actions: InstallAction[] = [];
+  const dry = !!opts.dry;
+
+  if (wantsBin(opts)) {
+    actions.push({
+      kind: "binary",
+      summary: `binary: ${paths.binaryPath}`,
+      message: `Installing binary to ${paths.binaryPath}`,
+      run: () => installBinary(root, paths, dry).changedFiles,
+    });
+  }
+
+  if (wantsCompletions(opts)) {
+    const shells = detectShells();
+    if (shells.bash) {
+      actions.push({
+        kind: "completions",
+        summary: `bash completion: ${paths.bashCompletion}`,
+        message: `Writing bash completion to ${paths.bashCompletion}`,
+        run: () => {
+          const all = installCompletions(root, paths, dry);
+          return all.filter((p) => p === paths.bashCompletion);
+        },
+      });
+    }
+    if (shells.zsh) {
+      actions.push({
+        kind: "completions",
+        summary: `zsh completion: ${paths.zshCompletion}`,
+        message: `Writing zsh completion to ${paths.zshCompletion}`,
+        run: () => {
+          const all = installCompletions(root, paths, dry);
+          return all.filter((p) => p === paths.zshCompletion);
+        },
+      });
+    }
+    if (shells.fish) {
+      actions.push({
+        kind: "completions",
+        summary: `fish completion: ${paths.fishCompletion}`,
+        message: `Writing fish completion to ${paths.fishCompletion}`,
+        run: () => {
+          const all = installCompletions(root, paths, dry);
+          return all.filter((p) => p === paths.fishCompletion);
+        },
+      });
+    }
+  }
+
+  if (wantsSkill(opts)) {
+    const home = userHome();
+    if (existsSync(join(home, ".cursor"))) {
+      actions.push({
+        kind: "cursor-skill",
+        summary: `cursor skill: ${paths.cursorSkillDir}/`,
+        message: `Installing Cursor skill to ${paths.cursorSkillDir}/`,
+        run: () => [],
+      });
+    }
+    if (existsSync(join(home, ".claude"))) {
+      actions.push({
+        kind: "claude-skill",
+        summary: `claude skill: ${paths.claudeSkillDir}/`,
+        message: `Installing Claude Code skill to ${paths.claudeSkillDir}/`,
+        run: () => [],
+      });
+    }
+  }
+
+  if (wantsMcp(opts, root)) {
+    const entry = expectedMcpEntry(root);
+    if (existsSync(join(userHome(), ".cursor"))) {
+      actions.push({
+        kind: "cursor-mcp",
+        summary: `cursor mcp: ${paths.cursorMcpPath} (server "${paths.mcpName}")`,
+        message: `Merging MCP server "${paths.mcpName}" into ${paths.cursorMcpPath}`,
+        run: () => {
+          mergeMcpConfig(paths.cursorMcpPath, paths.mcpName, entry, dry);
+          return [paths.cursorMcpPath];
+        },
+      });
+    }
+    actions.push({
+      kind: "claude-mcp",
+      summary: `claude mcp: ${paths.claudeMcpPath} (server "${paths.mcpName}")`,
+      message: `Merging MCP server "${paths.mcpName}" into ${paths.claudeMcpPath}`,
+      run: () => {
+        mergeMcpConfig(paths.claudeMcpPath, paths.mcpName, entry, dry);
+        return [paths.claudeMcpPath];
+      },
+    });
+  }
+
+  return actions;
+}
+
+/** Builds update actions for artifacts already installed. */
+export function buildUpdatePlan(root: CliProgram, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
+  const detected = detectInstalledArtifacts(paths);
+  const scoped: InstallOpts = {
+    bin: true,
+    completions: detected.bashCompletion || detected.zshCompletion || detected.fishCompletion,
+    skill: detected.cursorSkill || detected.claudeSkill,
+    mcp: (detected.cursorMcp || detected.claudeMcp) && root.mcpServer !== undefined,
+    dry: opts.dry,
+  };
+  const plan = buildInstallPlan(root, paths, scoped);
+
+  return plan.filter((action) => {
+    switch (action.kind) {
+      case "binary":
+        return true;
+      case "completions":
+        if (action.summary.startsWith("bash")) return detected.bashCompletion;
+        if (action.summary.startsWith("zsh")) return detected.zshCompletion;
+        if (action.summary.startsWith("fish")) return detected.fishCompletion;
+        return false;
+      case "cursor-skill":
+        return detected.cursorSkill;
+      case "claude-skill":
+        return detected.claudeSkill;
+      case "cursor-mcp":
+        return detected.cursorMcp;
+      case "claude-mcp":
+        return detected.claudeMcp;
+      default:
+        return false;
+    }
+  });
+}

package/src/install/shell.ts

@@ -0,0 +1,56 @@
+export interface ShellDetection {
+  bash: boolean;
+  zsh: boolean;
+  fish: boolean;
+}
+
+/** Detects which shells are available on PATH. */
+export function detectShells(): ShellDetection {
+  return {
+    bash: Bun.which("bash") !== null,
+    zsh: Bun.which("zsh") !== null,
+    fish: Bun.which("fish") !== null,
+  };
+}
+
+export function rcMarkerStart(appKey: string, tag: string): string {
+  return `# ${appKey}:${tag}`;
+}
+
+export function rcMarkerEnd(appKey: string, tag: string): string {
+  return `# end ${appKey}:${tag}`;
+}
+
+/** Returns rc snippet block for PATH, or null if already present. */
+export function buildPathRcBlock(appKey: string, bindir: string): string {
+  const start = rcMarkerStart(appKey, "path");
+  const end = rcMarkerEnd(appKey, "path");
+  return [start, `export PATH="${bindir}:$PATH"`, end].join("\n");
+}
+
+/** Returns rc snippet block for zsh fpath, or null if already present. */
+export function buildZshFpathRcBlock(appKey: string, completionsDir: string): string {
+  const start = rcMarkerStart(appKey, "fpath");
+  const end = rcMarkerEnd(appKey, "fpath");
+  return [start, `fpath=(${completionsDir} $fpath)`, end].join("\n");
+}
+
+/** Removes a marker-delimited block from rc file content. */
+export function removeRcBlock(content: string, appKey: string, tag: string): string {
+  const start = rcMarkerStart(appKey, tag);
+  const end = rcMarkerEnd(appKey, tag);
+  const re = new RegExp(
+    `${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}\\n?`,
+    "g",
+  );
+  return content.replace(re, "");
+}
+
+/** Returns true when the marker block already exists in content. */
+export function hasRcBlock(content: string, appKey: string, tag: string): boolean {
+  return content.includes(rcMarkerStart(appKey, tag));
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/install/status.ts

@@ -0,0 +1,63 @@
+import { CliProgram } from "../types.ts";
+import { buildInstallStatus, detectInstalledArtifacts } from "./detect-installed.ts";
+import type { InstallOpts } from "./plan.ts";
+import { resolveInstallPaths } from "./paths.ts";
+
+export function installOut(msg: string, opts: InstallOpts): void {
+  if (opts.quiet || opts.json) return;
+  process.stdout.write(msg + "\n");
+}
+
+export function installInfo(msg: string, opts: InstallOpts): void {
+  if (opts.quiet) return;
+  if (opts.json && !opts.dry) return;
+  const prefix = opts.dry ? "[dry run] " : "";
+  process.stderr.write(prefix + msg + "\n");
+}
+
+export function installErr(msg: string): void {
+  process.stderr.write(msg + "\n");
+}
+
+/** Prints install status to stdout (human or JSON). */
+export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
+  const paths = resolveInstallPaths(root, opts);
+  const detected = detectInstalledArtifacts(paths);
+  const status = buildInstallStatus(paths, detected);
+
+  if (opts.json) {
+    const json: Record<string, string> = {};
+    if (status.binary) json.binary = status.binary;
+    if (status.bashCompletion) json.bashCompletion = status.bashCompletion;
+    if (status.zshCompletion) json.zshCompletion = status.zshCompletion;
+    if (status.fishCompletion) json.fishCompletion = status.fishCompletion;
+    if (status.cursorSkill) json.cursorSkill = status.cursorSkill;
+    if (status.claudeSkill) json.claudeSkill = status.claudeSkill;
+    if (status.cursorMcp) json.cursorMcp = status.cursorMcp;
+    if (status.claudeMcp) json.claudeMcp = status.claudeMcp;
+    process.stdout.write(JSON.stringify(json, null, 2) + "\n");
+    return;
+  }
+
+  installOut(`Installed artifacts for ${root.key}:`, opts);
+  const lines: [string, string | undefined][] = [
+    ["binary", status.binary],
+    ["bash completion", status.bashCompletion],
+    ["zsh completion", status.zshCompletion],
+    ["fish completion", status.fishCompletion],
+    ["cursor skill", status.cursorSkill],
+    ["claude skill", status.claudeSkill],
+    ["cursor mcp", status.cursorMcp],
+    ["claude mcp", status.claudeMcp],
+  ];
+  let any = false;
+  for (const [label, value] of lines) {
+    if (value) {
+      installOut(`  ${label}: ${value}`, opts);
+      any = true;
+    }
+  }
+  if (!any) {
+    installOut("  (none detected)", opts);
+  }
+}

package/src/install/uninstall.ts

@@ -0,0 +1,111 @@
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { CliProgram } from "../types.ts";
+import { uninstallBinary } from "./binary.ts";
+import { uninstallCompletions } from "./completions.ts";
+import { detectInstalledArtifacts } from "./detect-installed.ts";
+import { removeMcpConfig } from "./mcp-config.ts";
+import { InstallPaths, userHome } from "./paths.ts";
+import type { InstallOpts } from "./plan.ts";
+
+export interface UninstallAction {
+  summary: string;
+  message: string;
+  run: () => string[];
+}
+
+function scopeAll(opts: InstallOpts): boolean {
+  return !opts.bin && !opts.completions && !opts.skill && !opts.mcp;
+}
+
+/** Builds uninstall actions from detected artifacts. */
+export function buildUninstallPlan(
+  root: CliProgram,
+  paths: InstallPaths,
+  opts: InstallOpts,
+): UninstallAction[] {
+  const detected = detectInstalledArtifacts(paths);
+  const all = scopeAll(opts);
+  const dry = !!opts.dry;
+  const actions: UninstallAction[] = [];
+
+  if ((all || opts.bin) && detected.binary) {
+    actions.push({
+      summary: `binary: ${paths.binaryPath}`,
+      message: `Removing binary ${paths.binaryPath}`,
+      run: () => uninstallBinary(root, paths, dry),
+    });
+  }
+
+  if ((all || opts.completions) && (detected.bashCompletion || detected.zshCompletion || detected.fishCompletion)) {
+    if (detected.bashCompletion) {
+      actions.push({
+        summary: `bash completion: ${paths.bashCompletion}`,
+        message: `Removing bash completion ${paths.bashCompletion}`,
+        run: () => uninstallCompletions(paths, dry).filter((p) => p === paths.bashCompletion),
+      });
+    }
+    if (detected.zshCompletion) {
+      actions.push({
+        summary: `zsh completion: ${paths.zshCompletion}`,
+        message: `Removing zsh completion ${paths.zshCompletion}`,
+        run: () => uninstallCompletions(paths, dry).filter((p) => p === paths.zshCompletion),
+      });
+    }
+    if (detected.fishCompletion) {
+      actions.push({
+        summary: `fish completion: ${paths.fishCompletion}`,
+        message: `Removing fish completion ${paths.fishCompletion}`,
+        run: () => uninstallCompletions(paths, dry).filter((p) => p === paths.fishCompletion),
+      });
+    }
+  }
+
+  if ((all || opts.skill) && detected.cursorSkill) {
+    actions.push({
+      summary: `cursor skill: ${paths.cursorSkillDir}/`,
+      message: `Removing Cursor skill ${paths.cursorSkillDir}/`,
+      run: () => [],
+    });
+  }
+
+  if ((all || opts.skill) && detected.claudeSkill) {
+    actions.push({
+      summary: `claude skill: ${paths.claudeSkillDir}/`,
+      message: `Removing Claude Code skill ${paths.claudeSkillDir}/`,
+      run: () => [],
+    });
+  }
+
+  if ((all || opts.mcp) && root.mcpServer !== undefined) {
+    if (detected.cursorMcp) {
+      actions.push({
+        summary: `cursor mcp: ${paths.cursorMcpPath}`,
+        message: `Removing MCP server "${paths.mcpName}" from ${paths.cursorMcpPath}`,
+        run: () => {
+          removeMcpConfig(paths.cursorMcpPath, paths.mcpName, dry);
+          return [paths.cursorMcpPath];
+        },
+      });
+    }
+    if (detected.claudeMcp) {
+      actions.push({
+        summary: `claude mcp: ${paths.claudeMcpPath}`,
+        message: `Removing MCP server "${paths.mcpName}" from ${paths.claudeMcpPath}`,
+        run: () => {
+          removeMcpConfig(paths.claudeMcpPath, paths.mcpName, dry);
+          return [paths.claudeMcpPath];
+        },
+      });
+    }
+  }
+
+  return actions;
+}
+
+/** Rimraf skill directories during uninstall. */
+export function uninstallSkillDir(dir: string, dry: boolean): string[] {
+  if (!existsSync(dir)) return [];
+  if (!dry) rmSync(dir, { recursive: true, force: true });
+  return [dir + "/"];
+}

package/src/invoke.ts

@@ -6,7 +6,7 @@ process.exit so MCP tool calls can run handlers repeatedly.
 
 import { CliContext } from "./context.ts";
 import { parse, postParseValidate, ParseKind } from "./parse.ts";
-import { CliCommand } from "./types.ts";
+import { type CliNode, type CliProgram, isCliRouter } from "./types.ts";
 import { format } from "node:util";
 
 /** Outcome of a non-exiting CLI invocation. */
@@ -40,7 +40,7 @@ class CliInvokeExit extends Error {
 }
 
 /** Looks up a subcommand or routing node by `key`. */
-function findChild(cmds: CliCommand[], name: string): CliCommand | undefined {
+function findChild(cmds: CliNode[], name: string): CliNode | undefined {
   return cmds.find((c) => c.key === name);
 }
 
@@ -48,7 +48,7 @@ function findChild(cmds: CliCommand[], name: string): CliCommand | undefined {
  * Parses argv against the user root, runs the leaf handler, and returns captured output.
  * Never calls process.exit.
  */
-export async function cliInvoke(root: CliCommand, argv: string[]): Promise<CliInvokeResult> {
+export async function cliInvoke(root: CliProgram, argv: string[]): Promise<CliInvokeResult> {
   let pr = parse(root, argv);
   pr = postParseValidate(root, pr);
 
@@ -82,9 +82,18 @@ export async function cliInvoke(root: CliCommand, argv: string[]): Promise<CliIn
     };
   }
 
-  let current: CliCommand = root;
+  let current: CliProgram = root;
   for (const seg of pr.path) {
-    const ch = findChild(current.commands ?? [], seg);
+    if (!isCliRouter(current)) {
+      return {
+        kind: "error",
+        exitCode: 1,
+        stdout: "",
+        stderr: "Internal error: missing handler for path.",
+        errorMsg: "Internal error: missing handler for path.",
+      };
+    }
+    const ch = findChild(current.commands, seg);
     if (!ch) {
       return {
         kind: "error",

package/src/mcp/server.ts

@@ -4,7 +4,7 @@ resources, and ping. Responses are newline-delimited JSON on stdout only.
 */
 
 import { cliInvoke } from "../invoke.ts";
-import { CliCommand } from "../types.ts";
+import { CliProgram } from "../types.ts";
 import { buildToolCallSuccess } from "./result.ts";
 import {
   allMcpResources,
@@ -41,7 +41,7 @@ function writeError(id: string | number | null | undefined, code: number, messag
 }
 
 /** Handles one NDJSON request line. */
-async function handleRequestLine(root: CliCommand, line: string): Promise<void> {
+async function handleRequestLine(root: CliProgram, line: string): Promise<void> {
   let req: JsonRpcRequest;
   try {
     req = JSON.parse(line) as JsonRpcRequest;
@@ -217,7 +217,7 @@ async function handleRequestLine(root: CliCommand, line: string): Promise<void>
 }
 
 /** Runs the MCP NDJSON read loop on stdin until EOF. */
-export async function mcpServeStdioLoop(root: CliCommand): Promise<void> {
+export async function mcpServeStdioLoop(root: CliProgram): Promise<void> {
   let buffer = "";
   for await (const chunk of Bun.stdin.stream()) {
     buffer += new TextDecoder().decode(chunk);

package/src/mcp/tools.ts

@@ -1,5 +1,5 @@
 /*
-This module maps CliCommand leaf nodes to MCP tool definitions and converts
+This module maps CliProgram leaf nodes to MCP tool definitions and converts
 flat JSON tool arguments into argv for cliInvoke.
 */
 
@@ -7,7 +7,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { collectOptionDefs } from "../parse.ts";
 import { cliSchemaJson } from "../schema.ts";
-import { CliCommand, CliOption, CliOptionKind, CliPositional } from "../types.ts";
+import { CliProgram, CliLeaf, CliNode, CliOption, CliOptionKind, CliPositional, isCliLeaf, isCliRouter } from "../types.ts";
 
 /** Default URI for the CLI schema MCP resource. */
 export const MCP_SCHEMA_URI_DEFAULT = "argsbarg://schema";
@@ -21,7 +21,7 @@ export interface McpToolDef {
   /** Command path segments from the program root. */
   path: string[];
   /** Leaf command node. */
-  leaf: CliCommand;
+  leaf: CliLeaf;
   /** JSON Schema for tools/call arguments. */
   inputSchema: Record<string, unknown>;
 }
@@ -38,7 +38,7 @@ export function sanitizeToolSegment(key: string): string {
 }
 
 /** Builds the MCP tool name for a leaf at the given path. */
-export function mcpToolName(root: CliCommand, path: string[]): string {
+export function mcpToolName(root: CliProgram, path: string[]): string {
   if (path.length === 0) {
     return sanitizeToolSegment(root.key);
   }
@@ -71,7 +71,7 @@ function positionalProperty(p: CliPositional): Record<string, unknown> {
 }
 
 /** Builds inputSchema for a leaf command. */
-function buildInputSchema(root: CliCommand, path: string[], leaf: CliCommand): Record<string, unknown> {
+function buildInputSchema(root: CliProgram, path: string[], leaf: CliLeaf): Record<string, unknown> {
   const properties: Record<string, unknown> = {};
   const required: string[] = [];
 
@@ -102,7 +102,7 @@ function buildInputSchema(root: CliCommand, path: string[], leaf: CliCommand): R
 }
 
 /** Resolves MCP tool description with optional override and requiresEnv suffix. */
-function resolveToolDescription(root: CliCommand, path: string[], leaf: CliCommand): string {
+function resolveToolDescription(root: CliProgram, path: string[], leaf: CliLeaf): string {
   if (leaf.mcpTool?.description) {
     return leaf.mcpTool.description;
   }
@@ -124,7 +124,7 @@ export interface McpResourceEntry {
 }
 
 /** Returns built-in schema resource plus user mcpServer.resources. */
-export function allMcpResources(root: CliCommand): McpResourceEntry[] {
+export function allMcpResources(root: CliProgram): McpResourceEntry[] {
   const schemaUri = resolveMcpSchemaUri(root);
   const builtIn: McpResourceEntry = {
     uri: schemaUri,
@@ -144,13 +144,13 @@ export function allMcpResources(root: CliCommand): McpResourceEntry[] {
 }
 
 /** Recursively collects MCP tool definitions from user leaf commands. */
-export function collectMcpTools(root: CliCommand): McpToolDef[] {
+export function collectMcpTools(root: CliProgram): McpToolDef[] {
   const out: McpToolDef[] = [];
 
   /** Walks the command tree and appends leaf tools. */
-  function walk(cmd: CliCommand, path: string[]): void {
-    if ("handler" in cmd && cmd.handler) {
-      if (cmd.key === "completion" || cmd.key === "ai") {
+  function walk(cmd: CliNode, path: string[]): void {
+    if (isCliLeaf(cmd)) {
+      if (cmd.key === "completion" || cmd.key === "install" || cmd.key === "mcp") {
         return;
       }
       if (cmd.mcpTool?.enabled === false) {
@@ -165,15 +165,15 @@ export function collectMcpTools(root: CliCommand): McpToolDef[] {
       });
       return;
     }
-    for (const ch of cmd.commands ?? []) {
+    for (const ch of cmd.commands) {
       walk(ch, [...path, ch.key]);
     }
   }
 
-  if ("handler" in root && root.handler) {
+  if (isCliLeaf(root)) {
     walk(root, []);
   } else {
-    for (const ch of root.commands ?? []) {
+    for (const ch of root.commands) {
       walk(ch, [ch.key]);
     }
   }
@@ -193,7 +193,7 @@ function resolveMcpVersionFromPackageJson(): string | undefined {
 }
 
 /** Resolves MCP server name and version for initialize. */
-export function resolveMcpServerInfo(root: CliCommand): { name: string; version: string } {
+export function resolveMcpServerInfo(root: CliProgram): { name: string; version: string } {
   return {
     name: root.mcpServer?.name ?? root.key,
     version: root.mcpServer?.version ?? resolveMcpVersionFromPackageJson() ?? "0.0.0",
@@ -201,13 +201,13 @@ export function resolveMcpServerInfo(root: CliCommand): { name: string; version:
 }
 
 /** Resolves the schema resource URI for this app. */
-export function resolveMcpSchemaUri(root: CliCommand): string {
+export function resolveMcpSchemaUri(root: CliProgram): string {
   return root.mcpServer?.schemaResourceUri ?? MCP_SCHEMA_URI_DEFAULT;
 }
 
 /** Converts flat MCP tool arguments to argv for cliInvoke. */
 export function mcpToolCallToArgv(
-  root: CliCommand,
+  root: CliProgram,
   tool: McpToolDef,
   args: Record<string, unknown>,
 ): string[] | { error: string } {

package/src/mcp.ts

@@ -4,13 +4,13 @@ This module starts the ArgsBarg MCP stdio server for opt-in program roots.
 
 import { mcpServeStdioLoop } from "./mcp/server.ts";
 import { bootstrapMcpEnv } from "./mcp/env.ts";
-import { CliCommand } from "./types.ts";
+import { CliProgram } from "./types.ts";
 
 /**
  * Runs the MCP JSON-RPC server on stdin/stdout until stdin closes, then exits.
  * Caller must ensure `root.mcpServer` is set.
  */
-export async function cliMcpServeStdio(root: CliCommand): Promise<never> {
+export async function cliMcpServeStdio(root: CliProgram): Promise<never> {
   try {
     if (root.mcpServer) {
       bootstrapMcpEnv(root.mcpServer);