argsbarg 4.0.4 → 4.1.1

package/src/install/targets/configure.ts

@@ -0,0 +1,63 @@
+import { appConfigInstalled, displayAppConfigPath, uninstallAppConfig } from "../../config/file.ts";
+import type { CliProgram, InstallAgentIntegration } from "../../types.ts";
+import type { InstallPaths } from "../paths.ts";
+import { InstallTarget } from "../target-base.ts";
+import type {
+  DetectedSnapshot,
+  InstallAction,
+  InstalledArtifacts,
+  InstallStatus,
+  TargetPlanContext,
+  UninstallAction,
+} from "../target-types.ts";
+
+/** App config file (install --configure / wizard). */
+class ConfigureInstallTarget extends InstallTarget {
+  readonly key = "configure" as const;
+  readonly actionKind = "configure" as const;
+  readonly category = "core" as const;
+
+  defaultIncludedInAll(_integration: InstallAgentIntegration): boolean {
+    return false;
+  }
+
+  isAvailable(root: CliProgram, _paths: InstallPaths): boolean {
+    return root.appConfig !== undefined;
+  }
+
+  isDetected(_paths: InstallPaths, root: CliProgram): boolean {
+    if (!root.appConfig) return false;
+    return appConfigInstalled(root);
+  }
+
+  applyDetected(_paths: InstallPaths, _root: CliProgram, _out: InstalledArtifacts): void {}
+
+  protected isDetectedFromSnapshot(detected: DetectedSnapshot): boolean {
+    return detected.appConfig ?? false;
+  }
+
+  protected formatStatusLine(_paths: InstallPaths, root: CliProgram): string {
+    return displayAppConfigPath(root);
+  }
+
+  protected assignStatusLine(_status: InstallStatus, _line: string): void {
+    // configure status shown via appConfigStatus in status.ts
+  }
+
+  protected buildInstallActions(_ctx: TargetPlanContext): InstallAction[] {
+    return [];
+  }
+
+  protected buildUninstallActions(ctx: TargetPlanContext): UninstallAction[] {
+    return [
+      {
+        kind: "configure",
+        summary: `app config: ${displayAppConfigPath(ctx.root)}`,
+        message: `Removing app config ${displayAppConfigPath(ctx.root)}`,
+        run: () => uninstallAppConfig(ctx.root, ctx.dry),
+      },
+    ];
+  }
+}
+
+export const configureTarget = new ConfigureInstallTarget();

package/src/install/targets/cursor-mcp.ts

@@ -0,0 +1,15 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { userHome } from "../paths.ts";
+import { McpJsonInstallTarget } from "../target-mcp-json.ts";
+
+export const cursorMcpTarget = new McpJsonInstallTarget({
+  key: "cursorMcp",
+  actionKind: "cursor-mcp",
+  label: "cursor mcp",
+  pairedSkillKey: "cursorSkill",
+  configPath: (p) => p.cursorMcpPath,
+  detectedKey: "cursorMcp",
+  statusField: "cursorMcp",
+  isAvailable: () => existsSync(join(userHome(), ".cursor")),
+});

package/src/install/targets/cursor-skill.ts

@@ -0,0 +1,16 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { userHome } from "../paths.ts";
+import { SkillInstallTarget } from "../target-skill.ts";
+
+export const cursorSkillTarget = new SkillInstallTarget({
+  key: "cursorSkill",
+  actionKind: "cursor-skill",
+  label: "Cursor",
+  uninstallPrefix: "cursor skill",
+  pairedMcpKey: "cursorMcp",
+  skillDir: (p) => p.cursorSkillDir,
+  detectedKey: "cursorSkill",
+  statusField: "cursorSkill",
+  isAvailable: () => existsSync(join(userHome(), ".cursor")),
+});

package/src/install/targets/index.ts

