@cg3/equip 0.1.1 → 0.2.1

package/README.md

@@ -8,14 +8,24 @@ Equip handles the hard part of distributing your MCP tool: detecting which AI co
 
 | Platform | MCP Config | Rules |
 |---|---|---|
-| Claude Code | `~/.claude.json` (`mcpServers`) | `~/.claude/CLAUDE.md` (append) |
-| Cursor | `~/.cursor/mcp.json` (`mcpServers`) | Clipboard (no writable global path) |
-| Windsurf | `~/.codeium/windsurf/mcp_config.json` (`mcpServers`) | `global_rules.md` (append) |
-| VS Code | `Code/User/mcp.json` (`servers`, `type: "http"`) | Clipboard |
-| Cline | `globalStorage/.../cline_mcp_settings.json` (`mcpServers`) | `~/Documents/Cline/Rules/` (standalone file) |
-| Roo Code | `globalStorage/.../cline_mcp_settings.json` (`mcpServers`) | `~/.roo/rules/` (standalone file) |
+| Claude Code | `~/.claude.json` (JSON, `mcpServers`) | `~/.claude/CLAUDE.md` (append) |
+| Cursor | `~/.cursor/mcp.json` (JSON, `mcpServers`) | Clipboard (no writable global path) |
+| Windsurf | `~/.codeium/windsurf/mcp_config.json` (JSON, `mcpServers`) | `global_rules.md` (append) |
+| VS Code | `Code/User/mcp.json` (JSON, `servers`, `type: "http"`) | Clipboard |
+| Cline | `globalStorage/.../cline_mcp_settings.json` (JSON, `mcpServers`) | `~/Documents/Cline/Rules/` (standalone file) |
+| Roo Code | `globalStorage/.../cline_mcp_settings.json` (JSON, `mcpServers`) | `~/.roo/rules/` (standalone file) |
+| Codex | `~/.codex/config.toml` (TOML, `mcp_servers`) | `~/.codex/AGENTS.md` (append) |
+| Gemini CLI | `~/.gemini/settings.json` (JSON, `mcpServers`, `httpUrl`) | `~/.gemini/GEMINI.md` (append) |
+
+## Quick Start
+
+```bash
+npx @cg3/equip prior
+```
+
+That's it. Detects your platforms, authenticates, installs MCP + rules, and verifies — all in one command. Pass `--dry-run` to preview without writing files.
 
