argsbarg 4.1.1 → 5.0.1

package/src/configure/index.ts

@@ -0,0 +1,284 @@
+import { resolveCapabilities } from "../capabilities.ts";
+import { displayAppConfigPath, runConfigure } from "../config/bootstrap.ts";
+import { resolveInstallPaths } from "../install/paths.ts";
+import { buildInstallPlan, buildUpdatePlan } from "../install/plan.ts";
+import {
+  installErr,
+  installInfo,
+  installOut,
+  printInstallStatus,
+  writeInteractiveInstallIntro,
+} from "../install/status.ts";
+import { resolveEffectiveInstallTargets } from "../install/target-effective.ts";
+import { runTargetPreflight } from "../install/target-plan-build.ts";
+import { INSTALL_TARGETS, installTargetForKey } from "../install/target-registry.ts";
+import { buildDetectedSnapshot, buildTargetPlanContext } from "../install/target-scope.ts";
+import type {
+  CliInstallArtifactKey,
+  InstallAction,
+  InstallActionKind,
+  InstallOpts,
+  TargetPlanContext,
+  UninstallAction,
+} from "../install/target-types.ts";
+import {
+  buildUninstallPlan,
+  skillDirFromUninstallSummary,
+  uninstallSkillDir,
+} from "../install/uninstall.ts";
+import { cliSkillInstall, skillTargetFromActionKind } from "../skill/install.ts";
+import type { CliProgram } from "../types.ts";
+import { artifactPromptLabel, promptTargetAction } from "./prompt.ts";
+
+/** True when interactive `configure` should auto-run the app config wizard. */
+export function appConfigHasEntries(program: CliProgram): boolean {
+  const entries = program.appConfig?.entries;
+  return !!entries && Object.keys(entries).length > 0;
+}
+
+export interface ConfigureOpts {
+  sync?: boolean;
+  removeAll?: boolean;
+  removeConfig?: boolean;
+  status?: boolean;
+  yes?: boolean;
+  dry?: boolean;
+  json?: boolean;
+}
+
+export function parseConfigureOpts(raw: Record<string, string>): ConfigureOpts {
+  const flag = (name: string) => raw[name] === "1";
+  return {
+    sync: flag("sync"),
+    removeAll: flag("remove-all"),
+    removeConfig: flag("remove-config"),
+    status: flag("status"),
+    yes: flag("yes"),
+    dry: flag("dry"),
+    json: flag("json"),
+  };
+}
+
+export function validateConfigureOpts(opts: ConfigureOpts): string | null {
+  const flags = [opts.sync, opts.removeAll, opts.removeConfig, opts.status].filter(Boolean);
+  if (flags.length > 1) {
+    return "Use only one of --sync, --remove-all, --remove-config, or --status.";
+  }
+  if (opts.json) {
+    opts.yes = true;
+  }
+  if ((opts.sync || opts.removeAll || opts.removeConfig) && !opts.yes) {
+    return "--yes is required with --sync, --remove-all, or --remove-config.";
+  }
+  return null;
+}
+
+function configureToInstallOpts(opts: ConfigureOpts): InstallOpts {
+  if (opts.status) {
+    return { status: true, yes: opts.yes, dry: opts.dry, json: opts.json };
+  }
+  if (opts.sync) {
+    return { reinstall: true, yes: true, dry: opts.dry, json: opts.json };
+  }
+  if (opts.removeAll) {
+    return { uninstall: true, all: true, yes: true, dry: opts.dry, json: opts.json };
+  }
+  if (opts.removeConfig) {
+    return { uninstall: true, configure: true, yes: true, dry: opts.dry, json: opts.json };
+  }
+  return { dry: opts.dry, json: opts.json };
+}
+
+function runSkillAction(root: CliProgram, kind: InstallActionKind, opts: InstallOpts): string[] {
+  const target = skillTargetFromActionKind(kind);
+  if (!target) return [];
+  return cliSkillInstall(root, target, {
+    global: true,
+    rimraf: true,
+    dry: opts.dry,
+  });
+}
+
+function executePlan(
+  root: CliProgram,
+  actions: Array<InstallAction | UninstallAction>,
+  opts: InstallOpts,
+  showProgress: boolean,
+): string[] {
+  const changed: string[] = [];
+  const paths = resolveInstallPaths(root);
+  for (const action of actions) {
+    if (showProgress) {
+      installInfo(action.message, opts);
+    }
+    if ("kind" in action && action.kind) {
+      const skillTarget = skillTargetFromActionKind(action.kind);
+      if (skillTarget) {
+        changed.push(...runSkillAction(root, action.kind as InstallActionKind, opts));
+        continue;
+      }
+    }
+    if (!("kind" in action) || !action.kind) {
+      const skillDir = skillDirFromUninstallSummary(action.summary, paths);
+      if (skillDir) {
+        changed.push(...uninstallSkillDir(skillDir, !!opts.dry));
+        continue;
+      }
+    }
+    changed.push(...action.run());
+  }
+  return changed;
+}
+
+function buildSingleTargetContext(
+  root: CliProgram,
+  paths: ReturnType<typeof resolveInstallPaths>,
+  detected: ReturnType<typeof buildDetectedSnapshot>,
+  key: CliInstallArtifactKey,
+  mode: "install" | "uninstall",
+  opts: InstallOpts,
+): TargetPlanContext {
+  const effective = resolveEffectiveInstallTargets(root.configure, root);
+  const base = buildTargetPlanContext(root, paths, opts, detected);
+  return {
+    ...base,
+    mode: mode === "install" ? "install-scoped" : "uninstall-scoped",
+    include: (k) => k === key && effective[k].enabled,
+  };
+}
+
+function actionsForTarget(
+  root: CliProgram,
+  paths: ReturnType<typeof resolveInstallPaths>,
+  key: CliInstallArtifactKey,
+  action: "install" | "uninstall",
+  opts: InstallOpts,
+): Array<InstallAction | UninstallAction> {
+  const detected = buildDetectedSnapshot(root, paths);
+  const target = installTargetForKey(key);
+  if (!target) return [];
+  const ctx = buildSingleTargetContext(root, paths, detected, key, action, opts);
+  if (action === "install") {
+    return target.planInstall(ctx);
+  }
+  return target.planUninstall(ctx);
+}
+
+async function runInteractiveConfigure(root: CliProgram, opts: ConfigureOpts): Promise<string[]> {
+  if (!process.stdin.isTTY) {
+    throw new Error("Interactive configure requires a TTY. Use flags such as --sync --yes.");
+  }
+
+  writeInteractiveInstallIntro(root);
+  const paths = resolveInstallPaths(root);
+  const detected = buildDetectedSnapshot(root, paths);
+  const effective = resolveEffectiveInstallTargets(root.configure, root);
+  const mutationOpts: InstallOpts = { dry: opts.dry, json: opts.json };
+  const changed: string[] = [];
+
+  for (const target of INSTALL_TARGETS) {
+    if (target.key === "app") continue;
+    if (!effective[target.key].enabled) continue;
+    if (target.key !== "configure" && !target.isAvailable(root, paths)) continue;
+    if (target.key === "configure" && !root.appConfig) continue;
+
+    if (target.key === "configure") {
+      if (!appConfigHasEntries(root)) continue;
+
+      const result = runConfigure(root, { context: "standalone", showHeading: false });
+      if (result.changed) {
+        installOut(`Wrote config: ${displayAppConfigPath(root)}`, mutationOpts);
+        changed.push(displayAppConfigPath(root));
+      }
+      continue;
+    }
+
+    const label = artifactPromptLabel(target.key);
+    const installed = target.detectedForSnapshot(detected);
+
+    const statusHint = installed ? "installed" : "not installed";
+    process.stderr.write(`\n${label} (${statusHint})\n`);
+    const choice = promptTargetAction(label, installed);
+    if (!choice || choice === "skip") continue;
+
+    const actions = actionsForTarget(root, paths, target.key, choice, mutationOpts);
+    if (actions.length === 0) continue;
+
+    const installActions = actions.filter(
+      (a): a is InstallAction =>
+        "kind" in a && typeof a.kind === "string" && a.kind.includes("-mcp"),
+    );
+    if (choice === "install" && resolveCapabilities(root).mcp && installActions.length > 0) {
+      runTargetPreflight(root, paths, mutationOpts, installActions);
+    }
+
+    changed.push(...executePlan(root, actions, mutationOpts, true));
+  }
+
+  return changed;
+}
+
+async function runAutomatedConfigure(root: CliProgram, opts: ConfigureOpts): Promise<string[]> {
+  const installOpts = configureToInstallOpts(opts);
+  const paths = resolveInstallPaths(root);
+
+  if (installOpts.status) {
+    printInstallStatus(root, installOpts);
+    return [];
+  }
+
+  let actions: Array<InstallAction | UninstallAction>;
+  if (installOpts.uninstall) {
+    actions = buildUninstallPlan(root, paths, installOpts);
+  } else if (installOpts.reinstall) {
+    actions = buildUpdatePlan(root, paths, installOpts);
+  } else {
+    actions = buildInstallPlan(root, paths, installOpts);
+  }
+
+  const installActions = actions.filter(
+    (a): a is InstallAction => "kind" in a && typeof a.kind === "string" && a.kind.includes("-mcp"),
+  );
+  if (!installOpts.uninstall && resolveCapabilities(root).mcp && installActions.length > 0) {
+    runTargetPreflight(root, paths, installOpts, installActions);
+  }
+
+  return executePlan(root, actions, installOpts, true);
+}
+
+/** Main configure command orchestrator. */
+export async function cliConfigure(
+  root: CliProgram,
+  rawOpts: Record<string, string>,
+): Promise<never> {
+  const opts = parseConfigureOpts(rawOpts);
+  const err = validateConfigureOpts(opts);
+  if (err) {
+    installErr(err);
+    process.exit(1);
+  }
+
+  const isInteractive = !opts.sync && !opts.removeAll && !opts.removeConfig && !opts.status;
+
+  let changed: string[] = [];
+  try {
+    changed = isInteractive
+      ? await runInteractiveConfigure(root, opts)
+      : await runAutomatedConfigure(root, opts);
+  } catch (mutationErr) {
+    installErr(mutationErr instanceof Error ? mutationErr.message : String(mutationErr));
+    process.exit(1);
+  }
+
+  if (opts.json && !opts.status) {
+    process.stdout.write(`${JSON.stringify(changed, null, 2)}\n`);
+    process.exit(0);
+  }
+
+  if (!opts.status && changed.length > 0) {
+    const verb = opts.removeAll || opts.removeConfig ? "Removed" : opts.sync ? "Synced" : "Updated";
+    installOut(`${verb} ${changed.length} file(s).`, configureToInstallOpts(opts));
+  }
+
+  process.exit(0);
+}

