@algosuite/vo-mcp 0.2.0-beta.8 → 0.2.0-beta.9

package/dist/install-cli.js

@@ -3,8 +3,8 @@ import { createRequire as __cr } from 'module'; const require = __cr(import.meta
 
 // src/install.ts
 import { homedir as homedir3, platform as platform3 } from "node:os";
-import { join as join3, dirname as dirname2 } from "node:path";
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, copyFileSync as copyFileSync2 } from "node:fs";
+import { join as join4, dirname as dirname3 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, copyFileSync as copyFileSync3 } from "node:fs";
 import { fileURLToPath } from "node:url";
 
 // src/cloud/pairing.ts
@@ -197,27 +197,156 @@ async function runPairing(deps = {}) {
   }
 }
 
+// src/codex-mcp-config.ts
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+var MANAGED_BEGIN = "# BEGIN AlgoHQ MCP (managed by vo-mcp install)";
+var MANAGED_END = "# END AlgoHQ MCP (managed by vo-mcp install)";
+var MANAGED_SERVER_NAMES = /* @__PURE__ */ new Set(["algohq", "vo", "vo-mcp", "vo_mcp"]);
+function resolveCodexConfigPath(home) {
+  return join2(home, ".codex", "config.toml");
+}
+function normalizeKey(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function tablePath(line) {
+  const match = /^\s*\[([^\r\n]+)\]\s*(?:#.*)?$/.exec(line);
+  const rawPath = match?.[1];
+  if (!rawPath || rawPath.includes("[") || rawPath.includes("]")) return null;
+  return rawPath.split(".").map(normalizeKey);
+}
+function tableSections(lines) {
+  const starts = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const path = tablePath(lines[index] ?? "");
+    if (path) starts.push({ path, start: index });
+  }
+  return starts.map((section, index) => ({
+    ...section,
+    end: starts[index + 1]?.start ?? lines.length
+  }));
+}
+function isManagedSection(section) {
+  return section.path[0] === "mcp_servers" && MANAGED_SERVER_NAMES.has(section.path[1] ?? "");
+}
+function assignmentKey(line) {
+  const match = /^\s*((?:[A-Za-z0-9_-]+)|(?:"[^"]+")|(?:'[^']+'))\s*=/.exec(line);
+  return match?.[1] ? normalizeKey(match[1]) : null;
+}
+function isStructurallySafeToml(raw) {
+  const lines = raw.split(/\r?\n/);
+  const beginIndexes = lines.flatMap((line, index) => line.trim() === MANAGED_BEGIN ? [index] : []);
+  const endIndexes = lines.flatMap((line, index) => line.trim() === MANAGED_END ? [index] : []);
+  if (beginIndexes.length !== endIndexes.length || beginIndexes.length > 1) return false;
+  if (beginIndexes[0] !== void 0 && (endIndexes[0] ?? -1) <= beginIndexes[0]) return false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^\[\[?mcp_servers(?:\.|\s|$)/.test(trimmed) && tablePath(line) === null) return false;
+  }
+  return true;
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function preservedSectionLines(lines, section, managedKeys) {
+  if (!section) return [];
+  return lines.slice(section.start + 1, section.end).filter((line) => {
+    if (line.trim() === MANAGED_BEGIN || line.trim() === MANAGED_END) return false;
+    const key = assignmentKey(line);
+    return key === null || !managedKeys.has(key);
+  }).filter((line, index, all) => line.trim() !== "" || index > 0 && index < all.length - 1);
+}
+function renderCodexMcpConfig(raw, cliPath, controlPlaneUrl) {
+  if (!isStructurallySafeToml(raw)) {
+    throw new Error("Codex config is malformed; refusing to overwrite it");
+  }
+  const eol = raw.includes("\r\n") ? "\r\n" : "\n";
+  const lines = raw.split(/\r?\n/);
+  const sections = tableSections(lines);
+  const rootSections = sections.filter((section) => isManagedSection(section) && section.path.length === 2);
+  const preferredRoot = rootSections.find((section) => section.path[1] === "algohq") ?? rootSections[0];
+  const preferredName = preferredRoot?.path[1];
+  const envSection = sections.find((section) => isManagedSection(section) && section.path[1] === preferredName && section.path[2] === "env");
+  const rootExtras = preservedSectionLines(lines, preferredRoot, /* @__PURE__ */ new Set(["command", "args", "required"]));
+  const envExtras = preservedSectionLines(lines, envSection, /* @__PURE__ */ new Set(["VO_CONTROL_PLANE_URL"]));
+  const removed = /* @__PURE__ */ new Set();
+  const managedBegin = lines.findIndex((line) => line.trim() === MANAGED_BEGIN);
+  const managedEnd = lines.findIndex((line) => line.trim() === MANAGED_END);
+  if (managedBegin >= 0 && managedEnd >= managedBegin) {
+    for (let index = managedBegin; index <= managedEnd; index += 1) removed.add(index);
+  }
+  for (const section of sections.filter(isManagedSection)) {
+    for (let index = section.start; index < section.end; index += 1) removed.add(index);
+  }
+  const base = lines.filter((_line, index) => !removed.has(index)).join(eol).trimEnd();
+  const block = [
+    MANAGED_BEGIN,
+    "[mcp_servers.algohq]",
+    'command = "node"',
+    `args = [${tomlString(cliPath)}]`,
+    "required = true",
+    ...rootExtras,
+    "",
+    "[mcp_servers.algohq.env]",
+    `VO_CONTROL_PLANE_URL = ${tomlString(controlPlaneUrl)}`,
+    ...envExtras,
+    MANAGED_END
+  ].join(eol);
+  return `${base}${base ? `${eol}${eol}` : ""}${block}${eol}`;
+}
+function installCodexMcpConfigAt(configPath, cliPath, controlPlaneUrl, log) {
+  const exists = existsSync2(configPath);
+  const raw = exists ? readFileSync2(configPath, "utf8") : "";
+  let rendered;
+  try {
+    rendered = renderCodexMcpConfig(raw, cliPath, controlPlaneUrl);
+  } catch (error) {
+    if (exists) {
+      const backupPath = `${configPath}.backup-${Date.now()}`;
+      copyFileSync(configPath, backupPath);
+      log(`  Backed up malformed Codex config \u2192 ${backupPath}`);
+    }
+    throw error;
+  }
+  if (rendered === raw) {
+    log(`  Codex already current: ${configPath}`);
+    return;
+  }
+  if (exists) {
+    const backupPath = `${configPath}.backup-${Date.now()}`;
+    copyFileSync(configPath, backupPath);
+    log(`  Backed up Codex config \u2192 ${backupPath}`);
+  }
+  mkdirSync2(dirname2(configPath), { recursive: true });
+  writeFileSync2(configPath, rendered, "utf8");
+  log(`\u2713 Wrote AlgoHQ MCP to Codex: ${configPath}`);
+}
+
 // src/autostart.ts
 import { homedir as homedir2, platform as platform2 } from "node:os";
-import { join as join2 } from "node:path";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2, unlinkSync, copyFileSync } from "node:fs";
+import { join as join3 } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync3, unlinkSync, copyFileSync as copyFileSync2 } from "node:fs";
 function resolveRunnerCommand(override) {
   return override ?? "vo-mcp runner";
 }
 function installWindowsAutostart(runnerCommand, log, env) {
-  const appData = env["APPDATA"] ?? join2(homedir2(), "AppData", "Roaming");
-  const startupDir = join2(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
-  mkdirSync2(startupDir, { recursive: true });
-  const launcherPath = join2(startupDir, "vo-runner.cmd");
-  if (existsSync2(launcherPath)) {
-    const existing = readFileSync2(launcherPath, "utf8");
+  const appData = env["APPDATA"] ?? join3(homedir2(), "AppData", "Roaming");
+  const startupDir = join3(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+  mkdirSync3(startupDir, { recursive: true });
+  const launcherPath = join3(startupDir, "vo-runner.cmd");
+  if (existsSync3(launcherPath)) {
+    const existing = readFileSync3(launcherPath, "utf8");
     if (existing.includes("vo-mcp runner")) {
       log(`\u2713 Auto-start is already configured (Windows Startup folder)`);
       log(`  Path: ${launcherPath}`);
       return;
     }
     const backupPath = `${launcherPath}.backup-${Date.now()}`;
-    copyFileSync(launcherPath, backupPath);
+    copyFileSync2(launcherPath, backupPath);
     log(`  Backed up existing launcher to: ${backupPath}`);
   }
   const launcherContent = `@echo off
@@ -225,24 +354,24 @@ REM Auto-start launcher for vo-mcp runner
 REM Created by vo-mcp autostart installer
 start /min cmd /c "${runnerCommand}"
 `;
-  writeFileSync2(launcherPath, launcherContent, "utf8");
+  writeFileSync3(launcherPath, launcherContent, "utf8");
   log(`\u2713 Installed Windows auto-start launcher`);
   log(`  Path: ${launcherPath}`);
   log(`  The runner will start minimized at next login.`);
 }
 async function installMacAutostart(runnerCommand, log) {
-  const launchAgentsDir = join2(homedir2(), "Library", "LaunchAgents");
-  mkdirSync2(launchAgentsDir, { recursive: true });
-  const plistPath = join2(launchAgentsDir, "ai.algosuite.vo-runner.plist");
-  if (existsSync2(plistPath)) {
-    const existing = readFileSync2(plistPath, "utf8");
+  const launchAgentsDir = join3(homedir2(), "Library", "LaunchAgents");
+  mkdirSync3(launchAgentsDir, { recursive: true });
+  const plistPath = join3(launchAgentsDir, "ai.algosuite.vo-runner.plist");
+  if (existsSync3(plistPath)) {
+    const existing = readFileSync3(plistPath, "utf8");
     if (existing.includes("vo-mcp runner")) {
       log(`\u2713 Auto-start is already configured (launchd)`);
       log(`  Path: ${plistPath}`);
       return;
     }
     const backupPath = `${plistPath}.backup-${Date.now()}`;
-    copyFileSync(plistPath, backupPath);
+    copyFileSync2(plistPath, backupPath);
     log(`  Backed up existing plist to: ${backupPath}`);
   }
   const parts = runnerCommand.split(/\s+/);
@@ -264,20 +393,20 @@ ${args.map((a) => `    <string>${a}</string>`).join("\n")}
   <key>KeepAlive</key>
   <true/>
   <key>StandardOutPath</key>
-  <string>${join2(homedir2(), ".claude", "vo-runner.log")}</string>
+  <string>${join3(homedir2(), ".claude", "vo-runner.log")}</string>
   <key>StandardErrorPath</key>
-  <string>${join2(homedir2(), ".claude", "vo-runner-error.log")}</string>
+  <string>${join3(homedir2(), ".claude", "vo-runner-error.log")}</string>
 </dict>
 </plist>
 `;
-  writeFileSync2(plistPath, plistContent, "utf8");
+  writeFileSync3(plistPath, plistContent, "utf8");
   log(`\u2713 Installed launchd plist`);
   log(`  Path: ${plistPath}`);
   try {
     const { execSync } = await import("node:child_process");
     execSync(`launchctl load "${plistPath}"`, { stdio: "ignore" });
     log(`\u2713 Loaded plist with launchctl (runner will start at next login)`);
-    log(`  Logs: ${join2(homedir2(), ".claude", "vo-runner.log")}`);
+    log(`  Logs: ${join3(homedir2(), ".claude", "vo-runner.log")}`);
   } catch {
     log(`\u26A0 Failed to load plist with launchctl (you may need to load it manually)`);
     log(`  Run: launchctl load "${plistPath}"`);
@@ -285,23 +414,23 @@ ${args.map((a) => `    <string>${a}</string>`).join("\n")}
 }
 async function installLinuxAutostart(runnerCommand, log, env) {
   const home = env["HOME"]?.trim() || homedir2();
-  const unitDir = join2(home, ".config", "systemd", "user");
-  mkdirSync2(unitDir, { recursive: true });
-  const unitPath = join2(unitDir, "vo-runner.service");
-  if (existsSync2(unitPath)) {
-    const existing = readFileSync2(unitPath, "utf8");
+  const unitDir = join3(home, ".config", "systemd", "user");
+  mkdirSync3(unitDir, { recursive: true });
+  const unitPath = join3(unitDir, "vo-runner.service");
+  if (existsSync3(unitPath)) {
+    const existing = readFileSync3(unitPath, "utf8");
     if (existing.includes(runnerCommand) || existing.includes("vo-mcp runner")) {
       log(`\u2713 Auto-start is already configured (systemd user unit)`);
       log(`  Path: ${unitPath}`);
       return;
     }
     const backupPath = `${unitPath}.backup-${Date.now()}`;
-    copyFileSync(unitPath, backupPath);
+    copyFileSync2(unitPath, backupPath);
     log(`  Backed up existing unit to: ${backupPath}`);
   }
-  const logFile = join2(home, ".claude", "vo-runner.log");
-  const errFile = join2(home, ".claude", "vo-runner-error.log");
-  mkdirSync2(join2(home, ".claude"), { recursive: true });
+  const logFile = join3(home, ".claude", "vo-runner.log");
+  const errFile = join3(home, ".claude", "vo-runner-error.log");
+  mkdirSync3(join3(home, ".claude"), { recursive: true });
   const unit = `[Unit]
 Description=VO Code Runner (vo-mcp)
 After=network-online.target
@@ -318,7 +447,7 @@ StandardError=append:${errFile}
 [Install]
 WantedBy=default.target
 `;
-  writeFileSync2(unitPath, unit, "utf8");
+  writeFileSync3(unitPath, unit, "utf8");
   log(`\u2713 Installed systemd user unit`);
   log(`  Path: ${unitPath}`);
   if (process.env["VITEST"]) {
@@ -356,21 +485,21 @@ async function installAutostart(opts = {}) {
 // src/install.ts
 var DEFAULT_CONTROL_PLANE_URL2 = "https://vo-control-plane-bzjphrajaq-uc.a.run.app";
 function resolveCodeConfigPath(home) {
-  return join3(home, ".claude.json");
+  return join4(home, ".claude.json");
 }
 function resolveDesktopConfigPath(home, plat, appData) {
   if (plat === "win32") {
-    return join3(appData ?? join3(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+    return join4(appData ?? join4(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
   }
   if (plat === "darwin") {
-    return join3(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return join4(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
-  return join3(home, ".config", "Claude", "claude_desktop_config.json");
+  return join4(home, ".config", "Claude", "claude_desktop_config.json");
 }
 function readClaudeConfig(path) {
   try {
-    if (!existsSync3(path)) return {};
-    const raw = readFileSync3(path, "utf8");
+    if (!existsSync4(path)) return {};
+    const raw = readFileSync4(path, "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
@@ -378,12 +507,12 @@ function readClaudeConfig(path) {
   }
 }
 function writeClaudeConfig(path, config) {
-  mkdirSync3(dirname2(path), { recursive: true });
-  writeFileSync3(path, `${JSON.stringify(config, null, 2)}
+  mkdirSync4(dirname3(path), { recursive: true });
+  writeFileSync4(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 function resolveVoMcpCliPath() {
-  return join3(dirname2(fileURLToPath(import.meta.url)), "cli.js");
+  return join4(dirname3(fileURLToPath(import.meta.url)), "cli.js");
 }
 function installMcpConfigAt(configPath, cliPath, controlPlaneUrl, log, label) {
   const existing = readClaudeConfig(configPath);
@@ -393,9 +522,9 @@ function installMcpConfigAt(configPath, cliPath, controlPlaneUrl, log, label) {
     log(`  ${label} already current: ${configPath}`);
     return;
   }
-  if (existsSync3(configPath)) {
+  if (existsSync4(configPath)) {
     const backupPath = `${configPath}.backup-${Date.now()}`;
-    copyFileSync2(configPath, backupPath);
+    copyFileSync3(configPath, backupPath);
     log(`  Backed up ${label} config \u2192 ${backupPath}`);
   }
   const merged = {
@@ -422,6 +551,7 @@ function installMcpConfig(log, env) {
   const controlPlaneUrl = env["VO_CONTROL_PLANE_URL"]?.trim() || DEFAULT_CONTROL_PLANE_URL2;
   installMcpConfigAt(resolveCodeConfigPath(home), cliPath, controlPlaneUrl, log, "Claude Code CLI");
   installMcpConfigAt(resolveDesktopConfigPath(home, plat, appData), cliPath, controlPlaneUrl, log, "Claude Desktop");
+  installCodexMcpConfigAt(resolveCodexConfigPath(home), cliPath, controlPlaneUrl, log);
 }
 async function runPairFlow(log, env) {
   log("\n\u2501\u2501\u2501 Step 2: Link your VO account (device code) \u2501\u2501\u2501");
@@ -437,27 +567,33 @@ async function runPairFlow(log, env) {
     log("  No problem \u2014 the rest will finish; pair anytime with: vo-mcp pair");
   }
 }
-function printNextSteps(log, autostartInstalled) {
+function printNextSteps(log, autostartInstalled, configOnly) {
   log("\n\u2501\u2501\u2501 Installation complete! \u2501\u2501\u2501\n");
   log("What's configured:");
-  log("  \u2713 Claude Desktop / Claude Code will load vo-mcp on next restart");
-  log("  \u2713 Your scoped credential is stored (revocable via the dashboard)");
+  log("  \u2713 Claude Desktop, Claude Code, and Codex will load AlgoHQ MCP on next restart");
+  if (configOnly) {
+    log("  \u2713 Existing pairing and runner auto-start settings were left unchanged");
+  } else {
+    log("  \u2713 Your scoped credential is stored (revocable via the dashboard)");
+  }
   if (autostartInstalled) {
     log("  \u2713 Runner daemon will start automatically at login\n");
   } else {
     log("\n");
   }
   log("Next steps:");
-  log("  1. Restart Claude Desktop / Claude Code (if running).");
-  if (autostartInstalled) {
+  log("  1. Restart Claude Desktop / Claude Code / Codex (if running).");
+  if (configOnly) {
+    log("  2. Restart the existing AlgoHQ runner service or runner terminal.");
+  } else if (autostartInstalled) {
     log("  2. Log out and back in (or start the runner manually now: vo-mcp runner)");
   } else {
     log("  2. Start the agent runner in a terminal (keep it running):");
     log("       vo-mcp runner");
     log("     (To set up auto-start at login: vo-mcp runner --install-autostart)");
   }
-  log("  3. Visit the VO Command Center to dispatch your first agent:");
-  log("       https://algosuite.ai/virtualoffice\n");
+  log("  3. Visit AlgoHQ to dispatch your first agent:");
+  log("       https://algosuite.ai/algohq\n");
   log("The runner watches for tasks you dispatch and spins up agents in fresh worktrees.");
   log("Agents only run while the runner is connected. Ctrl+C to stop it anytime.\n");
 }
@@ -465,11 +601,13 @@ async function install(opts = {}) {
   const log = opts.log ?? ((m) => console.error(m));
   const env = opts.env ?? process.env;
   log("\u2501\u2501\u2501 vo-mcp installer \u2501\u2501\u2501");
-  log("This will set up your machine to dispatch VO agents from anywhere.\n");
-  log("\u2501\u2501\u2501 Step 1: Configure Claude Desktop / Claude Code \u2501\u2501\u2501");
+  log("This will set up your machine to dispatch AlgoHQ agents from anywhere.\n");
+  log("\u2501\u2501\u2501 Step 1: Configure Claude Desktop / Claude Code / Codex \u2501\u2501\u2501");
   installMcpConfig(log, env);
   if (!opts.skipLogin) {
     await runPairFlow(log, env);
+  } else if (opts.configOnly) {
+    log("\n(Config-only refresh \u2014 existing pairing left unchanged.)");
   } else {
     log("\n(Pairing skipped \u2014 run `vo-mcp pair` when ready.)");
   }
@@ -484,11 +622,15 @@ async function install(opts = {}) {
       autostartInstalled = true;
     }
   }
-  printNextSteps(log, autostartInstalled);
+  printNextSteps(log, autostartInstalled, opts.configOnly === true);
+}
+function installOptionsFromArgs(args) {
+  const configOnly = args.includes("--config-only");
+  return configOnly ? { configOnly: true, skipLogin: true, skipAutostart: true } : {};
 }
 
 // src/install-cli.ts
-install().catch((err) => {
+install(installOptionsFromArgs(process.argv.slice(2))).catch((err) => {
   console.error("[vo-mcp install] fatal:", err);
   process.exit(1);
 });