-## Usage
+## Programmatic Usage
 
 ```js
 const { Equip } = require("@cg3/equip");
@@ -84,7 +94,7 @@ const { detectPlatforms, installMcpJson, installRules, createManualPlatform, pla
 ## Key Features
 
 - **Zero dependencies** — Pure Node.js, works with Node 18+
-- **Platform-aware** — Handles each platform's config quirks (root keys, URL fields, type requirements)
+- **Platform-aware** — Handles each platform's config quirks (JSON vs TOML, root keys, URL fields, type requirements)
 - **Non-destructive** — Merges into existing configs, creates backups, preserves other servers
 - **Versioned rules** — Marker-based blocks enable idempotent updates without clobbering user content
 - **Dry-run support** — Preview changes without writing files

package/bin/equip.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// @cg3/equip CLI — universal entry point for AI tool setup.
+// Usage: npx @cg3/equip <tool> [args...]
+//   e.g. npx @cg3/equip prior --dry-run
+
+"use strict";
+
+const { spawn } = require("child_process");
+
+// ─── Tool Registry ──────────────────────────────────────────
+
+const TOOLS = {
+  prior: { package: "@cg3/prior-node", command: "setup" },
+};
+
+// ─── CLI ─────────────────────────────────────────────────────
+
+const alias = process.argv[2];
+const extraArgs = process.argv.slice(3);
+
+if (!alias || alias === "--help" || alias === "-h") {
+  console.log("Usage: npx @cg3/equip <tool> [options]");
+  console.log("");
+  console.log("Available tools:");
+  for (const [name, info] of Object.entries(TOOLS)) {
+    console.log(`  ${name}  →  ${info.package} ${info.command}`);
+  }
+  console.log("");
+  console.log("Options are forwarded to the tool (e.g. --dry-run, --platform codex)");
+  process.exit(0);
+}
+
+const entry = TOOLS[alias];
+if (!entry) {
+  console.error(`Unknown tool: ${alias}`);
+  console.error(`Available: ${Object.keys(TOOLS).join(", ")}`);
+  process.exit(1);
+}
+
+// Spawn: npx -y <package> <command> [...extraArgs]
+const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
+const child = spawn(npxCmd, ["-y", entry.package, entry.command, ...extraArgs], {
+  stdio: "inherit",
+  shell: process.platform === "win32",
+});
+
+child.on("close", (code) => process.exit(code || 0));
+child.on("error", (err) => {
+  console.error(`Failed to run ${entry.package}: ${err.message}`);
+  process.exit(1);
+});

package/index.js

@@ -1,10 +1,10 @@
 // @cg3/equip — Universal MCP + behavioral rules installer for AI coding agents.
-// Zero dependencies. Works with Claude Code, Cursor, Windsurf, VS Code, Cline, Roo Code.
+// Zero dependencies. Works with Claude Code, Cursor, Windsurf, VS Code, Cline, Roo Code, Codex, Gemini CLI.
 
 "use strict";
 
 const { detectPlatforms, whichSync, dirExists, fileExists } = require("./lib/detect");
-const { readMcpEntry, buildHttpConfig, buildHttpConfigWithAuth, buildStdioConfig, installMcp, installMcpJson, uninstallMcp, updateMcpKey } = require("./lib/mcp");
+const { readMcpEntry, buildHttpConfig, buildHttpConfigWithAuth, buildStdioConfig, installMcp, installMcpJson, installMcpToml, uninstallMcp, updateMcpKey, parseTomlServerEntry, parseTomlSubTables, buildTomlEntry, removeTomlEntry } = require("./lib/mcp");
 const { parseRulesVersion, installRules, uninstallRules, markerPatterns } = require("./lib/rules");
 const { createManualPlatform, platformName, KNOWN_PLATFORMS } = require("./lib/platforms");
 const cli = require("./lib/cli");
@@ -145,7 +145,7 @@ class Equip {
    * @returns {object|null} Existing MCP config or null
    */
   readMcp(platform) {
-    return readMcpEntry(platform.configPath, platform.rootKey, this.name);
+    return readMcpEntry(platform.configPath, platform.rootKey, this.name, platform.configFormat || "json");
   }
 }
 
@@ -159,8 +159,13 @@ module.exports = {
   buildStdioConfig,
   installMcp,
   installMcpJson,
+  installMcpToml,
   uninstallMcp,
   updateMcpKey,
+  parseTomlServerEntry,
+  parseTomlSubTables,
+  buildTomlEntry,
+  removeTomlEntry,
   installRules,
   uninstallRules,
   parseRulesVersion,

package/lib/detect.js

@@ -7,7 +7,7 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 const { execSync } = require("child_process");
-const { getVsCodeMcpPath, getVsCodeUserDir, getClineConfigPath, getRooConfigPath } = require("./platforms");
+const { getVsCodeMcpPath, getVsCodeUserDir, getClineConfigPath, getRooConfigPath, getCodexConfigPath, getGeminiSettingsPath } = require("./platforms");
 const { readMcpEntry } = require("./mcp");
 
 // ─── Helpers ─────────────────────────────────────────────────
@@ -67,6 +67,7 @@ function detectPlatforms(serverName) {
       existingMcp: serverName ? readMcpEntry(configPath, "mcpServers", serverName) : null,
       hasCli: !!whichSync("claude"),
       rootKey: "mcpServers",
+      configFormat: "json",
     });
   }
 
@@ -82,6 +83,7 @@ function detectPlatforms(serverName) {
       existingMcp: serverName ? readMcpEntry(configPath, "mcpServers", serverName) : null,
       hasCli: !!whichSync("cursor"),
       rootKey: "mcpServers",
+      configFormat: "json",
     });
   }
 
@@ -98,6 +100,7 @@ function detectPlatforms(serverName) {
       existingMcp: serverName ? readMcpEntry(configPath, "mcpServers", serverName) : null,
       hasCli: false,
       rootKey: "mcpServers",
+      configFormat: "json",
     });
   }
 
@@ -112,6 +115,7 @@ function detectPlatforms(serverName) {
       existingMcp: serverName ? readMcpEntry(vscodeMcpPath, "servers", serverName) : null,
       hasCli: !!whichSync("code"),
       rootKey: "servers",
+      configFormat: "json",
     });
   }
 
@@ -127,6 +131,7 @@ function detectPlatforms(serverName) {
       existingMcp: serverName ? readMcpEntry(clineConfigPath, "mcpServers", serverName) : null,
       hasCli: false,
       rootKey: "mcpServers",
+      configFormat: "json",
     });
   }
 
@@ -141,6 +146,39 @@ function detectPlatforms(serverName) {
       existingMcp: serverName ? readMcpEntry(rooConfigPath, "mcpServers", serverName) : null,
       hasCli: false,
       rootKey: "mcpServers",
+      configFormat: "json",
+    });
+  }
+
+  // Codex (OpenAI CLI)
+  const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
+  const codexConfigPath = getCodexConfigPath();
+  if (whichSync("codex") || dirExists(codexHome)) {
+    platforms.push({
+      platform: "codex",
+      version: cliVersion("codex") || "unknown",
+      configPath: codexConfigPath,
+      rulesPath: path.join(codexHome, "AGENTS.md"),
+      existingMcp: serverName ? readMcpEntry(codexConfigPath, "mcp_servers", serverName, "toml") : null,
+      hasCli: !!whichSync("codex"),
+      rootKey: "mcp_servers",
+      configFormat: "toml",
+    });
+  }
+
+  // Gemini CLI (Google)
+  const geminiDir = path.join(home, ".gemini");
+  const geminiSettingsPath = getGeminiSettingsPath();
+  if (whichSync("gemini") || dirExists(geminiDir)) {
+    platforms.push({
+      platform: "gemini-cli",
+      version: cliVersion("gemini") || "unknown",
+      configPath: geminiSettingsPath,
+      rulesPath: path.join(geminiDir, "GEMINI.md"),
+      existingMcp: serverName ? readMcpEntry(geminiSettingsPath, "mcpServers", serverName) : null,
+      hasCli: !!whichSync("gemini"),
+      rootKey: "mcpServers",
+      configFormat: "json",
     });
   }
 

package/lib/mcp.js

@@ -8,19 +8,170 @@ const fs = require("fs");
 const path = require("path");
 const { execSync } = require("child_process");
 
+// ─── TOML Helpers (minimal, zero-dep) ───────────────────────
+
+/**
+ * Parse a TOML table entry for [mcp_servers.<name>].
+ * Returns key-value pairs as a plain object. Supports string, number, boolean, arrays.
+ * This is NOT a full TOML parser — only handles flat tables needed for MCP config.
+ */
+function parseTomlServerEntry(tomlContent, rootKey, serverName) {
+  const tableHeader = `[${rootKey}.${serverName}]`;
+  const idx = tomlContent.indexOf(tableHeader);
+  if (idx === -1) return null;
+
+  const afterHeader = tomlContent.slice(idx + tableHeader.length);
+  const nextTable = afterHeader.search(/\n\[(?!\[)/); // next top-level table
+  const block = nextTable === -1 ? afterHeader : afterHeader.slice(0, nextTable);
+
+  const result = {};
+  for (const line of block.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("[")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let val = trimmed.slice(eq + 1).trim();
+    // Parse value
+    if (val.startsWith('"') && val.endsWith('"')) {
+      result[key] = val.slice(1, -1);
+    } else if (val === "true") {
+      result[key] = true;
+    } else if (val === "false") {
+      result[key] = false;
+    } else if (!isNaN(Number(val)) && val !== "") {
+      result[key] = Number(val);
+    } else {
+      result[key] = val;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+
+/**
+ * Parse a nested TOML sub-table (e.g., [mcp_servers.prior.env] or [mcp_servers.prior.http_headers]).
+ */
+function parseTomlSubTables(tomlContent, rootKey, serverName) {
+  const prefix = `[${rootKey}.${serverName}.`;
+  const result = {};
+  let idx = 0;
+  while ((idx = tomlContent.indexOf(prefix, idx)) !== -1) {
+    const lineStart = tomlContent.lastIndexOf("\n", idx) + 1;
+    const lineEnd = tomlContent.indexOf("\n", idx);
+    const header = tomlContent.slice(idx, lineEnd === -1 ? undefined : lineEnd).trim();
+    // Extract sub-table name from [mcp_servers.prior.env]
+    const subName = header.slice(prefix.length, -1); // remove trailing ]
+    if (!subName || subName.includes(".")) { idx++; continue; }
+
+    const afterHeader = tomlContent.slice(lineEnd === -1 ? tomlContent.length : lineEnd);
+    const nextTable = afterHeader.search(/\n\[(?!\[)/);
+    const block = nextTable === -1 ? afterHeader : afterHeader.slice(0, nextTable);
+
+    const sub = {};
+    for (const line of block.split("\n")) {
+      const t = line.trim();
+      if (!t || t.startsWith("#") || t.startsWith("[")) continue;
+      const eq = t.indexOf("=");
+      if (eq === -1) continue;
+      const k = t.slice(0, eq).trim();
+      let v = t.slice(eq + 1).trim();
+      if (v.startsWith('"') && v.endsWith('"')) sub[k] = v.slice(1, -1);
+      else sub[k] = v;
+    }
+    if (Object.keys(sub).length > 0) result[subName] = sub;
+    idx++;
+  }
+  return result;
+}
+
+/**
+ * Build TOML text for a server entry.
+ * @param {string} rootKey - e.g., "mcp_servers"
+ * @param {string} serverName - e.g., "prior"
+ * @param {object} config - { url, bearer_token_env_var, http_headers, ... }
+ * @returns {string} TOML text block
+ */
+function buildTomlEntry(rootKey, serverName, config) {
+  const lines = [`[${rootKey}.${serverName}]`];
+  const subTables = {};
+
+  for (const [k, v] of Object.entries(config)) {
+    if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+      subTables[k] = v;
+    } else if (typeof v === "string") {
+      lines.push(`${k} = "${v}"`);
+    } else if (typeof v === "boolean" || typeof v === "number") {
+      lines.push(`${k} = ${v}`);
+    } else if (Array.isArray(v)) {
+      lines.push(`${k} = [${v.map(x => typeof x === "string" ? `"${x}"` : x).join(", ")}]`);
+    }
+  }
+
+  for (const [subName, subObj] of Object.entries(subTables)) {
+    lines.push("", `[${rootKey}.${serverName}.${subName}]`);
+    for (const [k, v] of Object.entries(subObj)) {
+      if (typeof v === "string") lines.push(`${k} = "${v}"`);
+      else lines.push(`${k} = ${v}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Remove a TOML server entry block from content.
+ * Removes [rootKey.serverName] and any [rootKey.serverName.*] sub-tables.
+ */
+function removeTomlEntry(tomlContent, rootKey, serverName) {
+  const mainHeader = `[${rootKey}.${serverName}]`;
+  const subPrefix = `[${rootKey}.${serverName}.`;
+
+  // Find all lines belonging to this entry
+  const lines = tomlContent.split("\n");
+  const result = [];
+  let inEntry = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === mainHeader || trimmed.startsWith(subPrefix)) {
+      inEntry = true;
+      continue;
+    }
+    if (inEntry && trimmed.startsWith("[") && !trimmed.startsWith(subPrefix)) {
+      inEntry = false;
+    }
+    if (!inEntry) {
+      result.push(line);
+    }
+  }
+
+  // Clean up extra blank lines
+  return result.join("\n").replace(/\n{3,}/g, "\n\n").trim() + "\n";
+}
+
 // ─── Read ────────────────────────────────────────────────────
 
 /**
- * Read an MCP server entry from a config file.
- * @param {string} configPath - Path to config JSON file
- * @param {string} rootKey - Root key ("mcpServers" or "servers")
+ * Read an MCP server entry from a config file (JSON or TOML).
+ * @param {string} configPath - Path to config file
+ * @param {string} rootKey - Root key ("mcpServers", "servers", or "mcp_servers")
  * @param {string} serverName - Server name to read
+ * @param {string} [configFormat="json"] - "json" or "toml"
  * @returns {object|null} Server config or null
  */