@@ -0,0 +1,50 @@
+import type { InstallTarget } from "../target-base.ts";
+import { appTarget } from "./app.ts";
+import { chatgptMcpTarget } from "./chatgpt-mcp.ts";
+import { claudeCodeMcpTarget } from "./claude-code-mcp.ts";
+import { claudeDesktopMcpTarget } from "./claude-desktop-mcp.ts";
+import { claudeSkillTarget } from "./claude-skill.ts";
+import { codexMcpTarget } from "./codex-mcp.ts";
+import { codexSkillTarget } from "./codex-skill.ts";
+import { configureTarget } from "./configure.ts";
+import { cursorMcpTarget } from "./cursor-mcp.ts";
+import { cursorSkillTarget } from "./cursor-skill.ts";
+import { openclawMcpTarget } from "./openclaw-mcp.ts";
+import { openclawSkillTarget } from "./openclaw-skill.ts";
+import { opencodeMcpTarget } from "./opencode-mcp.ts";
+import { opencodeSkillTarget } from "./opencode-skill.ts";
+
+/** Ordered install targets (plan iteration order). */
+export const INSTALL_TARGETS: InstallTarget[] = [
+  appTarget,
+  cursorSkillTarget,
+  claudeSkillTarget,
+  codexSkillTarget,
+  opencodeSkillTarget,
+  openclawSkillTarget,
+  cursorMcpTarget,
+  claudeCodeMcpTarget,
+  claudeDesktopMcpTarget,
+  opencodeMcpTarget,
+  codexMcpTarget,
+  openclawMcpTarget,
+  chatgptMcpTarget,
+  configureTarget,
+];
+
+export {
+  appTarget,
+  chatgptMcpTarget,
+  claudeCodeMcpTarget,
+  claudeDesktopMcpTarget,
+  claudeSkillTarget,
+  codexMcpTarget,
+  codexSkillTarget,
+  configureTarget,
+  cursorMcpTarget,
+  cursorSkillTarget,
+  openclawMcpTarget,
+  openclawSkillTarget,
+  opencodeMcpTarget,
+  opencodeSkillTarget,
+};

package/src/install/targets/openclaw-mcp.ts

@@ -0,0 +1,25 @@
+import { openclawOnPath } from "../mcp-openclaw.ts";
+import {
+  checkOpenclawMcpConflict,
+  McpCliInstallTarget,
+  mergeOpenclawMcpConfig,
+  openclawMcpHasServer,
+  removeOpenclawMcpConfig,
+} from "../target-mcp-cli.ts";
+
+export const openclawMcpTarget = new McpCliInstallTarget({
+  key: "openclawMcp",
+  actionKind: "openclaw-mcp",
+  label: "openclaw mcp",
+  pairedSkillKey: "openclawSkill",
+  configPath: (p) => p.openclawConfigPath,
+  detectedKey: "openclawMcp",
+  statusField: "openclawMcp",
+  isAvailable: () => openclawOnPath(),
+  hasServer: openclawMcpHasServer,
+  installMessage: 'Registering MCP server "{name}" via openclaw mcp add',
+  uninstallMessage: 'Removing MCP server "{name}" from OpenClaw via openclaw mcp unset',
+  merge: mergeOpenclawMcpConfig,
+  remove: removeOpenclawMcpConfig,
+  preflight: checkOpenclawMcpConflict,
+});

package/src/install/targets/openclaw-skill.ts

@@ -0,0 +1,17 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { openclawOnPath } from "../mcp-openclaw.ts";
+import { userHome } from "../paths.ts";
+import { SkillInstallTarget } from "../target-skill.ts";
+
+export const openclawSkillTarget = new SkillInstallTarget({
+  key: "openclawSkill",
+  actionKind: "openclaw-skill",
+  label: "OpenClaw",
+  uninstallPrefix: "openclaw skill",
+  pairedMcpKey: "openclawMcp",
+  skillDir: (p) => p.openclawSkillDir,
+  detectedKey: "openclawSkill",
+  statusField: "openclawSkill",
+  isAvailable: () => existsSync(join(userHome(), ".openclaw")) || openclawOnPath(),
+});

package/src/install/targets/opencode-mcp.ts