package/src/configure/prompt.ts

@@ -0,0 +1,40 @@
+import { readSync } from "node:fs";
+import type { CliInstallArtifactKey } from "../install/target-types.ts";
+
+const LABELS: Record<CliInstallArtifactKey, string> = {
+  app: "App binary",
+  cursorSkill: "Cursor skill",
+  claudeSkill: "Claude skill",
+  codexSkill: "Codex skill",
+  opencodeSkill: "OpenCode skill",
+  openclawSkill: "OpenClaw skill",
+  cursorMcp: "Cursor MCP",
+  claudeCodeMcp: "Claude Code MCP",
+  claudeDesktopMcp: "Claude Desktop MCP",
+  opencodeMcp: "OpenCode MCP",
+  codexMcp: "Codex MCP",
+  openclawMcp: "OpenClaw MCP",
+  chatgptMcp: "ChatGPT desktop MCP",
+  configure: "App config",
+};
+
+export function artifactPromptLabel(key: CliInstallArtifactKey): string {
+  return LABELS[key];
+}
+
+export type TargetPromptAction = "install" | "skip" | "uninstall";
+
+/** Prompt per target: Y/n when not installed, y/N when installed. */
+export function promptTargetAction(label: string, installed: boolean): TargetPromptAction | null {
+  const hint = installed ? `${label} [y/N]: ` : `${label} [Y/n]: `;
+  process.stderr.write(hint);
+  const buf = Buffer.alloc(256);
+  const n = readSync(0, buf, { length: 256 });
+  const ans = buf.toString("utf8", 0, n).trim().toLowerCase();
+  if (installed) {
+    if (ans === "n") return "uninstall";
+    return "skip";
+  }
+  if (ans === "n") return "skip";
+  return "install";
+}

