argsbarg 4.0.4 → 4.1.1

package/src/install/install.test.ts

@@ -1,14 +1,25 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { writeAppConfigFile } from "../config/file.ts";
 import type { CliProgram } from "../types.ts";
 import { detectInstalledArtifacts } from "./detect-installed.ts";
-import { parseInstallOpts, runInstallMutation, validateInstallOpts } from "./index.ts";
+import {
+  cliInstall,
+  interactiveSelectionAssumesApp,
+  mergeInteractiveSelection,
+  parseInstallOpts,
+  runInstallMutation,
+  runUninstallMutation,
+  validateInstallOpts,
+  validateUninstallOpts,
+} from "./index.ts";
 import { opencodeConfigDir } from "./mcp-opencode.ts";
+import { normalizeUninstallRawOpts } from "./normalize-uninstall.ts";
 import { resolveClaudeDesktopMcpPath, resolveInstallPaths } from "./paths.ts";
-import { buildInstallPlan } from "./plan.ts";
-import { printInstallStatus } from "./status.ts";
+import { buildInstallPlan, buildUpdatePlan } from "./plan.ts";
+import { printInstallStatus, writeInteractiveInstallIntro } from "./status.ts";
 import { buildUninstallPlan } from "./uninstall.ts";
 
 const fixture: CliProgram = {
@@ -21,7 +32,6 @@ const fixture: CliProgram = {
 
 let home: string;
 let prevHome: string | undefined;
-
 let prevXdg: string | undefined;
 
 beforeEach(() => {
@@ -41,16 +51,10 @@ afterEach(() => {
 });
 
 describe("install paths", () => {
-  test("resolveInstallPaths honors prefix", () => {
-    const paths = resolveInstallPaths(fixture, { prefix: join(home, "custom", "bin") });
-    expect(paths.binaryPath).toBe(join(home, "custom", "bin", "testapp"));
-  });
-
-  test("fish completion uses XDG_CONFIG_HOME", () => {
-    const xdg = join(home, "xdg");
-    process.env.XDG_CONFIG_HOME = xdg;
-    const paths = resolveInstallPaths(fixture, {});
-    expect(paths.fishCompletion).toBe(join(xdg, "fish", "completions", "testapp.fish"));
+  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", () => {
@@ -67,63 +71,101 @@ describe("install paths", () => {
 });
 
 describe("detect installed", () => {
-  test("detects binary and completions", () => {
-    const paths = resolveInstallPaths(fixture, {});
-    mkdirSync(paths.bindir, { recursive: true });
-    writeFileSync(paths.binaryPath, "fake", "utf8");
-    mkdirSync(join(home, ".bash_completion.d"), { recursive: true });
-    writeFileSync(paths.bashCompletion, "# bash", "utf8");
-
-    const detected = detectInstalledArtifacts(paths);
-    expect(detected.binary).toBe(true);
-    expect(detected.bashCompletion).toBe(true);
-    expect(detected.zshCompletion).toBe(false);
+  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("install plan", () => {
-  test("buildInstallPlan --all includes binary", () => {
-    const paths = resolveInstallPaths(fixture, {});
+  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 === "binary")).toBe(true);
+    expect(plan.some((a) => a.kind === "app")).toBe(false);
+    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(true);
+  });
+
+  test("buildInstallPlan --mcp without yes omits implicit app", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
+    expect(plan.some((a) => a.kind === "app")).toBe(false);
+  });
+
+  test("buildUpdatePlan greenfield falls back to install-all", () => {
+    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 --mcp skips MCP when agentIntegration is skill", () => {
+    const skillApp: CliProgram = {
+      ...fixture,
+      install: { 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);
   });
 
   test("buildInstallPlan --mcp includes claude desktop when app data exists", () => {
-    const paths = resolveInstallPaths(fixture, {});
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(join(home, ".claude"), { recursive: true });
     mkdirSync(join(home, "Library", "Application Support", "Claude"), { recursive: true });
     const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
     expect(plan.some((a) => a.kind === "claude-desktop-mcp")).toBe(process.platform === "darwin");
     expect(plan.some((a) => a.kind === "claude-mcp")).toBe(true);
   });
 
-  test("buildInstallPlan --mcp skips claude desktop without app data", () => {
-    const paths = resolveInstallPaths(fixture, {});
-    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
-    expect(plan.some((a) => a.kind === "claude-desktop-mcp")).toBe(false);
-  });
-
   test("buildInstallPlan --mcp includes opencode when config dir exists", () => {
-    const paths = resolveInstallPaths(fixture, {});
+    const paths = resolveInstallPaths(fixture);
     mkdirSync(opencodeConfigDir(home), { recursive: true });
     const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
     expect(plan.some((a) => a.kind === "opencode-mcp")).toBe(true);
   });
 
-  test("buildInstallPlan --mcp includes chatgpt when app data exists", () => {
-    const paths = resolveInstallPaths(fixture, {});
-    if (process.platform === "darwin") {
-      mkdirSync(join(home, "Library", "Application Support", "ChatGPT"), { recursive: true });
-      const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
-      expect(plan.some((a) => a.kind === "chatgpt-desktop-mcp")).toBe(true);
-    }
+  test("buildInstallPlan --mcp --skill --configure is not empty when agents exist", () => {
+    const program: CliProgram = {
+      ...fixture,
+      install: { agentIntegration: "both" },
+      appConfig: {
+        entries: { token: { description: "API token." } },
+      },
+    };
+    const paths = resolveInstallPaths(program);
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    mkdirSync(join(home, ".claude"), { recursive: true });
+    const plan = buildInstallPlan(
+      program,
+      paths,
+      parseInstallOpts({ mcp: "1", skill: "1", configure: "1" }),
+    );
+    expect(plan.length).toBeGreaterThan(0);
+    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(true);
+    expect(plan.some((a) => a.kind.endsWith("-skill"))).toBe(true);
   });
 });
 
 describe("install status", () => {
-  test("printInstallStatus human output", () => {
-    const paths = resolveInstallPaths(fixture, {});
-    mkdirSync(paths.bindir, { recursive: true });
-    writeFileSync(paths.binaryPath, "fake", "utf8");
+  test("printInstallStatus human output with MCP", () => {
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    writeFileSync(
+      paths.cursorMcpPath,
+      JSON.stringify({ mcpServers: { testapp: { command: "testapp", args: ["mcp"] } } }),
+      "utf8",
+    );
 
     const chunks: string[] = [];
     const orig = process.stdout.write;
@@ -135,14 +177,14 @@ describe("install status", () => {
       printInstallStatus(fixture, {});
       const out = chunks.join("");
       expect(out).toContain("Installed artifacts for testapp");
-      expect(out).toContain(paths.binaryPath);
+      expect(out).toContain("cursor mcp");
     } finally {
       process.stdout.write = orig;
     }
   });
 
   test("printInstallStatus json output", () => {
-    const paths = resolveInstallPaths(fixture, {});
+    const paths = resolveInstallPaths(fixture);
     mkdirSync(join(home, ".cursor"), { recursive: true });
     writeFileSync(
       paths.cursorMcpPath,
@@ -166,72 +208,110 @@ describe("install status", () => {
   });
 });
 
-describe("parseInstallOpts", () => {
-  test("json implies yes in validate path via cliInstall", () => {
-    const opts = parseInstallOpts({ json: "1", all: "1" });
-    expect(opts.json).toBe(true);
-    expect(opts.all).toBe(true);
+describe("interactive selection", () => {
+  test("mergeInteractiveSelection prepends 1 when app is assumed", () => {
+    expect(mergeInteractiveSelection([2, 3], 5, true)).toEqual([1, 2, 3]);
+    expect(mergeInteractiveSelection([1, 3], 5, true)).toEqual([1, 3]);
+    expect(mergeInteractiveSelection([2, 3], 5, false)).toEqual([2, 3]);
+  });
+
+  test("interactiveSelectionAssumesApp is always false", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
+    expect(interactiveSelectionAssumesApp(plan, false)).toBe(false);
   });
 });
 
-describe("validateInstallOpts", () => {
-  test("uninstall requires a target flag", () => {
-    const opts = parseInstallOpts({ uninstall: "1", yes: "1" });
-    expect(validateInstallOpts(opts)).toContain("Specify at least one target");
+describe("install output", () => {
+  test("writeInteractiveInstallIntro prints app Setup banner on stderr", () => {
+    const chunks: string[] = [];
+    const orig = process.stderr.write;
+    process.stderr.write = ((s: string | Uint8Array) => {
+      chunks.push(String(s));
+      return true;
+    }) as typeof process.stderr.write;
+    try {
+      writeInteractiveInstallIntro(fixture);
+      expect(chunks.join("")).toBe("\ntestapp Setup\n\n");
+    } finally {
+      process.stderr.write = orig;
+    }
+  });
+});
+
+describe("validateUninstallOpts", () => {
+  test("bare uninstall normalizes to --all", () => {
+    const opts = parseInstallOpts(normalizeUninstallRawOpts({ yes: "1" }));
+    expect(validateUninstallOpts(opts)).toBeNull();
+    expect(opts.all).toBe(true);
   });
 
   test("uninstall allows --all", () => {
     const opts = parseInstallOpts({ uninstall: "1", all: "1", yes: "1" });
-    expect(validateInstallOpts(opts)).toBeNull();
+    expect(validateUninstallOpts(opts)).toBeNull();
   });
 
   test("uninstall rejects --reinstall", () => {
     const opts = parseInstallOpts({ uninstall: "1", reinstall: "1", all: "1" });
-    expect(validateInstallOpts(opts)).toContain("--reinstall");
+    expect(validateUninstallOpts(opts)).toContain("--reinstall");
+  });
+});
+
+describe("validateInstallOpts", () => {
+  test("install --uninstall is rejected", () => {
+    const opts = parseInstallOpts({ uninstall: "1", all: "1", yes: "1" });
+    expect(validateInstallOpts(opts)).toContain("uninstall");
   });
 });
 
 describe("install mutation", () => {
   test("uninstall --all with nothing installed succeeds", async () => {
-    const result = await runInstallMutation(fixture, { uninstall: "1", all: "1", yes: "1" });
+    const result = await runUninstallMutation(fixture, { all: "1", yes: "1" });
     expect(result.changed).toEqual([]);
   });
 
-  test("install --skill with no agent dirs succeeds", async () => {
+  test("install --skill skips cursor and claude when agent dirs missing", async () => {
     const result = await runInstallMutation(fixture, { skill: "1", yes: "1", dry: "1" });
-    expect(result.changed).toEqual([]);
+    expect(
+      result.changed.every((p) => !p.includes("/.cursor/") && !p.includes("/.claude/skills/")),
+    ).toBe(true);
   });
 
-  test("uninstall --all removes detected binary", async () => {
-    const paths = resolveInstallPaths(fixture, {});
-    mkdirSync(paths.bindir, { recursive: true });
-    writeFileSync(paths.binaryPath, "fake", "utf8");
-
-    const result = await runInstallMutation(fixture, { uninstall: "1", all: "1", yes: "1" });
-    expect(result.changed).toContain(paths.binaryPath);
-    expect(existsSync(paths.binaryPath)).toBe(false);
+  test("install --all --yes dry-run succeeds when stdin is not a TTY", async () => {
+    const program: CliProgram = {
+      ...fixture,
+      appConfig: {
+        entries: { token: { description: "API token." } },
+      },
+    };
+    const origIsTTY = process.stdin.isTTY;
+    Object.defineProperty(process.stdin, "isTTY", { value: false, configurable: true });
+    const exitCode = await new Promise<number>((resolve) => {
+      const origExit = process.exit;
+      process.exit = ((code?: number) => {
+        process.exit = origExit;
+        resolve(code ?? 0);
+      }) as typeof process.exit;
+      void cliInstall(program, { all: "1", yes: "1", dry: "1" });
+    });
+    Object.defineProperty(process.stdin, "isTTY", { value: origIsTTY, configurable: true });
+    expect(exitCode).toBe(0);
   });
 });
 
 describe("uninstall plan", () => {
-  test("buildUninstallPlan --all scopes like install --all", () => {
-    const paths = resolveInstallPaths(fixture, {});
-    mkdirSync(paths.bindir, { recursive: true });
-    writeFileSync(paths.binaryPath, "fake", "utf8");
-
-    const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", all: "1" }));
-    expect(plan.some((a) => a.summary.startsWith("binary:"))).toBe(true);
-  });
-
-  test("buildUninstallPlan --bin ignores completions", () => {
-    const paths = resolveInstallPaths(fixture, {});
-    mkdirSync(paths.bindir, { recursive: true });
-    writeFileSync(paths.binaryPath, "fake", "utf8");
-    mkdirSync(join(home, ".bash_completion.d"), { recursive: true });
-    writeFileSync(paths.bashCompletion, "# bash", "utf8");
+  test("buildUninstallPlan --all runs configure last when config exists", () => {
+    const program: CliProgram = {
+      ...fixture,
+      appConfig: {
+        entries: { token: { description: "API token." } },
+      },
+    };
+    const paths = resolveInstallPaths(program);
+    writeAppConfigFile(program, { token: "secret" });
 
-    const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", bin: "1" }));
-    expect(plan).toHaveLength(1);
-    expect(plan[0]?.summary.startsWith("binary:")).toBe(true);
+    const plan = buildUninstallPlan(program, paths, parseInstallOpts({ uninstall: "1", all: "1" }));
+    const configureIdx = plan.findIndex((a) => a.summary.startsWith("app config:"));
+    expect(configureIdx).toBe(plan.length - 1);
   });
 });

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

@@ -0,0 +1,40 @@
+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 { openclawMcpHasServer, resolveOpenclawConfigPath } from "./mcp-openclaw.ts";
+
+let home: string;
+let prevHome: string | undefined;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "argsbarg-openclaw-"));
+  prevHome = process.env.HOME;
+  process.env.HOME = home;
+});
+
+afterEach(() => {
+  if (prevHome === undefined) delete process.env.HOME;
+  else process.env.HOME = prevHome;
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("openclaw mcp config", () => {
+  test("openclawMcpHasServer detects configured server", () => {
+    const path = resolveOpenclawConfigPath(home);
+    mkdirSync(join(home, ".openclaw"), { recursive: true });
+    writeFileSync(
+      path,
+      JSON.stringify({
+        mcp: {
+          servers: {
+            testapp: { command: "testapp", args: ["mcp"] },
+          },
+        },
+      }),
+      "utf8",
+    );
+    expect(openclawMcpHasServer(home, "testapp")).toBe(true);
+    expect(openclawMcpHasServer(home, "other")).toBe(false);
+  });
+});

package/src/install/mcp-openclaw.ts

@@ -0,0 +1,106 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { McpServerEntry } from "./mcp-config.ts";
+
+/** True when the `openclaw` executable is on PATH. */
+export function openclawOnPath(): boolean {
+  return Bun.which("openclaw") !== null;
+}
+
+/** Global OpenClaw config path (`~/.openclaw/openclaw.json`). */
+export function resolveOpenclawConfigPath(home: string): string {
+  return join(home, ".openclaw", "openclaw.json");
+}
+
+function readOpenclawMcpEntry(path: string, name: string): McpServerEntry | undefined {
+  if (!existsSync(path)) return undefined;
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8")) as {
+      mcp?: { servers?: Record<string, { command?: string; args?: string[] }> };
+    };
+    const entry = data.mcp?.servers?.[name];
+    if (!entry?.command) return undefined;
+    return { command: entry.command, args: entry.args ?? [] };
+  } catch {
+    return undefined;
+  }
+}
+
+export function openclawMcpHasServer(home: string, name: string): boolean {
+  const path = resolveOpenclawConfigPath(home);
+  if (!existsSync(path)) return false;
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8")) as {
+      mcp?: { servers?: Record<string, unknown> };
+    };
+    return data.mcp?.servers?.[name] !== undefined;
+  } catch {
+    return false;
+  }
+}
+
+function entriesEqual(a: McpServerEntry, b: McpServerEntry): boolean {
+  return a.command === b.command && JSON.stringify(a.args) === JSON.stringify(b.args);
+}
+
+/** Returns an error when an existing OpenClaw entry conflicts, or null if safe to merge. */
+export function checkOpenclawMcpConflict(
+  home: string,
+  name: string,
+  expected: McpServerEntry,
+  yes: boolean,
+): string | null {
+  const path = resolveOpenclawConfigPath(home);
+  const existing = readOpenclawMcpEntry(path, name);
+  if (existing && !entriesEqual(existing, expected) && !yes) {
+    return (
+      `MCP server "${name}" in ${path} differs from expected OpenClaw entry.\n` +
+      `  existing: ${JSON.stringify(existing)}\n` +
+      `  expected: ${JSON.stringify(expected)}\n` +
+      `Use --yes to overwrite.`
+    );
+  }
+  return null;
+}
+
+function runOpenclaw(args: string[]): void {
+  const proc = Bun.spawnSync({
+    cmd: ["openclaw", ...args],
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (proc.exitCode !== 0) {
+    const err = new TextDecoder().decode(proc.stderr).trim();
+    throw new Error(err || `openclaw ${args.join(" ")} failed (exit ${proc.exitCode})`);
+  }
+}
+
+/** Registers a stdio MCP server via `openclaw mcp add`. */
+export function mergeOpenclawMcpConfig(
+  home: string,
+  name: string,
+  entry: McpServerEntry,
+  dry: boolean,
+  overwrite: boolean,
+): string {
+  const configPath = resolveOpenclawConfigPath(home);
+  if (dry) return configPath;
+
+  mkdirSync(join(home, ".openclaw"), { recursive: true });
+  if (openclawMcpHasServer(home, name) && overwrite) {
+    runOpenclaw(["mcp", "unset", name]);
+  }
+
+  const args = ["mcp", "add", name, "--command", entry.command];
+  for (const arg of entry.args) {
+    args.push("--arg", arg);
+  }
+  runOpenclaw(args);
+  return configPath;
+}
+
+/** Removes an OpenClaw MCP server via `openclaw mcp unset`. */
+export function removeOpenclawMcpConfig(home: string, name: string, dry: boolean): void {
+  if (dry || !openclawMcpHasServer(home, name)) return;
+  runOpenclaw(["mcp", "unset", name]);
+}

package/src/install/normalize-uninstall.ts

@@ -0,0 +1,11 @@
+/** Normalizes bare `uninstall` to `--all`. */
+export function normalizeUninstallRawOpts(raw: Record<string, string>): Record<string, string> {
+  const flag = (name: string) => raw[name] === "1";
+  const out: Record<string, string> = { ...raw, uninstall: "1" };
+
+  const hasUninstallTarget = flag("all") || flag("skill") || flag("mcp") || flag("configure");
+  if (!hasUninstallTarget) {
+    out.all = "1";
+  }
+  return out;
+}

package/src/install/normalize.ts

@@ -0,0 +1,20 @@
+/** Normalizes bare `install` to `--all`. */
+export function normalizeInstallRawOpts(raw: Record<string, string>): Record<string, string> {
+  const flag = (name: string) => raw[name] === "1";
+  const out = { ...raw };
+
+  if (flag("status") || flag("reinstall")) {
+    return out;
+  }
+
+  const hasInstallTarget = flag("all") || flag("skill") || flag("mcp");
+
+  if (flag("configure") && !hasInstallTarget) {
+    return out;
+  }
+
+  if (!hasInstallTarget) {
+    out.all = "1";
+  }
+  return out;
+}

package/src/install/paths.ts

@@ -1,39 +1,34 @@
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { mcpServerId, sanitizeToolSegment } from "../mcp/tools.ts";
-import { expandTilde, userHome, xdgConfigHome } from "../paths/host.ts";
+import { displayHomePath, userHome, xdgConfigHome } from "../paths/host.ts";
+import { skillDirNameForTarget } from "../skill/install.ts";
 import type { CliProgram } from "../types.ts";
+import { resolveOpenclawConfigPath } from "./mcp-openclaw.ts";
 import { resolveOpenCodeConfigPathForInstall } from "./mcp-opencode.ts";
 
 export interface InstallPaths {
-  bindir: string;
-  binaryPath: string;
-  bashCompletion: string;
-  zshCompletion: string;
-  fishCompletion: string;
   cursorSkillDir: string;
   claudeSkillDir: string;
+  codexSkillDir: string;
+  opencodeSkillDir: string;
+  openclawSkillDir: string;
   cursorMcpPath: string;
   claudeMcpPath: string;
   claudeDesktopMcpPath: string;
   opencodeMcpPath: string;
   chatGptMcpPath: string;
   codexConfigPath: string;
-  bashRc: string;
-  zshRc: string;
+  openclawConfigPath: string;
   mcpName: string;
   skillDirName: string;
 }
 
 export { userHome } from "../paths/host.ts";
 
-/** Resolves the binary install directory from CLI flag, env, or config. */
-export function resolveBindir(root: CliProgram, prefix?: string): string {
-  const raw = prefix ?? process.env.INSTALL_PREFIX ?? root.install?.prefix;
-  if (raw) {
-    return expandTilde(raw);
-  }
-  return join(userHome(), ".local", "bin");
+/** Format an absolute path for user-facing install output. */
+export function displayInstallPath(path: string): string {
+  return displayHomePath(path);
 }
 
 /** Resolves Claude Desktop `claude_desktop_config.json` for the current OS. */
@@ -71,31 +66,28 @@ export function chatGptDesktopPresent(_home: string, configPath: string): boolea
 }
 
 /** Resolves all install artifact paths for a program root. */
-export function resolveInstallPaths(root: CliProgram, opts: { prefix?: string }): InstallPaths {
+export function resolveInstallPaths(root: CliProgram): InstallPaths {
   const home = userHome();
-  const bindir = resolveBindir(root, opts.prefix);
-  const key = root.key;
   const skillDirName = sanitizeToolSegment(root.key);
-  const xdgConfig = xdgConfigHome(home);
+  const codexSlug = skillDirNameForTarget(root.key, "codex");
+  const opencodeSlug = skillDirNameForTarget(root.key, "opencode");
+  const openclawSlug = skillDirNameForTarget(root.key, "openclaw");
   const claudeDesktopMcpPath = resolveClaudeDesktopMcpPath(home);
   const chatGptMcpPath = resolveChatGptMcpPath(home);
 
   return {
-    bindir,
-    binaryPath: join(bindir, key),
-    bashCompletion: join(home, ".bash_completion.d", key),
-    zshCompletion: join(home, ".zsh", "completions", `_${key}`),
-    fishCompletion: join(xdgConfig, "fish", "completions", `${key}.fish`),
     cursorSkillDir: join(home, ".cursor", "skills", skillDirName),
     claudeSkillDir: join(home, ".claude", "skills", skillDirName),
+    codexSkillDir: join(home, ".codex", "skills", codexSlug),
+    opencodeSkillDir: join(home, ".config", "opencode", "skills", opencodeSlug),
+    openclawSkillDir: join(home, ".openclaw", "skills", openclawSlug),
     cursorMcpPath: join(home, ".cursor", "mcp.json"),
     claudeMcpPath: join(home, ".claude.json"),
     claudeDesktopMcpPath,
     opencodeMcpPath: resolveOpenCodeConfigPathForInstall(home),
     chatGptMcpPath,
     codexConfigPath: join(home, ".codex", "config.toml"),
-    bashRc: join(home, ".bashrc"),
-    zshRc: join(home, ".zshrc"),
+    openclawConfigPath: resolveOpenclawConfigPath(home),
     mcpName: mcpServerId(root),
     skillDirName,
   };