argsbarg 4.0.3 → 4.1.0

package/src/install/install.test.ts

@@ -2,13 +2,20 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { 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 {
+  interactiveSelectionAssumesApp,
+  mergeInteractiveSelection,
+  parseInstallOpts,
+  runInstallMutation,
+  validateInstallOpts,
+} from "./index.ts";
 import { opencodeConfigDir } from "./mcp-opencode.ts";
 import { resolveClaudeDesktopMcpPath, resolveInstallPaths } from "./paths.ts";
 import { buildInstallPlan } from "./plan.ts";
-import { printInstallStatus } from "./status.ts";
+import { printInstallStatus, writeInteractiveInstallIntro } from "./status.ts";
 import { buildUninstallPlan } from "./uninstall.ts";
 
 const fixture: CliProgram = {
@@ -41,15 +48,15 @@ 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("resolveInstallPaths uses ~/.local/bin for app", () => {
+    const paths = resolveInstallPaths(fixture);
+    expect(paths.appPath).toBe(join(home, ".local", "bin", "testapp"));
   });
 
   test("fish completion uses XDG_CONFIG_HOME", () => {
     const xdg = join(home, "xdg");
     process.env.XDG_CONFIG_HOME = xdg;
-    const paths = resolveInstallPaths(fixture, {});
+    const paths = resolveInstallPaths(fixture);
     expect(paths.fishCompletion).toBe(join(xdg, "fish", "completions", "testapp.fish"));
   });
 
@@ -67,29 +74,56 @@ 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");
+  test("detects app and completions", () => {
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(paths.appDir, { recursive: true });
+    writeFileSync(paths.appPath, "fake", "utf8");
     mkdirSync(join(home, ".bash_completion.d"), { recursive: true });
     writeFileSync(paths.bashCompletion, "# bash", "utf8");
 
-    const detected = detectInstalledArtifacts(paths);
-    expect(detected.binary).toBe(true);
+    const detected = detectInstalledArtifacts(paths, fixture);
+    expect(detected.app).toBe(true);
     expect(detected.bashCompletion).toBe(true);
     expect(detected.zshCompletion).toBe(false);
   });
 });
 
 describe("install plan", () => {
-  test("buildInstallPlan --all includes binary", () => {
-    const paths = resolveInstallPaths(fixture, {});
+  test("buildInstallPlan --all includes app", () => {
+    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(true);
+  });
+
+  test("buildInstallPlan --mcp --yes also includes app", () => {
+    const paths = resolveInstallPaths(fixture);
+    const opts = parseInstallOpts({ mcp: "1", yes: "1" });
+    validateInstallOpts(opts);
+    const plan = buildInstallPlan(fixture, paths, opts);
+    expect(plan.some((a) => a.kind === "app")).toBe(true);
+  });
+
+  test("buildInstallPlan --mcp without yes omits app", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
+    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");
@@ -97,20 +131,20 @@ describe("install plan", () => {
   });
 
   test("buildInstallPlan --mcp skips claude desktop without app data", () => {
-    const paths = resolveInstallPaths(fixture, {});
+    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, {});
+    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" }));
@@ -121,9 +155,9 @@ describe("install plan", () => {
 
 describe("install status", () => {
   test("printInstallStatus human output", () => {
-    const paths = resolveInstallPaths(fixture, {});
-    mkdirSync(paths.bindir, { recursive: true });
-    writeFileSync(paths.binaryPath, "fake", "utf8");
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(paths.appDir, { recursive: true });
+    writeFileSync(paths.appPath, "fake", "utf8");
 
     const chunks: string[] = [];
     const orig = process.stdout.write;
@@ -135,14 +169,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("~/.local/bin/testapp");
     } 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,6 +200,45 @@ describe("install status", () => {
   });
 });
 
+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 when install plan starts with app", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
+    expect(interactiveSelectionAssumesApp(plan, false)).toBe(true);
+    expect(interactiveSelectionAssumesApp(plan, true)).toBe(false);
+  });
+
+  test("interactiveSelectionAssumesApp false when app not in plan", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ completions: "1" }));
+    expect(plan.some((a) => a.kind === "app")).toBe(false);
+    expect(interactiveSelectionAssumesApp(plan, false)).toBe(false);
+  });
+});
+
+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("parseInstallOpts", () => {
   test("json implies yes in validate path via cliInstall", () => {
     const opts = parseInstallOpts({ json: "1", all: "1" });
@@ -197,41 +270,64 @@ describe("install mutation", () => {
     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");
+  test("uninstall --all removes detected app", async () => {
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(paths.appDir, { recursive: true });
+    writeFileSync(paths.appPath, "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);
+    expect(result.changed).toContain(paths.appPath);
+    expect(existsSync(paths.appPath)).toBe(false);
+    expect(existsSync(paths.appDir)).toBe(true);
   });
 });
 
 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 paths = resolveInstallPaths(fixture);
+    mkdirSync(paths.appDir, { recursive: true });
+    writeFileSync(paths.appPath, "fake", "utf8");
 
     const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", all: "1" }));
-    expect(plan.some((a) => a.summary.startsWith("binary:"))).toBe(true);
+    expect(plan.some((a) => a.summary.startsWith("app:"))).toBe(true);
+  });
+
+  test("buildUninstallPlan --all runs configure last", () => {
+    const program: CliProgram = {
+      ...fixture,
+      appConfig: {
+        entries: { token: { description: "API token." } },
+      },
+    };
+    const paths = resolveInstallPaths(program);
+    mkdirSync(paths.appDir, { recursive: true });
+    writeFileSync(paths.appPath, "fake", "utf8");
+    writeAppConfigFile(program, { token: "secret" });
+
+    const plan = buildUninstallPlan(program, paths, parseInstallOpts({ uninstall: "1", all: "1" }));
+    const appIdx = plan.findIndex((a) => a.summary.startsWith("app:"));
+    const configureIdx = plan.findIndex((a) => a.summary.startsWith("app config:"));
+    expect(appIdx).toBeGreaterThanOrEqual(0);
+    expect(configureIdx).toBeGreaterThan(appIdx);
+    expect(configureIdx).toBe(plan.length - 1);
   });
 
-  test("buildUninstallPlan --bin ignores completions", () => {
-    const paths = resolveInstallPaths(fixture, {});
-    mkdirSync(paths.bindir, { recursive: true });
-    writeFileSync(paths.binaryPath, "fake", "utf8");
+  test("buildUninstallPlan --app ignores completions", () => {
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(paths.appDir, { recursive: true });
+    writeFileSync(paths.appPath, "fake", "utf8");
     mkdirSync(join(home, ".bash_completion.d"), { recursive: true });
     writeFileSync(paths.bashCompletion, "# bash", "utf8");
 
-    const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", bin: "1" }));
+    const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", app: "1" }));
     expect(plan).toHaveLength(1);
-    expect(plan[0]?.summary.startsWith("binary:")).toBe(true);
+    expect(plan[0]?.summary.startsWith("app:")).toBe(true);
   });
 });

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.ts

@@ -0,0 +1,35 @@
+/** Normalizes bare `install` / `install --uninstall` 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") || flag("update")) {
+    return out;
+  }
+
+  const hasInstallTarget =
+    flag("all") || flag("app") || flag("completions") || flag("skill") || flag("mcp");
+  const hasUninstallTarget =
+    flag("all") ||
+    flag("app") ||
+    flag("completions") ||
+    flag("skill") ||
+    flag("mcp") ||
+    flag("configure");
+
+  if (flag("configure") && !flag("uninstall") && !hasInstallTarget) {
+    return out;
+  }
+
+  if (flag("uninstall")) {
+    if (!hasUninstallTarget) {
+      out.all = "1";
+    }
+    return out;
+  }
+
+  if (!hasInstallTarget) {
+    out.all = "1";
+  }
+  return out;
+}

package/src/install/paths.ts

@@ -1,24 +1,30 @@
 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;
+  appDir: string;
+  appPath: 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;
+  openclawConfigPath: string;
   bashRc: string;
   zshRc: string;
   mcpName: string;
@@ -27,12 +33,13 @@ export interface InstallPaths {
 
 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);
-  }
+/** Format an absolute path for user-facing install output. */
+export function displayInstallPath(path: string): string {
+  return displayHomePath(path);
+}
+
+/** App install directory (`~/.local/bin`). */
+export function resolveAppDir(): string {
   return join(userHome(), ".local", "bin");
 }
 
@@ -71,29 +78,36 @@ 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 appDir = resolveAppDir();
   const key = root.key;
   const skillDirName = sanitizeToolSegment(root.key);
+  const codexSlug = skillDirNameForTarget(root.key, "codex");
+  const opencodeSlug = skillDirNameForTarget(root.key, "opencode");
+  const openclawSlug = skillDirNameForTarget(root.key, "openclaw");
   const xdgConfig = xdgConfigHome(home);
   const claudeDesktopMcpPath = resolveClaudeDesktopMcpPath(home);
   const chatGptMcpPath = resolveChatGptMcpPath(home);
 
   return {
-    bindir,
-    binaryPath: join(bindir, key),
+    appDir,
+    appPath: join(appDir, 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"),
+    openclawConfigPath: resolveOpenclawConfigPath(home),
     bashRc: join(home, ".bashrc"),
     zshRc: join(home, ".zshrc"),
     mcpName: mcpServerId(root),