-function readMcpEntry(configPath, rootKey, serverName) {
+function readMcpEntry(configPath, rootKey, serverName, configFormat = "json") {
   try {
     let raw = fs.readFileSync(configPath, "utf-8");
     if (raw.charCodeAt(0) === 0xFEFF) raw = raw.slice(1); // Strip BOM
+
+    if (configFormat === "toml") {
+      const entry = parseTomlServerEntry(raw, rootKey, serverName);
+      if (!entry) return null;
+      // Merge sub-tables
+      const subs = parseTomlSubTables(raw, rootKey, serverName);
+      return { ...entry, ...subs };
+    }
+
     const data = JSON.parse(raw);
     return data?.[rootKey]?.[serverName] || null;
   } catch { return null; }
@@ -38,6 +189,9 @@ function readMcpEntry(configPath, rootKey, serverName) {
 function buildHttpConfig(serverUrl, platform) {
   if (platform === "windsurf") return { serverUrl };
   if (platform === "vscode") return { type: "http", url: serverUrl };
+  if (platform === "cursor") return { type: "streamable-http", url: serverUrl };
+  if (platform === "gemini-cli") return { httpUrl: serverUrl };
+  // codex, claude-code, cline, roo-code all use { url }
   return { url: serverUrl };
 }
 
@@ -50,8 +204,32 @@ function buildHttpConfig(serverUrl, platform) {
  * @returns {object} MCP config with headers
  */
 function buildHttpConfigWithAuth(serverUrl, apiKey, platform, extraHeaders) {
+  const base = buildHttpConfig(serverUrl, platform);
+
+  if (platform === "codex") {
+    // Codex TOML uses http_headers for static headers
+    return {
+      ...base,
+      http_headers: {
+        Authorization: `Bearer ${apiKey}`,
+        ...extraHeaders,
+      },
+    };
+  }
+
+  if (platform === "gemini-cli") {
+    // Gemini CLI uses headers object
+    return {
+      ...base,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        ...extraHeaders,
+      },
+    };
+  }
+
   return {
-    ...buildHttpConfig(serverUrl, platform),
+    ...base,
     headers: {
       Authorization: `Bearer ${apiKey}`,
       ...extraHeaders,
@@ -141,7 +319,29 @@ function installMcp(platform, serverName, mcpEntry, options = {}) {
     } catch { /* fall through */ }
   }
 
-  // JSON write (all platforms, fallback for CLI failures)
+  // Codex: try CLI first (codex mcp add <name> <url>)
+  if (platform.platform === "codex" && platform.hasCli && mcpEntry.url) {
+    try {
+      if (!dryRun) {
+        execSync(`codex mcp add ${serverName} ${mcpEntry.url}`, {
+          encoding: "utf-8", timeout: 15000, stdio: "pipe",
+        });
+        const check = readMcpEntry(platform.configPath, platform.rootKey, serverName, "toml");
+        if (check) return { success: true, method: "cli" };
+      } else {
+        return { success: true, method: "cli" };
+      }
+    } catch { /* fall through to TOML write */ }
+  }
+
+  // Gemini CLI: try CLI first (gemini mcp add <name> -- or manual JSON)
+  // Gemini's `gemini mcp add` is for stdio primarily; HTTP goes through settings.json
+  // Fall through to JSON write for HTTP
+
+  // TOML write for Codex, JSON write for all others
+  if (platform.configFormat === "toml") {
+    return installMcpToml(platform, serverName, mcpEntry, dryRun);
+  }
   return installMcpJson(platform, serverName, mcpEntry, dryRun);
 }
 
@@ -182,6 +382,44 @@ function installMcpJson(platform, serverName, mcpEntry, dryRun) {
   return { success: true, method: "json" };
 }
 
+/**
+ * Write MCP config to TOML file (Codex).
+ * Appends or replaces a [mcp_servers.<name>] table.
+ * @param {object} platform - Platform object
+ * @param {string} serverName - Server name
+ * @param {object} mcpEntry - MCP config
+ * @param {boolean} dryRun
+ * @returns {{ success: boolean, method: string }}
+ */
+function installMcpToml(platform, serverName, mcpEntry, dryRun) {
+  const { configPath, rootKey } = platform;
+
+  let existing = "";
+  try { existing = fs.readFileSync(configPath, "utf-8"); } catch { /* start fresh */ }
+
+  // Remove existing entry if present
+  const tableHeader = `[${rootKey}.${serverName}]`;
+  if (existing.includes(tableHeader)) {
+    existing = removeTomlEntry(existing, rootKey, serverName);
+  }
+
+  const newBlock = buildTomlEntry(rootKey, serverName, mcpEntry);
+
+  if (!dryRun) {
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    if (fileExists(configPath)) {
+      try { fs.copyFileSync(configPath, configPath + ".bak"); } catch {}
+    }
+
+    const sep = existing && !existing.endsWith("\n\n") ? (existing.endsWith("\n") ? "\n" : "\n\n") : "";
+    fs.writeFileSync(configPath, existing + sep + newBlock + "\n");
+  }
+
+  return { success: true, method: "toml" };
+}
+
 /**
  * Remove an MCP server entry from a platform config.
  * @param {object} platform - Platform object
@@ -193,6 +431,26 @@ function uninstallMcp(platform, serverName, dryRun) {
   const { configPath, rootKey } = platform;
   if (!fileExists(configPath)) return false;
 
+  // TOML path (Codex)
+  if (platform.configFormat === "toml") {
+    try {
+      const content = fs.readFileSync(configPath, "utf-8");
+      const tableHeader = `[${rootKey}.${serverName}]`;
+      if (!content.includes(tableHeader)) return false;
+      if (!dryRun) {
+        fs.copyFileSync(configPath, configPath + ".bak");
+        const cleaned = removeTomlEntry(content, rootKey, serverName);
+        if (cleaned.trim()) {
+          fs.writeFileSync(configPath, cleaned);
+        } else {
+          fs.unlinkSync(configPath);
+        }
+      }
+      return true;
+    } catch { return false; }
+  }
+
+  // JSON path
   try {
     const data = JSON.parse(fs.readFileSync(configPath, "utf-8"));
     if (!data?.[rootKey]?.[serverName]) return false;
@@ -218,6 +476,9 @@ function uninstallMcp(platform, serverName, dryRun) {
  * @returns {{ success: boolean, method: string }}
  */
 function updateMcpKey(platform, serverName, mcpEntry) {
+  if (platform.configFormat === "toml") {
+    return installMcpToml(platform, serverName, mcpEntry, false);
+  }
   return installMcpJson(platform, serverName, mcpEntry, false);
 }
 
@@ -228,6 +489,12 @@ module.exports = {
   buildStdioConfig,
   installMcp,
   installMcpJson,
+  installMcpToml,
   uninstallMcp,
   updateMcpKey,
+  // TOML helpers (exported for testing)
+  parseTomlServerEntry,
+  parseTomlSubTables,
+  buildTomlEntry,
+  removeTomlEntry,
 };

package/lib/platforms.js

@@ -29,6 +29,16 @@ function getRooConfigPath() {
   return path.join(base, "globalStorage", "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json");
 }
 
+function getCodexConfigPath() {
+  const home = os.homedir();
+  return path.join(process.env.CODEX_HOME || path.join(home, ".codex"), "config.toml");
+}
+
+function getGeminiSettingsPath() {
+  const home = os.homedir();
+  return path.join(home, ".gemini", "settings.json");
+}
+
 // ─── Platform Registry ──────────────────────────────────────
 
 /**
@@ -43,31 +53,49 @@ function createManualPlatform(platformId) {
       configPath: path.join(home, ".claude.json"),
       rulesPath: path.join(home, ".claude", "CLAUDE.md"),
       rootKey: "mcpServers",
+      configFormat: "json",
     },
     cursor: {
       configPath: path.join(home, ".cursor", "mcp.json"),
       rulesPath: null,
       rootKey: "mcpServers",
+      configFormat: "json",
     },
     windsurf: {
       configPath: path.join(home, ".codeium", "windsurf", "mcp_config.json"),
       rulesPath: path.join(home, ".codeium", "windsurf", "memories", "global_rules.md"),
       rootKey: "mcpServers",
+      configFormat: "json",
     },
     vscode: {
       configPath: getVsCodeMcpPath(),
       rulesPath: null,
       rootKey: "servers",
+      configFormat: "json",
     },
     cline: {
       configPath: getClineConfigPath(),
       rulesPath: path.join(home, "Documents", "Cline", "Rules"),
       rootKey: "mcpServers",
+      configFormat: "json",
     },
     "roo-code": {
       configPath: getRooConfigPath(),
       rulesPath: path.join(home, ".roo", "rules"),
       rootKey: "mcpServers",
+      configFormat: "json",
+    },
+    codex: {
+      configPath: getCodexConfigPath(),
+      rulesPath: path.join(process.env.CODEX_HOME || path.join(home, ".codex"), "AGENTS.md"),
+      rootKey: "mcp_servers",
+      configFormat: "toml",
+    },
+    "gemini-cli": {
+      configPath: getGeminiSettingsPath(),
+      rulesPath: path.join(home, ".gemini", "GEMINI.md"),
+      rootKey: "mcpServers",
+      configFormat: "json",
     },
   };
 
@@ -90,6 +118,8 @@ function platformName(id) {
     vscode: "VS Code",
     cline: "Cline",
     "roo-code": "Roo Code",
+    codex: "Codex",
+    "gemini-cli": "Gemini CLI",
   };
   return names[id] || id;
 }
@@ -97,13 +127,15 @@ function platformName(id) {
 /**
  * All known platform IDs.
  */
-const KNOWN_PLATFORMS = ["claude-code", "cursor", "windsurf", "vscode", "cline", "roo-code"];
+const KNOWN_PLATFORMS = ["claude-code", "cursor", "windsurf", "vscode", "cline", "roo-code", "codex", "gemini-cli"];
 
 module.exports = {
   getVsCodeUserDir,
   getVsCodeMcpPath,
   getClineConfigPath,
   getRooConfigPath,
+  getCodexConfigPath,
+  getGeminiSettingsPath,
   createManualPlatform,
   platformName,
   KNOWN_PLATFORMS,

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@cg3/equip",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Universal MCP + behavioral rules installer for AI coding agents",
   "main": "index.js",
+  "bin": {
+    "equip": "bin/equip.js"
+  },
   "exports": {
     ".": "./index.js",
     "./detect": "./lib/detect.js",
@@ -13,6 +16,7 @@
   },
   "files": [
     "index.js",
+    "bin/",
     "lib/"
   ],
   "keywords": [
@@ -25,7 +29,9 @@
     "windsurf",
     "vscode",
     "cline",
-    "roo-code"
+    "roo-code",
+    "codex",
+    "gemini"
   ],
   "author": "CG3 LLC",
   "license": "MIT",