@@ -0,0 +1,101 @@
+import type { CliProgram } from "../../types.ts";
+import {
+  checkOpenCodeMcpConflict,
+  detectOpenCodeMcpConfigPath,
+  expectedOpenCodeMcpEntry,
+  mergeOpenCodeMcpConfig,
+  opencodePresent,
+  removeOpenCodeMcpConfig,
+} from "../mcp-opencode.ts";
+import { displayInstallPath, type InstallPaths, userHome } from "../paths.ts";
+import { InstallTarget } from "../target-base.ts";
+import type {
+  DetectedSnapshot,
+  InstallAction,
+  InstalledArtifacts,
+  InstallStatus,
+  TargetPlanContext,
+  UninstallAction,
+} from "../target-types.ts";
+
+function resolveConfigPath(paths: InstallPaths, home: string): string {
+  return detectOpenCodeMcpConfigPath(home, paths.mcpName) ?? paths.opencodeMcpPath;
+}
+
+/** OpenCode MCP (top-level `mcp` key, not `mcpServers`). */
+class OpenCodeMcpInstallTarget extends InstallTarget {
+  readonly key = "opencodeMcp" as const;
+  readonly actionKind = "opencode-mcp" as const;
+  readonly category = "mcp" as const;
+  readonly pairedKey = "opencodeSkill" as const;
+
+  isAvailable(_root: CliProgram, _paths: InstallPaths): boolean {
+    return opencodePresent(userHome());
+  }
+
+  isDetected(paths: InstallPaths, _root: CliProgram): boolean {
+    return detectOpenCodeMcpConfigPath(userHome(), paths.mcpName) !== undefined;
+  }
+
+  applyDetected(paths: InstallPaths, root: CliProgram, out: InstalledArtifacts): void {
+    out.opencodeMcp = this.isDetected(paths, root);
+  }
+
+  protected isDetectedFromSnapshot(detected: DetectedSnapshot): boolean {
+    return detected.opencodeMcp;
+  }
+
+  protected formatStatusLine(paths: InstallPaths, _root: CliProgram): string {
+    const home = userHome();
+    const path = detectOpenCodeMcpConfigPath(home, paths.mcpName) ?? paths.opencodeMcpPath;
+    return `${displayInstallPath(path)} (server "${paths.mcpName}")`;
+  }
+
+  protected assignStatusLine(status: InstallStatus, line: string): void {
+    status.opencodeMcp = line;
+  }
+
+  preflight(ctx: TargetPlanContext): string | null {
+    const entry = expectedOpenCodeMcpEntry(ctx.root);
+    return checkOpenCodeMcpConflict(
+      ctx.paths.opencodeMcpPath,
+      ctx.paths.mcpName,
+      entry,
+      !!ctx.opts.yes,
+    );
+  }
+
+  protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {
+    const entry = expectedOpenCodeMcpEntry(ctx.root);
+    const configPath = ctx.paths.opencodeMcpPath;
+    return [
+      {
+        kind: this.actionKind,
+        summary: `opencode mcp: ${displayInstallPath(configPath)}`,
+        message: `Merging MCP server "${ctx.paths.mcpName}" into ${displayInstallPath(configPath)}`,
+        run: () => {
+          mergeOpenCodeMcpConfig(configPath, ctx.paths.mcpName, entry, ctx.dry);
+          return [configPath];
+        },
+      },
+    ];
+  }
+
+  protected buildUninstallActions(ctx: TargetPlanContext): UninstallAction[] {
+    const home = userHome();
+    const configPath = resolveConfigPath(ctx.paths, home);
+    return [
+      {
+        kind: this.actionKind,
+        summary: `opencode mcp: ${displayInstallPath(configPath)}`,
+        message: `Removing MCP server "${ctx.paths.mcpName}" from ${displayInstallPath(configPath)}`,
+        run: () => {
+          removeOpenCodeMcpConfig(configPath, ctx.paths.mcpName, ctx.dry);
+          return [configPath];
+        },
+      },
+    ];
+  }
+}
+
+export const opencodeMcpTarget = new OpenCodeMcpInstallTarget();

package/src/install/targets/opencode-skill.ts

@@ -0,0 +1,15 @@
+import { opencodePresent } from "../mcp-opencode.ts";
+import { userHome } from "../paths.ts";
+import { SkillInstallTarget } from "../target-skill.ts";
+
+export const opencodeSkillTarget = new SkillInstallTarget({
+  key: "opencodeSkill",
+  actionKind: "opencode-skill",
+  label: "OpenCode",
+  uninstallPrefix: "opencode skill",
+  pairedMcpKey: "opencodeMcp",
+  skillDir: (p) => p.opencodeSkillDir,
+  detectedKey: "opencodeSkill",
+  statusField: "opencodeSkill",
+  isAvailable: () => opencodePresent(userHome()),
+});

