argsbarg 5.1.8 → 5.1.10

package/src/docs/save.ts

@@ -21,20 +21,12 @@ export function docsSaveGeneratedHint(program: CliProgram, topic: string): strin
 }
 
 /** Inserts save hint without breaking YAML frontmatter (`docs skill`). */
-export function applySaveGeneratedHint(
-  program: CliProgram,
-  topic: string,
-  content: string,
-): string {
+export function applySaveGeneratedHint(program: CliProgram, topic: string, content: string): string {
   if (!docsTopicIsGeneratedByArgsbarg(topic)) {
     return content;
   }
   const hint = docsSaveGeneratedHint(program, topic);
-  return insertGeneratedHint(
-    content,
-    hint,
-    topic === "skill" ? { afterFrontmatter: true } : undefined,
-  );
+  return insertGeneratedHint(content, hint, topic === "skill" ? { afterFrontmatter: true } : undefined);
 }
 
 /** File body for `--save` (hint on argsbarg-generated markdown only). */

package/src/formats.test.ts

@@ -3,13 +3,7 @@ Tests for formats module behavior.
 */
 
 import { expect, test } from "bun:test";
-import {
-  parseCommaList,
-  parseDate,
-  parseDateTime,
-  parseDurationMs,
-  validateFormatValue,
-} from "./formats.ts";
+import { parseCommaList, parseDate, parseDateTime, parseDurationMs, validateFormatValue } from "./formats.ts";
 import { CliValueFormat } from "./types.ts";
 
 test("parseDurationMs parses minutes and hours", () => {

package/src/formats.ts

@@ -108,11 +108,7 @@ export function formatValidationError(format: CliValueFormat, value: string): st
 }
 
 /** Validates a string value against format and/or pattern metadata. */
-export function validateFormatValue(
-  value: string,
-  format?: CliValueFormat,
-  pattern?: string,
-): void {
+export function validateFormatValue(value: string, format?: CliValueFormat, pattern?: string): void {
   if (format !== undefined) {
     switch (format) {
       case CliValueFormat.Duration:

package/src/headless.test.ts

@@ -26,28 +26,16 @@ test("shouldRunHeadless is true for MCP and json", () => {
 });
 
 test("shouldRunHeadlessWithPositionals requires positionals in non-tty", () => {
-  expect(shouldRunHeadlessWithPositionals({ invocation: "cli" }, false, [], false, false)).toBe(
-    false,
-  );
-  expect(shouldRunHeadlessWithPositionals({ invocation: "cli" }, false, ["a"], false, false)).toBe(
-    true,
-  );
+  expect(shouldRunHeadlessWithPositionals({ invocation: "cli" }, false, [], false, false)).toBe(false);
+  expect(shouldRunHeadlessWithPositionals({ invocation: "cli" }, false, ["a"], false, false)).toBe(true);
 });
 
 /** Tests that shouldRunHeadlessWithYes requires yes in non-tty. */
 test("shouldRunHeadlessWithYes requires yes in non-tty", () => {
+  expect(shouldRunHeadlessWithYes({ invocation: "cli" }, { yes: true, hasRequiredArgs: true }, false)).toBe(true);
+  expect(shouldRunHeadlessWithYes({ invocation: "cli" }, { yes: false, hasRequiredArgs: true }, false)).toBe(false);
   expect(
-    shouldRunHeadlessWithYes({ invocation: "cli" }, { yes: true, hasRequiredArgs: true }, false),
-  ).toBe(true);
-  expect(
-    shouldRunHeadlessWithYes({ invocation: "cli" }, { yes: false, hasRequiredArgs: true }, false),
-  ).toBe(false);
-  expect(
-    shouldRunHeadlessWithYes(
-      { invocation: "cli" },
-      { yes: false, hasRequiredArgs: true, dryRun: true },
-      false,
-    ),
+    shouldRunHeadlessWithYes({ invocation: "cli" }, { yes: false, hasRequiredArgs: true, dryRun: true }, false),
   ).toBe(true);
 });
 

package/src/help.ts

@@ -252,20 +252,10 @@ function renderTextBox(title: string, lines: string[], hw: number, color: boolea
 
   for (const line of lines) {
     const padded = padVisible(line, contentWidth);
-    out.push(
-      (color ? style.gray(kBoxV) : kBoxV) +
-        " " +
-        padded +
-        " " +
-        (color ? style.gray(kBoxV) : kBoxV),
-    );
+    out.push(`${color ? style.gray(kBoxV) : kBoxV} ${padded} ${color ? style.gray(kBoxV) : kBoxV}`);
   }
 
-  out.push(
-    color
-      ? style.gray(kBoxBL + repeatBoxH(borderWidth) + kBoxBR)
-      : kBoxBL + repeatBoxH(borderWidth) + kBoxBR,
-  );
+  out.push(color ? style.gray(kBoxBL + repeatBoxH(borderWidth) + kBoxBR) : kBoxBL + repeatBoxH(borderWidth) + kBoxBR);
 
   return out;
 }
@@ -287,11 +277,7 @@ function renderTableBox(title: string, rows: HelpRow[], hw: number, color: boole
   const bodyLines: string[] = [];
   for (const row of rows) {
     const wrapped = wrapText(row.description, descWidth);
-    const first =
-      row.label +
-      spaces(labelWidth - visibleWidth(row.label)) +
-      "  " +
-      (color ? style.white(wrapped[0]) : wrapped[0]);
+    const first = `${row.label + spaces(labelWidth - visibleWidth(row.label))}  ${color ? style.white(wrapped[0]) : wrapped[0]}`;
     bodyLines.push(first);
     for (let idx = 1; idx < wrapped.length; idx++) {
       const pad = color ? style.gray(spaces(labelWidth)) : spaces(labelWidth);
@@ -324,20 +310,10 @@ function renderTableBox(title: string, rows: HelpRow[], hw: number, color: boole
 
   for (const line of bodyLines) {
     const padded = padVisible(line, contentWidth);
-    out.push(
-      (color ? style.gray(kBoxV) : kBoxV) +
-        " " +
-        padded +
-        " " +
-        (color ? style.gray(kBoxV) : kBoxV),
-    );
+    out.push(`${color ? style.gray(kBoxV) : kBoxV} ${padded} ${color ? style.gray(kBoxV) : kBoxV}`);
   }
 
-  out.push(
-    color
-      ? style.gray(kBoxBL + repeatBoxH(borderWidth) + kBoxBR)
-      : kBoxBL + repeatBoxH(borderWidth) + kBoxBR,
-  );
+  out.push(color ? style.gray(kBoxBL + repeatBoxH(borderWidth) + kBoxBR) : kBoxBL + repeatBoxH(borderWidth) + kBoxBR);
 
   return out;
 }
@@ -402,13 +378,7 @@ function rowsForSubcommands(cmds: CliNode[]): HelpRow[] {
 
 // ── Main Help Render ──────────────────────────────────────────────────────────
 
-function appendNotesBox(
-  lines: string[],
-  notes: string | undefined,
-  appKey: string,
-  hw: number,
-  color: boolean,
-): void {
+function appendNotesBox(lines: string[], notes: string | undefined, appKey: string, hw: number, color: boolean): void {
   if ((notes ?? "").length === 0) {
     return;
   }
@@ -441,21 +411,14 @@ export function cliHelpRender(schema: CliRouter, helpPath: string[], _useStderr:
       ).join("\n"),
     );
 
-    const optBox = renderTableBox(
-      "Options",
-      rowsForOptions(visibleOptions(schema.options), color),
-      hw,
-      color,
-    );
+    const optBox = renderTableBox("Options", rowsForOptions(visibleOptions(schema.options), color), hw, color);
     if (optBox.length > 0) {
       lines.push("");
       lines.push(optBox.join("\n"));
     }
     if ((schema.commands ?? []).length > 0) {
       lines.push("");
-      lines.push(
-        renderTableBox("Commands", rowsForSubcommands(schema.commands ?? []), hw, color).join("\n"),
-      );
+      lines.push(renderTableBox("Commands", rowsForSubcommands(schema.commands ?? []), hw, color).join("\n"));
     }
     appendNotesBox(lines, schema.notes, schema.key, hw, color);
     return `${lines.join("\n")}\n\n`;
@@ -496,12 +459,7 @@ export function cliHelpRender(schema: CliRouter, helpPath: string[], _useStderr:
     ).join("\n"),
   );
 
-  const optBox = renderTableBox(
-    "Options",
-    rowsForOptions(visibleOptions(node.options), color),
-    hw,
-    color,
-  );
+  const optBox = renderTableBox("Options", rowsForOptions(visibleOptions(node.options), color), hw, color);
   if (optBox.length > 0) {
     lines.push("");
     lines.push(optBox.join("\n"));

package/src/hidden-mcpb.test.ts

@@ -9,12 +9,7 @@ import { join } from "node:path";
 import { exportPresentationBuiltins } from "./builtins/export.ts";
 import { cliParseRoot, cliPresentationRoot } from "./builtins/presentation.ts";
 import { cliHelpRender } from "./help.ts";
-import {
-  defaultMcpBundlePaths,
-  generateMcpManifest,
-  packMcpBundle,
-  runMcpBundle,
-} from "./mcp/bundle.ts";
+import { defaultMcpBundlePaths, generateMcpManifest, packMcpBundle, runMcpBundle } from "./mcp/bundle.ts";
 import { collectMcpTools } from "./mcp/tools.ts";
 import { cliSchemaExport } from "./schema.ts";
 import { CliOptionKind, type CliProgram } from "./types.ts";
@@ -128,8 +123,7 @@ describe("mcp bundle", () => {
     expect(manifest.manifest_version).toBe("0.3");
     expect((manifest.server as { type: string }).type).toBe("binary");
     expect((manifest.server as { entry_point: string }).entry_point).toBe("myapp");
-    const mcpConfig = (manifest.server as { mcp_config: { command: string; args: string[] } })
-      .mcp_config;
+    const mcpConfig = (manifest.server as { mcp_config: { command: string; args: string[] } }).mcp_config;
     expect(mcpConfig.command).toBe("${__dirname}/myapp");
     expect(mcpConfig.args).toEqual(["mcp"]);
     expect((manifest.compatibility as { platforms: string[] }).platforms).toEqual(["darwin"]);
@@ -185,10 +179,7 @@ describe("mcp bundle", () => {
       }
       const lines = stdout.join("").trim().split("\n");
       const norm = (p: string) => realpathSync.native(p);
-      expect(lines.map(norm)).toEqual([
-        norm(join(dist, "myapp.mcpb")),
-        norm(join(dist, "claude-plugin", "myapp.zip")),
-      ]);
+      expect(lines.map(norm)).toEqual([norm(join(dist, "myapp.mcpb")), norm(join(dist, "claude-plugin", "myapp.zip"))]);
       const zip = readFileSync(join(dist, "claude-plugin", "myapp.zip"));
       expect(zip.indexOf(Buffer.from(".mcp.json"))).toBeGreaterThanOrEqual(0);
     } finally {

package/src/hidden.ts

@@ -18,9 +18,7 @@ export function presentationNode(node: CliNode): CliNode | null {
   }
   const options = visibleOptions(node.options);
   if (isCliRouter(node)) {
-    const commands = node.commands
-      .map((ch) => presentationNode(ch))
-      .filter((ch): ch is CliNode => ch !== null);
+    const commands = node.commands.map((ch) => presentationNode(ch)).filter((ch): ch is CliNode => ch !== null);
     return { ...node, options, commands };
   }
   return { ...node, options };

package/src/install/binary-placement.test.ts

@@ -3,15 +3,11 @@ Tests for install/binary-placement module behavior.
 */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { chmodSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { CliProgram } from "../types.ts";
-import {
-  isAppInstalled,
-  isExternallyManagedBinary,
-  resolvePathCommand,
-} from "./binary-placement.ts";
+import { isAppInstalled, isExternallyManagedBinary, resolvePathCommand } from "./binary-placement.ts";
 
 const program: CliProgram = {
   key: "placementapp",

package/src/install/binary-placement.ts

@@ -32,10 +32,7 @@ function realpathOrSelf(path: string): string {
 }
 
 /** True when PATH resolves to the running executable (e.g. Homebrew Cellar). */
-export function isExternallyManagedBinary(
-  key: string,
-  execPath: string = process.execPath,
-): boolean {
+export function isExternallyManagedBinary(key: string, execPath: string = process.execPath): boolean {
   const resolved = resolvePathCommand(key);
   if (!resolved) return false;
   return resolved === realpathOrSelf(execPath);

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

@@ -1,12 +1,4 @@
-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";
@@ -150,9 +142,7 @@ export function createGhFetchLatest(
               ? ` ${config.repoEnvHint}`
               : ` No releases found for ${config.repo}.`
             : "";
-      throw new Error(
-        `Failed to fetch latest release from ${config.repo}: ${detail || "unknown error"}.${hint}`,
-      );
+      throw new Error(`Failed to fetch latest release from ${config.repo}: ${detail || "unknown error"}.${hint}`);
     }
 
     let parsed: { tagName?: string };
@@ -172,16 +162,11 @@ export function createGhFetchLatest(
 
 function ensureGhAvailable(): void {
   if (Bun.which("gh") === null) {
-    throw new Error(
-      "GitHub CLI (gh) is required. Install from https://cli.github.com/ and run `gh auth login`.",
-    );
+    throw new Error("GitHub CLI (gh) is required. Install from https://cli.github.com/ and run `gh auth login`.");
   }
 }
 
-async function downloadReleaseAsset(
-  config: GhReleaseUpdateConfig,
-  tempDir: string,
-): Promise<string> {
+async function downloadReleaseAsset(config: GhReleaseUpdateConfig, tempDir: string): Promise<string> {
   const result = await runGh([
     "release",
     "download",
@@ -206,9 +191,7 @@ async function downloadReleaseAsset(
   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/mcp-codex.ts

@@ -45,8 +45,7 @@ export function readCodexMcpEntry(path: string, name: string): McpServerEntry |
   const transport = block.match(/transport\s*=\s*\{[^}]*type\s*=\s*"stdio"[^}]*\}/s)?.[0];
   const search = transport ?? block;
 
-  const cmd =
-    search.match(/command\s*=\s*"([^"]*)"/)?.[1] ?? search.match(/command\s*=\s*'([^']*)'/)?.[1];
+  const cmd = search.match(/command\s*=\s*"([^"]*)"/)?.[1] ?? search.match(/command\s*=\s*'([^']*)'/)?.[1];
   if (!cmd) return undefined;
 
   const argsMatch = search.match(/args\s*=\s*\[([^\]]*)\]/s);

package/src/install/mcp-config.ts

@@ -29,12 +29,7 @@ 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 {
+export function checkMcpConflict(path: string, name: string, expected: McpServerEntry, yes: boolean): string | null {
   const existing = readMcpServerEntry(path, name);
   if (existing && !entriesEqual(existing, expected) && !yes) {
     return (
@@ -48,12 +43,7 @@ export function checkMcpConflict(
 }
 
 /** Merges MCP server entry into config file. */
-export function mergeMcpConfig(
-  path: string,
-  name: string,
-  entry: McpServerEntry,
-  dry: boolean,
-): void {
+export function mergeMcpConfig(path: string, name: string, entry: McpServerEntry, dry: boolean): void {
   if (dry) return;
   let data: Record<string, unknown> = {};
   if (existsSync(path)) {

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

@@ -57,9 +57,7 @@ describe("opencode mcp config", () => {
 
   test("resolveOpenCodeConfigPathForInstall defaults to config.json", () => {
     mkdirSync(opencodeConfigDir(home), { recursive: true });
-    expect(resolveOpenCodeConfigPathForInstall(home)).toBe(
-      join(opencodeConfigDir(home), "config.json"),
-    );
+    expect(resolveOpenCodeConfigPathForInstall(home)).toBe(join(opencodeConfigDir(home), "config.json"));
   });
 
   test("mergeOpenCodeMcpConfig writes mcp block", () => {

package/src/install/mcp-opencode.ts

@@ -6,11 +6,7 @@ import { expectedMcpEntry } from "./mcp-config.ts";
 export const OPENCODE_CONFIG_SCHEMA = "https://opencode.ai/config.json";
 
 /** Global OpenCode config filenames, in precedence order (matches OpenCode). */
-export const OPENCODE_CONFIG_FILENAMES = [
-  "opencode.jsonc",
-  "opencode.json",
-  "config.json",
-] as const;
+export const OPENCODE_CONFIG_FILENAMES = ["opencode.jsonc", "opencode.json", "config.json"] as const;
 
 export interface OpenCodeLocalMcpEntry {
   type: "local";
@@ -71,10 +67,7 @@ function readConfig(path: string): Record<string, unknown> {
 }
 
 /** Reads `mcp[name]` when it is a local stdio server. */
-export function readOpenCodeMcpEntry(
-  path: string,
-  name: string,
-): OpenCodeLocalMcpEntry | undefined {
+export function readOpenCodeMcpEntry(path: string, name: string): OpenCodeLocalMcpEntry | undefined {
   if (!existsSync(path)) return undefined;
   try {
     const data = readConfig(path);
@@ -122,12 +115,7 @@ export function checkOpenCodeMcpConflict(
 }
 
 /** Merges a local MCP entry into OpenCode `mcp` config. */
-export function mergeOpenCodeMcpConfig(
-  path: string,
-  name: string,
-  entry: OpenCodeLocalMcpEntry,
-  dry: boolean,
-): void {
+export function mergeOpenCodeMcpConfig(path: string, name: string, entry: OpenCodeLocalMcpEntry, dry: boolean): void {
   if (dry) return;
   const data = readConfig(path);
   if (!data.$schema) data.$schema = OPENCODE_CONFIG_SCHEMA;

package/src/install/plan.ts

@@ -7,20 +7,12 @@ import type { InstallAction, InstallOpts } from "./target-types.ts";
 export type { InstallAction, InstallActionKind, InstallOpts } from "./target-types.ts";
 
 /** Builds install actions for normal mode (--all / scoped targets). */
-export function buildInstallPlan(
-  root: CliProgram,
-  paths: InstallPaths,
-  opts: InstallOpts,
-): InstallAction[] {
+export function buildInstallPlan(root: CliProgram, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
   return buildInstallPlanFromTargets(root, paths, opts);
 }
 
 /** Builds update/reinstall actions; greenfield fallback when nothing detected. */
-export function buildUpdatePlan(
-  root: CliProgram,
-  paths: InstallPaths,
-  opts: InstallOpts,
-): InstallAction[] {
+export function buildUpdatePlan(root: CliProgram, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
   const refresh = buildInstallPlanFromTargets(root, paths, {
     ...opts,
     reinstall: true,

package/src/install/status.ts

@@ -79,12 +79,10 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
 
   const configStatus = appConfigStatus(root);
   if (configStatus) {
-    installOut(
-      `  app config: ${configStatus.path}${configStatus.exists ? "" : " (missing)"}`,
-      opts,
-    );
+    installOut(`  app config: ${configStatus.path}${configStatus.exists ? "" : " (missing)"}`, opts);
     for (const req of configStatus.required) {
-      installOut(`    ${req.key}: ${req.set ? "set" : "missing"}`, opts);
+      const bindingHint = req.binding && req.binding !== "missing" && req.set ? ` (${req.binding})` : "";
+      installOut(`    ${req.key}: ${req.set ? "set" : "missing"}${bindingHint}`, opts);
     }
   }
 }

package/src/install/target-base.ts

@@ -46,11 +46,7 @@ export abstract class InstallTarget {
 
   protected abstract isDetectedFromSnapshot(detected: DetectedSnapshot): boolean;
 
-  statusLine(
-    paths: InstallPaths,
-    root: CliProgram,
-    detected: InstalledArtifacts,
-  ): string | undefined {
+  statusLine(paths: InstallPaths, root: CliProgram, detected: InstalledArtifacts): string | undefined {
     if (!this.isDetectedFromInstalled(detected)) return undefined;
     return this.formatStatusLine(paths, root);
   }
@@ -78,12 +74,7 @@ export abstract class InstallTarget {
 
   protected abstract buildUninstallActions(ctx: TargetPlanContext): UninstallAction[];
 
-  contributeStatus(
-    paths: InstallPaths,
-    root: CliProgram,
-    detected: InstalledArtifacts,
-    status: InstallStatus,
-  ): void {
+  contributeStatus(paths: InstallPaths, root: CliProgram, detected: InstalledArtifacts, status: InstallStatus): void {
     const line = this.statusLine(paths, root, detected);
     if (!line) return;
     this.assignStatusLine(status, line);

package/src/install/target-detect.ts

@@ -7,11 +7,7 @@ export { buildDetectedSnapshot, detectInstalledArtifacts } from "./target-scope.
 export type { InstalledArtifacts, InstallStatus } from "./target-types.ts";
 
 /** Builds a status inventory from detected artifacts. */
-export function buildInstallStatus(
-  paths: InstallPaths,
-  detected: InstalledArtifacts,
-  root: CliProgram,
-): InstallStatus {
+export function buildInstallStatus(paths: InstallPaths, detected: InstalledArtifacts, root: CliProgram): InstallStatus {
   const status: InstallStatus = {};
   for (const target of INSTALL_TARGETS) {
     target.contributeStatus(paths, root, detected, status);

package/src/install/target-effective.ts

@@ -19,10 +19,7 @@ export type { InstallTargetSpec, ResolvedInstallTarget } from "../types.ts";
 
 export type { InstallPlanMode, InstallScope } from "./target-types.ts";
 
-export function resolveAgentIntegration(
-  configure?: CliConfigureConfig,
-  mcpEnabled = false,
-): InstallAgentIntegration {
+export function resolveAgentIntegration(configure?: CliConfigureConfig, mcpEnabled = false): InstallAgentIntegration {
   return configure?.agentIntegration ?? (mcpEnabled ? "mcp" : "skill");
 }
 
@@ -95,10 +92,7 @@ export function resolveEffectiveInstallTargets(
   const user = configure?.targets;
   const out = {} as Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>;
   for (const key of INSTALL_ARTIFACT_KEYS) {
-    out[key] = resolveInstallTargetSpec(
-      user?.[key],
-      artifactDefaults(key, integration, mcpEnabled),
-    );
+    out[key] = resolveInstallTargetSpec(user?.[key], artifactDefaults(key, integration, mcpEnabled));
   }
   applyAgentPairDedupe(out, user, integration);
   return out;
@@ -132,10 +126,6 @@ export function resolveInstallPlanMode(opts: {
 }
 
 /** @deprecated Use target registry. */
-export function isInstallTargetAvailable(
-  key: CliInstallArtifactKey,
-  root: CliProgram,
-  paths: InstallPaths,
-): boolean {
+export function isInstallTargetAvailable(key: CliInstallArtifactKey, root: CliProgram, paths: InstallPaths): boolean {
   return installTargetForKey(key)?.isAvailable(root, paths) ?? false;
 }

package/src/install/target-mcp-cli.ts

@@ -1,10 +1,5 @@
 import type { CliProgram } from "../types.ts";
-import {
-  checkCodexMcpConflict,
-  codexMcpHasServer,
-  mergeCodexMcpConfig,
-  removeCodexMcpConfig,
-} from "./mcp-codex.ts";
+import { checkCodexMcpConflict, codexMcpHasServer, mergeCodexMcpConfig, removeCodexMcpConfig } from "./mcp-codex.ts";
 import { expectedMcpEntry } from "./mcp-config.ts";
 import {
   checkOpenclawMcpConflict,
@@ -37,20 +32,9 @@ export interface McpCliHostSpec {
   hasServer: (home: string, name: string) => boolean;
   installMessage: string;
   uninstallMessage: string;
-  merge: (
-    home: string,
-    name: string,
-    entry: ReturnType<typeof expectedMcpEntry>,
-    dry: boolean,
-    yes: boolean,
-  ) => string;
+  merge: (home: string, name: string, entry: ReturnType<typeof expectedMcpEntry>, dry: boolean, yes: boolean) => string;
   remove: (home: string, name: string, dry: boolean) => void;
-  preflight: (
-    home: string,
-    name: string,
-    entry: ReturnType<typeof expectedMcpEntry>,
-    yes: boolean,
-  ) => string | null;
+  preflight: (home: string, name: string, entry: ReturnType<typeof expectedMcpEntry>, yes: boolean) => string | null;
 }
 
 /** MCP host registered via an external CLI (codex, openclaw). */
@@ -108,13 +92,7 @@ export class McpCliInstallTarget extends InstallTarget {
         summary: `${this.spec.label}: ${displayInstallPath(configPath)}`,
         message: this.spec.installMessage.replace("{name}", ctx.paths.mcpName),
         run: () => {
-          const written = this.spec.merge(
-            userHome(),
-            ctx.paths.mcpName,
-            entry,
-            ctx.dry,
-            !!ctx.opts.yes,
-          );
+          const written = this.spec.merge(userHome(), ctx.paths.mcpName, entry, ctx.dry, !!ctx.opts.yes);
           return [written];
         },
       },

package/src/install/target-mcp-json.ts

@@ -25,14 +25,8 @@ export interface McpJsonHostSpec {
   label: string;
   pairedSkillKey?: CliInstallArtifactKey;
   configPath: (paths: InstallPaths) => string;
-  detectedKey: keyof Pick<
-    InstalledArtifacts,
-    "cursorMcp" | "claudeMcp" | "claudeDesktopMcp" | "chatGptMcp"
-  >;
-  statusField: keyof Pick<
-    InstallStatus,
-    "cursorMcp" | "claudeMcp" | "claudeDesktopMcp" | "chatGptMcp"
-  >;
+  detectedKey: keyof Pick<InstalledArtifacts, "cursorMcp" | "claudeMcp" | "claudeDesktopMcp" | "chatGptMcp">;
+  statusField: keyof Pick<InstallStatus, "cursorMcp" | "claudeMcp" | "claudeDesktopMcp" | "chatGptMcp">;
   isAvailable: (root: CliProgram, paths: InstallPaths) => boolean;
   /** Append server name to status line (default false). */
   statusIncludesServer?: boolean;
@@ -89,12 +83,7 @@ export class McpJsonInstallTarget extends InstallTarget {
 
   preflight(ctx: TargetPlanContext): string | null {
     const entry = expectedMcpEntry(ctx.root);
-    return checkMcpConflict(
-      this.spec.configPath(ctx.paths),
-      ctx.paths.mcpName,
-      entry,
-      !!ctx.opts.yes,
-    );
+    return checkMcpConflict(this.spec.configPath(ctx.paths), ctx.paths.mcpName, entry, !!ctx.opts.yes);
   }
 
   protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {

package/src/install/target-plan-build.ts

@@ -7,11 +7,7 @@ import { buildDetectedSnapshot, buildTargetPlanContext } from "./target-scope.ts
 import type { InstallAction, InstallOpts, UninstallAction } from "./target-types.ts";
 
 /** Builds install actions for normal mode (--all / scoped targets). */
-export function buildInstallPlanFromTargets(
-  root: CliProgram,
-  paths: InstallPaths,
-  opts: InstallOpts,
-): InstallAction[] {
+export function buildInstallPlanFromTargets(root: CliProgram, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
   const detected = buildDetectedSnapshot(root, paths);
   const ctx = buildTargetPlanContext(root, paths, opts, detected);