argsbarg 3.4.1 → 3.5.0

package/src/index.ts

@@ -7,28 +7,8 @@ It gives consumers one stable import path without forcing them to know the inter
 module layout.
 */
 
-export { cliInvoke } from "./invoke.ts";
-export type { CliInvokeKind, CliInvokeResult } from "./invoke.ts";
 export { CliContext } from "./context.ts";
-export { cliErrWithHelp, cliRun } from "./runtime";
-export { CliFallbackMode, CliOptionKind, CliSchemaValidationError } from "./types.ts";
-export type {
-  CliProgram,
-  CliHandler,
-  CliInvocation,
-  CliMcpResource,
-  CliMcpServerConfig,
-  CliMcpBundleConfig,
-  CliMcpToolConfig,
-  CliInstallConfig,
-  CliUpdateArtifact,
-  CliUpdateGetLatest,
-  CliDocsConfig,
-  CliDocsTopic,
-  CliOption,
-  CliPositional,
-} from "./types.ts";
-export { isInteractiveTty } from "./utils.ts";
+export type { HeadlessContext } from "./headless.ts";
 export {
   formatDryRunMessage,
   requireYesInNonTty,
@@ -37,7 +17,7 @@ export {
   shouldRunHeadlessWithYes,
   wantsExplicitJson,
 } from "./headless.ts";
-export type { HeadlessContext } from "./headless.ts";
+export type { GhReleaseUpdateConfig, GhVersionCheckConfig } from "./install/gh-release-update.ts";
 export {
   createGhFetchLatest,
   createGhVersionCheck,
@@ -45,6 +25,26 @@ export {
   isAlreadyCurrent,
   parseReleaseTag,
 } from "./install/gh-release-update.ts";
-export type { GhReleaseUpdateConfig, GhVersionCheckConfig } from "./install/gh-release-update.ts";
-export { generateMcpManifest, packMcpBundle, defaultMcpBundlePaths } from "./mcp/bundle.ts";
+export type { CliInvokeKind, CliInvokeResult } from "./invoke.ts";
+export { cliInvoke } from "./invoke.ts";
 export type { McpBundlePaths, PackMcpBundleOpts } from "./mcp/bundle.ts";
+export { defaultMcpBundlePaths, generateMcpManifest, packMcpBundle } from "./mcp/bundle.ts";
+export { cliErrWithHelp, cliRun } from "./runtime";
+export type {
+  CliDocsConfig,
+  CliDocsTopic,
+  CliHandler,
+  CliInstallConfig,
+  CliInvocation,
+  CliMcpBundleConfig,
+  CliMcpResource,
+  CliMcpServerConfig,
+  CliMcpToolConfig,
+  CliOption,
+  CliPositional,
+  CliProgram,
+  CliUpdateArtifact,
+  CliUpdateGetLatest,
+} from "./types.ts";
+export { CliFallbackMode, CliOptionKind, CliSchemaValidationError } from "./types.ts";
+export { isInteractiveTty } from "./utils.ts";

package/src/install/binary.ts

@@ -1,7 +1,14 @@
-import { copyFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { dirname, join } from "node:path";
-import { CliProgram } from "../types.ts";
-import { InstallPaths } from "./paths.ts";
+import type { CliProgram } from "../types.ts";
+import type { InstallPaths } from "./paths.ts";
 import {
   buildPathRcBlock,
   buildZshFpathRcBlock,
@@ -39,7 +46,7 @@ export function installBinary(
     let content = existsSync(paths.bashRc) ? readFileSync(paths.bashRc, "utf8") : "";
     if (!hasRcBlock(content, root.key, "path")) {
       if (!content.endsWith("\n") && content.length > 0) content += "\n";
-      content += block + "\n";
+      content += `${block}\n`;
       if (!dry) writeFileSync(paths.bashRc, content, "utf8");
       changed.push(paths.bashRc);
       patchedBashRc = true;
@@ -52,7 +59,7 @@ export function installBinary(
     let content = existsSync(paths.zshRc) ? readFileSync(paths.zshRc, "utf8") : "";
     if (!hasRcBlock(content, root.key, "fpath")) {
       if (!content.endsWith("\n") && content.length > 0) content += "\n";
-      content += block + "\n";
+      content += `${block}\n`;
       if (!dry) writeFileSync(paths.zshRc, content, "utf8");
       changed.push(paths.zshRc);
       patchedZshRc = true;

package/src/install/completions.ts

@@ -1,9 +1,13 @@
 import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
-import { CliProgram } from "../types.ts";
-import { completionBashScript, completionFishScript, completionZshScript } from "../builtins/index.ts";
+import {
+  completionBashScript,
+  completionFishScript,
+  completionZshScript,
+} from "../builtins/index.ts";
 import { cliPresentationRoot } from "../builtins/presentation.ts";
-import { InstallPaths } from "./paths.ts";
+import type { CliProgram } from "../types.ts";
+import type { InstallPaths } from "./paths.ts";
 import { detectShells } from "./shell.ts";
 
 /** Writes shell completion scripts for detected shells. */

package/src/install/detect-installed.ts

@@ -1,5 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
-import { InstallPaths } from "./paths.ts";
+import { codexMcpHasServer } from "./mcp-codex.ts";
+import { detectOpenCodeMcpConfigPath } from "./mcp-opencode.ts";
+import { type InstallPaths, userHome } from "./paths.ts";
 
 export interface InstalledArtifacts {
   binary: boolean;
@@ -10,6 +12,10 @@ export interface InstalledArtifacts {
   claudeSkill: boolean;
   cursorMcp: boolean;
   claudeMcp: boolean;
+  claudeDesktopMcp: boolean;
+  opencodeMcp: boolean;
+  codexMcp: boolean;
+  chatGptMcp: boolean;
   bashRcPath: boolean;
   zshRcFpath: boolean;
 }
@@ -35,6 +41,10 @@ export function detectInstalledArtifacts(paths: InstallPaths): InstalledArtifact
     claudeSkill: existsSync(paths.claudeSkillDir),
     cursorMcp: mcpConfigHasServer(paths.cursorMcpPath, paths.mcpName),
     claudeMcp: mcpConfigHasServer(paths.claudeMcpPath, paths.mcpName),
+    claudeDesktopMcp: mcpConfigHasServer(paths.claudeDesktopMcpPath, paths.mcpName),
+    opencodeMcp: detectOpenCodeMcpConfigPath(userHome(), paths.mcpName) !== undefined,
+    codexMcp: codexMcpHasServer(userHome(), paths.mcpName),
+    chatGptMcp: mcpConfigHasServer(paths.chatGptMcpPath, paths.mcpName),
     bashRcPath: false,
     zshRcFpath: false,
   };
@@ -49,18 +59,39 @@ export interface InstallStatus {
   claudeSkill?: string;
   cursorMcp?: string;
   claudeMcp?: string;
+  claudeDesktopMcp?: string;
+  opencodeMcp?: string;
+  codexMcp?: string;
+  chatGptMcp?: string;
 }
 
 /** Builds a status inventory from detected artifacts. */
-export function buildInstallStatus(paths: InstallPaths, detected: InstalledArtifacts): InstallStatus {
+export function buildInstallStatus(
+  paths: InstallPaths,
+  detected: InstalledArtifacts,
+): InstallStatus {
   const status: InstallStatus = {};
   if (detected.binary) status.binary = paths.binaryPath;
   if (detected.bashCompletion) status.bashCompletion = paths.bashCompletion;
   if (detected.zshCompletion) status.zshCompletion = paths.zshCompletion;
   if (detected.fishCompletion) status.fishCompletion = paths.fishCompletion;
-  if (detected.cursorSkill) status.cursorSkill = paths.cursorSkillDir + "/";
-  if (detected.claudeSkill) status.claudeSkill = paths.claudeSkillDir + "/";
+  if (detected.cursorSkill) status.cursorSkill = `${paths.cursorSkillDir}/`;
+  if (detected.claudeSkill) status.claudeSkill = `${paths.claudeSkillDir}/`;
   if (detected.cursorMcp) status.cursorMcp = `${paths.cursorMcpPath} (server "${paths.mcpName}")`;
   if (detected.claudeMcp) status.claudeMcp = `${paths.claudeMcpPath} (server "${paths.mcpName}")`;
+  if (detected.claudeDesktopMcp) {
+    status.claudeDesktopMcp = `${paths.claudeDesktopMcpPath} (server "${paths.mcpName}")`;
+  }
+  if (detected.opencodeMcp) {
+    const openCodePath =
+      detectOpenCodeMcpConfigPath(userHome(), paths.mcpName) ?? paths.opencodeMcpPath;
+    status.opencodeMcp = `${openCodePath} (server "${paths.mcpName}")`;
+  }
+  if (detected.codexMcp) {
+    status.codexMcp = `${paths.codexConfigPath} (server "${paths.mcpName}")`;
+  }
+  if (detected.chatGptMcp) {
+    status.chatGptMcp = `${paths.chatGptMcpPath} (server "${paths.mcpName}")`;
+  }
   return status;
 }

package/src/install/gh-release-update.ts

@@ -1,4 +1,12 @@
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import type { CliUpdateGetLatest } from "../types.ts";
@@ -113,7 +121,8 @@ export function createGhVersionCheck(config: GhVersionCheckConfig): {
         return;
       }
 
-      void config.fetchLatest()
+      void config
+        .fetchLatest()
         .then((latest) => {
           writeVersionCheckCache(config.cachePath, { fetchedAt: Date.now(), latest });
         })
@@ -125,26 +134,22 @@ export function createGhVersionCheck(config: GhVersionCheckConfig): {
 }
 
 /** Shared `gh release view` fetcher for hooks and version-check refresh. */
-export function createGhFetchLatest(config: Pick<GhReleaseUpdateConfig, "repo" | "repoEnvHint">): () => Promise<string> {
+export function createGhFetchLatest(
+  config: Pick<GhReleaseUpdateConfig, "repo" | "repoEnvHint">,
+): () => Promise<string> {
   return async () => {
-    const result = await runGh([
-      "release",
-      "view",
-      "--repo",
-      config.repo,
-      "--json",
-      "tagName",
-    ]);
+    const result = await runGh(["release", "view", "--repo", config.repo, "--json", "tagName"]);
 
     if (result.exitCode !== 0) {
       const detail = result.stderr.trim() || result.stdout.trim();
-      const hint = detail.includes("auth") || detail.includes("401")
-        ? " Run `gh auth login` and try again."
-        : detail.includes("release not found") || detail.includes("Not Found")
-          ? config.repoEnvHint
-            ? ` ${config.repoEnvHint}`
-            : ` No releases found for ${config.repo}.`
-          : "";
+      const hint =
+        detail.includes("auth") || detail.includes("401")
+          ? " Run `gh auth login` and try again."
+          : detail.includes("release not found") || detail.includes("Not Found")
+            ? config.repoEnvHint
+              ? ` ${config.repoEnvHint}`
+              : ` No releases found for ${config.repo}.`
+            : "";
       throw new Error(
         `Failed to fetch latest release from ${config.repo}: ${detail || "unknown error"}.${hint}`,
       );
@@ -173,7 +178,10 @@ function ensureGhAvailable(): void {
   }
 }
 
-async function downloadReleaseAsset(config: GhReleaseUpdateConfig, tempDir: string): Promise<string> {
+async function downloadReleaseAsset(
+  config: GhReleaseUpdateConfig,
+  tempDir: string,
+): Promise<string> {
   const result = await runGh([
     "release",
     "download",
@@ -187,9 +195,7 @@ async function downloadReleaseAsset(config: GhReleaseUpdateConfig, tempDir: stri
 
   if (result.exitCode !== 0) {
     const detail = result.stderr.trim() || result.stdout.trim();
-    throw new Error(
-      `Failed to download release from ${config.repo}: ${detail || "unknown error"}`,
-    );
+    throw new Error(`Failed to download release from ${config.repo}: ${detail || "unknown error"}`);
   }
 
   const downloadedPath = join(tempDir, config.asset);
@@ -200,7 +206,9 @@ async function downloadReleaseAsset(config: GhReleaseUpdateConfig, tempDir: stri
   return downloadedPath;
 }
 
-async function runGh(args: string[]): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+async function runGh(
+  args: string[],
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
   const proc = Bun.spawn(["gh", ...args], { stdout: "pipe", stderr: "pipe" });
   const [exitCode, stdout, stderr] = await Promise.all([
     proc.exited,

package/src/install/index.ts

@@ -1,17 +1,14 @@
 import { readSync } from "node:fs";
 import { resolveCapabilities } from "../capabilities.ts";
-import { CliProgram } from "../types.ts";
 import { cliSkillInstall } from "../skill/install.ts";
+import type { CliProgram } from "../types.ts";
+import { checkCodexMcpConflict } from "./mcp-codex.ts";
 import { checkMcpConflict, expectedMcpEntry } from "./mcp-config.ts";
-import {
-  buildInstallPlan,
-  buildUpdatePlan,
-  type InstallAction,
-  type InstallOpts,
-} from "./plan.ts";
-import { resolveInstallPaths } from "./paths.ts";
+import { checkOpenCodeMcpConflict, expectedOpenCodeMcpEntry } from "./mcp-opencode.ts";
+import { resolveInstallPaths, userHome } from "./paths.ts";
+import { buildInstallPlan, buildUpdatePlan, type InstallAction, type InstallOpts } from "./plan.ts";
 import { installErr, installInfo, installOut, printInstallStatus } from "./status.ts";
-import { buildUninstallPlan, uninstallSkillDir, type UninstallAction } from "./uninstall.ts";
+import { buildUninstallPlan, type UninstallAction, uninstallSkillDir } from "./uninstall.ts";
 import { cliUpdate } from "./update.ts";
 
 export function parseInstallOpts(raw: Record<string, string>): InstallOpts {
@@ -54,19 +51,39 @@ export function validateInstallOpts(opts: InstallOpts): string | null {
   }
 
   const mutationFlags =
-    opts.all || opts.bin || opts.completions || opts.skill || opts.mcp || opts.reinstall || opts.update || opts.uninstall;
+    opts.all ||
+    opts.bin ||
+    opts.completions ||
+    opts.skill ||
+    opts.mcp ||
+    opts.reinstall ||
+    opts.update ||
+    opts.uninstall;
   if (opts.status && mutationFlags) {
     return "--status is mutually exclusive with install/reinstall/uninstall targets.";
   }
   if (
     opts.reinstall &&
-    (opts.all || opts.completions || opts.skill || opts.mcp || opts.uninstall || opts.status || opts.update)
+    (opts.all ||
+      opts.completions ||
+      opts.skill ||
+      opts.mcp ||
+      opts.uninstall ||
+      opts.status ||
+      opts.update)
   ) {
     return "--reinstall cannot be combined with other target flags.";
   }
   if (
     opts.update &&
-    (opts.all || opts.bin || opts.completions || opts.skill || opts.mcp || opts.uninstall || opts.status || opts.reinstall)
+    (opts.all ||
+      opts.bin ||
+      opts.completions ||
+      opts.skill ||
+      opts.mcp ||
+      opts.uninstall ||
+      opts.status ||
+      opts.reinstall)
   ) {
     return "--update cannot be combined with other target flags.";
   }
@@ -134,7 +151,11 @@ function executePlan(
 export async function runInstallMutation(
   root: CliProgram,
   rawOpts: Record<string, string>,
-): Promise<{ changed: string[]; opts: InstallOpts; paths: ReturnType<typeof resolveInstallPaths> }> {
+): Promise<{
+  changed: string[];
+  opts: InstallOpts;
+  paths: ReturnType<typeof resolveInstallPaths>;
+}> {
   const opts = parseInstallOpts(rawOpts);
   const err = validateInstallOpts(opts);
   if (err) {
@@ -150,13 +171,32 @@ export async function runInstallMutation(
 
   if (!opts.uninstall && resolveCapabilities(root).mcp && (opts.all || opts.mcp)) {
     const entry = expectedMcpEntry(root);
+    const openCodeEntry = expectedOpenCodeMcpEntry(root);
     const yes = !!opts.yes;
-    for (const p of [paths.cursorMcpPath, paths.claudeMcpPath]) {
+    for (const p of [
+      paths.cursorMcpPath,
+      paths.claudeMcpPath,
+      paths.claudeDesktopMcpPath,
+      paths.chatGptMcpPath,
+    ]) {
       const conflict = checkMcpConflict(p, paths.mcpName, entry, yes);
       if (conflict) {
         throw new Error(conflict);
       }
     }
+    const openCodeConflict = checkOpenCodeMcpConflict(
+      paths.opencodeMcpPath,
+      paths.mcpName,
+      openCodeEntry,
+      yes,
+    );
+    if (openCodeConflict) {
+      throw new Error(openCodeConflict);
+    }
+    const codexConflict = checkCodexMcpConflict(userHome(), paths.mcpName, entry, yes);
+    if (codexConflict) {
+      throw new Error(codexConflict);
+    }
   }
 
   let actions: Array<InstallAction | UninstallAction>;
@@ -173,9 +213,12 @@ export async function runInstallMutation(
   }
 
   if (!opts.quiet && !opts.json) {
-    installOut("About to " + (opts.uninstall ? "remove" : opts.reinstall ? "reinstall" : "install") + ":", opts);
+    installOut(
+      `About to ${opts.uninstall ? "remove" : opts.reinstall ? "reinstall" : "install"}:`,
+      opts,
+    );
     for (const a of actions) {
-      installOut("  - " + a.summary, opts);
+      installOut(`  - ${a.summary}`, opts);
     }
   }
 
@@ -194,7 +237,10 @@ export async function runInstallMutation(
 }
 
 /** Main install command orchestrator. */
-export async function cliInstall(root: CliProgram, rawOpts: Record<string, string>): Promise<never> {
+export async function cliInstall(
+  root: CliProgram,
+  rawOpts: Record<string, string>,
+): Promise<never> {
   const opts = parseInstallOpts(rawOpts);
   const err = validateInstallOpts(opts);
   if (err) {
@@ -225,12 +271,16 @@ export async function cliInstall(root: CliProgram, rawOpts: Record<string, strin
   }
 
   if (mutationOpts.json) {
-    process.stdout.write(JSON.stringify(changed, null, 2) + "\n");
+    process.stdout.write(`${JSON.stringify(changed, null, 2)}\n`);
     process.exit(0);
   }
 
   if (!mutationOpts.quiet && changed.length > 0) {
-    const verb = mutationOpts.uninstall ? "Removed" : mutationOpts.reinstall ? "Reinstalled" : "Installed";
+    const verb = mutationOpts.uninstall
+      ? "Removed"
+      : mutationOpts.reinstall
+        ? "Reinstalled"
+        : "Installed";
     installOut(`${verb} ${changed.length} file(s).`, mutationOpts);
     if (
       !mutationOpts.uninstall &&

package/src/install/install.test.ts

@@ -1,14 +1,15 @@
-import { describe, expect, test, beforeEach, afterEach } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { CliProgram } from "../types.ts";
+import { join } from "node:path";
+import type { CliProgram } from "../types.ts";
 import { detectInstalledArtifacts } from "./detect-installed.ts";
-import { resolveInstallPaths } from "./paths.ts";
+import { parseInstallOpts, runInstallMutation, validateInstallOpts } from "./index.ts";
+import { opencodeConfigDir } from "./mcp-opencode.ts";
+import { resolveClaudeDesktopMcpPath, resolveInstallPaths } from "./paths.ts";
 import { buildInstallPlan } from "./plan.ts";
-import { buildUninstallPlan } from "./uninstall.ts";
 import { printInstallStatus } from "./status.ts";
-import { parseInstallOpts, runInstallMutation, validateInstallOpts } from "./index.ts";
+import { buildUninstallPlan } from "./uninstall.ts";
 
 const fixture: CliProgram = {
   key: "testapp",
@@ -21,15 +22,21 @@ const fixture: CliProgram = {
 let home: string;
 let prevHome: string | undefined;
 
+let prevXdg: string | undefined;
+
 beforeEach(() => {
   home = mkdtempSync(join(tmpdir(), "argsbarg-install-"));
   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 });
 });
 
@@ -45,6 +52,18 @@ describe("install paths", () => {
     const paths = resolveInstallPaths(fixture, {});
     expect(paths.fishCompletion).toBe(join(xdg, "fish", "completions", "testapp.fish"));
   });
+
+  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", () => {
@@ -68,6 +87,36 @@ describe("install plan", () => {
     const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
     expect(plan.some((a) => a.kind === "binary")).toBe(true);
   });
+
+  test("buildInstallPlan --mcp includes claude desktop when app data exists", () => {
+    const paths = resolveInstallPaths(fixture, {});
+    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, {});
+    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);
+    }
+  });
 });
 
 describe("install status", () => {
@@ -183,6 +232,6 @@ describe("uninstall plan", () => {
 
     const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", bin: "1" }));
     expect(plan).toHaveLength(1);
-    expect(plan[0]!.summary.startsWith("binary:")).toBe(true);
+    expect(plan[0]?.summary.startsWith("binary:")).toBe(true);
   });
 });

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

@@ -0,0 +1,57 @@
+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 { codexMcpHasServer, readCodexMcpEntry, resolveCodexConfigPath } from "./mcp-codex.ts";
+
+let home: string;
+let prevHome: string | undefined;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "argsbarg-codex-"));
+  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("codex mcp config", () => {
+  test("readCodexMcpEntry parses simple command/args", () => {
+    const path = resolveCodexConfigPath(home);
+    mkdirSync(join(home, ".codex"), { recursive: true });
+    writeFileSync(
+      path,
+      `[mcp_servers.testapp]
+command = "testapp"
+args = ["mcp"]
+`,
+      "utf8",
+    );
+    expect(readCodexMcpEntry(path, "testapp")).toEqual({
+      command: "testapp",
+      args: ["mcp"],
+    });
+    expect(codexMcpHasServer(home, "testapp")).toBe(true);
+  });
+
+  test("readCodexMcpEntry parses transport stdio block", () => {
+    const path = resolveCodexConfigPath(home);
+    mkdirSync(join(home, ".codex"), { recursive: true });
+    writeFileSync(
+      path,
+      `[mcp_servers.testapp]
+enabled = true
+transport = { type = "stdio", command = "testapp", args = ["mcp"] }
+`,
+      "utf8",
+    );
+    expect(readCodexMcpEntry(path, "testapp")).toEqual({
+      command: "testapp",
+      args: ["mcp"],
+    });
+  });
+});