package/src/install/targets.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, test } from "bun:test";
+import type { CliProgram } from "../types.ts";
+import { normalizeInstallRawOpts } from "./normalize.ts";
+import { normalizeUninstallRawOpts } from "./normalize-uninstall.ts";
+import { resolveAgentIntegration, resolveEffectiveInstallTargets } from "./target-effective.ts";
+import { isArtifactInScope } from "./target-scope.ts";
+
+describe("normalizeInstallRawOpts", () => {
+  test("bare install sets all", () => {
+    expect(normalizeInstallRawOpts({})).toEqual({ all: "1" });
+  });
+
+  test("bare uninstall sets all", () => {
+    expect(normalizeUninstallRawOpts({})).toEqual({
+      uninstall: "1",
+      all: "1",
+    });
+  });
+
+  test("configure-only install unchanged", () => {
+    expect(normalizeInstallRawOpts({ configure: "1" })).toEqual({ configure: "1" });
+  });
+});
+
+describe("resolveAgentIntegration", () => {
+  test("defaults to skill without MCP", () => {
+    expect(resolveAgentIntegration(undefined, false)).toBe("skill");
+  });
+
+  test("defaults to mcp when MCP enabled", () => {
+    expect(resolveAgentIntegration(undefined, true)).toBe("mcp");
+  });
+});
+
+describe("resolveEffectiveInstallTargets", () => {
+  test("defaults app and configure not in --all", () => {
+    const t = resolveEffectiveInstallTargets(undefined);
+    expect(t.app.includedInAll).toBe(false);
+    expect(t.configure.includedInAll).toBe(false);
+  });
+
+  test("skill mode includes skills in --all not MCP pairs", () => {
+    const program: Pick<CliProgram, "mcpServer"> = {};
+    const t = resolveEffectiveInstallTargets(undefined, program);
+    expect(t.cursorSkill.includedInAll).toBe(true);
+    expect(t.cursorMcp.includedInAll).toBe(false);
+  });
+
+  test("mcp mode includes MCP in --all not paired skills", () => {
+    const program: Pick<CliProgram, "mcpServer"> = { mcpServer: { enabled: true } };
+    const t = resolveEffectiveInstallTargets(undefined, program);
+    expect(t.cursorMcp.includedInAll).toBe(true);
+    expect(t.cursorSkill.includedInAll).toBe(false);
+    expect(t.claudeDesktopMcp.includedInAll).toBe(true);
+  });
+
+  test("both mode includes MCP and skills", () => {
+    const program: Pick<CliProgram, "mcpServer"> = { mcpServer: { enabled: true } };
+    const t = resolveEffectiveInstallTargets({ agentIntegration: "both" }, program);
+    expect(t.cursorMcp.includedInAll).toBe(true);
+    expect(t.cursorSkill.includedInAll).toBe(true);
+  });
+
+  test("per-key override disables one skill", () => {
+    const t = resolveEffectiveInstallTargets({
+      targets: { cursorSkill: false },
+    });
+    expect(t.claudeSkill.includedInAll).toBe(true);
+    expect(t.cursorSkill.enabled).toBe(false);
+  });
+
+  test("scoped --mcp uses effective targets not all MCP hosts", () => {
+    const program: CliProgram = {
+      key: "app",
+      version: "1",
+      description: "x",
+      mcpServer: { enabled: true },
+      install: { agentIntegration: "skill" },
+      handler: () => {},
+    };
+    const effective = resolveEffectiveInstallTargets(program.install, program);
+    const scope = { mcp: true };
+    expect(isArtifactInScope("cursorMcp", scope, effective, "install-scoped", program)).toBe(false);
+    expect(
+      isArtifactInScope(
+        "cursorMcp",
+        scope,
+        resolveEffectiveInstallTargets(
+          { targets: { cursorMcp: true }, agentIntegration: "both" },
+          program,
+        ),
+        "install-scoped",
+        program,
+      ),
+    ).toBe(true);
+  });
+
+  test("scoped --mcp --skill --configure includes skill and mcp not only configure", () => {
+    const program: CliProgram = {
+      key: "app",
+      version: "1",
+      description: "x",
+      mcpServer: { enabled: true },
+      install: { agentIntegration: "both" },
+      handler: () => {},
+    };
+    const effective = resolveEffectiveInstallTargets(program.install, program);
+    const scope = { mcp: true, skill: true, configure: true };
+    expect(isArtifactInScope("cursorSkill", scope, effective, "install-scoped", program)).toBe(
+      true,
+    );
+    expect(isArtifactInScope("cursorMcp", scope, effective, "install-scoped", program)).toBe(true);
+    expect(isArtifactInScope("configure", scope, effective, "install-scoped", program)).toBe(true);
+    expect(isArtifactInScope("claudeSkill", scope, effective, "install-scoped", program)).toBe(
+      true,
+    );
+  });
+});

