argsbarg 3.4.1 → 3.5.0

package/src/install/mcp-codex.ts

@@ -0,0 +1,125 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { McpServerEntry } from "./mcp-config.ts";
+
+/** True when the `codex` executable is on PATH. */
+export function codexOnPath(): boolean {
+  return Bun.which("codex") !== null;
+}
+
+/** Global Codex config path (`~/.codex/config.toml`). */
+export function resolveCodexConfigPath(home: string): string {
+  return join(home, ".codex", "config.toml");
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function parseTomlStringArray(inner: string): string[] {
+  const re = /"([^"]*)"/g;
+  const out: string[] = [];
+  let m = re.exec(inner);
+  while (m !== null) {
+    const value = m[1];
+    if (value !== undefined) {
+      out.push(value);
+    }
+    m = re.exec(inner);
+  }
+  return out;
+}
+
+/** Reads stdio `command`/`args` from a Codex `[mcp_servers.name]` block, if present. */
+export function readCodexMcpEntry(path: string, name: string): McpServerEntry | undefined {
+  if (!existsSync(path)) return undefined;
+  const text = readFileSync(path, "utf8");
+  const sectionRe = new RegExp(`^\\[mcp_servers\\.${escapeRegExp(name)}\\]\\s*$`, "m");
+  const match = sectionRe.exec(text);
+  if (!match) return undefined;
+
+  const after = text.slice(match.index + match[0].length);
+  const nextSection = after.search(/^\[/m);
+  const block = nextSection === -1 ? after : after.slice(0, nextSection);
+
+  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];
+  if (!cmd) return undefined;
+
+  const argsMatch = search.match(/args\s*=\s*\[([^\]]*)\]/s);
+  const argsInner = argsMatch?.[1];
+  const args = argsInner !== undefined ? parseTomlStringArray(argsInner) : [];
+  return { command: cmd, args };
+}
+
+export function codexMcpHasServer(home: string, name: string): boolean {
+  const path = resolveCodexConfigPath(home);
+  if (!existsSync(path)) return false;
+  const text = readFileSync(path, "utf8");
+  return new RegExp(`^\\[mcp_servers\\.${escapeRegExp(name)}\\]`, "m").test(text);
+}
+
+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 Codex entry conflicts, or null if safe to merge. */
+export function checkCodexMcpConflict(
+  home: string,
+  name: string,
+  expected: McpServerEntry,
+  yes: boolean,
+): string | null {
+  const path = resolveCodexConfigPath(home);
+  const existing = readCodexMcpEntry(path, name);
+  if (existing && !entriesEqual(existing, expected) && !yes) {
+    return (
+      `MCP server "${name}" in ${path} differs from expected Codex entry.\n` +
+      `  existing: ${JSON.stringify(existing)}\n` +
+      `  expected: ${JSON.stringify(expected)}\n` +
+      `Use --yes to overwrite.`
+    );
+  }
+  return null;
+}
+
+function runCodex(args: string[]): void {
+  const proc = Bun.spawnSync({
+    cmd: ["codex", ...args],
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (proc.exitCode !== 0) {
+    const err = new TextDecoder().decode(proc.stderr).trim();
+    throw new Error(err || `codex ${args.join(" ")} failed (exit ${proc.exitCode})`);
+  }
+}
+
+/** Registers a stdio MCP server via `codex mcp add`. */
+export function mergeCodexMcpConfig(
+  home: string,
+  name: string,
+  entry: McpServerEntry,
+  dry: boolean,
+  overwrite: boolean,
+): string {
+  const configPath = resolveCodexConfigPath(home);
+  if (dry) return configPath;
+
+  mkdirSync(dirname(configPath), { recursive: true });
+  if (codexMcpHasServer(home, name) && overwrite) {
+    runCodex(["mcp", "remove", name]);
+  }
+
+  runCodex(["mcp", "add", name, "--", entry.command, ...entry.args]);
+  return configPath;
+}
+
+/** Removes a Codex MCP server via `codex mcp remove`. */
+export function removeCodexMcpConfig(home: string, name: string, dry: boolean): void {
+  if (dry || !codexMcpHasServer(home, name)) return;
+  runCodex(["mcp", "remove", name]);
+}

package/src/install/mcp-config.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
-import { CliProgram } from "../types.ts";
+import type { CliProgram } from "../types.ts";
 
 export interface McpServerEntry {
   command: string;
@@ -19,7 +19,9 @@ function entriesEqual(a: McpServerEntry, b: McpServerEntry): boolean {
 export function readMcpServerEntry(path: string, name: string): McpServerEntry | undefined {
   if (!existsSync(path)) return undefined;
   try {
-    const data = JSON.parse(readFileSync(path, "utf8")) as { mcpServers?: Record<string, McpServerEntry> };
+    const data = JSON.parse(readFileSync(path, "utf8")) as {
+      mcpServers?: Record<string, McpServerEntry>;
+    };
     return data.mcpServers?.[name];
   } catch {
     return undefined;
@@ -46,7 +48,12 @@ 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)) {
@@ -56,7 +63,7 @@ export function mergeMcpConfig(path: string, name: string, entry: McpServerEntry
   servers[name] = entry;
   data.mcpServers = servers;
   mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
 }
 
 /** Removes MCP server entry from config file (keeps file if other keys remain). */
@@ -65,5 +72,5 @@ export function removeMcpConfig(path: string, name: string, dry: boolean): void
   const data = JSON.parse(readFileSync(path, "utf8")) as { mcpServers?: Record<string, unknown> };
   if (!data.mcpServers?.[name]) return;
   delete data.mcpServers[name];
-  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
 }

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

@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CliProgram } from "../types.ts";
+import {
+  detectOpenCodeMcpConfigPath,
+  expectedOpenCodeMcpEntry,
+  mergeOpenCodeMcpConfig,
+  OPENCODE_CONFIG_SCHEMA,
+  opencodeConfigDir,
+  removeOpenCodeMcpConfig,
+  resolveOpenCodeConfigPathForInstall,
+} from "./mcp-opencode.ts";
+
+const fixture: CliProgram = {
+  key: "testapp",
+  version: "0.0.0",
+  description: "Test",
+  mcpServer: { enabled: true },
+  handler: () => {},
+};
+
+let home: string;
+let prevHome: string | undefined;
+let prevXdg: string | undefined;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "argsbarg-opencode-"));
+  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 });
+});
+
+describe("opencode mcp config", () => {
+  test("resolveOpenCodeConfigPathForInstall prefers existing file", () => {
+    const dir = opencodeConfigDir(home);
+    mkdirSync(dir, { recursive: true });
+    const existing = join(dir, "opencode.json");
+    writeFileSync(existing, "{}", "utf8");
+    expect(resolveOpenCodeConfigPathForInstall(home)).toBe(existing);
+  });
+
+  test("resolveOpenCodeConfigPathForInstall defaults to config.json", () => {
+    mkdirSync(opencodeConfigDir(home), { recursive: true });
+    expect(resolveOpenCodeConfigPathForInstall(home)).toBe(
+      join(opencodeConfigDir(home), "config.json"),
+    );
+  });
+
+  test("mergeOpenCodeMcpConfig writes mcp block", () => {
+    const path = resolveOpenCodeConfigPathForInstall(home);
+    mkdirSync(opencodeConfigDir(home), { recursive: true });
+    const entry = expectedOpenCodeMcpEntry(fixture);
+    mergeOpenCodeMcpConfig(path, "testapp", entry, false);
+    const data = JSON.parse(readFileSync(path, "utf8")) as {
+      $schema: string;
+      mcp: Record<string, unknown>;
+    };
+    expect(data.$schema).toBe(OPENCODE_CONFIG_SCHEMA);
+    expect(data.mcp.testapp).toEqual(entry);
+  });
+
+  test("detectOpenCodeMcpConfigPath finds entry across filenames", () => {
+    const dir = opencodeConfigDir(home);
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, "config.json");
+    writeFileSync(
+      path,
+      JSON.stringify({
+        mcp: {
+          testapp: { type: "local", command: ["testapp", "mcp"] },
+        },
+      }),
+      "utf8",
+    );
+    expect(detectOpenCodeMcpConfigPath(home, "testapp")).toBe(path);
+  });
+
+  test("removeOpenCodeMcpConfig deletes server entry", () => {
+    const path = resolveOpenCodeConfigPathForInstall(home);
+    mkdirSync(opencodeConfigDir(home), { recursive: true });
+    mergeOpenCodeMcpConfig(path, "testapp", expectedOpenCodeMcpEntry(fixture), false);
+    removeOpenCodeMcpConfig(path, "testapp", false);
+    const data = JSON.parse(readFileSync(path, "utf8")) as { mcp?: Record<string, unknown> };
+    expect(data.mcp?.testapp).toBeUndefined();
+    expect(existsSync(path)).toBe(true);
+  });
+});

