argsbarg 3.4.2 → 3.6.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,8 +1,9 @@
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { CliProgram } from "../types.ts";
-import { sanitizeToolSegment, mcpServerId } from "../mcp/tools.ts";
+import { mcpServerId, sanitizeToolSegment } from "../mcp/tools.ts";
+import type { CliProgram } from "../types.ts";
+import { resolveOpenCodeConfigPathForInstall } from "./mcp-opencode.ts";
 
 export interface InstallPaths {
   bindir: string;
@@ -15,6 +16,9 @@ export interface InstallPaths {
   cursorMcpPath: string;
   claudeMcpPath: string;
   claudeDesktopMcpPath: string;
+  opencodeMcpPath: string;
+  chatGptMcpPath: string;
+  codexConfigPath: string;
   bashRc: string;
   zshRc: string;
   mcpName: string;
@@ -59,7 +63,25 @@ export function resolveClaudeDesktopMcpPath(home: string): string {
 }
 
 /** True when Claude Desktop app data exists (config file or app support directory). */
-export function claudeDesktopPresent(home: string, configPath: string): boolean {
+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));
 }
 
@@ -71,6 +93,7 @@ export function resolveInstallPaths(root: CliProgram, opts: { prefix?: string })
   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,
@@ -83,6 +106,9 @@ export function resolveInstallPaths(root: CliProgram, opts: { prefix?: string })
     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, claudeDesktopPresent } 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 {
@@ -34,7 +45,10 @@ export type InstallActionKind =
   | "claude-skill"
   | "cursor-mcp"
   | "claude-mcp"
-  | "claude-desktop-mcp";
+  | "claude-desktop-mcp"
+  | "opencode-mcp"
+  | "codex-mcp"
+  | "chatgpt-desktop-mcp";
 
 export interface InstallAction {
   kind: InstallActionKind;
@@ -60,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;
 
@@ -164,20 +182,63 @@ export function buildInstallPlan(root: CliProgram, paths: InstallPaths, opts: In
         },
       });
     }
+    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 || detected.claudeDesktopMcp) &&
+      (detected.cursorMcp ||
+        detected.claudeMcp ||
+        detected.claudeDesktopMcp ||
+        detected.opencodeMcp ||
+        detected.codexMcp ||
+        detected.chatGptMcp) &&
       resolveCapabilities(root).mcp,
     dry: opts.dry,
   };
@@ -202,6 +263,12 @@ export function buildUpdatePlan(root: CliProgram, paths: InstallPaths, opts: Ins
         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, "");
 }
 

package/src/install/status.ts

@@ -1,22 +1,22 @@
-import { CliProgram } from "../types.ts";
+import type { CliProgram } from "../types.ts";
 import { buildInstallStatus, detectInstalledArtifacts } from "./detect-installed.ts";
-import type { InstallOpts } from "./plan.ts";
 import { resolveInstallPaths } from "./paths.ts";
+import type { InstallOpts } from "./plan.ts";
 
 export function installOut(msg: string, opts: InstallOpts): void {
   if (opts.quiet || opts.json) return;
-  process.stdout.write(msg + "\n");
+  process.stdout.write(`${msg}\n`);
 }
 
 export function installInfo(msg: string, opts: InstallOpts): void {
   if (opts.quiet) return;
   if (opts.json && !opts.dry) return;
   const prefix = opts.dry ? "[dry run] " : "";
-  process.stderr.write(prefix + msg + "\n");
+  process.stderr.write(`${prefix + msg}\n`);
 }
 
 export function installErr(msg: string): void {
-  process.stderr.write(msg + "\n");
+  process.stderr.write(`${msg}\n`);
 }
 
 /** Prints install status to stdout (human or JSON). */
@@ -36,7 +36,10 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
     if (status.cursorMcp) json.cursorMcp = status.cursorMcp;
     if (status.claudeMcp) json.claudeMcp = status.claudeMcp;
     if (status.claudeDesktopMcp) json.claudeDesktopMcp = status.claudeDesktopMcp;
-    process.stdout.write(JSON.stringify(json, null, 2) + "\n");
+    if (status.opencodeMcp) json.opencodeMcp = status.opencodeMcp;
+    if (status.codexMcp) json.codexMcp = status.codexMcp;
+    if (status.chatGptMcp) json.chatGptMcp = status.chatGptMcp;
+    process.stdout.write(`${JSON.stringify(json, null, 2)}\n`);
     return;
   }
 
@@ -51,6 +54,9 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
     ["cursor mcp", status.cursorMcp],
     ["claude code mcp", status.claudeMcp],
     ["claude desktop mcp", status.claudeDesktopMcp],
+    ["opencode mcp", status.opencodeMcp],
+    ["codex mcp", status.codexMcp],
+    ["chatgpt desktop mcp", status.chatGptMcp],
   ];
   let any = false;
   for (const [label, value] of lines) {