package/src/install/uninstall.ts

@@ -1,164 +1,19 @@
 import { existsSync, rmSync } from "node:fs";
-import { resolveAppConfigPath, uninstallAppConfig } from "../config/file.ts";
 import type { CliProgram } from "../types.ts";
-import { uninstallBinary } from "./binary.ts";
-import { uninstallCompletions } from "./completions.ts";
-import { detectInstalledArtifacts } from "./detect-installed.ts";
-import { removeCodexMcpConfig } from "./mcp-codex.ts";
-import { removeMcpConfig } from "./mcp-config.ts";
-import { detectOpenCodeMcpConfigPath, removeOpenCodeMcpConfig } from "./mcp-opencode.ts";
-import { type InstallPaths, userHome } from "./paths.ts";
-import {
-  type InstallOpts,
-  wantsInstallBin,
-  wantsInstallCompletions,
-  wantsInstallMcp,
-  wantsInstallSkill,
-  wantsUninstallConfig,
-} from "./plan.ts";
+import type { InstallPaths } from "./paths.ts";
+import { buildUninstallPlanFromTargets } from "./target-plan-build.ts";
+import { skillTargetForUninstallSummary } from "./target-registry.ts";
+import type { InstallOpts, UninstallAction } from "./target-types.ts";
 
-export interface UninstallAction {
-  summary: string;
-  message: string;
-  run: () => string[];
-}
+export type { InstallActionKind, InstallOpts, UninstallAction } from "./target-types.ts";
 
