argsbarg 6.3.2 → 7.0.0

package/src/configure/artifacts/mcp-config.ts

@@ -1,12 +1,15 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import type { CliProgram } from "../../core/types.ts";
+import { displayHomePath } from "../../paths/host.ts";
 
 export interface McpServerEntry {
   command: string;
   args: string[];
 }
 
+export type McpInstallResult = "installed" | "skipped-match" | "skipped-conflict";
+
 export function expectedMcpEntry(root: CliProgram): McpServerEntry {
   return { command: root.key, args: ["mcp"] };
 }
@@ -28,18 +31,20 @@ export function readMcpServerEntry(path: string, name: string): McpServerEntry |
   }
 }
 
-/** Returns an error message when existing entry conflicts, or null if safe to merge. */
-export function checkMcpConflict(path: string, name: string, expected: McpServerEntry, yes: boolean): string | null {
+/** Installs MCP entry when missing; skips when matching; warns and skips on conflict. */
+export function installMcpServerEntry(path: string, name: string, entry: McpServerEntry): McpInstallResult {
   const existing = readMcpServerEntry(path, name);
-  if (existing && !entriesEqual(existing, expected) && !yes) {
-    return (
-      `MCP server "${name}" in ${path} differs from expected entry.\n` +
-      `  existing: ${JSON.stringify(existing)}\n` +
-      `  expected: ${JSON.stringify(expected)}\n` +
-      `Use --yes to overwrite.`
+  if (existing) {
+    if (entriesEqual(existing, entry)) {
+      return "skipped-match";
+    }
+    process.stderr.write(
+      `MCP server "${name}" in ${displayHomePath(path)} differs; leaving existing entry unchanged.\n`,
     );
+    return "skipped-conflict";
   }
-  return null;
+  mergeMcpConfig(path, name, entry, false);
+  return "installed";
 }
 
 /** Merges MCP server entry into config file. */
@@ -57,10 +62,11 @@ export function mergeMcpConfig(path: string, name: string, entry: McpServerEntry
 }
 
 /** Removes MCP server entry from config file (keeps file if other keys remain). */
-export function removeMcpConfig(path: string, name: string, dry: boolean): void {
-  if (dry || !existsSync(path)) return;
+export function removeMcpConfig(path: string, name: string, dry: boolean): string[] {
+  if (dry || !existsSync(path)) return [];
   const data = JSON.parse(readFileSync(path, "utf8")) as { mcpServers?: Record<string, unknown> };
-  if (!data.mcpServers?.[name]) return;
+  if (!data.mcpServers?.[name]) return [];
   delete data.mcpServers[name];
   writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+  return [path];
 }

package/src/configure/artifacts/target-mcp-json.ts

@@ -1,11 +1,5 @@
 import type { CliProgram } from "../../core/types.ts";
-import {
-  checkMcpConflict,
-  expectedMcpEntry,
-  mergeMcpConfig,
-  readMcpServerEntry,
-  removeMcpConfig,
-} from "./mcp-config.ts";
+import { expectedMcpEntry, installMcpServerEntry, readMcpServerEntry, removeMcpConfig } from "./mcp-config.ts";
 import { displayInstallPath, type InstallPaths } from "./paths.ts";
 import { InstallTarget } from "./target-base.ts";
 import type {
@@ -78,22 +72,25 @@ export class McpJsonInstallTarget extends InstallTarget {
     status[this.spec.statusField] = line;
   }
 
-  preflight(ctx: TargetPlanContext): string | null {
-    const entry = expectedMcpEntry(ctx.root);
-    return checkMcpConflict(this.spec.configPath(ctx.paths), ctx.paths.mcpName, entry, !!ctx.opts.yes);
+  preflight(_ctx: TargetPlanContext): string | null {
+    return null;
   }
 
   protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {
     const configPath = this.spec.configPath(ctx.paths);
     const entry = expectedMcpEntry(ctx.root);
+    const displayPath = displayInstallPath(configPath);
     return [
       {
         kind: this.actionKind,
-        summary: `${this.spec.label}: ${displayInstallPath(configPath)}`,
-        message: `Merging MCP server "${ctx.paths.mcpName}" into ${displayInstallPath(configPath)}`,
+        summary: `${this.spec.label}: ${displayPath}`,
+        message: `Merging MCP server "${ctx.paths.mcpName}" into ${displayPath}`,
         run: () => {
-          mergeMcpConfig(configPath, ctx.paths.mcpName, entry, ctx.dry);
-          return [configPath];
+          const result = installMcpServerEntry(configPath, ctx.paths.mcpName, entry);
+          if (result === "installed") {
+            process.stdout.write(`Registered MCP server in ${displayPath}\n`);
+          }
+          return result === "installed" ? [configPath] : [];
         },
       },
     ];
@@ -101,14 +98,18 @@ export class McpJsonInstallTarget extends InstallTarget {
 
   protected buildUninstallActions(ctx: TargetPlanContext): UninstallAction[] {
     const configPath = this.spec.configPath(ctx.paths);
+    const displayPath = displayInstallPath(configPath);
     return [
       {
         kind: this.actionKind,
-        summary: `${this.spec.label}: ${displayInstallPath(configPath)}`,
-        message: `Removing MCP server "${ctx.paths.mcpName}" from ${displayInstallPath(configPath)}`,
+        summary: `${this.spec.label}: ${displayPath}`,
+        message: `Removing MCP server "${ctx.paths.mcpName}" from ${displayPath}`,
         run: () => {
-          removeMcpConfig(configPath, ctx.paths.mcpName, ctx.dry);
-          return [configPath];
+          const changed = removeMcpConfig(configPath, ctx.paths.mcpName, ctx.dry);
+          if (changed.length > 0 && !ctx.dry) {
+            process.stdout.write(`Removed MCP server from ${displayPath}\n`);
+          }
+          return changed;
         },
       },
     ];

package/src/configure/artifacts/target-skill.ts

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import type { CliProgram } from "../../core/types.ts";
+import { cliSkillInstall } from "../../skill/install.ts";
 import { displayInstallPath, type InstallPaths } from "./paths.ts";
 import { InstallTarget } from "./target-base.ts";
 import type {
@@ -72,12 +73,16 @@ export class SkillInstallTarget extends InstallTarget {
 
   protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {
     const dir = this.spec.skillDir(ctx.paths);
+    const displayDir = `${displayInstallPath(dir)}/`;
     return [
       {
         kind: this.actionKind,
-        summary: `${this.spec.label.toLowerCase()}: ${displayInstallPath(dir)}/`,
-        message: `Installing ${this.spec.label.toLowerCase()} to ${displayInstallPath(dir)}/`,
-        run: () => [],
+        summary: `${this.spec.label.toLowerCase()}: ${displayDir}`,
+        message: `Installing ${this.spec.label.toLowerCase()} to ${displayDir}`,
+        run: () => {
+          cliSkillInstall(ctx.root, { global: true, rimraf: true, dry: ctx.dry });
+          return [];
+        },
       },
     ];
   }

package/src/configure/artifacts/targets/agents-mcp.ts

@@ -7,5 +7,5 @@ export const agentsMcpTarget = new McpJsonInstallTarget({
   configPath: (p) => p.agentsMcpPath,
   detectedKey: "agentsMcp",
   statusField: "agentsMcp",
-  isAvailable: (_root, _paths) => true,
+  isAvailable: (root) => root.mcpServer?.enabled === true,
 });

package/src/configure/artifacts/targets/configure.ts

@@ -17,12 +17,11 @@ class ConfigureInstallTarget extends InstallTarget {
   readonly actionKind = "configure" as const;
   readonly category = "core" as const;
 
-  isAvailable(root: CliProgram, _paths: InstallPaths): boolean {
-    return root.appConfig !== undefined;
+  isAvailable(_root: CliProgram, _paths: InstallPaths): boolean {
+    return true;
   }
 
   isDetected(_paths: InstallPaths, root: CliProgram): boolean {
-    if (!root.appConfig) return false;
     return appConfigInstalled(root);
   }
 

package/src/configure/artifacts/uninstall.ts

@@ -1,5 +1,6 @@
 import { existsSync, rmSync } from "node:fs";
 import type { CliProgram } from "../../core/types.ts";
+import { displayHomePath } from "../../paths/host.ts";
 import type { InstallPaths } from "./paths.ts";
 import { buildUninstallPlanFromTargets } from "./target-plan-build.ts";
 import { skillTargetForUninstallSummary } from "./target-registry.ts";
@@ -15,7 +16,10 @@ export function buildUninstallPlan(root: CliProgram, paths: InstallPaths, opts:
 /** 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 });
+  if (!dry) {
+    rmSync(dir, { recursive: true, force: true });
+    process.stdout.write(`Removed skill from ${displayHomePath(dir)}/\n`);
+  }
   return [`${dir}/`];
 }
 

package/src/configure/configure.test.ts

@@ -10,18 +10,14 @@ import { appConfigFileExists } from "../config/file.ts";
 import type { CliProgram } from "../core/types.ts";
 import { Cli } from "../index.ts";
 import { detectInstalledArtifacts } from "./artifacts/detect-installed.ts";
+import { installMcpServerEntry } from "./artifacts/mcp-config.ts";
 import { parseInstallOpts } from "./artifacts/opts.ts";
 import { resolveClaudeDesktopMcpPath, resolveInstallPaths } from "./artifacts/paths.ts";
 import { buildInstallPlan, buildUpdatePlan } from "./artifacts/plan.ts";
 import { installTargetForKey } from "./artifacts/target-registry.ts";
 import { buildDetectedSnapshot, buildTargetPlanContext } from "./artifacts/target-scope.ts";
 import { buildUninstallPlan } from "./artifacts/uninstall.ts";
-import {
-  appConfigHasEntries,
-  formatConfigureMutationSummary,
-  parseConfigureOpts,
-  validateConfigureOpts,
-} from "./index.ts";
+import { appConfigHasEntries } from "./index.ts";
 
 const fixture: CliProgram = {
   key: "testapp",
@@ -52,63 +48,6 @@ afterEach(() => {
   rmSync(home, { recursive: true, force: true });
 });
 
-/** Tests for configure opts. */
-describe("configure opts", () => {
-  test("validate rejects multiple modes", () => {
-    const opts = parseConfigureOpts({ refresh: "1", status: "1" });
-    expect(validateConfigureOpts(opts)).toContain("only one");
-  });
-
-  test("refresh requires --yes", () => {
-    const opts = parseConfigureOpts({ refresh: "1" });
-    expect(validateConfigureOpts(opts)).toContain("--yes");
-  });
-
-  test("remove-all requires --yes", () => {
-    const opts = parseConfigureOpts({ "remove-all": "1" });
-    expect(validateConfigureOpts(opts)).toContain("--yes");
-  });
-});
-
-describe("configure mutation summary", () => {
-  test("interactive uninstall reports removed artifacts not file count", () => {
-    const msg = formatConfigureMutationSummary(
-      { paths: ["~/.agents/skills/testapp/"], installed: 0, removed: 1, configured: 0 },
-      {},
-    );
-    expect(msg).toBe("Removed 1 artifact.");
-  });
-
-  test("interactive install reports installed artifacts not file count", () => {
-    const msg = formatConfigureMutationSummary(
-      {
-        paths: ["~/.agents/skills/testapp/SKILL.md", "~/.agents/skills/testapp/reference.md"],
-        installed: 1,
-        removed: 0,
-        configured: 0,
-      },
-      {},
-    );
-    expect(msg).toBe("Installed 1 artifact.");
-  });
-
-  test("refresh mode uses refreshed verb and artifact count", () => {
-    const msg = formatConfigureMutationSummary(
-      { paths: ["a", "b", "c"], installed: 3, removed: 0, configured: 0 },
-      { refresh: true },
-    );
-    expect(msg).toBe("Refreshed 3 artifacts.");
-  });
-
-  test("remove-all uses removed verb", () => {
-    const msg = formatConfigureMutationSummary(
-      { paths: ["a"], installed: 0, removed: 2, configured: 0 },
-      { removeAll: true },
-    );
-    expect(msg).toBe("Removed 2 artifacts.");
-  });
-});
-
 /** Tests for install paths. */
 describe("install paths", () => {
   test("resolveInstallPaths includes agents skill and mcp paths", () => {
@@ -147,8 +86,8 @@ describe("detect installed", () => {
   });
 });
 
-/** Tests for refresh plan. */
-describe("refresh plan", () => {
+/** Tests for install plan. */
+describe("install plan", () => {
   test("buildUpdatePlan greenfield includes skill when enabled", () => {
     const paths = resolveInstallPaths(fixture);
     const plan = buildUpdatePlan(fixture, paths, parseInstallOpts({ reinstall: "1", yes: "1" }));
@@ -172,26 +111,43 @@ describe("refresh plan", () => {
   });
 });
 
-/** Tests for remove plan. */
-describe("remove plan", () => {
+/** Tests for uninstall plan. */
+describe("uninstall 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);
   });
 
-  test("configure --remove-all removes installed agent skill", async () => {
+  test("configure uninstall removes installed agent skill", async () => {
     const paths = resolveInstallPaths(fixture);
     mkdirSync(paths.agentsSkillDir, { recursive: true });
     writeFileSync(join(paths.agentsSkillDir, "SKILL.md"), "# test\n", "utf8");
 
     expect(detectInstalledArtifacts(paths, fixture).skill).toBe(true);
 
-    const result = await new Cli(fixture).invoke(["configure", "--remove-all", "--yes"]);
+    const result = await new Cli(fixture).invoke(["configure", "uninstall", "--yes"]);
     expect(result.exitCode).toBe(0);
     expect(existsSync(paths.agentsSkillDir)).toBe(false);
   });
 
+  test("configure uninstall removes skill when HOME is a Homebrew sandbox", async () => {
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(paths.agentsSkillDir, { recursive: true });
+    writeFileSync(join(paths.agentsSkillDir, "SKILL.md"), "# test\n", "utf8");
+
+    const prevHome = process.env.HOME;
+    process.env.HOME = "/private/tmp/sqsp-workspaces-postinstall-20260807-fake";
+    try {
+      const result = await new Cli(fixture).invoke(["configure", "uninstall", "--yes"]);
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(paths.agentsSkillDir)).toBe(false);
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+    }
+  });
+
   test("scoped skill uninstall action removes directory", () => {
     const paths = resolveInstallPaths(fixture);
     mkdirSync(paths.agentsSkillDir, { recursive: true });
@@ -212,7 +168,6 @@ describe("remove plan", () => {
   });
 });
 
-/** Tests for app config wizard. */
 describe("app config wizard", () => {
   test("appConfigHasEntries when entries exist", () => {
     expect(
@@ -229,41 +184,41 @@ describe("app config wizard", () => {
   });
 });
 
-describe("configure --refresh bootstrap", () => {
+describe("configure install bootstrap", () => {
   test("creates config.json for apps without appConfig", async () => {
     const program: CliProgram = {
-      key: "refreshboot",
+      key: "installboot",
       version: "0.0.0",
-      description: "Refresh bootstrap test.",
+      description: "Install bootstrap test.",
       skill: { enabled: true },
       handler: () => {},
       configure: { enabled: true },
     };
     expect(appConfigFileExists(program)).toBe(false);
-    const result = await new Cli(program).invoke(["configure", "--refresh", "--yes"]);
+    const result = await new Cli(program).invoke(["configure", "install"]);
     expect(result.exitCode).toBe(0);
     expect(appConfigFileExists(program)).toBe(true);
   });
 });
 
 describe("configure lifecycle hooks", () => {
-  test("afterRefresh runs after --refresh plan", async () => {
+  test("afterInstall runs after install plan", async () => {
     const calls: string[] = [];
     const program: CliProgram = {
       ...fixture,
-      key: "hookrefresh",
+      key: "hookinstall",
       configure: {
-        afterRefresh: async (ctx) => {
+        afterInstall: async (ctx) => {
           calls.push(`after:${ctx.paths.mcpName}:dry=${ctx.dry}`);
         },
       },
     };
-    const result = await new Cli(program).invoke(["configure", "--refresh", "--yes"]);
+    const result = await new Cli(program).invoke(["configure", "install"]);
     expect(result.exitCode).toBe(0);
-    expect(calls).toEqual([`after:hookrefresh:dry=false`]);
+    expect(calls).toEqual([`after:hookinstall:dry=false`]);
   });
 
-  test("beforeRemoveAll runs before --remove-all plan", async () => {
+  test("beforeUninstall runs before uninstall plan", async () => {
     const paths = resolveInstallPaths({ ...fixture, key: "hookremove" });
     mkdirSync(paths.agentsSkillDir, { recursive: true });
     writeFileSync(join(paths.agentsSkillDir, "SKILL.md"), "# test\n", "utf8");
@@ -273,48 +228,25 @@ describe("configure lifecycle hooks", () => {
       ...fixture,
       key: "hookremove",
       configure: {
-        beforeRemoveAll: async (ctx) => {
+        beforeUninstall: async (ctx) => {
           calls.push(`before:${ctx.paths.skillDirName}`);
           expect(existsSync(ctx.paths.agentsSkillDir)).toBe(true);
         },
       },
     };
-    const result = await new Cli(program).invoke(["configure", "--remove-all", "--yes"]);
+    const result = await new Cli(program).invoke(["configure", "uninstall", "--yes"]);
     expect(result.exitCode).toBe(0);
     expect(calls).toEqual(["before:hookremove"]);
     expect(existsSync(paths.agentsSkillDir)).toBe(false);
   });
+});
 
-  test("hooks receive dry from --dry", async () => {
-    const calls: string[] = [];
-    const program: CliProgram = {
-      ...fixture,
-      key: "hookdry",
-      configure: {
-        afterRefresh: (ctx) => {
-          calls.push(`dry=${ctx.dry}`);
-        },
-      },
-    };
-    const result = await new Cli(program).invoke(["configure", "--refresh", "--yes", "--dry"]);
-    expect(result.exitCode).toBe(0);
-    expect(calls).toEqual(["dry=true"]);
-  });
-
-  test("beforeRemoveAll is not called for --remove-config", async () => {
-    let called = false;
-    const program: CliProgram = {
-      ...fixture,
-      key: "hookcfg",
-      appConfig: { entries: { token: { description: "Token." } } },
-      configure: {
-        beforeRemoveAll: () => {
-          called = true;
-        },
-      },
-    };
-    const result = await new Cli(program).invoke(["configure", "--remove-config", "--yes"]);
-    expect(result.exitCode).toBe(0);
-    expect(called).toBe(false);
+describe("MCP install idempotency", () => {
+  test("installMcpServerEntry skips matching entry", () => {
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(join(home, ".agents"), { recursive: true });
+    const entry = { command: "testapp", args: ["mcp"] };
+    writeFileSync(paths.agentsMcpPath, JSON.stringify({ mcpServers: { testapp: entry } }), "utf8");
+    expect(installMcpServerEntry(paths.agentsMcpPath, "testapp", entry)).toBe("skipped-match");
   });
 });