agentic-relay 3.8.0

package/bin/install.mjs

@@ -0,0 +1,887 @@
+#!/usr/bin/env node
+
+/**
+ * Agent Relay Installer v3 — multi-agent (skill, MCP, deeplink modes)
+ *
+ * Usage:
+ *
+ *   Interactive (human):
+ *     npx agentic-relay
+ *
+ *   Non-interactive (AI agent / scripted):
+ *     npx agentic-relay --all --api-key=am_live_xxx
+ *     npx agentic-relay --target=claude,codex,gemini --api-key=am_live_xxx
+ *     npx agentic-relay --target=cursor,boltai
+ *
+ * Flags:
+ *   --target=a,b,c   Comma-separated list of agent IDs to install (see AGENTS map)
+ *   --all            Install for every Tier 1 + Tier 2 agent (skips manual)
+ *   --project        Also install project-scoped configs (Roo Code) when in a repo
+ *   --api-key=KEY    Set API key non-interactively
+ *   --librechat=PATH Path to librechat.yaml (required for LibreChat install)
+ *
+ * Modes:
+ *   skill            Drop SKILL.md + (if supported) append CLAUDE.md/AGENTS.md
+ *   mcp_json         Idempotent JSON merge of agentrelay entry under {mcpServers|servers}
+ *   mcp_yaml         Idempotent YAML block merge under mcpServers:
+ *   mcp_witsy        Bespoke nested merge inside Witsy's settings.json
+ *   project_roo      Workspace-scoped .roo/mcp.json + .roo/rules/agent-relay.md (needs --project + git repo)
+ *   deeplink         Print URL the agent registers (tome://, raycast://) — user clicks Install
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+import { execSync } from "child_process";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HOME = homedir();
+
+const SECTION_START = "# Agent Relay MCP Server";
+const CREDENTIALS_PATH = join(HOME, ".config", "agent-relay", "credentials.json");
+const LEGACY_CREDENTIALS_PATH = join(HOME, ".config", "penguin", "credentials.json");
+const SIGNUP_URL = "https://attentionmarket-auth.vercel.app";
+const API_BASE =
+  "https://peruwnbrqkvmrldhpoom.supabase.co/functions/v1/api-v1";
+const MCP_URL = "https://peruwnbrqkvmrldhpoom.supabase.co/functions/v1/mcp";
+const SERVER_NAME = "agent-relay";
+
+// ═══════════════════════════════════════════════════════════════════════
+// Agent matrix
+// ═══════════════════════════════════════════════════════════════════════
+
+// Mode legend:
+//   skill        — drop SKILL.md + optionally append CLAUDE.md content to instructions
+//   mcp_json     — idempotent merge of agentrelay entry into a JSON config
+//   mcp_yaml     — idempotent merge into a YAML config (LibreChat)
+//   mcp_witsy    — Witsy-specific nested merge
+//   project_roo  — workspace-scoped Roo Code (only with --project flag inside a repo)
+//   deeplink     — print URL, optionally `open` it on macOS
+
+const AGENTS = {
+  // ── Tier 1A: skill mode ──────────────────────────────────────────
+  claude: {
+    mode: "skill",
+    label: "Claude Code",
+    skillDir: join(HOME, ".claude", "skills", "agent-relay"),
+    instructionsPath: join(HOME, ".claude", "CLAUDE.md"),
+    detectPath: join(HOME, ".claude"),
+  },
+  codex: {
+    mode: "skill",
+    label: "Codex CLI",
+    skillDir: join(HOME, ".codex", "skills", "agent-relay"),
+    instructionsPath: join(HOME, ".codex", "AGENTS.md"),
+    detectPath: join(HOME, ".codex"),
+  },
+  gemini: {
+    mode: "skill",
+    label: "Gemini CLI",
+    skillDir: join(HOME, ".gemini", "skills", "agent-relay"),
+    instructionsPath: join(HOME, ".gemini", "GEMINI.md"),
+    detectPath: join(HOME, ".gemini"),
+  },
+  goose: {
+    mode: "skill",
+    label: "Goose",
+    skillDir: join(HOME, ".config", "goose", "skills", "agent-relay"),
+    instructionsPath: null,
+    detectPath: join(HOME, ".config", "goose"),
+  },
+  windsurf: {
+    mode: "skill",
+    label: "Windsurf",
+    skillDir: join(HOME, ".codeium", "windsurf", "skills", "agent-relay"),
+    instructionsPath: null,
+    detectPath: join(HOME, ".codeium", "windsurf"),
+  },
+  openclaw: {
+    mode: "skill",
+    label: "OpenClaw",
+    skillDir: join(HOME, ".openclaw", "skills", "agent-relay"),
+    instructionsPath: null,
+    detectPath: join(HOME, ".openclaw"),
+  },
+
+  // ── Tier 1B: MCP JSON mode ───────────────────────────────────────
+  cursor: {
+    mode: "mcp_json",
+    label: "Cursor",
+    configPath: join(HOME, ".cursor", "mcp.json"),
+    schemaKey: "mcpServers",
+    detectPath: join(HOME, ".cursor"),
+  },
+  claude_desktop: {
+    mode: "mcp_json",
+    label: "Claude Desktop",
+    configPath: join(
+      HOME,
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json",
+    ),
+    schemaKey: "mcpServers",
+    detectPath: join(HOME, "Library", "Application Support", "Claude"),
+  },
+  vscode: {
+    mode: "mcp_json",
+    label: "VS Code",
+    configPath: join(
+      HOME,
+      "Library",
+      "Application Support",
+      "Code",
+      "User",
+      "mcp.json",
+    ),
+    schemaKey: "servers", // NOTE: VS Code uses "servers" not "mcpServers"
+    detectPath: join(HOME, "Library", "Application Support", "Code"),
+  },
+  vscode_insiders: {
+    mode: "mcp_json",
+    label: "VS Code Insiders",
+    configPath: join(
+      HOME,
+      "Library",
+      "Application Support",
+      "Code - Insiders",
+      "User",
+      "mcp.json",
+    ),
+    schemaKey: "servers",
+    detectPath: join(HOME, "Library", "Application Support", "Code - Insiders"),
+  },
+  cline: {
+    mode: "mcp_json",
+    label: "Cline",
+    configPath: join(
+      HOME,
+      "Library",
+      "Application Support",
+      "Code",
+      "User",
+      "globalStorage",
+      "saoudrizwan.claude-dev",
+      "settings",
+      "cline_mcp_settings.json",
+    ),
+    schemaKey: "mcpServers",
+    detectPath: join(
+      HOME,
+      "Library",
+      "Application Support",
+      "Code",
+      "User",
+      "globalStorage",
+      "saoudrizwan.claude-dev",
+    ),
+  },
+  boltai: {
+    mode: "mcp_json",
+    label: "BoltAI",
+    configPath: join(HOME, ".boltai", "mcp.json"),
+    schemaKey: "mcpServers",
+    detectPath: join(HOME, ".boltai"),
+  },
+  amazon_q_cli: {
+    mode: "mcp_json",
+    label: "Amazon Q (CLI)",
+    configPath: join(HOME, ".aws", "amazonq", "mcp.json"),
+    schemaKey: "mcpServers",
+    detectPath: join(HOME, ".aws", "amazonq"),
+  },
+  amazon_q_ide: {
+    mode: "mcp_json",
+    label: "Amazon Q (IDE)",
+    configPath: join(HOME, ".aws", "amazonq", "default.json"),
+    schemaKey: "mcpServers",
+    detectPath: join(HOME, ".aws", "amazonq"),
+  },
+
+  // ── Bespoke writers ───────────────────────────────────────────────
+  witsy: {
+    mode: "mcp_witsy",
+    label: "Witsy",
+    configPath: join(HOME, "Library", "Application Support", "Witsy", "settings.json"),
+    detectPath: join(HOME, "Library", "Application Support", "Witsy"),
+  },
+  librechat: {
+    mode: "mcp_yaml",
+    label: "LibreChat",
+    configPath: null, // user-supplied via --librechat=path
+    schemaKey: "mcpServers",
+    detectPath: null,
+  },
+
+  // ── Tier 1C: project-scoped (requires --project + git repo) ──────
+  roo_code: {
+    mode: "project_roo",
+    label: "Roo Code (project)",
+    projectScoped: true,
+    detectPath: null,
+  },
+
+  // ── Tier 2: deeplink ─────────────────────────────────────────────
+  tome: {
+    mode: "deeplink",
+    label: "Tome",
+    deeplink: () =>
+      `tome://mcp/install?config=${encodeURIComponent(
+        JSON.stringify({ mcpServers: { [SERVER_NAME]: { url: MCP_URL } } }),
+      )}`,
+    detectPath: join(HOME, "Library", "Application Support", "Tome"),
+  },
+  raycast: {
+    mode: "deeplink",
+    label: "Raycast",
+    deeplink: () =>
+      // Raycast MCP extension URL — users install/configure via the extension UI.
+      `raycast://extensions/EvanZhouDev/mcp/manage-mcp`,
+    detectPath: join(HOME, "Library", "Application Support", "com.raycast.macos"),
+  },
+};
+
+// Tier 3 (manual) targets are intentionally not in this build per the plan.
+// Will be added in a follow-up release.
+
+// ═══════════════════════════════════════════════════════════════════════
+// Logging helpers
+// ═══════════════════════════════════════════════════════════════════════
+
+const log = (m) => console.log(`\x1b[36m[agent-relay]\x1b[0m ${m}`);
+const success = (m) => console.log(`\x1b[32m[agent-relay]\x1b[0m ${m}`);
+const warn = (m) => console.log(`\x1b[33m[agent-relay]\x1b[0m ${m}`);
+const error = (m) => console.error(`\x1b[31m[agent-relay]\x1b[0m ${m}`);
+
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// CLI args
+// ═══════════════════════════════════════════════════════════════════════
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const flags = {
+    targets: null,
+    all: args.includes("--all"),
+    project: args.includes("--project"),
+    apiKey: null,
+    librechat: null,
+    // Legacy single-flag shortcuts (kept for backward compat)
+    legacyClaude: args.includes("--claude"),
+    legacyCodex: args.includes("--codex"),
+    legacyCursor: args.includes("--cursor"),
+  };
+
+  for (const arg of args) {
+    if (arg.startsWith("--target=")) {
+      flags.targets = arg
+        .slice("--target=".length)
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    } else if (arg.startsWith("--api-key=")) {
+      flags.apiKey = arg.slice("--api-key=".length);
+    } else if (arg.startsWith("--librechat=")) {
+      flags.librechat = arg.slice("--librechat=".length);
+    }
+  }
+
+  // Support `--api-key VALUE` (space-separated) too
+  const keyIdx = args.indexOf("--api-key");
+  if (keyIdx !== -1 && args[keyIdx + 1] && !args[keyIdx + 1].startsWith("--")) {
+    flags.apiKey = args[keyIdx + 1];
+  }
+
+  return flags;
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Skill installer
+// ═══════════════════════════════════════════════════════════════════════
+
+function installSkill(skillContent, instructionsContent, agent) {
+  try {
+    mkdirSync(agent.skillDir, { recursive: true });
+    writeFileSync(join(agent.skillDir, "SKILL.md"), skillContent);
+    success(`${agent.label}: skill → ${agent.skillDir}/SKILL.md`);
+  } catch (err) {
+    warn(`${agent.label}: could not write skill — ${err.message}`);
+  }
+
+  if (agent.instructionsPath) {
+    installInstructions(instructionsContent, agent.instructionsPath, agent.label);
+  }
+}
+
+function installInstructions(instructions, path, label) {
+  try {
+    const dir = dirname(path);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+    const existing = existsSync(path) ? readFileSync(path, "utf-8") : "";
+
+    if (existing.includes(SECTION_START)) {
+      const sectionRegex = new RegExp(
+        `${escapeRegex(SECTION_START)}[\\s\\S]*?(?=\\n# (?!Agent Relay)|\\s*$)`,
+      );
+      writeFileSync(path, existing.replace(sectionRegex, instructions));
+      success(`${label}: instructions updated → ${path}`);
+    } else {
+      const sep = existing.length > 0 ? "\n\n" : "";
+      writeFileSync(path, existing + sep + instructions + "\n");
+      success(`${label}: instructions added → ${path}`);
+    }
+  } catch (err) {
+    warn(`${label}: could not write instructions — ${err.message}`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// MCP JSON installer (handles both `mcpServers` and `servers` keys)
+// ═══════════════════════════════════════════════════════════════════════
+
+function installMcpJson(agent) {
+  try {
+    const dir = dirname(agent.configPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+    let config = {};
+    if (existsSync(agent.configPath)) {
+      try {
+        const raw = readFileSync(agent.configPath, "utf-8").trim();
+        config = raw.length > 0 ? JSON.parse(raw) : {};
+      } catch (parseErr) {
+        warn(`${agent.label}: existing config is not valid JSON — overwriting (${parseErr.message})`);
+        config = {};
+      }
+    }
+
+    const key = agent.schemaKey;
+    if (!config[key] || typeof config[key] !== "object") {
+      config[key] = {};
+    }
+
+    // VS Code's "servers" entries support {type, url} format
+    // Other agents use {url} or {command, args}
+    if (key === "servers") {
+      config[key][SERVER_NAME] = { type: "http", url: MCP_URL };
+    } else {
+      config[key][SERVER_NAME] = { url: MCP_URL };
+    }
+
+    writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + "\n");
+    success(`${agent.label}: MCP server registered → ${agent.configPath}`);
+  } catch (err) {
+    warn(`${agent.label}: could not write MCP config — ${err.message}`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Witsy bespoke installer — settings.json has nested mcp config
+// ═══════════════════════════════════════════════════════════════════════
+
+function installWitsy(agent) {
+  try {
+    const dir = dirname(agent.configPath);
+    if (!existsSync(dir)) {
+      warn(`${agent.label}: not detected (skipping). Install Witsy and run again to configure.`);
+      return;
+    }
+
+    let config = {};
+    if (existsSync(agent.configPath)) {
+      try {
+        config = JSON.parse(readFileSync(agent.configPath, "utf-8"));
+      } catch (parseErr) {
+        warn(`${agent.label}: existing settings.json invalid — skipping (${parseErr.message})`);
+        return;
+      }
+    }
+
+    // Witsy stores MCP servers under config.mcp.servers as an array of {uuid, url, label, ...}
+    // We add a single agentrelay entry, replacing any previous one.
+    if (!config.mcp || typeof config.mcp !== "object") config.mcp = {};
+    if (!Array.isArray(config.mcp.servers)) config.mcp.servers = [];
+
+    // Remove any existing agentrelay entry by label match
+    config.mcp.servers = config.mcp.servers.filter(
+      (s) => !(s && (s.label === SERVER_NAME || s.uuid === SERVER_NAME)),
+    );
+
+    config.mcp.servers.push({
+      uuid: SERVER_NAME,
+      label: SERVER_NAME,
+      type: "http",
+      url: MCP_URL,
+      enabled: true,
+    });
+
+    writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + "\n");
+    success(`${agent.label}: MCP server registered → ${agent.configPath}`);
+  } catch (err) {
+    warn(`${agent.label}: could not write Witsy config — ${err.message}`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// LibreChat YAML installer (line-based block patcher, no YAML lib)
+// ═══════════════════════════════════════════════════════════════════════
+
+function installLibreChat(agent, librechatPath) {
+  if (!librechatPath) {
+    warn(`${agent.label}: needs --librechat=<path> flag pointing to your librechat.yaml`);
+    return;
+  }
+  if (!existsSync(librechatPath)) {
+    warn(`${agent.label}: librechat.yaml not found at ${librechatPath}`);
+    return;
+  }
+
+  try {
+    const yaml = readFileSync(librechatPath, "utf-8");
+    const lines = yaml.split("\n");
+
+    // Build the agentrelay block (2-space indent inside mcpServers:)
+    const relayBlock = [
+      `  ${SERVER_NAME}:`,
+      `    type: streamable-http`,
+      `    url: ${MCP_URL}`,
+    ];
+
+    // Find existing mcpServers: section
+    const mcpIdx = lines.findIndex((l) => /^mcpServers\s*:/.test(l));
+
+    if (mcpIdx === -1) {
+      // No mcpServers section — append a new one at the bottom
+      const trailing = yaml.endsWith("\n") ? "" : "\n";
+      writeFileSync(
+        librechatPath,
+        yaml + trailing + "\n" + "mcpServers:\n" + relayBlock.join("\n") + "\n",
+      );
+      success(`${agent.label}: mcpServers section added → ${librechatPath}`);
+      return;
+    }
+
+    // Find the existing agentrelay entry inside mcpServers
+    let entryStart = -1;
+    let entryEnd = lines.length;
+    for (let i = mcpIdx + 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (/^\S/.test(line) && line.trim()) {
+        // hit a top-level key — end of mcpServers section
+        entryEnd = i;
+        break;
+      }
+      if (new RegExp(`^  ${SERVER_NAME}\\s*:`).test(line)) {
+        entryStart = i;
+        // find end of this entry (next 2-space key or top-level)
+        for (let j = i + 1; j < lines.length; j++) {
+          const ln = lines[j];
+          if (/^\S/.test(ln) && ln.trim()) {
+            entryEnd = j;
+            break;
+          }
+          if (/^  \S/.test(ln) && !/^    /.test(ln)) {
+            entryEnd = j;
+            break;
+          }
+        }
+        break;
+      }
+    }
+
+    let updated;
+    if (entryStart !== -1) {
+      // Replace existing agentrelay entry
+      updated = [
+        ...lines.slice(0, entryStart),
+        ...relayBlock,
+        ...lines.slice(entryEnd),
+      ].join("\n");
+    } else {
+      // Insert agentrelay entry at the start of mcpServers section
+      updated = [
+        ...lines.slice(0, mcpIdx + 1),
+        ...relayBlock,
+        ...lines.slice(mcpIdx + 1),
+      ].join("\n");
+    }
+
+    writeFileSync(librechatPath, updated);
+    success(`${agent.label}: agentrelay entry merged → ${librechatPath}`);
+  } catch (err) {
+    warn(`${agent.label}: could not patch librechat.yaml — ${err.message}`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Roo Code project installer (workspace-scoped)
+// ═══════════════════════════════════════════════════════════════════════
+
+function installRoo(agent, instructionsContent) {
+  let repoRoot;
+  try {
+    repoRoot = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    warn(`${agent.label}: not in a git repo. Run with --project from a repo root.`);
+    return;
+  }
+
+  const rooDir = join(repoRoot, ".roo");
+  const rulesDir = join(rooDir, "rules");
+  try {
+    mkdirSync(rulesDir, { recursive: true });
+
+    // Write .roo/mcp.json
+    const mcpPath = join(rooDir, "mcp.json");
+    let mcpConfig = {};
+    if (existsSync(mcpPath)) {
+      try { mcpConfig = JSON.parse(readFileSync(mcpPath, "utf-8")); } catch {}
+    }
+    if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+    mcpConfig.mcpServers[SERVER_NAME] = { url: MCP_URL };
+    writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2) + "\n");
+
+    // Write .roo/rules/agent-relay.md
+    const rulesPath = join(rulesDir, "agent-relay.md");
+    writeFileSync(rulesPath, instructionsContent + "\n");
+
+    success(`${agent.label}: project config written → ${rooDir}/`);
+  } catch (err) {
+    warn(`${agent.label}: could not write project config — ${err.message}`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Deeplink "installer"
+// ═══════════════════════════════════════════════════════════════════════
+
+function installDeeplink(agent) {
+  const url = agent.deeplink();
+  log(`${agent.label}: open this URL to install Agent Relay in the app:`);
+  console.log(`  \x1b[4m${url}\x1b[0m`);
+
+  // Try to open it on macOS
+  if (process.platform === "darwin") {
+    try {
+      execSync(`open "${url}"`, { stdio: "ignore" });
+      success(`${agent.label}: opened ${agent.label} install URL`);
+    } catch {
+      // ignore — user can click the URL manually
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// API key
+// ═══════════════════════════════════════════════════════════════════════
+
+function saveApiKey(key) {
+  mkdirSync(dirname(CREDENTIALS_PATH), { recursive: true });
+  writeFileSync(
+    CREDENTIALS_PATH,
+    JSON.stringify({ api_key: key }, null, 2) + "\n",
+  );
+  success(`API key saved → ${CREDENTIALS_PATH}`);
+}
+
+function getExistingKey() {
+  // Prefer the new path, but recognise a legacy ~/.config/penguin key too so an
+  // existing user isn't re-prompted (resolveApiKey applies the same fallback).
+  for (const path of [CREDENTIALS_PATH, LEGACY_CREDENTIALS_PATH]) {
+    if (!existsSync(path)) continue;
+    try {
+      const creds = JSON.parse(readFileSync(path, "utf-8"));
+      if (creds.api_key && creds.api_key.startsWith("am_live_")) return creds.api_key;
+    } catch {}
+  }
+  return null;
+}
+
+/**
+ * Link a bare global `agentrelay` command so users skip `npx` after install.
+ * Installs the exact package copy being run (works whether invoked via npx or a
+ * checkout). No-ops if `agentrelay` already resolves; warns + falls back to a
+ * manual instruction if the global prefix isn't writable (EACCES etc.).
+ */
+function linkGlobalCli() {
+  try {
+    execSync("agentrelay version", { stdio: "ignore" });
+    success("`agentrelay` already on your PATH");
+    return;
+  } catch {
+    // not linked yet — proceed to install it
+  }
+  const pkgRoot = join(__dirname, "..");
+  try {
+    execSync(`npm install -g "${pkgRoot}"`, { stdio: "ignore" });
+    success("linked global `agentrelay` CLI");
+  } catch {
+    warn("could not auto-link the global CLI (permissions?). Run once:  npm i -g agentic-relay");
+  }
+}
+
+async function setupApiKeyInteractive() {
+  const existing = getExistingKey();
+  if (existing) {
+    success(`API key already configured (${CREDENTIALS_PATH})`);
+    return true;
+  }
+
+  console.log("");
+  log("API key setup");
+  console.log("");
+  console.log("  Your API key starts with \x1b[1mam_live_\x1b[0m.");
+  console.log(
+    `  Don't have one? Sign up at \x1b[4m${SIGNUP_URL}\x1b[0m (Account tab).`,
+  );
+  console.log("");
+
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    for (;;) {
+      const key = (await rl.question("  Paste your API key: ")).trim();
+      if (key.startsWith("am_live_") && key.length > 20) {
+        saveApiKey(key);
+        return true;
+      }
+      if (key === "" || key.toLowerCase() === "skip") {
+        warn("Skipped API key setup. Agents will prompt you for it later.");
+        return false;
+      }
+      console.log(
+        '  Key should start with "am_live_". Try again, or type "skip" to set it up later.',
+      );
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Verify
+// ═══════════════════════════════════════════════════════════════════════
+
+async function verifyInstall() {
+  const key = getExistingKey();
+  if (!key) return;
+
+  log("Verifying API key…");
+  try {
+    const resp = await fetch(`${API_BASE}/search`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-AM-API-Key": key,
+      },
+      body: JSON.stringify({ query: "test", max_results: 1 }),
+    });
+    const data = await resp.json();
+    if (resp.ok && data.capabilities) {
+      success("API key verified — search is working");
+    } else {
+      warn(`API returned ${resp.status}: ${data.error || "unknown error"}`);
+    }
+  } catch (err) {
+    warn(`Verification failed: ${err.message}`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Detection + interactive selection
+// ═══════════════════════════════════════════════════════════════════════
+
+function detectInstalledAgents() {
+  const installed = [];
+  for (const [id, agent] of Object.entries(AGENTS)) {
+    if (agent.projectScoped) continue; // skip project-only agents
+    if (!agent.detectPath) continue;
+    if (existsSync(agent.detectPath)) installed.push(id);
+  }
+  return installed;
+}
+
+async function selectTargetsInteractive() {
+  const installed = detectInstalledAgents();
+  const allIds = Object.keys(AGENTS).filter((id) => !AGENTS[id].projectScoped);
+
+  console.log("  Detected installed agents (will install Agent Relay in these by default):");
+  if (installed.length === 0) {
+    console.log("    \x1b[33m(none detected)\x1b[0m");
+  } else {
+    installed.forEach((id) => console.log(`    • ${AGENTS[id].label}`));
+  }
+  console.log("");
+
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const ans = (
+      await rl.question(
+        "  Press ENTER to install for detected agents, or type comma-separated IDs (or 'all'): ",
+      )
+    )
+      .trim()
+      .toLowerCase();
+
+    if (!ans) {
+      if (installed.length > 0) return installed;
+      // Nothing detected — show full list and re-prompt
+      console.log("");
+      console.log("  Available agent IDs:");
+      allIds.forEach((id) =>
+        console.log(`    ${id.padEnd(18)} ${AGENTS[id].label}`),
+      );
+      console.log("");
+      const ans2 = (
+        await rl.question("  Type comma-separated IDs (or 'all'): ")
+      ).trim().toLowerCase();
+      if (ans2 === "all") return allIds;
+      return ans2.split(",").map((s) => s.trim()).filter((s) => AGENTS[s]);
+    }
+
+    if (ans === "all") return allIds;
+    return ans.split(",").map((s) => s.trim()).filter((s) => AGENTS[s]);
+  } finally {
+    rl.close();
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Main
+// ═══════════════════════════════════════════════════════════════════════
+
+async function main() {
+  console.log("");
+  console.log("  \x1b[1mAgent Relay Installer\x1b[0m");
+  console.log(
+    "  AI-native search for software, tools, services & business solutions",
+  );
+  console.log("");
+
+  const flags = parseArgs();
+
+  // Resolve targets
+  let targets = [];
+  if (flags.all) {
+    targets = Object.keys(AGENTS).filter((id) => !AGENTS[id].projectScoped);
+    if (flags.project) {
+      // include project-scoped only when --project is also set
+      targets.push(...Object.keys(AGENTS).filter((id) => AGENTS[id].projectScoped));
+    }
+  } else if (flags.targets && flags.targets.length > 0) {
+    targets = flags.targets.filter((id) => {
+      if (!AGENTS[id]) {
+        warn(`Unknown agent id: ${id}`);
+        return false;
+      }
+      return true;
+    });
+  } else if (flags.legacyClaude || flags.legacyCodex || flags.legacyCursor) {
+    if (flags.legacyClaude) targets.push("claude");
+    if (flags.legacyCodex) targets.push("codex");
+    if (flags.legacyCursor) targets.push("cursor");
+  } else {
+    targets = await selectTargetsInteractive();
+  }
+
+  if (!targets || targets.length === 0) {
+    error("No agents selected. Exiting.");
+    process.exit(1);
+  }
+
+  log(
+    `Installing for: ${targets.map((t) => AGENTS[t]?.label || t).join(", ")}`,
+  );
+  console.log("");
+
+  // Load bundled files
+  const skillContent = readFileSync(
+    join(__dirname, "..", "skill", "SKILL.md"),
+    "utf-8",
+  );
+  const instructionsContent = readFileSync(
+    join(__dirname, "..", "CLAUDE.md"),
+    "utf-8",
+  ).trim();
+
+  // Run handlers per target
+  for (const id of targets) {
+    const agent = AGENTS[id];
+    if (!agent) continue;
+
+    switch (agent.mode) {
+      case "skill":
+        installSkill(skillContent, instructionsContent, agent);
+        break;
+      case "mcp_json":
+        installMcpJson(agent);
+        break;
+      case "mcp_witsy":
+        installWitsy(agent);
+        break;
+      case "mcp_yaml":
+        installLibreChat(agent, flags.librechat);
+        break;
+      case "project_roo":
+        if (!flags.project) {
+          warn(`${agent.label}: pass --project to install project-scoped config`);
+          break;
+        }
+        installRoo(agent, instructionsContent);
+        break;
+      case "deeplink":
+        installDeeplink(agent);
+        break;
+      default:
+        warn(`${agent.label}: unknown mode ${agent.mode}`);
+    }
+  }
+
+  // API key
+  console.log("");
+  if (flags.apiKey) {
+    if (flags.apiKey.startsWith("am_live_") && flags.apiKey.length > 20) {
+      saveApiKey(flags.apiKey);
+    } else {
+      error(`Invalid API key format: "${flags.apiKey}". Must start with "am_live_".`);
+    }
+  } else {
+    await setupApiKeyInteractive();
+  }
+
+  await verifyInstall();
+
+  // Put a bare `agentrelay` command on PATH so users don't need npx every time.
+  console.log("");
+  linkGlobalCli();
+
+  console.log("");
+  success("Done! Agent Relay is installed.");
+  console.log("");
+  console.log(
+    "  Your agents will now search Agent Relay before web search or training knowledge.",
+  );
+  console.log("");
+  console.log(`  Try it:       agentrelay search "weather api"`);
+  console.log(`  API key:      ${CREDENTIALS_PATH}`);
+  console.log("");
+  log(
+    "For MCP-based agents, you may need to authenticate once via the agent's MCP console.",
+  );
+  console.log("");
+}
+
+main().catch((err) => {
+  error(`Install failed: ${err.message}`);
+  process.exit(1);
+});