-/** Builds uninstall actions for scoped targets (--all mirrors install --all). */
+/** Builds uninstall actions for scoped targets or --all (ignores install.targets on --all). */
 export function buildUninstallPlan(
   root: CliProgram,
   paths: InstallPaths,
   opts: InstallOpts,
 ): UninstallAction[] {
-  const detected = detectInstalledArtifacts(paths);
-  const dry = !!opts.dry;
-  const actions: UninstallAction[] = [];
-
-  if (wantsInstallBin(opts) && detected.binary) {
-    actions.push({
-      summary: `binary: ${paths.binaryPath}`,
-      message: `Removing binary ${paths.binaryPath}`,
-      run: () => uninstallBinary(root, paths, dry),
-    });
-  }
-
-  if (
-    wantsInstallCompletions(opts) &&
-    (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 (wantsInstallSkill(opts) && detected.cursorSkill) {
-    actions.push({
-      summary: `cursor skill: ${paths.cursorSkillDir}/`,
-      message: `Removing Cursor skill ${paths.cursorSkillDir}/`,
-      run: () => [],
-    });
-  }
-
-  if (wantsInstallSkill(opts) && detected.claudeSkill) {
-    actions.push({
-      summary: `claude skill: ${paths.claudeSkillDir}/`,
-      message: `Removing Claude Code skill ${paths.claudeSkillDir}/`,
-      run: () => [],
-    });
-  }
-
-  if (wantsInstallMcp(opts, root)) {
-    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 code mcp: ${paths.claudeMcpPath}`,
-        message: `Removing MCP server "${paths.mcpName}" from ${paths.claudeMcpPath}`,
-        run: () => {
-          removeMcpConfig(paths.claudeMcpPath, paths.mcpName, dry);
-          return [paths.claudeMcpPath];
-        },
-      });
-    }
-    if (detected.claudeDesktopMcp) {
-      actions.push({
-        summary: `claude desktop mcp: ${paths.claudeDesktopMcpPath}`,
-        message: `Removing MCP server "${paths.mcpName}" from ${paths.claudeDesktopMcpPath}`,
-        run: () => {
-          removeMcpConfig(paths.claudeDesktopMcpPath, paths.mcpName, dry);
-          return [paths.claudeDesktopMcpPath];
-        },
-      });
-    }
-    if (detected.opencodeMcp) {
-      const openCodePath =
-        detectOpenCodeMcpConfigPath(userHome(), paths.mcpName) ?? paths.opencodeMcpPath;
-      actions.push({
-        summary: `opencode mcp: ${openCodePath}`,
-        message: `Removing MCP server "${paths.mcpName}" from ${openCodePath}`,
-        run: () => {
-          removeOpenCodeMcpConfig(openCodePath, paths.mcpName, dry);
-          return [openCodePath];
-        },
-      });
-    }
-    if (detected.codexMcp) {
-      actions.push({
-        summary: `codex mcp: ${paths.codexConfigPath}`,
-        message: `Removing MCP server "${paths.mcpName}" from Codex via codex mcp remove`,
-        run: () => {
-          removeCodexMcpConfig(userHome(), paths.mcpName, dry);
-          return [paths.codexConfigPath];
-        },
-      });
-    }
-    if (detected.chatGptMcp) {
-      actions.push({
-        summary: `chatgpt desktop mcp: ${paths.chatGptMcpPath}`,
-        message: `Removing MCP server "${paths.mcpName}" from ${paths.chatGptMcpPath}`,
-        run: () => {
-          removeMcpConfig(paths.chatGptMcpPath, paths.mcpName, dry);
-          return [paths.chatGptMcpPath];
-        },
-      });
-    }
-  }
-
-  if (wantsUninstallConfig(opts, root)) {
-    const configPath = resolveAppConfigPath(root);
-    actions.push({
-      summary: `app config: ${configPath}`,
-      message: `Removing app config ${configPath}`,
-      run: () => (uninstallAppConfig(root, dry) ? [configPath] : []),
-    });
-  }
-
-  return actions;
+  return buildUninstallPlanFromTargets(root, paths, opts);
 }
 
 /** Rimraf skill directories during uninstall. */
@@ -167,3 +22,12 @@ export function uninstallSkillDir(dir: string, dry: boolean): string[] {
   if (!dry) rmSync(dir, { recursive: true, force: true });
   return [`${dir}/`];
 }
+
+/** Skill directory for uninstall action summary prefix. */
+export function skillDirFromUninstallSummary(
+  summary: string,
+  paths: InstallPaths,
+): string | undefined {
+  const target = skillTargetForUninstallSummary(summary);
+  return target?.skillDir(paths);
+}

package/src/invoke.test.ts

@@ -16,7 +16,13 @@ test("ctx.invocation is cli via Cli.run", async () => {
   const indexPath = join(import.meta.dir, "index.ts");
   const { stdout } = await $`bun -e ${`
 import { Cli, CliProgram } from ${JSON.stringify(indexPath)};
-const program = { key: "t", description: "d", version: "0.0.0", handler: (ctx) => console.log(ctx.invocation) };
+const program = {
+  key: "t",
+  description: "d",
+  version: "0.0.0",
+  install: { enabled: false },
+  handler: (ctx) => console.log(ctx.invocation),
+};
 await new Cli(program).run([]);
   `}`.quiet();
   expect(stdout.toString().trim()).toBe("cli");

package/src/mcp/bundle.ts

@@ -160,9 +160,21 @@ export function packMcpBundle(program: CliProgram, opts: PackMcpBundleOpts = {})
   }
 }
 
-/** Runs `mcp bundle`: writes `.mcpb` and Claude Code plugin zip; prints both paths. */
+/** Runs `mcp bundle`: writes enabled dist artifacts; prints one path per line. */
 export function runMcpBundle(program: CliProgram): void {
-  const mcpbPath = packMcpBundle(program);
-  const pluginPath = packClaudePlugin(program);
-  process.stdout.write(`${mcpbPath}\n${pluginPath}\n`);
+  const mcp = program.mcpServer;
+  if (!mcp?.mcpd && !mcp?.claudePlugin) {
+    throw new Error(
+      "mcp bundle: enable mcpServer.mcpd and/or mcpServer.claudePlugin on the program root.",
+    );
+  }
+
+  const lines: string[] = [];
+  if (mcp.mcpd) {
+    lines.push(packMcpBundle(program));
+  }
+  if (mcp.claudePlugin) {
+    lines.push(packClaudePlugin(program));
+  }
+  process.stdout.write(`${lines.join("\n")}\n`);
 }