package/src/install/mcp-opencode.ts

@@ -0,0 +1,149 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { CliProgram } from "../types.ts";
+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 interface OpenCodeLocalMcpEntry {
+  type: "local";
+  command: string[];
+  enabled?: boolean;
+}
+
+/** `~/.config/opencode` (or `$XDG_CONFIG_HOME/opencode`). */
+export function opencodeConfigDir(home: string): string {
+  const xdg = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
+  return join(xdg, "opencode");
+}
+
+/** True when OpenCode config directory exists. */
+export function opencodePresent(home: string): boolean {
+  return existsSync(opencodeConfigDir(home));
+}
+
+/** Path to write a new entry: first existing config file, else `config.json`. */
+export function resolveOpenCodeConfigPathForInstall(home: string): string {
+  const dir = opencodeConfigDir(home);
+  for (const file of OPENCODE_CONFIG_FILENAMES) {
+    const path = join(dir, file);
+    if (existsSync(path)) return path;
+  }
+  return join(dir, "config.json");
+}
+
+/** First config file containing `mcp[name]`, if any. */
+export function detectOpenCodeMcpConfigPath(home: string, name: string): string | undefined {
+  const dir = opencodeConfigDir(home);
+  for (const file of OPENCODE_CONFIG_FILENAMES) {
+    const path = join(dir, file);
+    if (openCodeMcpHasServer(path, name)) return path;
+  }
+  return undefined;
+}
+
+export function expectedOpenCodeMcpEntry(root: CliProgram): OpenCodeLocalMcpEntry {
+  const entry = expectedMcpEntry(root);
+  return { type: "local", command: [entry.command, ...entry.args], enabled: true };
+}
+
+function entriesEqual(a: OpenCodeLocalMcpEntry, b: OpenCodeLocalMcpEntry): boolean {
+  return a.type === b.type && JSON.stringify(a.command) === JSON.stringify(b.command);
+}
+
+function readConfig(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+  } catch {
+    throw new Error(
+      `Could not parse OpenCode config at ${path} (JSON with comments is not supported by install --mcp). ` +
+        `Add the server manually or use a .json config file.`,
+    );
+  }
+}
+
+/** Reads `mcp[name]` when it is a local stdio server. */
+export function readOpenCodeMcpEntry(
+  path: string,
+  name: string,
+): OpenCodeLocalMcpEntry | undefined {
+  if (!existsSync(path)) return undefined;
+  try {
+    const data = readConfig(path);
+    const raw = (data.mcp as Record<string, unknown> | undefined)?.[name];
+    if (!raw || typeof raw !== "object") return undefined;
+    const entry = raw as { type?: string; command?: unknown };
+    if (entry.type !== "local" || !Array.isArray(entry.command)) return undefined;
+    if (!entry.command.every((p) => typeof p === "string")) return undefined;
+    return {
+      type: "local",
+      command: entry.command as string[],
+      enabled: (raw as { enabled?: boolean }).enabled,
+    };
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Could not parse OpenCode")) throw err;
+    return undefined;
+  }
+}
+
+export function openCodeMcpHasServer(path: string, name: string): boolean {
+  try {
+    return readOpenCodeMcpEntry(path, name) !== undefined;
+  } catch {
+    return false;
+  }
+}
+
+/** Returns an error when an existing OpenCode entry conflicts, or null if safe to merge. */
+export function checkOpenCodeMcpConflict(
+  path: string,
+  name: string,
+  expected: OpenCodeLocalMcpEntry,
+  yes: boolean,
+): string | null {
+  const existing = readOpenCodeMcpEntry(path, name);
+  if (existing && !entriesEqual(existing, expected) && !yes) {
+    return (
+      `MCP server "${name}" in ${path} differs from expected OpenCode entry.\n` +
+      `  existing: ${JSON.stringify(existing)}\n` +
+      `  expected: ${JSON.stringify(expected)}\n` +
+      `Use --yes to overwrite.`
+    );
+  }
+  return null;
+}
+
+/** Merges a local MCP entry into OpenCode `mcp` config. */
+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;
+  const servers = (data.mcp as Record<string, OpenCodeLocalMcpEntry> | undefined) ?? {};
+  servers[name] = entry;
+  data.mcp = servers;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+/** Removes `mcp[name]` from an OpenCode config file. */
+export function removeOpenCodeMcpConfig(path: string, name: string, dry: boolean): void {
+  if (dry || !existsSync(path)) return;
+  const data = readConfig(path);
+  const servers = data.mcp as Record<string, unknown> | undefined;
+  if (!servers?.[name]) return;
+  delete servers[name];
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}

