argsbarg 4.1.0 → 5.0.1

package/src/configure/configure.test.ts

@@ -0,0 +1,148 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  appConfigHasEntries,
+  parseConfigureOpts,
+  validateConfigureOpts,
+} from "../configure/index.ts";
+import { detectInstalledArtifacts } from "../install/detect-installed.ts";
+import { parseInstallOpts } from "../install/opts.ts";
+import { resolveClaudeDesktopMcpPath, resolveInstallPaths } from "../install/paths.ts";
+import { buildInstallPlan, buildUpdatePlan } from "../install/plan.ts";
+import { buildUninstallPlan } from "../install/uninstall.ts";
+import type { CliProgram } from "../types.ts";
+
+const fixture: CliProgram = {
+  key: "testapp",
+  version: "0.0.0",
+  description: "Test",
+  mcpServer: { enabled: true },
+  handler: () => {},
+};
+
+let home: string;
+let prevHome: string | undefined;
+let prevXdg: string | undefined;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "argsbarg-configure-"));
+  prevHome = process.env.HOME;
+  prevXdg = process.env.XDG_CONFIG_HOME;
+  process.env.HOME = home;
+  delete process.env.XDG_CONFIG_HOME;
+});
+
+afterEach(() => {
+  if (prevHome === undefined) delete process.env.HOME;
+  else process.env.HOME = prevHome;
+  if (prevXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+  else process.env.XDG_CONFIG_HOME = prevXdg;
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("configure opts", () => {
+  test("validate rejects multiple modes", () => {
+    const opts = parseConfigureOpts({ sync: "1", status: "1" });
+    expect(validateConfigureOpts(opts)).toContain("only one");
+  });
+
+  test("sync requires --yes", () => {
+    const opts = parseConfigureOpts({ sync: "1" });
+    expect(validateConfigureOpts(opts)).toContain("--yes");
+  });
+
+  test("remove-all requires --yes", () => {
+    const opts = parseConfigureOpts({ "remove-all": "1" });
+    expect(validateConfigureOpts(opts)).toContain("--yes");
+  });
+});
+
+describe("install paths", () => {
+  test("resolveInstallPaths includes skill and mcp paths", () => {
+    const paths = resolveInstallPaths(fixture);
+    expect(paths.cursorSkillDir).toContain(".cursor/skills");
+    expect(paths.cursorMcpPath).toContain("mcp.json");
+  });
+
+  test("claude desktop mcp path on darwin", () => {
+    const prev = process.platform;
+    Object.defineProperty(process, "platform", { value: "darwin" });
+    try {
+      expect(resolveClaudeDesktopMcpPath(home)).toBe(
+        join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+      );
+    } finally {
+      Object.defineProperty(process, "platform", { value: prev });
+    }
+  });
+});
+
+describe("detect installed", () => {
+  test("detects cursor mcp when configured", () => {
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    writeFileSync(
+      paths.cursorMcpPath,
+      JSON.stringify({ mcpServers: { testapp: { command: "testapp", args: ["mcp"] } } }),
+      "utf8",
+    );
+
+    const detected = detectInstalledArtifacts(paths, fixture);
+    expect(detected.cursorMcp).toBe(true);
+    expect(detected.app).toBe(false);
+  });
+});
+
+describe("sync plan", () => {
+  test("buildUpdatePlan greenfield includes agent targets", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildUpdatePlan(fixture, paths, parseInstallOpts({ reinstall: "1", yes: "1" }));
+    expect(plan.length).toBeGreaterThan(0);
+    expect(plan.some((a) => a.kind === "app")).toBe(false);
+  });
+
+  test("buildInstallPlan --all omits app self-install", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
+    expect(plan.some((a) => a.kind === "app")).toBe(false);
+    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(true);
+  });
+
+  test("buildInstallPlan respects configure.agentIntegration skill", () => {
+    const skillApp: CliProgram = {
+      ...fixture,
+      configure: { agentIntegration: "skill" },
+    };
+    const paths = resolveInstallPaths(skillApp);
+    mkdirSync(join(home, ".claude"), { recursive: true });
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    const plan = buildInstallPlan(skillApp, paths, parseInstallOpts({ mcp: "1" }));
+    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(false);
+  });
+});
+
+describe("remove plan", () => {
+  test("buildUninstallPlan --all with nothing installed is empty", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", all: "1" }));
+    expect(plan.length).toBe(0);
+  });
+});
+
+describe("app config wizard", () => {
+  test("appConfigHasEntries when entries exist", () => {
+    expect(
+      appConfigHasEntries({
+        ...fixture,
+        appConfig: { entries: { token: { description: "API token." } } },
+      }),
+    ).toBe(true);
+  });
+
+  test("appConfigHasEntries false for empty entries or missing appConfig", () => {
+    expect(appConfigHasEntries({ ...fixture, appConfig: { entries: {} } })).toBe(false);
+    expect(appConfigHasEntries(fixture)).toBe(false);
+  });
+});

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/api-guide.test.ts