package/src/docs/builtin.ts

@@ -1,3 +1,5 @@
+import { docsSkillTopicDescription } from "../builtins/configure-copy.ts";
+import { resolveCapabilities } from "../capabilities.ts";
 import {
   CliFallbackMode,
   type CliLeaf,
@@ -75,11 +77,7 @@ export function cliBuiltinDocsGroup(program: CliProgram): CliRouter {
   leaves.push(
     docsLeaf(program, "schema", "Print the full command tree as JSON."),
     docsLeaf(program, "api", "Print the full command reference as markdown."),
-    docsLeaf(
-      program,
-      "skill",
-      "Print a reference agent SKILL, use `install --skill` for optimized.",
-    ),
+    docsLeaf(program, "skill", docsSkillTopicDescription(program, resolveCapabilities(program))),
   );
 
   return {

package/src/docs/docs.test.ts

@@ -106,7 +106,7 @@ test("docs mcp when MCP enabled", async () => {
   expect(result.stdout).toContain("MCP server (myapp)");
   expect(result.stdout).toContain("myapp mcp");
   expect(result.stdout).toContain("claude_desktop_config.json");
-  expect(result.stdout).toContain("install --mcp --yes");
+  expect(result.stdout).toContain("configure --sync --yes");
 });
 
 test("docs rejects unknown subcommand", async () => {
@@ -176,14 +176,14 @@ test("docs skill prints Cursor SKILL.md", async () => {
   expect(result.stdout).not.toContain("mcp.json");
 });
 
-test("docs skill help recommends install --skill", async () => {
+test("docs skill help recommends configure", async () => {
   const presentation = cliPresentationRoot(docsFixture());
   const docsNode = presentation.commands.find((c) => c.key === "docs");
   expect(docsNode && "commands" in docsNode).toBe(true);
   if (docsNode && "commands" in docsNode) {
     const skill = docsNode.commands.find((c) => c.key === "skill");
     expect(skill?.description).toContain("reference agent SKILL");
-    expect(skill?.description).toContain("install --skill");
+    expect(skill?.description).toContain("configure");
     expect(skill?.notes).toBeUndefined();
     expect(docsNode.notes).toContain("--save");
     expect(docsNode.notes).not.toContain("install --skill");
@@ -210,14 +210,14 @@ test("completions offer docs subcommands", () => {
   expect(bash).toContain("skill) echo");
 });
 
-test("generateMcpGuide includes schema URI and install targets", () => {
+test("generateMcpGuide includes schema URI and configure sync", () => {
   const guide = generateMcpGuide(docsFixture(true));
   expect(guide).toContain("myapp://schema");
   expect(guide).toContain("~/.cursor/mcp.json");
   expect(guide).toContain("claude_desktop_config.json");
   expect(guide).toContain("## Installation");
   expect(guide).toContain("## Running directly");
-  expect(guide).toContain("install --mcp");
+  expect(guide).toContain("configure --sync");
   expect(guide).toContain("brew install myapp");
   expect(guide).toContain("OpenAI Codex");
   expect(guide).toContain("ChatGPT");

package/src/docs/mcp-guide.ts

@@ -105,11 +105,11 @@ export function generateMcpGuide(root: CliProgram): string {
     "",
     "## Installation",
     "",
-    "### `install --mcp`",
+    "### `configure`",
     "",
   ];
 
-  if (caps.install) {
+  if (caps.configure) {
     lines.push(
       `Install the CLI first so \`${root.key}\` is on your PATH (e.g. \`brew install ${root.key}\`). Host configs reference the app by name.`,
       "",
@@ -123,7 +123,7 @@ export function generateMcpGuide(root: CliProgram): string {
 
   lines.push(
     "```bash",
-    `${root.key} install --mcp --yes`,
+    `${root.key} configure --sync --yes`,
     "```",
     "",
     "Merges the server entry below into host config when each host is present:",
@@ -177,7 +177,7 @@ export function generateMcpGuide(root: CliProgram): string {
   if (root.appConfig?.entries && Object.keys(root.appConfig.entries).length > 0) {
     lines.push("## Configuration", "");
     lines.push(
-      `Configure before first use in Cursor or Claude Desktop (MCP hosts are non-interactive): \`${root.key} install --configure\`.`,
+      `Configure before first use in Cursor or Claude Desktop (MCP hosts are non-interactive): \`${root.key} configure\`.`,
       "",
       `Default config file: \`${displayAppConfigPath(root)}\` (flat JSON keys).`,
       "",

package/src/index.ts

@@ -34,11 +34,11 @@ export type {
   CliAppConfigEntry,
   CliAppConfigResolveContext,
   CliAppConfigResolveFn,
+  CliConfigureConfig,
+  CliConfigureTargets,
   CliDocsConfig,
   CliDocsTopic,
   CliHandler,
-  CliInstallConfig,
-  CliInstallTargets,
   CliInvocation,
   CliMcpBundleConfig,
   CliMcpResource,

package/src/install/install-validate.test.ts

@@ -10,7 +10,7 @@ const base: CliProgram = {
   handler: () => {},
 };
 
-describe("validateInstallConfig", () => {
+describe("validateConfigureConfig", () => {
   test("accepts empty install config", () => {
     expect(() => cliValidateProgram(base)).not.toThrow();
   });
@@ -18,7 +18,7 @@ describe("validateInstallConfig", () => {
   test("rejects removed allSkills shorthand", () => {
     const program = {
       ...base,
-      install: { targets: { allSkills: true } },
+      configure: { targets: { allSkills: true } },
     } as CliProgram;
     expect(() => cliValidateProgram(program)).toThrow(CliSchemaValidationError);
     expect(() => cliValidateProgram(program)).toThrow(/allSkills/);
@@ -28,7 +28,7 @@ describe("validateInstallConfig", () => {
     const program: CliProgram = {
       ...base,
       mcpServer: { enabled: true },
-      install: {
+      configure: {
         agentIntegration: "mcp",
         targets: { cursorMcp: true, cursorSkill: true },
       },
@@ -39,7 +39,7 @@ describe("validateInstallConfig", () => {
   test("rejects explicit MCP target in skill integration mode", () => {
     const program: CliProgram = {
       ...base,
-      install: {
+      configure: {
         agentIntegration: "skill",
         targets: { cursorMcp: true },
       },
@@ -51,7 +51,7 @@ describe("validateInstallConfig", () => {
     const program: CliProgram = {
       ...base,
       mcpServer: { enabled: true },
-      install: {
+      configure: {
         agentIntegration: "both",
         targets: { cursorMcp: true, cursorSkill: true },
       },

package/src/install/opts.ts

@@ -0,0 +1,17 @@
+import type { InstallOpts } from "./target-types.ts";
+
+export function parseInstallOpts(raw: Record<string, string>): InstallOpts {
+  const flag = (name: string) => raw[name] === "1";
+  return {
+    all: flag("all"),
+    skill: flag("skill"),
+    mcp: flag("mcp"),
+    reinstall: flag("reinstall"),
+    status: flag("status"),
+    uninstall: flag("uninstall"),
+    configure: flag("configure"),
+    yes: flag("yes"),
+    dry: flag("dry"),
+    json: flag("json"),
+  };
+}

package/src/install/target-effective.ts

@@ -1,7 +1,7 @@
 import { resolveCapabilities } from "../capabilities.ts";
 import type {
-  CliInstallConfig,
-  CliInstallTargets,
+  CliConfigureConfig,
+  CliConfigureTargets,
   CliProgram,
   InstallAgentIntegration,
   InstallTargetSpec,
@@ -15,10 +15,10 @@ export type { InstallTargetSpec, ResolvedInstallTarget } from "../types.ts";
 export type { InstallPlanMode, InstallScope } from "./target-types.ts";
 
 export function resolveAgentIntegration(
-  install?: CliInstallConfig,
+  configure?: CliConfigureConfig,
   mcpEnabled = false,
 ): InstallAgentIntegration {
-  return install?.agentIntegration ?? (mcpEnabled ? "mcp" : "skill");
+  return configure?.agentIntegration ?? (mcpEnabled ? "mcp" : "skill");
 }
 
 /** Resolves a boolean or object target spec against category defaults. */
@@ -52,7 +52,7 @@ function artifactDefaults(
 
 function applyAgentPairDedupe(
   out: Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>,
-  user: CliInstallTargets | undefined,
+  user: CliConfigureTargets | undefined,
   integration: InstallAgentIntegration,
 ): void {
   if (integration === "both") return;
@@ -78,12 +78,12 @@ function applyAgentPairDedupe(
 
 /** Effective per-artifact gates for install.targets. */
 export function resolveEffectiveInstallTargets(
-  install?: CliInstallConfig,
+  configure?: CliConfigureConfig,
   program?: Pick<CliProgram, "mcpServer">,
 ): Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }> {
   const mcpEnabled = program?.mcpServer?.enabled === true;
-  const integration = resolveAgentIntegration(install, mcpEnabled);
-  const user = install?.targets;
+  const integration = resolveAgentIntegration(configure, mcpEnabled);
+  const user = configure?.targets;
   const out = {} as Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>;
   for (const key of INSTALL_ARTIFACT_KEYS) {
     out[key] = resolveInstallTargetSpec(user?.[key], artifactDefaults(key, integration));

package/src/install/target-scope.ts

@@ -1,6 +1,6 @@
 import { resolveCapabilities } from "../capabilities.ts";
 import { appConfigInstalled } from "../config/file.ts";
-import type { CliInstallTargets, CliProgram } from "../types.ts";
+import type { CliConfigureTargets, CliProgram } from "../types.ts";
 import type { InstallPaths } from "./paths.ts";
 import {
   type InstallPlanMode,
@@ -78,7 +78,7 @@ export function buildDetectedSnapshot(root: CliProgram, paths: InstallPaths): De
 }
 
 function targetExplicitlyConfigured(
-  user: CliInstallTargets | undefined,
+  user: CliConfigureTargets | undefined,
   key: CliInstallArtifactKey,
 ): boolean {
   return user?.[key] !== undefined;
@@ -89,7 +89,7 @@ function agentCategoryInScope(
   categoryKeys: readonly CliInstallArtifactKey[],
   category: "skill" | "mcp",
   effective: Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>,
-  targets: CliInstallTargets | undefined,
+  targets: CliConfigureTargets | undefined,
   root: CliProgram,
 ): boolean {
   if (!categoryKeys.includes(key)) return false;
@@ -105,7 +105,7 @@ export function isArtifactInScope(
   effective: Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>,
   mode: InstallPlanMode,
   root: CliProgram,
-  targets?: CliInstallTargets,
+  targets?: CliConfigureTargets,
 ): boolean {
   if (mode === "uninstall-all") {
     return true;
@@ -150,7 +150,7 @@ export function shouldIncludeArtifact(
   detected?: Partial<Record<CliInstallArtifactKey, boolean>>,
 ): boolean {
   const target = installTargetForKey(key);
-  const targets = root.install?.targets;
+  const targets = root.configure?.targets;
 
   if (key !== "configure" && target && !target.isAvailable(root, paths)) {
     return false;
@@ -196,7 +196,7 @@ export function buildTargetPlanContext(
   opts: InstallOpts,
   detected: DetectedSnapshot,
 ): TargetPlanContext {
-  const effective = resolveEffectiveInstallTargets(root.install, root);
+  const effective = resolveEffectiveInstallTargets(root.configure, root);
   const mode = resolveInstallPlanMode(opts);
   const scope = resolveInstallScope(opts);
   const detPartial = Object.fromEntries(
@@ -236,8 +236,11 @@ export function resolveInstallTargetPreview(
   program: CliProgram,
   paths: InstallPaths,
 ): InstallTargetPreview {
-  const effective = resolveEffectiveInstallTargets(program.install, program);
-  const integration = resolveAgentIntegration(program.install, program.mcpServer?.enabled === true);
+  const effective = resolveEffectiveInstallTargets(program.configure, program);
+  const integration = resolveAgentIntegration(
+    program.configure,
+    program.mcpServer?.enabled === true,
+  );
 
   const keysForScope = (scope: InstallScope, mode: InstallPlanMode): CliInstallArtifactKey[] =>
     INSTALL_ARTIFACT_KEYS.filter((key) =>

package/src/install/targets/configure.ts

@@ -11,7 +11,7 @@ import type {
   UninstallAction,
 } from "../target-types.ts";
 
-/** App config file (install --configure / wizard). */
+/** App config file (interactive configure / wizard). */
 class ConfigureInstallTarget extends InstallTarget {
   readonly key = "configure" as const;
   readonly actionKind = "configure" as const;

package/src/install/targets.test.ts

@@ -75,10 +75,10 @@ describe("resolveEffectiveInstallTargets", () => {
       version: "1",
       description: "x",
       mcpServer: { enabled: true },
-      install: { agentIntegration: "skill" },
+      configure: { agentIntegration: "skill" },
       handler: () => {},
     };
-    const effective = resolveEffectiveInstallTargets(program.install, program);
+    const effective = resolveEffectiveInstallTargets(program.configure, program);
     const scope = { mcp: true };
     expect(isArtifactInScope("cursorMcp", scope, effective, "install-scoped", program)).toBe(false);
     expect(
@@ -101,10 +101,10 @@ describe("resolveEffectiveInstallTargets", () => {
       version: "1",
       description: "x",
       mcpServer: { enabled: true },
-      install: { agentIntegration: "both" },
+      configure: { agentIntegration: "both" },
       handler: () => {},
     };
-    const effective = resolveEffectiveInstallTargets(program.install, program);
+    const effective = resolveEffectiveInstallTargets(program.configure, program);
     const scope = { mcp: true, skill: true, configure: true };
     expect(isArtifactInScope("cursorSkill", scope, effective, "install-scoped", program)).toBe(
       true,

package/src/invoke.test.ts

@@ -20,7 +20,7 @@ const program = {
   key: "t",
   description: "d",
   version: "0.0.0",
-  install: { enabled: false },
+  configure: { enabled: false },
   handler: (ctx) => console.log(ctx.invocation),
 };
 await new Cli(program).run([]);

package/src/mcp/tools.ts

@@ -224,7 +224,7 @@ export function collectMcpTools(root: CliProgram): McpToolDef[] {
     if (isCliLeaf(cmd)) {
       if (
         cmd.key === "completion" ||
-        cmd.key === "install" ||
+        cmd.key === "configure" ||
         cmd.key === "mcp" ||
         cmd.key === "version"
       ) {