package/src/install/paths.ts

@@ -1,7 +1,9 @@
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
-import { CliProgram } from "../types.ts";
-import { sanitizeToolSegment, mcpServerId } from "../mcp/tools.ts";
+import { dirname, join } from "node:path";
+import { mcpServerId, sanitizeToolSegment } from "../mcp/tools.ts";
+import type { CliProgram } from "../types.ts";
+import { resolveOpenCodeConfigPathForInstall } from "./mcp-opencode.ts";
 
 export interface InstallPaths {
   bindir: string;
@@ -13,6 +15,10 @@ export interface InstallPaths {
   claudeSkillDir: string;
   cursorMcpPath: string;
   claudeMcpPath: string;
+  claudeDesktopMcpPath: string;
+  opencodeMcpPath: string;
+  chatGptMcpPath: string;
+  codexConfigPath: string;
   bashRc: string;
   zshRc: string;
   mcpName: string;
@@ -43,6 +49,42 @@ export function resolveBindir(root: CliProgram, prefix?: string): string {
   return join(userHome(), ".local", "bin");
 }
 
+/** Resolves Claude Desktop `claude_desktop_config.json` for the current OS. */
+export function resolveClaudeDesktopMcpPath(home: string): string {
+  if (process.platform === "darwin") {
+    return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
+    return join(appData, "Claude", "claude_desktop_config.json");
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
+  return join(xdgConfig, "Claude", "claude_desktop_config.json");
+}
+
+/** True when Claude Desktop app data exists (config file or app support directory). */
+export function claudeDesktopPresent(_home: string, configPath: string): boolean {
+  return existsSync(configPath) || existsSync(dirname(configPath));
+}
+
+/** Resolves ChatGPT desktop `chatgpt_mcp_config.json` for the current OS. */
+export function resolveChatGptMcpPath(home: string): string {
+  if (process.platform === "darwin") {
+    return join(home, "Library", "Application Support", "ChatGPT", "chatgpt_mcp_config.json");
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
+    return join(appData, "OpenAI", "ChatGPT", "chatgpt_mcp_config.json");
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
+  return join(xdgConfig, "ChatGPT", "chatgpt_mcp_config.json");
+}
+
+/** True when ChatGPT desktop app data exists (config file or app support directory). */
+export function chatGptDesktopPresent(_home: string, configPath: string): boolean {
+  return existsSync(configPath) || existsSync(dirname(configPath));
+}
+
 /** Resolves all install artifact paths for a program root. */
 export function resolveInstallPaths(root: CliProgram, opts: { prefix?: string }): InstallPaths {
   const home = userHome();
@@ -50,6 +92,8 @@ export function resolveInstallPaths(root: CliProgram, opts: { prefix?: string })
   const key = root.key;
   const skillDirName = sanitizeToolSegment(root.key);
   const xdgConfig = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
+  const claudeDesktopMcpPath = resolveClaudeDesktopMcpPath(home);
+  const chatGptMcpPath = resolveChatGptMcpPath(home);
 
   return {
     bindir,
@@ -61,6 +105,10 @@ export function resolveInstallPaths(root: CliProgram, opts: { prefix?: string })
     claudeSkillDir: join(home, ".claude", "skills", skillDirName),
     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"),
     mcpName: mcpServerId(root),

package/src/install/plan.ts

@@ -1,12 +1,23 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { resolveCapabilities } from "../capabilities.ts";
-import { CliProgram } from "../types.ts";
+import type { CliProgram } from "../types.ts";
 import { installBinary } from "./binary.ts";
 import { installCompletions } from "./completions.ts";
 import { detectInstalledArtifacts } from "./detect-installed.ts";
+import { codexOnPath, mergeCodexMcpConfig } from "./mcp-codex.ts";
 import { expectedMcpEntry, mergeMcpConfig } from "./mcp-config.ts";
-import { InstallPaths, userHome } from "./paths.ts";
+import {
+  expectedOpenCodeMcpEntry,
+  mergeOpenCodeMcpConfig,
+  opencodePresent,
+} from "./mcp-opencode.ts";
+import {
+  chatGptDesktopPresent,
+  claudeDesktopPresent,
+  type InstallPaths,
+  userHome,
+} from "./paths.ts";
 import { detectShells } from "./shell.ts";
 
 export interface InstallOpts {
@@ -27,7 +38,17 @@ export interface InstallOpts {
   prefix?: string;
 }
 
-export type InstallActionKind = "binary" | "completions" | "cursor-skill" | "claude-skill" | "cursor-mcp" | "claude-mcp";
+export type InstallActionKind =
+  | "binary"
+  | "completions"
+  | "cursor-skill"
+  | "claude-skill"
+  | "cursor-mcp"
+  | "claude-mcp"
+  | "claude-desktop-mcp"
+  | "opencode-mcp"
+  | "codex-mcp"
+  | "chatgpt-desktop-mcp";
 
 export interface InstallAction {
   kind: InstallActionKind;
@@ -53,7 +74,11 @@ export function wantsInstallMcp(opts: InstallOpts, root: CliProgram): boolean {
 }
 
 /** 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[] {
   const actions: InstallAction[] = [];
   const dry = !!opts.dry;
 
@@ -139,26 +164,82 @@ export function buildInstallPlan(root: CliProgram, paths: InstallPaths, opts: In
     }
     actions.push({
       kind: "claude-mcp",
-      summary: `claude mcp: ${paths.claudeMcpPath} (server "${paths.mcpName}")`,
+      summary: `claude code mcp: ${paths.claudeMcpPath} (server "${paths.mcpName}")`,
       message: `Merging MCP server "${paths.mcpName}" into ${paths.claudeMcpPath}`,
       run: () => {
         mergeMcpConfig(paths.claudeMcpPath, paths.mcpName, entry, dry);
         return [paths.claudeMcpPath];
       },
     });
+    if (claudeDesktopPresent(userHome(), paths.claudeDesktopMcpPath)) {
+      actions.push({
+        kind: "claude-desktop-mcp",
+        summary: `claude desktop mcp: ${paths.claudeDesktopMcpPath} (server "${paths.mcpName}")`,
+        message: `Merging MCP server "${paths.mcpName}" into ${paths.claudeDesktopMcpPath}`,
+        run: () => {
+          mergeMcpConfig(paths.claudeDesktopMcpPath, paths.mcpName, entry, dry);
+          return [paths.claudeDesktopMcpPath];
+        },
+      });
+    }
+    if (opencodePresent(userHome())) {
+      const openCodeEntry = expectedOpenCodeMcpEntry(root);
+      actions.push({
+        kind: "opencode-mcp",
+        summary: `opencode mcp: ${paths.opencodeMcpPath} (server "${paths.mcpName}")`,
+        message: `Merging MCP server "${paths.mcpName}" into ${paths.opencodeMcpPath}`,
+        run: () => {
+          mergeOpenCodeMcpConfig(paths.opencodeMcpPath, paths.mcpName, openCodeEntry, dry);
+          return [paths.opencodeMcpPath];
+        },
+      });
+    }
+    if (codexOnPath()) {
+      actions.push({
+        kind: "codex-mcp",
+        summary: `codex mcp: ${paths.codexConfigPath} (server "${paths.mcpName}")`,
+        message: `Registering MCP server "${paths.mcpName}" via codex mcp add`,
+        run: () => {
+          const configPath = mergeCodexMcpConfig(userHome(), paths.mcpName, entry, dry, !!opts.yes);
+          return [configPath];
+        },
+      });
+    }
+    if (chatGptDesktopPresent(userHome(), paths.chatGptMcpPath)) {
+      actions.push({
+        kind: "chatgpt-desktop-mcp",
+        summary: `chatgpt desktop mcp: ${paths.chatGptMcpPath} (server "${paths.mcpName}")`,
+        message: `Merging MCP server "${paths.mcpName}" into ${paths.chatGptMcpPath}`,
+        run: () => {
+          mergeMcpConfig(paths.chatGptMcpPath, paths.mcpName, entry, dry);
+          return [paths.chatGptMcpPath];
+        },
+      });
+    }
   }
 
   return actions;
 }
 
 /** Builds update actions for artifacts already installed. */
-export function buildUpdatePlan(root: CliProgram, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
+export function buildUpdatePlan(
+  root: CliProgram,
+  paths: InstallPaths,
+  opts: InstallOpts,
+): InstallAction[] {
   const detected = detectInstalledArtifacts(paths);
   const scoped: InstallOpts = {
     bin: true,
     completions: detected.bashCompletion || detected.zshCompletion || detected.fishCompletion,
     skill: detected.cursorSkill || detected.claudeSkill,
-    mcp: (detected.cursorMcp || detected.claudeMcp) && resolveCapabilities(root).mcp,
+    mcp:
+      (detected.cursorMcp ||
+        detected.claudeMcp ||
+        detected.claudeDesktopMcp ||
+        detected.opencodeMcp ||
+        detected.codexMcp ||
+        detected.chatGptMcp) &&
+      resolveCapabilities(root).mcp,
     dry: opts.dry,
   };
   const plan = buildInstallPlan(root, paths, scoped);
@@ -180,6 +261,14 @@ export function buildUpdatePlan(root: CliProgram, paths: InstallPaths, opts: Ins
         return detected.cursorMcp;
       case "claude-mcp":
         return detected.claudeMcp;
+      case "claude-desktop-mcp":
+        return detected.claudeDesktopMcp;
+      case "opencode-mcp":
+        return detected.opencodeMcp;
+      case "codex-mcp":
+        return detected.codexMcp;
+      case "chatgpt-desktop-mcp":
+        return detected.chatGptMcp;
       default:
         return false;
     }

package/src/install/shell.ts

@@ -39,10 +39,7 @@ export function buildZshFpathRcBlock(appKey: string, completionsDir: string): st
 export function removeRcBlock(content: string, appKey: string, tag: string): string {
   const start = rcMarkerStart(appKey, tag);
   const end = rcMarkerEnd(appKey, tag);
-  const re = new RegExp(
-    `${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}\\n?`,
-    "g",
-  );
+  const re = new RegExp(`${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}\\n?`, "g");
   return content.replace(re, "");
 }