@synap-core/eve 0.1.0

package/dist/chunk-MUEQNBE6.js

@@ -0,0 +1,1140 @@
+import { createRequire as __eveCreateRequire } from 'module'; const require = __eveCreateRequire(import.meta.url);
+import {
+  materializeTargets,
+  normalizeBareDomain
+} from "./chunk-YQWV5W4U.js";
+import {
+  runBrainInit,
+  runInferenceInit
+} from "./chunk-22RIHU4J.js";
+import {
+  installDashboardContainer,
+  runLegsProxySetup,
+  verifyComponent
+} from "./chunk-23XQDB7K.js";
+import {
+  resolveSynapDelegate
+} from "./chunk-HVJEW7TU.js";
+import {
+  entityStateManager
+} from "./chunk-5TBV2VHZ.js";
+import {
+  COMPONENTS,
+  resolveComponent
+} from "./chunk-O5WTCVMZ.js";
+import {
+  readEveSecrets,
+  writeEveSecrets
+} from "./chunk-T7GCAJK5.js";
+
+// src/commands/add.ts
+import { execa } from "execa";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { existsSync } from "fs";
+import { join } from "path";
+import { select, text, isCancel, cancel } from "@clack/prompts";
+
+// src/lib/ui.ts
+import chalk from "chalk";
+import boxen from "boxen";
+var colors = {
+  primary: chalk.hex("#6366f1"),
+  success: chalk.green,
+  warning: chalk.yellow,
+  error: chalk.red,
+  info: chalk.blue,
+  muted: chalk.gray,
+  brain: chalk.hex("#f59e0b"),
+  arms: chalk.green,
+  builder: chalk.blue,
+  eyes: chalk.magenta,
+  legs: chalk.cyan
+};
+var emojis = {
+  brain: "\u{1F9E0}",
+  arms: "\u{1F9BE}",
+  builder: "\u{1F3D7}\uFE0F",
+  eyes: "\u{1F441}\uFE0F",
+  legs: "\u{1F9BF}",
+  entity: "\u{1F33F}",
+  success: "\u2705",
+  error: "\u274C",
+  warning: "\u26A0\uFE0F",
+  info: "\u2139\uFE0F",
+  sparkles: "\u2728",
+  check: "\u2713",
+  cross: "\u2717",
+  bullet: "\u2022"
+};
+var CLEAR_LINE = "\r\x1B[2K";
+function createSpinner(text2) {
+  let interval;
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let i = 0;
+  return {
+    start() {
+      process.stdout.write(`${CLEAR_LINE}${colors.info(`${frames[0]} ${text2}`)}`);
+      interval = setInterval(() => {
+        process.stdout.write(`${CLEAR_LINE}${colors.info(`${frames[i]} ${text2}`)}`);
+        i = (i + 1) % frames.length;
+      }, 80);
+    },
+    succeed(msg) {
+      clearInterval(interval);
+      console.log(`${CLEAR_LINE}${colors.success(`${emojis.check} ${msg || text2}`)}`);
+    },
+    fail(msg) {
+      clearInterval(interval);
+      console.log(`${CLEAR_LINE}${colors.error(`${emojis.cross} ${msg || text2}`)}`);
+    },
+    warn(msg) {
+      clearInterval(interval);
+      console.log(`${CLEAR_LINE}${colors.warning(`${emojis.warning} ${msg || text2}`)}`);
+    }
+  };
+}
+function printHeader(title, emoji) {
+  console.log();
+  console.log(colors.primary.bold(`${emoji ? emoji + " " : ""}${title}`));
+  console.log(colors.primary("\u2500".repeat(title.length + (emoji ? 2 : 0))));
+}
+function printSuccess(message) {
+  console.log(colors.success(`${emojis.success} ${message}`));
+}
+function printError(message) {
+  console.log(colors.error(`${emojis.error} ${message}`));
+}
+function printWarning(message) {
+  console.log(colors.warning(`${emojis.warning} ${message}`));
+}
+function printInfo(message) {
+  console.log(colors.info(`${emojis.info} ${message}`));
+}
+function printKeyValue(key, value, keyWidth = 20) {
+  const paddedKey = key.padEnd(keyWidth);
+  console.log(`${colors.muted(paddedKey)} ${value}`);
+}
+function formatOrgan(organ) {
+  const organColors = {
+    brain: colors.brain,
+    arms: colors.arms,
+    builder: colors.builder,
+    eyes: colors.eyes,
+    legs: colors.legs
+  };
+  const color = organColors[organ] || colors.info;
+  const emoji = emojis[organ] || emojis.bullet;
+  return color(`${emoji} ${organ.charAt(0).toUpperCase() + organ.slice(1)}`);
+}
+function printBox(title, lines) {
+  const body = lines.join("\n");
+  console.log(
+    boxen(`${colors.primary.bold(title)}
+
+${body}`, {
+      padding: 1,
+      margin: { top: 0, bottom: 1, left: 0, right: 0 },
+      borderStyle: "round",
+      borderColor: "#6366f1"
+    })
+  );
+}
+
+// src/commands/add.ts
+var execFileAsync = promisify(execFile);
+async function containerExists(name) {
+  try {
+    const { stdout } = await execFileAsync(
+      "docker",
+      ["ps", "-a", "--filter", `name=^${name}$`, "--format", "{{.Names}}"],
+      { timeout: 4e3 }
+    );
+    return stdout.trim() === name;
+  } catch {
+    return false;
+  }
+}
+async function findSynapComposeContainer(service) {
+  try {
+    const { stdout } = await execFileAsync(
+      "docker",
+      [
+        "ps",
+        "--filter",
+        "label=com.docker.compose.project=synap-backend",
+        "--filter",
+        `label=com.docker.compose.service=${service}`,
+        "--format",
+        "{{.Names}}"
+      ],
+      { timeout: 4e3 }
+    );
+    return stdout.trim().split("\n")[0]?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function findSynapBackendContainer() {
+  return findSynapComposeContainer("backend");
+}
+function hasCanonicalSynapDeployment() {
+  const delegate = resolveSynapDelegate();
+  return Boolean(delegate && existsSync(join(delegate.deployDir, ".env")));
+}
+async function reportExistingSynapDeployment() {
+  const delegate = resolveSynapDelegate();
+  if (!delegate || !hasCanonicalSynapDeployment()) return false;
+  const [backend, podAdmin] = await Promise.all([
+    findSynapComposeContainer("backend"),
+    findSynapComposeContainer("pod-admin")
+  ]);
+  printWarning(`Synap Data Pod is already installed at ${delegate.repoRoot}.`);
+  if (backend && podAdmin) {
+    await entityStateManager.updateComponentEntry("synap", { state: "ready" });
+    printInfo(`  Backend (${backend}) and Pod Admin (${podAdmin}) are running.`);
+  } else {
+    await entityStateManager.updateComponentEntry("synap", { state: "error" });
+    const missing = [!backend && "backend", !podAdmin && "pod-admin"].filter(Boolean).join(", ");
+    printWarning(`  Pod service${missing.includes(",") ? "s" : ""} not running: ${missing}.`);
+    printInfo("  Eve will not reinstall the Pod or replace its identity.");
+    printInfo("  Recover it with: eve update synap");
+  }
+  return true;
+}
+async function findSynapPostgresContainer() {
+  try {
+    const { stdout } = await execFileAsync(
+      "docker",
+      [
+        "ps",
+        "--filter",
+        "label=com.docker.compose.service=postgres",
+        "--filter",
+        "ancestor=postgres",
+        "--format",
+        "{{.Names}}"
+      ],
+      { timeout: 4e3 }
+    );
+    return stdout.trim().split("\n")[0]?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function isBrainReady() {
+  const state = await entityStateManager.getState();
+  if (state.organs.brain.state === "ready") return true;
+  const container = await findSynapBackendContainer();
+  if (!container) return false;
+  printInfo(`Synap container (${container}) is running \u2014 reconciling state to ready.`);
+  await entityStateManager.updateOrgan("brain", "ready");
+  return true;
+}
+async function addTraefik() {
+  await runLegsProxySetup({ standalone: true });
+}
+async function addSynap() {
+  const flags = process.argv.slice(2);
+  const flagRepoIdx = flags.indexOf("--synap-repo");
+  const flagRepo = flagRepoIdx >= 0 ? flags[flagRepoIdx + 1] : void 0;
+  const envRepo = process.env.SYNAP_REPO_ROOT;
+  const delegate = resolveSynapDelegate();
+  const repoRoot = flagRepo || envRepo || delegate?.repoRoot;
+  if (!repoRoot || !existsSync(repoRoot)) {
+    printWarning(
+      `Synap installation requires a synap-backend checkout.
+  Pass --synap-repo <path>, set SYNAP_REPO_ROOT, or clone to /opt/synap-backend.
+  See: https://github.com/synap/synap-backend`
+    );
+    process.exit(1);
+  }
+  const secrets = await readEveSecrets(process.env.EVE_HOME ?? process.cwd()).catch(() => null);
+  const flagDomainIdx = flags.indexOf("--domain");
+  const flagDomain = flagDomainIdx >= 0 ? flags[flagDomainIdx + 1] : void 0;
+  const domain = normalizeBareDomain(flagDomain) || normalizeBareDomain(secrets?.domain?.primary) || "localhost";
+  const email = process.env.LETSENCRYPT_EMAIL?.trim() || secrets?.domain?.email?.trim() || (domain !== "localhost" ? `noreply@${domain}` : void 0);
+  await runBrainInit({
+    synapRepo: repoRoot,
+    domain,
+    email,
+    adminBootstrapMode: "token",
+    withAi: false,
+    withOpenclaw: false,
+    withRsshub: false
+  });
+}
+async function addOllama(model) {
+  await runInferenceInit({ model, withGateway: true, internalOllamaOnly: true });
+}
+async function addOpenclaw() {
+  if (!await isBrainReady()) {
+    printError("Brain is not ready. Please install Synap first: `eve add synap`");
+    process.exit(1);
+  }
+  const synapScript = process.env.SYNAP_SETUP_SCRIPT;
+  if (synapScript && existsSync(synapScript)) {
+    await execa("bash", [synapScript, "profiles", "enable", "openclaw"], {
+      env: { ...process.env, SYNAP_DEPLOY_DIR: process.env.SYNAP_DEPLOY_DIR || "", SYNAP_ASSUME_YES: "1" },
+      stdio: "inherit"
+    });
+    await execa("bash", [synapScript, "services", "add", "openclaw"], {
+      env: { ...process.env, SYNAP_DEPLOY_DIR: process.env.SYNAP_DEPLOY_DIR || "", SYNAP_ASSUME_YES: "1" },
+      stdio: "inherit"
+    });
+  } else {
+    printWarning("OpenClaw add via Synap delegate not available.");
+    printInfo("  Set SYNAP_SETUP_SCRIPT to point to synap-backend/setup.sh for auto-provisioning.");
+    printInfo("  Otherwise install OpenClaw manually: https://github.com/danielmiessler/openclaw");
+  }
+}
+async function applyNangoConnectUiPolyfill(originalDockerRunArgs) {
+  const hostPath = "/opt/nango/connect-ui-index.html";
+  const containerPath = "/app/nango/packages/connect-ui/dist/index.html";
+  const containerName = "eve-arms-nango";
+  const image = "nangohq/nango-server:hosted";
+  printInfo("Applying setImmediate polyfill to Nango Connect UI...");
+  const extractAndPatch = `
+    const fs = require('fs');
+    const p = '${containerPath}';
+    let h = fs.readFileSync(p, 'utf8');
+    if (h.includes('window.setImmediate = window.setImmediate ||')) {
+      console.log('already patched'); process.exit(0);
+    }
+    const poly = '<script>\\n(function() {\\n' +
+      '  window.setImmediate = window.setImmediate || function(fn) {\\n' +
+      '    var args = Array.prototype.slice.call(arguments, 1);\\n' +
+      '    var id = setTimeout(function() { fn.apply(null, args); }, 0);\\n' +
+      '    return { _id: id, type: \\'Immediate\\' };\\n' +
+      '  };\\n' +
+      '  window.clearImmediate = window.clearImmediate || function(h) { clearTimeout(h && h._id !== undefined ? h._id : h); };\\n' +
+      '})();\\n' +
+      '<\\/script>';
+    // Insert as first element in <head> so it runs before any module scripts
+    h = h.replace('<head>', '<head>\\n' + poly);
+    fs.writeFileSync(p, h);
+    console.log('patched ok');
+  `.trim();
+  const tmpContainer = "eve-nango-polyfill-tmp";
+  try {
+    await execFileAsync("docker", ["rm", "-f", tmpContainer], { timeout: 1e4 }).catch(() => {
+    });
+    await execFileAsync("docker", ["create", "--name", tmpContainer, image], { timeout: 15e3 });
+    await execFileAsync("docker", ["exec", tmpContainer, "node", "-e", extractAndPatch], { timeout: 15e3 });
+    await execFileAsync("sh", ["-c", `mkdir -p "$(dirname ${hostPath})"`], { timeout: 5e3 }).catch(() => {
+    });
+    await execFileAsync("docker", ["cp", `${tmpContainer}:${containerPath}`, hostPath], { timeout: 1e4 });
+    await execFileAsync("docker", ["rm", "-f", tmpContainer], { timeout: 1e4 }).catch(() => {
+    });
+  } catch (err) {
+    printWarning(`  Could not patch via temp container: ${err.message}`);
+    try {
+      await execFileAsync("docker", ["exec", containerName, "node", "-e", extractAndPatch], { timeout: 15e3 });
+      await execFileAsync("docker", ["cp", `${containerName}:${containerPath}`, hostPath], { timeout: 1e4 });
+    } catch (err2) {
+      printWarning(`  Fallback also failed: ${err2.message}`);
+      return;
+    }
+  }
+  printInfo("  Recreating container with polyfill volume mount...");
+  await execFileAsync("docker", ["rm", "-f", containerName], { timeout: 1e4 }).catch(() => {
+  });
+  const newArgs = [
+    ...originalDockerRunArgs,
+    "-v",
+    `${hostPath}:${containerPath}:ro`
+  ];
+  await execFileAsync("docker", newArgs, { timeout: 3e4 });
+  printInfo("  Container recreated \u2014 polyfill is now permanent.");
+}
+async function nangoAutoSignup(secretKey, ownerEmail) {
+  const email = ownerEmail ?? "admin@eve.local";
+  const pw = `Nango_${secretKey.slice(0, 12)}`;
+  const node = `
+    const attempt = (n) => fetch('http://127.0.0.1:3003/api/v1/account/signup', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'Admin', email: ${JSON.stringify(email)}, password: ${JSON.stringify(pw)} }),
+    }).then(r => r.json()).then(d => {
+      const code = d?.error?.code ?? d?.error;
+      if (d?.data?.uuid || code === 'account_already_exists' || code === 'email_not_verified') process.exit(0);
+      if (n > 0) setTimeout(() => attempt(n - 1), 2000); else process.exit(1);
+    }).catch(() => { if (n > 0) setTimeout(() => attempt(n - 1), 2000); else process.exit(1); });
+    attempt(15);
+  `;
+  await execFileAsync("docker", ["exec", "eve-arms-nango", "node", "-e", node], { timeout: 4e4 }).catch(() => {
+  });
+  const pgContainer = await findSynapPostgresContainer();
+  if (pgContainer) {
+    await execFileAsync("docker", [
+      "exec",
+      pgContainer,
+      "psql",
+      "-U",
+      "synap",
+      "-d",
+      "nango",
+      "-c",
+      `UPDATE nango._nango_users SET email_verified = true WHERE email = '${email}';`
+    ], { timeout: 1e4 }).catch(() => {
+    });
+  }
+  const fetchEnvKey = `
+    const signin = await fetch('http://127.0.0.1:3003/api/v1/account/signin', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email: ${JSON.stringify(email)}, password: ${JSON.stringify(pw)} }),
+    }).then(r => r.json()).catch(() => null);
+    const token = signin?.data?.token;
+    if (!token) { process.stdout.write(''); process.exit(0); }
+    const env = await fetch('http://127.0.0.1:3003/api/v1/environment', {
+      headers: { Authorization: 'Bearer ' + token },
+    }).then(r => r.json()).catch(() => null);
+    const key = env?.data?.secret_key ?? env?.secret_key ?? '';
+    process.stdout.write(key);
+  `;
+  try {
+    const { stdout } = await execFileAsync("docker", ["exec", "eve-arms-nango", "node", "--input-type=module", "-e", fetchEnvKey], { timeout: 15e3 });
+    const envKey = stdout.trim();
+    if (envKey && envKey.length > 10) {
+      printInfo(`  Nango environment secret key retrieved: ${envKey.slice(0, 8)}...`);
+      return envKey;
+    }
+  } catch {
+  }
+  return null;
+}
+async function addNango() {
+  if (!await isBrainReady()) {
+    printError("Brain is not ready. Install Synap first: `eve add synap`");
+    process.exit(1);
+  }
+  const { randomUUID } = await import("crypto");
+  const { readFile, writeFile } = await import("fs/promises");
+  const { existsSync: existsSync2 } = await import("fs");
+  const { join: pathJoin } = await import("path");
+  const secrets = await readEveSecrets(process.cwd()).catch(() => null);
+  const existingKey = secrets?.connectors?.nango?.secretKey;
+  const uuidV4Re = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  const secretKey = existingKey && uuidV4Re.test(existingKey) ? existingKey : randomUUID();
+  const _autoDetectDeployDir = async () => {
+    const container = await findSynapBackendContainer();
+    if (!container) return null;
+    try {
+      const { stdout } = await execFileAsync("docker", [
+        "inspect",
+        container,
+        "--format",
+        '{{index .Config.Labels "com.docker.compose.project.working_dir"}}'
+      ], { timeout: 4e3 });
+      const dir = stdout.trim();
+      return dir || null;
+    } catch {
+      return null;
+    }
+  };
+  const deployDir = process.env.SYNAP_DEPLOY_DIR || (existsSync2("/opt/synap-backend/deploy") ? "/opt/synap-backend/deploy" : null) || await _autoDetectDeployDir();
+  let podPublicUrl = "";
+  let pgUser = "synap";
+  let pgPassword = "synap";
+  if (deployDir) {
+    const { readFile: rf } = await import("fs/promises");
+    const envPath = pathJoin(deployDir, ".env");
+    try {
+      const envContent = await rf(envPath, "utf8");
+      const matchUrl = envContent.match(/^PUBLIC_URL=(.+)$/m);
+      if (matchUrl?.[1]) podPublicUrl = matchUrl[1].trim();
+      const matchUser = envContent.match(/^POSTGRES_USER=(.+)$/m);
+      if (matchUser?.[1]) pgUser = matchUser[1].trim();
+      const matchPass = envContent.match(/^POSTGRES_PASSWORD=(.+)$/m);
+      if (matchPass?.[1]) pgPassword = matchPass[1].trim();
+    } catch {
+    }
+  }
+  const postgresContainer = await findSynapPostgresContainer();
+  if (!postgresContainer) {
+    printWarning("  Could not find synap-backend postgres container \u2014 skipping database creation.");
+  } else {
+    printInfo(`Creating Nango database in ${postgresContainer}...`);
+    try {
+      await execFileAsync("docker", [
+        "exec",
+        postgresContainer,
+        "psql",
+        "-U",
+        pgUser,
+        "-c",
+        "CREATE DATABASE nango;"
+      ], { timeout: 1e4 });
+    } catch {
+    }
+    try {
+      await execFileAsync("docker", [
+        "network",
+        "connect",
+        "--alias",
+        "eve-brain-postgres",
+        "eve-network",
+        postgresContainer
+      ], { timeout: 1e4 });
+      printInfo(`  Connected ${postgresContainer} to eve-network as eve-brain-postgres.`);
+    } catch {
+    }
+  }
+  printInfo("Pulling nangohq/nango-server:hosted...");
+  await execFileAsync("docker", ["pull", "nangohq/nango-server:hosted"], { timeout: 12e4 });
+  const { stdout: runningOut } = await execFileAsync(
+    "docker",
+    ["ps", "--filter", "name=eve-arms-nango", "--format", "{{.Names}}"],
+    { timeout: 4e3 }
+  ).catch(() => ({ stdout: "" }));
+  const alreadyRunning = runningOut.trim().split("\n").includes("eve-arms-nango");
+  const _nangoDomain = secrets?.domain?.primary;
+  const _nangoSsl = secrets?.domain?.ssl !== false;
+  const nangoHost = _nangoDomain ? `${_nangoSsl ? "https" : "http"}://nango.${_nangoDomain}` : "http://eve-arms-nango:3003";
+  const connectUrl = _nangoDomain ? `${_nangoSsl ? "https" : "http"}://connect.${_nangoDomain}` : "";
+  if (!alreadyRunning) {
+    await execFileAsync("docker", ["rm", "-f", "eve-arms-nango"], { timeout: 1e4 }).catch(() => {
+    });
+    const { createHash } = await import("crypto");
+    const nangoEncryptionKey = createHash("sha256").update(secretKey).digest("base64");
+    const dockerRunArgs = [
+      "run",
+      "-d",
+      "--name",
+      "eve-arms-nango",
+      "--network",
+      "eve-network",
+      "--restart",
+      "unless-stopped",
+      "-e",
+      `NANGO_SECRET_KEY=${secretKey}`,
+      // Self-hosted Nango authenticates Bearer tokens via NANGO_SECRET_KEY_<envname> env vars,
+      // NOT via the api_secrets DB table. Setting these makes our secretKey the API key for
+      // both the prod and dev environments created during account signup.
+      "-e",
+      `NANGO_SECRET_KEY_PROD=${secretKey}`,
+      "-e",
+      `NANGO_SECRET_KEY_DEV=${secretKey}`,
+      // Required by @nangohq/keystore for AES encryption of session tokens — throws without it.
+      "-e",
+      `NANGO_ENCRYPTION_KEY=${nangoEncryptionKey}`,
+      "-e",
+      "SERVER_PORT=3003",
+      "-e",
+      `NANGO_DATABASE_URL=postgresql://${pgUser}:${pgPassword}@eve-brain-postgres:5432/nango`,
+      "-e",
+      "NODE_ENV=production",
+      "-e",
+      "NANGO_EMAIL_ACCOUNT_VERIFICATION_REQUIRED=false",
+      "-e",
+      "FLAG_SERVE_CONNECT_UI=true",
+      "-e",
+      "NANGO_CONNECT_UI_PORT=3009",
+      ...nangoHost ? ["-e", `NANGO_SERVER_URL=${nangoHost}`] : [],
+      // NANGO_PUBLIC_CONNECT_URL: read by Nango server to populate env.js connectUrl field
+      // NANGO_CONNECT_URL: read by our NangoConnector to build redirect URLs for the pod backend
+      ...connectUrl ? ["-e", `NANGO_PUBLIC_CONNECT_URL=${connectUrl}`, "-e", `NANGO_CONNECT_URL=${connectUrl}`] : [],
+      ...podPublicUrl ? ["-e", `NANGO_WEBHOOK_URL=${podPublicUrl}/api/connectors/nango-webhook`] : [],
+      "-v",
+      "eve-arms-nango-data:/var/lib/nango",
+      "nangohq/nango-server:hosted"
+    ];
+    printInfo("Starting Nango container...");
+    await execFileAsync("docker", dockerRunArgs, { timeout: 3e4 });
+    await applyNangoConnectUiPolyfill(dockerRunArgs);
+  } else {
+    printInfo("Nango container already running.");
+    printInfo("  View admin credentials:  eve connectors admin");
+    printInfo("  Update admin email:      eve connectors admin --set-email <email>");
+    printInfo("  Change admin password:   eve connectors admin --reset-password");
+  }
+  let ownerEmail;
+  if (!alreadyRunning) {
+    ownerEmail = secrets?.synap?.userSession?.email ?? secrets?.builder?.openwebui?.adminEmail;
+    if (!ownerEmail) {
+      console.log();
+      ownerEmail = await text({
+        message: "Nango admin email (used to sign in to the dashboard)",
+        placeholder: "you@example.com",
+        validate: (v) => v && v.includes("@") ? void 0 : "Enter a valid email address"
+      });
+      if (isCancel(ownerEmail)) {
+        cancel("Setup cancelled.");
+        process.exit(0);
+      }
+    }
+  }
+  let effectiveSecretKey = secretKey;
+  if (!alreadyRunning) {
+    const nangoEnvKey = await nangoAutoSignup(secretKey, ownerEmail);
+    if (nangoEnvKey) effectiveSecretKey = nangoEnvKey;
+    if (nangoEnvKey && nangoEnvKey !== secretKey) {
+      printInfo(`  Using Nango environment key for backend API calls: ${nangoEnvKey.slice(0, 8)}...`);
+    }
+  }
+  if (!podPublicUrl) {
+    printWarning("  PUBLIC_URL not found in deploy/.env \u2014 NANGO_WEBHOOK_URL not set.");
+    printWarning("  After setting PUBLIC_URL, re-run: eve add nango");
+  }
+  await writeEveSecrets({
+    ...secrets ?? {},
+    connectors: {
+      ...secrets?.connectors ?? {},
+      nango: {
+        secretKey: effectiveSecretKey,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        oauthApps: secrets?.connectors?.nango?.oauthApps ?? {}
+      }
+    }
+  }, process.cwd());
+  if (deployDir) {
+    const envPath = pathJoin(deployDir, ".env");
+    let envContent = "";
+    try {
+      envContent = await readFile(envPath, "utf8");
+    } catch {
+    }
+    const setEnvVar = (content, key, value) => {
+      const re = new RegExp(`^${key}=.*$`, "m");
+      const line = `${key}=${value}`;
+      return re.test(content) ? content.replace(re, line) : `${content}
+${line}`;
+    };
+    envContent = setEnvVar(envContent, "NANGO_HOST", "http://eve-arms-nango:3003");
+    envContent = setEnvVar(envContent, "NANGO_SECRET_KEY", effectiveSecretKey);
+    if (connectUrl) envContent = setEnvVar(envContent, "NANGO_CONNECT_URL", connectUrl);
+    await writeFile(envPath, envContent.trimStart(), "utf8");
+    printInfo(`  Wrote NANGO_HOST=${nangoHost} + NANGO_SECRET_KEY${connectUrl ? ` + NANGO_CONNECT_URL=${connectUrl}` : ""} to ${envPath}`);
+    const backendContainer = await findSynapBackendContainer();
+    if (backendContainer) {
+      printInfo(`  Recreating ${backendContainer} to apply NANGO_SECRET_KEY...`);
+      const { stdout: svcOut } = await execFileAsync("docker", [
+        "inspect",
+        backendContainer,
+        "--format",
+        '{{index .Config.Labels "com.docker.compose.service"}}'
+      ], { timeout: 4e3 }).catch(() => ({ stdout: "backend" }));
+      const serviceName = svcOut.trim() || "backend";
+      await execFileAsync("docker", [
+        "compose",
+        "--project-directory",
+        deployDir,
+        "up",
+        "-d",
+        "--no-deps",
+        "--force-recreate",
+        serviceName
+      ], { timeout: 12e4 });
+      printInfo("  Backend recreated with updated env.");
+    } else {
+      printWarning("  Could not find synap-backend container \u2014 run `docker compose up -d --force-recreate backend` in your deploy dir to apply NANGO_SECRET_KEY.");
+    }
+  } else {
+    printWarning("  Could not locate deploy/.env \u2014 set SYNAP_DEPLOY_DIR and rerun to write env vars.");
+    printInfo(`  Add manually: NANGO_HOST=http://eve-arms-nango:3003  NANGO_SECRET_KEY=${secretKey}`);
+  }
+  await materializeTargets(null, ["traefik-routes"]);
+  if (!alreadyRunning) {
+    const adminPw = `Nango_${secretKey.slice(0, 12)}`;
+    printSuccess("Nango installed.");
+    printInfo(`  Dashboard: ${nangoHost}`);
+    printInfo(`  Admin email: ${ownerEmail ?? "admin@eve.local"}`);
+    printInfo(`  Admin password: ${adminPw}`);
+    printInfo('  Email verification is bypassed \u2014 sign in directly, do not use the "sign up" link.');
+  } else {
+    printSuccess("Nango is running.");
+    printInfo(`  Dashboard: ${nangoHost}`);
+    printInfo("  Manage your account:  eve connectors admin");
+  }
+  console.log();
+  printInfo("  Next: register an OAuth app so users can connect their accounts:");
+  printInfo("    eve connectors setup google     # or github, notion, slack, linear");
+  printInfo('  Until a provider is set up, `synap connect <provider>` returns "Integration does not exist".');
+}
+async function addRsshub() {
+  if (!await isBrainReady()) {
+    printError("Brain is not ready. Please install Synap first: `eve add synap`");
+    process.exit(1);
+  }
+  const { RSSHubService } = await import("./dist-2VRFSXMO.js");
+  const rsshub = new RSSHubService();
+  if (await rsshub.isInstalled()) {
+    printInfo("RSSHub is already installed. Use `eve eyes:start` to start it.");
+    return;
+  }
+  await rsshub.install({ port: 1200 });
+  await entityStateManager.updateOrgan("eyes", "ready");
+  printSuccess("RSSHub installed successfully!");
+  printInfo("  URL: http://localhost:1200");
+}
+async function runAdd(componentId, opts = {}) {
+  const comp = resolveComponent(componentId);
+  if (componentId === "synap" && await reportExistingSynapDeployment()) {
+    return;
+  }
+  const existing = await entityStateManager.isComponentInstalled(componentId);
+  if (existing) {
+    printWarning(`${comp.label} is already installed.`);
+    const statusCmd = comp.organ ? `eve ${comp.organ} status` : "eve status";
+    printInfo(`  Run "${statusCmd}" to check its state.`);
+    const containerName = comp.service?.containerName;
+    if (containerName && !await containerExists(containerName)) {
+      printWarning(`  \u2026but the ${containerName} container is missing. Reinstalling...`);
+      await entityStateManager.updateComponentEntry(componentId, { state: "error" });
+    } else {
+      printInfo(`  Or "eve update ${componentId}" to pull the latest image.`);
+      return;
+    }
+  }
+  const currentComponents = await entityStateManager.getInstalledComponents();
+  const missingDeps = (comp.requires ?? []).filter((dep) => !currentComponents.includes(dep));
+  if (missingDeps.length > 0) {
+    const depNames = missingDeps.map((dep) => {
+      const info = COMPONENTS.find((c) => c.id === dep);
+      return info ? info.label : dep;
+    });
+    printError(`Missing prerequisites: ${depNames.join(", ")}`);
+    printInfo(`  Install them first: ${missingDeps.map((d) => `eve add ${d}`).join(" / ")}`);
+    process.exit(1);
+  }
+  if (opts.synapRepo) {
+    process.env.SYNAP_REPO_ROOT = opts.synapRepo;
+  }
+  printHeader(`Adding ${comp.label}`, comp.emoji);
+  console.log();
+  printInfo(comp.description.split("\n")[0]);
+  console.log();
+  let step;
+  try {
+    step = buildAddStep(comp.id, opts);
+  } catch (err) {
+    printError(String(err));
+    process.exit(1);
+  }
+  const spinner = createSpinner(step.label);
+  spinner.start();
+  try {
+    await step.fn();
+    spinner.succeed(step.label);
+  } catch (err) {
+    spinner.fail(step.label);
+    printError(`Failed to add ${comp.label}: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const verifySpinner = createSpinner(`Verifying ${comp.label} is reachable...`);
+  verifySpinner.start();
+  const verification = await verifyComponent(comp.id);
+  if (verification.ok) {
+    verifySpinner.succeed(verification.summary);
+  } else {
+    verifySpinner.warn(verification.summary);
+    for (const c of verification.checks) {
+      if (!c.ok && c.detail) {
+        printWarning(`  \u2022 ${c.name}: ${c.detail}`);
+      }
+    }
+    printInfo(`  Component installed but not yet responding. Check logs: docker logs ${comp.id}`);
+  }
+  await updateStateAfterAdd(comp.id, verification.ok ? "ready" : "error");
+  const [refresh] = await materializeTargets(null, ["traefik-routes"]);
+  if (refresh?.changed) {
+    printInfo(refresh.summary);
+  } else if (refresh && !refresh.ok) {
+    printWarning(`Could not refresh Traefik routes: ${refresh.error ?? refresh.summary}`);
+  }
+  console.log();
+  printSuccess(`${comp.label} added successfully!`);
+  console.log();
+  printInfo("Next steps:");
+  printInfo(`  - Run "eve status" to check entity state`);
+  if (comp.organ) printInfo(`  - Run "eve ${comp.organ} status" for ${comp.label} status`);
+  if (refresh?.changed) printInfo(`  - Run "eve domain check" to verify routing`);
+  console.log();
+}
+function buildAddStep(componentId, opts) {
+  const model = opts.model || "llama3.1:8b";
+  switch (componentId) {
+    case "traefik":
+      return {
+        label: "Setting up Traefik routing...",
+        fn: addTraefik
+      };
+    case "synap":
+      return {
+        label: "Installing Synap Data Pod...",
+        fn: addSynap
+      };
+    case "ollama":
+      return {
+        label: "Setting up Ollama + AI gateway...",
+        fn: () => addOllama(model)
+      };
+    case "openclaw":
+      return {
+        label: "Installing OpenClaw...",
+        fn: addOpenclaw
+      };
+    case "nango":
+      return {
+        label: "Installing Nango (self-hosted OAuth platform)...",
+        fn: addNango
+      };
+    case "rsshub":
+      return {
+        label: "Installing RSSHub...",
+        fn: addRsshub
+      };
+    case "openwebui": {
+      return {
+        label: "Installing Open WebUI...",
+        async fn() {
+          const { mkdirSync, writeFileSync, existsSync: existsSync2 } = await import("fs");
+          const { join: pathJoin } = await import("path");
+          const { readAgentKeyOrLegacy, readEveSecrets: readEveSecrets2 } = await import("./dist-C2QB4IKT.js");
+          const { randomBytes } = await import("crypto");
+          const { execa: execa2 } = await import("execa");
+          const deployDir = "/opt/openwebui";
+          mkdirSync(deployDir, { recursive: true });
+          const secrets = await readEveSecrets2(process.cwd());
+          const synapApiKey = await readAgentKeyOrLegacy("openwebui-pipelines", process.cwd()) || process.env.SYNAP_API_KEY || "";
+          const isUrl = process.env.SYNAP_IS_URL ?? "http://intelligence-hub:3001";
+          const composeYaml = `# Open WebUI \u2014 generated by Eve CLI
+# Self-contained compose. Joins eve-network so Traefik can route chat.<domain>
+# to this container. Uses SQLite by default (no external DB).
+
+services:
+  openwebui:
+    image: ghcr.io/open-webui/open-webui:main
+    container_name: hestia-openwebui
+    restart: unless-stopped
+    environment:
+      - ENV=production
+      - WEBUI_SECRET_KEY=\${WEBUI_SECRET_KEY:-change-me}
+      - SCARF_NO_ANALYTICS=true
+      - DO_NOT_TRACK=true
+      # Synap IS as the OpenAI-compat backend
+      - ENABLE_OPENAI_API=true
+      - OPENAI_API_BASE_URLS=\${OPENAI_API_BASE_URLS:-http://eve-brain-synap:4000/v1}
+      - OPENAI_API_KEYS=\${OPENAI_API_KEYS:-}
+      # Local Ollama as fallback
+      - OLLAMA_BASE_URL=\${OLLAMA_BASE_URL:-http://eve-brain-ollama:11434}
+      # Features
+      - ENABLE_RAG=true
+      - ENABLE_WEB_SEARCH=true
+      - WEB_SEARCH_ENGINE=duckduckgo
+      - ENABLE_SIGNUP=\${ENABLE_SIGNUP:-true}
+      - DEFAULT_USER_ROLE=\${DEFAULT_USER_ROLE:-user}
+    ports:
+      - "3011:8080"
+    volumes:
+      - openwebui-data:/app/backend/data
+    networks:
+      - eve-network
+
+networks:
+  eve-network:
+    external: true
+
+volumes:
+  openwebui-data:
+`;
+          writeFileSync(pathJoin(deployDir, "docker-compose.yml"), composeYaml);
+          const envPath = pathJoin(deployDir, ".env");
+          if (!existsSync2(envPath)) {
+            writeFileSync(envPath, [
+              "# Open WebUI \u2014 generated by Eve CLI",
+              `SYNAP_API_KEY=${synapApiKey}`,
+              `SYNAP_IS_URL=${isUrl}`,
+              `WEBUI_SECRET_KEY=${randomBytes(32).toString("hex")}`,
+              `OLLAMA_BASE_URL=http://eve-brain-ollama:11434`,
+              `ENABLE_SIGNUP=true`,
+              `DEFAULT_USER_ROLE=user`
+            ].join("\n"), { mode: 384 });
+          }
+          try {
+            await execa2("docker", ["network", "inspect", "eve-network"], { stdio: "ignore" });
+          } catch {
+            await execa2("docker", ["network", "create", "eve-network"], { stdio: "inherit" });
+          }
+          console.log(`  Config: ${deployDir}/docker-compose.yml`);
+          await execa2("docker", ["compose", "up", "-d"], {
+            cwd: deployDir,
+            stdio: "inherit"
+          });
+        }
+      };
+    }
+    case "openwebui-pipelines":
+      return {
+        label: "Installing Open WebUI Pipelines sidecar...",
+        async fn() {
+          const { runActionToCompletion } = await import("./dist-GN2DN7CI.js");
+          const result = await runActionToCompletion("openwebui-pipelines", "install");
+          if (!result.ok) {
+            throw new Error(result.error ?? "Pipelines install failed");
+          }
+          for (const line of result.logs) console.log("  " + line);
+        }
+      };
+    case "eve-dashboard":
+      return {
+        label: "Installing Eve Dashboard...",
+        async fn() {
+          const { randomBytes } = await import("crypto");
+          let secrets = await readEveSecrets(process.cwd());
+          let secret = secrets?.dashboard?.secret;
+          if (!secret) {
+            secret = randomBytes(32).toString("hex");
+            await writeEveSecrets({ dashboard: { secret, port: 7979 } });
+            console.log();
+            console.log(colors.primary.bold("Dashboard key generated \u2014 save this somewhere safe:"));
+            console.log(colors.muted("\u2500".repeat(66)));
+            console.log(colors.primary.bold(secret));
+            console.log(colors.muted("\u2500".repeat(66)));
+          } else {
+            console.log();
+            console.log(colors.muted("Reusing existing dashboard key."));
+          }
+          installDashboardContainer({
+            workspaceRoot: process.cwd(),
+            secret
+          });
+        }
+      };
+    // Thin delegate to the ONE install recipe in @eve/lifecycle — deliberately
+    // NOT a second inline compose string here. `openwebui` has exactly that
+    // (a different YAML in this file from the one lifecycle writes), and the
+    // two have drifted; adding a third copy is how that becomes permanent.
+    case "freellmapi":
+      return {
+        label: "Installing FreeLLMAPI gateway\u2026",
+        async fn() {
+          const { runActionToCompletion } = await import("./dist-GN2DN7CI.js");
+          const result = await runActionToCompletion("freellmapi", "install");
+          if (!result.ok) throw new Error(result.error ?? "FreeLLMAPI install failed");
+          for (const line of result.logs) console.log("  " + line);
+        }
+      };
+    case "hermes":
+      return {
+        label: "Installing Hermes AI agent\u2026",
+        async fn() {
+          const { runActionToCompletion } = await import("./dist-GN2DN7CI.js");
+          const result = await runActionToCompletion("hermes", "install");
+          if (!result.ok) throw new Error(result.error ?? "Hermes install failed");
+          for (const line of result.logs) console.log("  " + line);
+        }
+      };
+    case "dokploy":
+    case "opencode":
+    case "openclaude":
+      return {
+        label: `Installing ${COMPONENTS.find((c) => c.id === componentId)?.label ?? componentId}\u2026`,
+        async fn() {
+          const { runActionToCompletion } = await import("./dist-GN2DN7CI.js");
+          const result = await runActionToCompletion(componentId, "install");
+          if (!result.ok) throw new Error(result.error ?? "Install failed");
+          for (const line of result.logs) console.log("  " + line);
+        }
+      };
+    case "t3code":
+      return {
+        label: "Installing T3 Code server\u2026",
+        async fn() {
+          const { select: clackSelect, text: clackInput, password } = await import("@clack/prompts");
+          const secrets = await readEveSecrets(process.cwd()).catch(() => null);
+          const existing = secrets?.builder?.t3code ?? {};
+          const currentBaseUrl = existing.openaiBaseUrl ?? "";
+          const podApiUrl = secrets?.synap?.apiUrl ? `${secrets.synap.apiUrl}/v1` : "";
+          const isPodIs = currentBaseUrl && podApiUrl && currentBaseUrl === podApiUrl;
+          const currentProvider = isPodIs ? "pod" : currentBaseUrl.includes("openrouter") ? "openrouter" : currentBaseUrl ? "custom" : podApiUrl ? "pod" : "openai";
+          const provider = await clackSelect({
+            message: "AI provider for Codex (T3 Code uses the OpenAI-compatible API)",
+            options: [
+              ...podApiUrl ? [{ value: "pod", label: "Pod IS", hint: `${podApiUrl} \u2014 already configured` }] : [],
+              { value: "openai", label: "OpenAI", hint: "api.openai.com \u2014 official" },
+              { value: "openrouter", label: "OpenRouter", hint: "openrouter.ai \u2014 200+ models, unified key" },
+              { value: "custom", label: "Custom", hint: "Any OpenAI-compatible base URL" }
+            ],
+            initialValue: currentProvider
+          });
+          if (typeof provider !== "string") throw new Error("Cancelled");
+          let openaiBaseUrl = "";
+          if (provider === "pod") {
+            openaiBaseUrl = podApiUrl;
+          } else if (provider === "openrouter") {
+            openaiBaseUrl = "https://openrouter.ai/api/v1";
+          } else if (provider === "custom") {
+            const url = await clackInput({
+              message: "Base URL (e.g. https://my-proxy.example.com/v1)",
+              initialValue: currentBaseUrl,
+              validate: (v) => v.trim() ? void 0 : "URL is required"
+            });
+            if (typeof url !== "string") throw new Error("Cancelled");
+            openaiBaseUrl = url.trim();
+          }
+          const podKey = secrets?.synap?.agentApiKey ?? "";
+          const existingKey = existing.openaiApiKey ?? process.env.OPENAI_API_KEY ?? "";
+          let openaiApiKey = provider === "pod" ? podKey : existingKey;
+          if (!openaiApiKey) {
+            const keyLabel = provider === "openrouter" ? "OpenRouter API key" : "API key";
+            const val = await password({ message: keyLabel });
+            if (typeof val !== "string" || !val.trim()) throw new Error("API key is required");
+            openaiApiKey = val.trim();
+          }
+          await writeEveSecrets({
+            builder: { t3code: { ...existing, openaiApiKey, openaiBaseUrl: openaiBaseUrl || void 0 } }
+          });
+          const { runActionToCompletion } = await import("./dist-GN2DN7CI.js");
+          const result = await runActionToCompletion("t3code", "install");
+          if (!result.ok) throw new Error(result.error ?? "T3 Code install failed");
+          for (const line of result.logs) console.log("  " + line);
+        }
+      };
+    default:
+      throw new Error(`No add handler for component: ${componentId}`);
+  }
+}
+async function updateStateAfterAdd(componentId, finalState = "ready") {
+  const organMap = {
+    synap: "brain",
+    ollama: "brain",
+    openclaw: "arms",
+    hermes: "arms",
+    // Hermes is the primary agent, same organ as OpenClaw
+    rsshub: "eyes",
+    traefik: "legs",
+    openwebui: "eyes",
+    "openwebui-pipelines": "eyes",
+    dokploy: "builder",
+    opencode: "builder",
+    openclaude: "builder",
+    t3code: "builder",
+    "eve-dashboard": "legs"
+  };
+  const organ = organMap[componentId];
+  if (organ) {
+    await entityStateManager.updateOrgan(organ, finalState, { version: "0.1.0" });
+  }
+  await entityStateManager.updateComponentEntry(componentId, {
+    state: finalState,
+    version: "0.1.0",
+    managedBy: "eve"
+  });
+  const current = await entityStateManager.getInstalledComponents();
+  if (!current.includes(componentId)) {
+    await entityStateManager.updateSetupProfile({ components: [...current, componentId] });
+  }
+}
+var BUILDER_OPTIONS = [
+  {
+    id: "opencode",
+    label: "OpenCode",
+    hint: "AI-powered code editor running on your server"
+  },
+  {
+    id: "openclaude",
+    label: "OpenClaude",
+    hint: "Claude Code as a service \u2014 delegate hard coding tasks to Claude"
+  },
+  {
+    id: "dokploy",
+    label: "Dokploy",
+    hint: "Visual PaaS for deploying apps (like a self-hosted Railway)"
+  },
+  {
+    id: "t3code",
+    label: "T3 Code",
+    hint: "External code execution backend \u2014 store connection details for DevPlane pipeline"
+  }
+];
+async function pickBuilder() {
+  console.log();
+  const choice = await select({
+    message: "Which builder would you like to install?",
+    options: BUILDER_OPTIONS.map((b) => ({
+      value: b.id,
+      label: b.label,
+      hint: b.hint
+    }))
+  });
+  if (isCancel(choice)) {
+    printInfo("Cancelled.");
+    return null;
+  }
+  return choice;
+}
+function addCommand(program) {
+  program.command("add").description("Add a component to an existing entity").argument("[components...]", "One component ID or category to add (hermes, synap, ollama, openclaw, rsshub, openwebui, builder, opencode, openclaude, dokploy, \u2026)").option("--synap-repo <path>", "Path to synap-backend checkout (for synap component)").option("--model <model>", "Ollama model (for ollama component)", "llama3.1:8b").action(async (components, opts) => {
+    const requested = components ?? [];
+    if (requested.length > 1) {
+      if (requested.includes("synap") && requested.includes("pod-admin")) {
+        printInfo("Pod Admin ships with the Synap Data Pod; it is not a separately added component.");
+        printInfo("Use `eve add synap` only for a new Pod, or `eve update synap` to recover an existing one.");
+      } else {
+        printWarning("`eve add` installs one component at a time.");
+        printInfo(`Received: ${requested.join(", ")}`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    let component = requested[0];
+    if (component === "builder") {
+      const picked = await pickBuilder();
+      if (!picked) process.exit(0);
+      component = picked;
+    }
+    if (!component) {
+      console.log();
+      printHeader("Eve \u2014 Add Component", emojis.entity);
+      console.log();
+      printInfo("Usage: eve add <component>");
+      console.log();
+      const groups = [
+        { heading: "AI agents", ids: ["hermes", "openclaw"] },
+        { heading: "Data & inference", ids: ["synap", "ollama", "openwebui", "openwebui-pipelines", "rsshub"] },
+        { heading: "Builders", ids: ["opencode", "openclaude", "dokploy", "t3code"] },
+        { heading: "Infrastructure", ids: ["traefik", "eve-dashboard"] }
+      ];
+      for (const group of groups) {
+        console.log(colors.muted.bold(`
+  ${group.heading}`));
+        for (const id of group.ids) {
+          const comp = COMPONENTS.find((c) => c.id === id);
+          if (!comp) continue;
+          const installed = await entityStateManager.isComponentInstalled(id);
+          const tag = installed ? colors.success(" [installed]") : comp.deprecated ? colors.muted(" [deprecated]") : "";
+          console.log(`  ${comp.emoji}  ${colors.primary.bold(comp.label)}${tag}`);
+          console.log(`     ${colors.muted(comp.description.split("\n")[0])}`);
+        }
+      }
+      console.log();
+      printInfo("Tip: `eve add builder` shows a picker for OpenCode / OpenClaude / Dokploy");
+      printInfo("Examples:");
+      printInfo("  eve add hermes              # AI agent with sovereign memory");
+      printInfo("  eve add ollama              # Local AI inference");
+      printInfo("  eve add builder             # Pick a code-execution builder");
+      console.log();
+      return;
+    }
+    await runAdd(component, opts);
+  });
+}
+
+export {
+  colors,
+  emojis,
+  createSpinner,
+  printHeader,
+  printSuccess,
+  printError,
+  printWarning,
+  printInfo,
+  printKeyValue,
+  formatOrgan,
+  printBox,
+  runAdd,
+  addCommand
+};
+//# sourceMappingURL=chunk-MUEQNBE6.js.map