@algosuite/vo-mcp 0.1.0

package/dist/install-cli.js

@@ -0,0 +1,603 @@
+#!/usr/bin/env node
+import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
+
+// src/install.ts
+import { homedir as homedir3, platform as platform2 } 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 { resolve } from "node:path";
+
+// src/cloud/login.ts
+import { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+
+// src/cloud/credential-store.ts
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  chmodSync,
+  rmSync
+} from "node:fs";
+
+// src/cloud/keychain.ts
+import { createRequire } from "node:module";
+var SERVICE = "vo-mcp";
+var ACCOUNT = "refresh-credential";
+var cached;
+function loadKeyring() {
+  if (cached !== void 0) return cached;
+  try {
+    const req = createRequire(import.meta.url);
+    const mod = req("@napi-rs/keyring");
+    cached = mod && typeof mod.Entry === "function" ? mod : null;
+  } catch {
+    cached = null;
+  }
+  return cached;
+}
+function keychainAvailable() {
+  return loadKeyring() !== null;
+}
+function keychainGet() {
+  const k = loadKeyring();
+  if (!k) return null;
+  try {
+    return new k.Entry(SERVICE, ACCOUNT).getPassword();
+  } catch {
+    return null;
+  }
+}
+function keychainSet(secret) {
+  const k = loadKeyring();
+  if (!k) return false;
+  try {
+    new k.Entry(SERVICE, ACCOUNT).setPassword(secret);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function keychainDelete() {
+  const k = loadKeyring();
+  if (!k) return false;
+  try {
+    return new k.Entry(SERVICE, ACCOUNT).deletePassword();
+  } catch {
+    return false;
+  }
+}
+
+// src/cloud/credential-store.ts
+var realKeychain = {
+  available: keychainAvailable,
+  get: keychainGet,
+  set: keychainSet,
+  delete: keychainDelete
+};
+var KEYCHAIN_LOCATION = 'OS keychain (service "vo-mcp")';
+function credentialPath(env = process.env) {
+  const override = env["VO_MCP_CREDENTIALS_PATH"]?.trim();
+  if (override) return override;
+  return join(homedir(), ".config", "vo-mcp", "credentials.json");
+}
+function keychainEnabled(env, keychain) {
+  const disabled = (env["VO_MCP_DISABLE_KEYCHAIN"] ?? "").trim().toLowerCase();
+  if (disabled === "1" || disabled === "true" || disabled === "yes") return false;
+  return keychain.available();
+}
+function deleteFile(env) {
+  try {
+    rmSync(credentialPath(env), { force: true });
+  } catch {
+  }
+}
+function writeToFile(payload, env) {
+  const p = credentialPath(env);
+  mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, `${JSON.stringify(payload, null, 2)}
+`, { mode: 384 });
+  try {
+    chmodSync(p, 384);
+  } catch {
+  }
+  return p;
+}
+function writeStoredCredential(cred, storedAt, env = process.env, keychain = realKeychain) {
+  const payload = {
+    ...cred.refresh_token ? { refresh_token: cred.refresh_token } : {},
+    ...cred.api_key ? { api_key: cred.api_key } : {},
+    ...cred.vo_credential ? { vo_credential: cred.vo_credential } : {},
+    ...cred.vo_credential_expires_at ? { vo_credential_expires_at: cred.vo_credential_expires_at } : {},
+    ...cred.email ? { email: cred.email } : {},
+    stored_at: cred.stored_at ?? storedAt
+  };
+  if (keychainEnabled(env, keychain) && keychain.set(JSON.stringify(payload))) {
+    deleteFile(env);
+    return KEYCHAIN_LOCATION;
+  }
+  const p = writeToFile(payload, env);
+  if (keychainEnabled(env, keychain)) keychain.delete();
+  return p;
+}
+
+// src/cloud/login.ts
+var DEFAULT_DASHBOARD_URL = "https://vo-dashboard.web.app";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var MAX_BODY_BYTES = 16384;
+function processCapture(rawBody, expectedState, store) {
+  let data;
+  try {
+    data = JSON.parse(rawBody);
+  } catch {
+    return { ok: false, httpStatus: 400, error: "invalid JSON body" };
+  }
+  if (!data || typeof data !== "object") return { ok: false, httpStatus: 400, error: "invalid body" };
+  if (typeof data.state !== "string" || data.state !== expectedState) {
+    return { ok: false, httpStatus: 403, error: "state mismatch (possible CSRF) \u2014 login aborted" };
+  }
+  const refresh = typeof data.refresh_token === "string" ? data.refresh_token.trim() : "";
+  const apiKey = typeof data.api_key === "string" ? data.api_key.trim() : "";
+  if (!refresh || !apiKey) {
+    return { ok: false, httpStatus: 400, error: "login response missing refresh_token / api_key" };
+  }
+  const email = typeof data.email === "string" && data.email.trim() ? data.email.trim() : void 0;
+  const path = store({ refresh_token: refresh, api_key: apiKey, ...email ? { email } : {} });
+  return {
+    ok: true,
+    httpStatus: 200,
+    result: { ...email ? { email } : {}, credentialPath: path },
+    captured: { refresh_token: refresh, api_key: apiKey, ...email ? { email } : {} }
+  };
+}
+function captureHtml() {
+  return `<!doctype html><html><head><meta charset="utf-8"><title>VO login</title></head>
+<body style="font-family:system-ui;max-width:32rem;margin:4rem auto;text-align:center">
+<h2 id="m">Completing sign-in\u2026</h2>
+<script>
+(function(){
+  var h=location.hash.replace(/^#/,''), p=new URLSearchParams(h), b={};
+  ['state','refresh_token','api_key','email'].forEach(function(k){ if(p.get(k)) b[k]=p.get(k); });
+  fetch('/capture',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify(b)})
+    .then(function(r){ document.getElementById('m').textContent = r.ok ? 'Sign-in complete \u2014 you can close this tab.' : 'Sign-in failed \u2014 check the terminal.'; })
+    .catch(function(){ document.getElementById('m').textContent = 'Sign-in failed \u2014 check the terminal.'; });
+})();
+</script></body></html>`;
+}
+function defaultOpenBrowser(url) {
+  const platform3 = process.platform;
+  if (platform3 === "win32") {
+    spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
+  } else if (platform3 === "darwin") {
+    spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+  } else {
+    spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+  }
+}
+async function runLogin(opts = {}) {
+  const dashboardUrl = (opts.dashboardUrl ?? DEFAULT_DASHBOARD_URL).replace(/\/+$/, "");
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const env = opts.env ?? process.env;
+  const log = opts.log ?? ((m) => console.error(m));
+  const nowIso = opts.nowIso ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const openBrowser = opts.openBrowser ?? defaultOpenBrowser;
+  const state = randomBytes(32).toString("base64url");
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const finish = (err, result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      server.close();
+      if (err) reject(err);
+      else resolve2(result);
+    };
+    const server = createServer((req, res) => {
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      if (req.method === "GET" && url.pathname === "/callback") {
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        res.end(captureHtml());
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/capture") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString("utf8");
+          if (body.length > MAX_BODY_BYTES) req.destroy();
+        });
+        req.on("end", () => {
+          void (async () => {
+            if (body.length > MAX_BODY_BYTES) {
+              res.writeHead(413, { "content-type": "text/plain" });
+              res.end("payload too large");
+              finish(new Error("login request body exceeded the size cap"));
+              return;
+            }
+            const writeNow = (cred) => writeStoredCredential(cred, nowIso(), env);
+            const outcome = processCapture(body, state, opts.exchange ? () => "pending" : writeNow);
+            let result = outcome.result;
+            if (outcome.ok && outcome.captured && opts.exchange) {
+              const capt = outcome.captured;
+              let cred = {
+                refresh_token: capt.refresh_token,
+                api_key: capt.api_key,
+                ...capt.email ? { email: capt.email } : {}
+              };
+              try {
+                const voc = await opts.exchange(capt.refresh_token, capt.api_key);
+                if (voc && voc.vo_credential) {
+                  cred = {
+                    vo_credential: voc.vo_credential,
+                    vo_credential_expires_at: voc.expires_at,
+                    ...capt.email ? { email: capt.email } : {}
+                  };
+                }
+              } catch {
+              }
+              const path = writeNow(cred);
+              result = { ...capt.email ? { email: capt.email } : {}, credentialPath: path };
+            }
+            res.writeHead(outcome.httpStatus, { "content-type": "text/html; charset=utf-8" });
+            res.end(outcome.ok ? "<h2>VO login complete \u2014 you can close this tab.</h2>" : `<h2>Login failed: ${outcome.error}</h2>`);
+            finish(outcome.ok ? null : new Error(outcome.error ?? "login failed"), result);
+          })();
+        });
+        return;
+      }
+      res.writeHead(404);
+      res.end("not found");
+    });
+    const timer = setTimeout(
+      () => finish(new Error(`login timed out after ${timeoutMs}ms \u2014 no sign-in captured`)),
+      timeoutMs
+    );
+    server.on("error", (e) => finish(e));
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = addr && typeof addr === "object" ? addr.port : 0;
+      if (!port) {
+        finish(new Error("failed to bind a loopback port"));
+        return;
+      }
+      const loginUrl = `${dashboardUrl}/cli-login?port=${port}&state=${encodeURIComponent(state)}`;
+      log(`[vo-mcp] Opening your browser to sign in:
+  ${loginUrl}`);
+      log("[vo-mcp] If it did not open, paste that URL into your browser. Waiting for sign-in\u2026");
+      try {
+        openBrowser(loginUrl);
+      } catch {
+      }
+    });
+  });
+}
+
+// src/cloud/auth-token-source.ts
+var FIREBASE_SECURETOKEN_URL = "https://securetoken.googleapis.com/v1/token";
+var REFRESH_SKEW_MS = 6e4;
+function createFirebaseRefreshTokenSource(opts) {
+  const refreshToken = opts.refreshToken.trim();
+  const apiKey = opts.apiKey.trim();
+  const now = opts.now ?? (() => Date.now());
+  const fetchFn = opts.fetchFn ?? globalThis.fetch;
+  let cachedToken = null;
+  let expiresAtMs = 0;
+  let inFlight = null;
+  async function refresh() {
+    try {
+      const res = await fetchFn(`${FIREBASE_SECURETOKEN_URL}?key=${encodeURIComponent(apiKey)}`, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: `grant_type=refresh_token&refresh_token=${encodeURIComponent(refreshToken)}`
+      });
+      const text = await res.text();
+      if (res.status < 200 || res.status >= 300) {
+        cachedToken = null;
+        return null;
+      }
+      const parsed = JSON.parse(text);
+      const idToken = typeof parsed.id_token === "string" ? parsed.id_token : "";
+      if (!idToken) {
+        cachedToken = null;
+        return null;
+      }
+      const expiresInSec = Number(parsed.expires_in);
+      const ttlMs = Number.isFinite(expiresInSec) && expiresInSec > 0 ? expiresInSec * 1e3 : 36e5;
+      cachedToken = idToken;
+      expiresAtMs = now() + ttlMs;
+      return idToken;
+    } catch {
+      cachedToken = null;
+      return null;
+    }
+  }
+  return {
+    kind: "firebase-refresh",
+    async getToken() {
+      if (cachedToken && now() < expiresAtMs - REFRESH_SKEW_MS) return cachedToken;
+      if (!inFlight) {
+        inFlight = refresh().finally(() => {
+          inFlight = null;
+        });
+      }
+      return inFlight;
+    }
+  };
+}
+
+// src/cloud/vo-credential-exchange.ts
+async function exchangeForVoCredential(opts) {
+  const base = opts.controlPlaneUrl.replace(/\/+$/, "");
+  if (!base) return null;
+  const fetchFn = opts.fetchFn ?? globalThis.fetch;
+  try {
+    const idToken = await createFirebaseRefreshTokenSource({
+      refreshToken: opts.refreshToken,
+      apiKey: opts.apiKey,
+      ...opts.fetchFn ? { fetchFn: opts.fetchFn } : {}
+    }).getToken();
+    if (!idToken) return null;
+    const res = await fetchFn(`${base}/api/v1/auth/vo-credential`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${idToken}` },
+      body: JSON.stringify(opts.label ? { label: opts.label } : {})
+    });
+    if (res.status !== 200) return null;
+    const parsed = JSON.parse(await res.text());
+    const token = typeof parsed.token === "string" ? parsed.token : "";
+    const expiresAt = typeof parsed.expires_at === "string" ? parsed.expires_at : "";
+    if (!token.startsWith("vocred_") || !expiresAt) return null;
+    return { vo_credential: token, expires_at: expiresAt };
+  } catch {
+    return null;
+  }
+}
+
+// src/autostart.ts
+import { homedir as homedir2, platform } 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";
+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");
+    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);
+    log(`  Backed up existing launcher to: ${backupPath}`);
+  }
+  const launcherContent = `@echo off
+REM Auto-start launcher for vo-mcp runner
+REM Created by vo-mcp autostart installer
+start /min cmd /c "${runnerCommand}"
+`;
+  writeFileSync2(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");
+    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);
+    log(`  Backed up existing plist to: ${backupPath}`);
+  }
+  const parts = runnerCommand.split(/\s+/);
+  const program = parts[0] ?? "vo-mcp";
+  const args = parts.length > 1 ? parts.slice(1) : ["runner"];
+  const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>ai.algosuite.vo-runner</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${program}</string>
+${args.map((a) => `    <string>${a}</string>`).join("\n")}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join2(homedir2(), ".claude", "vo-runner.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join2(homedir2(), ".claude", "vo-runner-error.log")}</string>
+</dict>
+</plist>
+`;
+  writeFileSync2(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")}`);
+  } catch {
+    log(`\u26A0 Failed to load plist with launchctl (you may need to load it manually)`);
+    log(`  Run: launchctl load "${plistPath}"`);
+  }
+}
+async function installAutostart(opts = {}) {
+  const log = opts.log ?? ((m) => console.error(m));
+  const env = opts.env ?? process.env;
+  const runnerCommand = resolveRunnerCommand(opts.runnerCommand);
+  const plat = platform();
+  if (plat === "win32") {
+    installWindowsAutostart(runnerCommand, log, env);
+  } else if (plat === "darwin") {
+    await installMacAutostart(runnerCommand, log);
+  } else {
+    log(`\u2717 Auto-start is not supported on platform: ${plat}`);
+    log(`  Supported platforms: win32 (Windows), darwin (macOS)`);
+  }
+}
+
+// src/install.ts
+function resolveClaudeConfigPath() {
+  const plat = platform2();
+  const codeConfig = join3(homedir3(), ".claude.json");
+  if (existsSync3(codeConfig)) return codeConfig;
+  if (plat === "win32") {
+    const appData = process.env["APPDATA"] ?? join3(homedir3(), "AppData", "Roaming");
+    return join3(appData, "Claude", "claude_desktop_config.json");
+  }
+  if (plat === "darwin") {
+    return join3(homedir3(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  return join3(homedir3(), ".config", "claude", "claude_desktop_config.json");
+}
+function readClaudeConfig(path) {
+  try {
+    if (!existsSync3(path)) return { mcpServers: {} };
+    const raw = readFileSync3(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return { mcpServers: parsed.mcpServers ?? {} };
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+function writeClaudeConfig(path, config) {
+  mkdirSync3(dirname2(path), { recursive: true });
+  writeFileSync3(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function resolveVoMcpCliPath() {
+  const scriptPath = process.argv[1] ?? "";
+  if (scriptPath.includes("install-cli.js") || scriptPath.includes("install-cli")) {
+    return scriptPath.replace(/install-cli\.js$/, "cli.js").replace(/install-cli$/, "cli.js");
+  }
+  return resolve(dirname2(scriptPath), "cli.js");
+}
+function installMcpConfig(log, env) {
+  const configPath = resolveClaudeConfigPath();
+  const existing = readClaudeConfig(configPath);
+  const cliPath = resolveVoMcpCliPath();
+  const voEntry = existing.mcpServers?.["vo"] ?? existing.mcpServers?.["vo-mcp"];
+  if (voEntry && voEntry.args && voEntry.args.some((a) => a.includes("vo-mcp"))) {
+    log(`\u2713 vo-mcp MCP server is already configured at: ${configPath}`);
+    return;
+  }
+  if (existsSync3(configPath)) {
+    const backupPath = `${configPath}.backup-${Date.now()}`;
+    copyFileSync2(configPath, backupPath);
+    log(`  Backed up existing config to: ${backupPath}`);
+  }
+  const controlPlaneUrl = env["VO_CONTROL_PLANE_URL"]?.trim() || DEFAULT_DASHBOARD_URL.replace("vo-dashboard.web.app", "vo-control-plane-bzjphrajaq-uc.a.run.app");
+  const merged = {
+    mcpServers: {
+      ...existing.mcpServers,
+      "vo-mcp": {
+        command: "node",
+        args: [cliPath],
+        env: {
+          VO_CONTROL_PLANE_URL: controlPlaneUrl
+        }
+      }
+    }
+  };
+  writeClaudeConfig(configPath, merged);
+  log(`\u2713 Wrote vo-mcp MCP server config to: ${configPath}`);
+}
+async function runLoginFlow(log, env) {
+  log("\n\u2501\u2501\u2501 Step 2: Link your Claude account \u2501\u2501\u2501");
+  log("We'll open your browser to sign in, then mint a scoped credential.");
+  log("Your raw token never persists locally (it's exchanged for a vocred_).\n");
+  const controlPlaneUrl = env["VO_CONTROL_PLANE_URL"]?.trim() || "https://vo-control-plane-bzjphrajaq-uc.a.run.app";
+  const exchange = async (refreshToken, apiKey) => {
+    return exchangeForVoCredential({
+      refreshToken,
+      apiKey,
+      controlPlaneUrl,
+      label: `vo-mcp install (${platform2()})`
+    });
+  };
+  try {
+    const result = await runLogin({ env, log, exchange });
+    log(`\u2713 Signed in${result.email ? ` as ${result.email}` : ""}. Credential stored at: ${result.credentialPath}`);
+  } catch (err) {
+    log(`\u2717 Login failed: ${err instanceof Error ? err.message : String(err)}`);
+    log("  You can retry later by running: vo-mcp login");
+    throw err;
+  }
+}
+function printNextSteps(log, autostartInstalled) {
+  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)");
+  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("  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 dashboard to dispatch your first agent:");
+  log("       https://vo-dashboard.web.app\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");
+}
+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");
+  installMcpConfig(log, env);
+  if (!opts.skipLogin) {
+    await runLoginFlow(log, env);
+  } else {
+    log("\n(Login skipped \u2014 run `vo-mcp login` manually when ready.)");
+  }
+  let autostartInstalled = false;
+  if (!opts.skipAutostart) {
+    const plat = platform2();
+    if (plat === "win32" || plat === "darwin") {
+      log("\n\u2501\u2501\u2501 Step 3: Set up auto-start \u2501\u2501\u2501");
+      log("Would you like the runner daemon to start automatically at login?");
+      log("(You can skip this and set it up later with: vo-mcp runner --install-autostart)\n");
+      await installAutostart({ log, env });
+      autostartInstalled = true;
+    }
+  }
+  printNextSteps(log, autostartInstalled);
+}
+
+// src/install-cli.ts
+install().catch((err) => {
+  console.error("[vo-mcp install] fatal:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=install-cli.js.map