@@ -71,21 +71,20 @@ test("generateApiGuide resolves program key in install notes", () => {
   };
   const md = generateApiGuide(fixture);
   expect(md).not.toContain("{argsbarg:program}");
-  expect(md).toContain("myapp install --yes");
+  expect(md).toContain("brew install");
   expect(md).not.toContain("Upgrade to latest release");
 });
 
-test("generateApiGuide includes upgrade section when updateGetLatest is set", () => {
+test("generateApiGuide mentions Homebrew upgrade", () => {
   const fixture: CliProgram = {
     key: "myapp",
     version: "1.0.0",
     description: "Demo app.",
-    install: { updateGetLatest: async () => ({ path: process.execPath }) },
     commands: [{ key: "run", description: "Run.", handler: () => {} }],
   };
   const md = generateApiGuide(fixture);
-  expect(md).toContain("Upgrade to latest release");
-  expect(md).toContain("myapp install --update");
+  expect(md).toContain("brew upgrade");
+  expect(md).not.toContain("install --update");
 });
 
 test("generateApiGuide resolves {argsbarg:program} in consumer notes", () => {

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,15 @@ 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 --app");
+  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,13 +105,13 @@ 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. \`${root.key} install --app --yes\` or \`install --all --yes\`). Host configs reference the app by name.`,
+      `Install the CLI first so \`${root.key}\` is on your PATH (e.g. \`brew install ${root.key}\`). Host configs reference the app by name.`,
       "",
     );
   } else {
@@ -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:",
@@ -167,18 +167,17 @@ export function generateMcpGuide(root: CliProgram): string {
     "",
   );
 
-  if (mcp.shellEnv) {
-    lines.push("## Environment", "");
-    lines.push(
-      "- **`shellEnv`** — captures login-shell environment at MCP startup (PATH, toolchain shims, exports).",
-    );
-    lines.push("");
-  }
+  lines.push(
+    "## Environment",
+    "",
+    "- **`shellEnv`** — on by default; captures login-shell environment at MCP startup (PATH, toolchain shims, exports). Opt out with `shellEnv: false`.",
+    "",
+  );
 
   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

@@ -9,6 +9,7 @@ module layout.
 
 export { Cli, type CliInvokeKind, type CliInvokeResult } from "./cli.ts";
 export { cliErrWithHelp } from "./cli-errors.ts";
+export { displayAppConfigPath, resolveAppConfigPath } from "./config/file.ts";
 export type { CliLeafInputs } from "./context.ts";
 export { CliContext } from "./context.ts";
 export {
@@ -26,24 +27,18 @@ export {
   shouldRunHeadlessWithYes,
   wantsExplicitJson,
 } from "./headless.ts";
-export type { GhReleaseUpdateConfig, GhVersionCheckConfig } from "./install/gh-release-update.ts";
-export {
-  createGhFetchLatest,
-  createGhVersionCheck,
-  ghReleaseUpdateGetLatest,
-  isAlreadyCurrent,
-  parseReleaseTag,
-} from "./install/gh-release-update.ts";
 export type { McpBundlePaths, PackMcpBundleOpts } from "./mcp/bundle.ts";
 export { defaultMcpBundlePaths, generateMcpManifest, packMcpBundle } from "./mcp/bundle.ts";
 export type {
   CliAppConfig,
   CliAppConfigEntry,
+  CliAppConfigResolveContext,
+  CliAppConfigResolveFn,
+  CliConfigureConfig,
+  CliConfigureTargets,
   CliDocsConfig,
   CliDocsTopic,
   CliHandler,
-  CliInstallConfig,
-  CliInstallTargets,
   CliInvocation,
   CliMcpBundleConfig,
   CliMcpResource,
@@ -52,8 +47,6 @@ export type {
   CliOption,
   CliPositional,
   CliProgram,
-  CliUpdateArtifact,
-  CliUpdateGetLatest,
   InstallAgentIntegration,
   InstallTargetSpec,
   ResolvedInstallTarget,