@synap-core/eve 0.1.0

package/dist/chunk-22RIHU4J.js

@@ -0,0 +1,975 @@
+import { createRequire as __eveCreateRequire } from 'module'; const require = __eveCreateRequire(import.meta.url);
+import {
+  InferenceGateway
+} from "./chunk-23XQDB7K.js";
+import {
+  resolveSynapDelegate,
+  toPodFqdn
+} from "./chunk-HVJEW7TU.js";
+import {
+  EntityStateManager,
+  describePodProviderResult,
+  entityStateManager,
+  getServerIp,
+  setPodProviderEnabled,
+  upsertPodProvider
+} from "./chunk-5TBV2VHZ.js";
+import {
+  resolveSynapUrl
+} from "./chunk-O5WTCVMZ.js";
+import {
+  readAgentKeyOrLegacy,
+  readEveSecrets
+} from "./chunk-T7GCAJK5.js";
+
+// ../@eve/brain/dist/index.js
+import { spawn } from "child_process";
+import { execSync } from "child_process";
+import { execSync as execSync2, spawnSync } from "child_process";
+import Table from "cli-table3";
+function execa(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: options?.stdio === "inherit" ? "inherit" : "pipe",
+      cwd: options?.cwd,
+      env: options?.env
+    });
+    let stdout = "";
+    let stderr = "";
+    if (child.stdout) {
+      child.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+    }
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({ stdout: stdout.trim(), stderr: stderr.trim() });
+      } else {
+        reject(new Error(`Command failed with code ${code}: ${stderr || stdout}`));
+      }
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+async function ensureNetwork() {
+  try {
+    const { stdout } = await execa("docker", ["network", "ls", "--format", "{{.Name}}"]);
+    if (!stdout.includes("eve-network")) {
+      console.log("Creating eve-network...");
+      await execa("docker", ["network", "create", "eve-network"]);
+    }
+  } catch (error) {
+    console.warn("Could not ensure Docker network:", error);
+  }
+}
+var OllamaService = class {
+  containerName = "eve-brain-ollama";
+  image = "ollama/ollama:latest";
+  async install() {
+    console.log("Installing Ollama...");
+    await execa("docker", ["pull", this.image], { stdio: "inherit" });
+    console.log("Ollama image pulled successfully");
+  }
+  /**
+   * @param publishToHost - When false, Ollama is only on `eve-network` (use with Traefik gateway on Full stack).
+   */
+  async start(options) {
+    const publishToHost = options?.publishToHost !== false;
+    const running = await this.isRunning();
+    if (running) {
+      console.log("Ollama is already running");
+      return;
+    }
+    const exists = await this.containerExists();
+    if (exists) {
+      await execa("docker", ["start", this.containerName], { stdio: "inherit" });
+    } else {
+      const args = [
+        "run",
+        "-d",
+        "--name",
+        this.containerName,
+        "--network",
+        "eve-network",
+        "-v",
+        "ollama-models:/root/.ollama",
+        "--restart",
+        "unless-stopped"
+      ];
+      if (publishToHost) {
+        args.push("-p", "127.0.0.1:11434:11434");
+      }
+      args.push(this.image);
+      await execa("docker", args, { stdio: "inherit" });
+    }
+    console.log(
+      publishToHost ? "Ollama started on http://127.0.0.1:11434" : "Ollama started (no host port; reachable on eve-network as eve-brain-ollama:11434)"
+    );
+  }
+  async pullModel(model, startOpts) {
+    console.log(`Pulling model: ${model}...`);
+    await this.start(startOpts);
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+    await execa("docker", [
+      "exec",
+      this.containerName,
+      "ollama",
+      "pull",
+      model
+    ], { stdio: "inherit" });
+    console.log(`Model ${model} pulled successfully`);
+  }
+  async isRunning() {
+    try {
+      const { stdout } = await execa("docker", [
+        "ps",
+        "--filter",
+        `name=${this.containerName}`,
+        "--filter",
+        "status=running",
+        "--format",
+        "{{.Names}}"
+      ]);
+      return stdout.trim() === this.containerName;
+    } catch {
+      return false;
+    }
+  }
+  async getStatus() {
+    const running = await this.isRunning();
+    const models = await this.listModels();
+    return {
+      running,
+      modelsInstalled: models,
+      currentModel: models.length > 0 ? models[0] : void 0
+    };
+  }
+  async listModels() {
+    try {
+      const { stdout } = await execa("docker", [
+        "exec",
+        this.containerName,
+        "ollama",
+        "list"
+      ]);
+      const lines = stdout.trim().split("\n").slice(1);
+      return lines.map((line) => line.split(/\s+/)[0]).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  async containerExists() {
+    try {
+      const { stdout } = await execa("docker", [
+        "ps",
+        "-a",
+        "--filter",
+        `name=${this.containerName}`,
+        "--format",
+        "{{.Names}}"
+      ]);
+      return stdout.trim() === this.containerName;
+    } catch {
+      return false;
+    }
+  }
+};
+async function cleanupKnownStaleState(deployDir) {
+  console.log("Cleaning known stale Synap artifacts...");
+  try {
+    await execa("bash", ["-lc", `rm -f "${deployDir}/patch_migration.js"`], { stdio: "inherit" });
+    await execa(
+      "bash",
+      [
+        "-lc",
+        `if [ -f "${deployDir}/docker-compose.override.yml" ] && grep -q "patch_migration.js" "${deployDir}/docker-compose.override.yml"; then rm -f "${deployDir}/docker-compose.override.yml"; fi`
+      ],
+      { stdio: "inherit" }
+    );
+  } catch {
+  }
+}
+async function runBrainInit(options) {
+  const repo = options.synapRepo?.trim() || process.env.SYNAP_REPO_ROOT?.trim() || void 0;
+  if (repo) {
+    process.env.SYNAP_REPO_ROOT = repo;
+  }
+  const domain = options.domain?.trim() || "localhost";
+  const email = options.email?.trim() || process.env.LETSENCRYPT_EMAIL?.trim() || process.env.SYNAP_LETSENCRYPT_EMAIL?.trim();
+  const adminEmail = options.adminEmail?.trim() || process.env.ADMIN_EMAIL?.trim();
+  const adminPassword = options.adminPassword?.trim() || process.env.ADMIN_PASSWORD?.trim();
+  const adminBootstrapMode = options.adminBootstrapMode ?? "token";
+  if (options.fromSource && options.fromImage) {
+    throw new Error("--from-image and --from-source are mutually exclusive.");
+  }
+  const explicitRepo = options.synapRepo?.trim() || process.env.SYNAP_REPO_ROOT?.trim();
+  const existingDelegate = explicitRepo ? resolveSynapDelegate() : null;
+  if (existingDelegate) {
+    await cleanupKnownStaleState(existingDelegate.deployDir);
+  }
+  if (options.fromSource === true) {
+    console.log("Installing Synap Data Pod from source (synap CLI delegate)...\n");
+  } else if (options.fromSource === false) {
+    console.log("Installing Synap Data Pod from Docker image (synap CLI delegate)...\n");
+  } else {
+    console.log("Installing Synap Data Pod (synap CLI delegate, auto-detect mode)...\n");
+  }
+  const { installSynapFromImage: installSynapFromImage2 } = await import("./synap-image-install-X36REYQ5-UGO4MAOP.js");
+  const result = await installSynapFromImage2({
+    deployDir: explicitRepo,
+    domain,
+    email,
+    adminEmail,
+    adminPassword,
+    adminBootstrapMode,
+    fromSource: options.fromSource,
+    withOpenclaw: options.withOpenclaw,
+    withRsshub: options.withRsshub
+  });
+  if (options.withAi) {
+    console.log("\n\u{1F916} Local Ollama (optional; not part of default Synap compose)\n");
+    await ensureNetwork();
+    const ollama = new OllamaService();
+    await ollama.install();
+    await ollama.start();
+    await ollama.pullModel(options.model ?? "llama3.1:8b");
+  }
+  const stateManager = new EntityStateManager();
+  await stateManager.updateOrgan("brain", "ready");
+  await entityStateManager.updateComponentEntry("synap", {
+    organ: "brain",
+    state: "ready",
+    version: options.fromSource ? "local" : "main",
+    managedBy: "eve",
+    config: { domain, withRsshub: options.withRsshub, repoRoot: result.deployDir }
+  });
+  console.log("\n\u2705 Synap Data Pod installed.");
+  if (result.bootstrapToken) {
+    const secrets = await readEveSecrets(process.cwd()).catch(() => null);
+    const configuredDomain = domain !== "localhost" ? domain : secrets?.domain?.primary;
+    const ssl = secrets?.domain?.ssl ?? false;
+    const serverIp = getServerIp();
+    console.log(`
+  Admin bootstrap token (save this \u2014 one-time use):`);
+    console.log(`  ${result.bootstrapToken}`);
+    console.log(`
+  Complete setup at:`);
+    if (configuredDomain) {
+      const proto = ssl ? "https" : "http";
+      console.log(`    ${proto}://${toPodFqdn(configuredDomain)}/admin/bootstrap`);
+    }
+    if (serverIp) {
+      console.log(`    http://${serverIp}:4000/admin/bootstrap`);
+    }
+    console.log(`    http://localhost:4000/admin/bootstrap`);
+  }
+  if (options.withRsshub) {
+    console.log("  RSSHub: http://localhost:1200 (default compose port)");
+  }
+}
+function initCommand(program) {
+  program.command("init").description(
+    "Install the Synap Data Pod. Uses pre-built Docker image by default; pass --synap-repo to use a local checkout."
+  ).option("--with-ai", "Include local Ollama sidecar (optional)").option("--model <model>", "AI model to use", "llama3.1:8b").option(
+    "--synap-repo <path>",
+    "Path to synap-backend checkout (optional \u2014 auto-detected or uses Docker image)"
+  ).option("--domain <host>", "Domain for the data pod", "localhost").option("--email <email>", "SSL contact email (required if domain is not localhost)").option("--with-openclaw", "With --synap-repo: pass --with-openclaw to synap install").option("--with-rsshub", "With --synap-repo: pass --with-rsshub to synap install").option("--from-image", "Force from-image install even if synap-repo is found").option("--from-source", "With --synap-repo: build from source instead of pulling image").option("--admin-email <email>", "Admin email for bootstrap").option("--admin-password <secret>", "Admin password (preseed bootstrap mode)").option("--admin-bootstrap-mode <mode>", "preseed | token (default: token)").action(
+    async (options) => {
+      try {
+        await runBrainInit({
+          withAi: options.withAi,
+          model: options.model,
+          synapRepo: options.synapRepo,
+          domain: options.domain,
+          email: options.email,
+          withOpenclaw: options.withOpenclaw,
+          withRsshub: options.withRsshub,
+          fromImage: options.fromImage,
+          fromSource: options.fromSource,
+          adminEmail: options.adminEmail,
+          adminPassword: options.adminPassword,
+          adminBootstrapMode: options.adminBootstrapMode
+        });
+      } catch (error) {
+        console.error("Failed to initialize brain:", error);
+        process.exit(1);
+      }
+    }
+  );
+}
+function checkSynapViaDocker() {
+  try {
+    const out = execSync(
+      'docker ps -a --filter "label=com.docker.compose.project=synap-backend" --format "{{.Names}}|{{.Status}}"',
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    ).trim();
+    const lines = out.split("\n").filter(Boolean);
+    if (lines.length === 0) return { found: false, healthy: false, containers: [] };
+    const containers = [];
+    let healthy = false;
+    for (const line of lines) {
+      const [name, status] = line.split("|");
+      containers.push(name);
+      if (status?.includes("healthy")) healthy = true;
+      else if (status?.includes("running")) healthy = false;
+    }
+    return { found: true, healthy, containers };
+  } catch {
+    return { found: false, healthy: false, containers: [] };
+  }
+}
+function statusCommand(program) {
+  program.command("status").description("Show brain health status").action(async () => {
+    try {
+      console.log("Checking brain health...\n");
+      const delegate = resolveSynapDelegate();
+      if (delegate) {
+        try {
+          await execa("bash", [delegate.synapScript, "health"], {
+            cwd: delegate.repoRoot,
+            env: { ...process.env, SYNAP_DEPLOY_DIR: delegate.deployDir },
+            stdio: "inherit"
+          });
+        } catch {
+        }
+      }
+      const synap = checkSynapViaDocker();
+      if (!synap.found) {
+        console.log("\u26A0\uFE0F Synap Data Pod: not found");
+        if (!delegate) {
+          console.log("  Set SYNAP_REPO_ROOT or run `eve brain init --synap-repo <path>`");
+        }
+      } else {
+        const mark = synap.healthy ? "\u2713" : "\u26A0";
+        const label = synap.healthy ? "Healthy" : "Running (not yet healthy)";
+        console.log(`${mark} Synap Data Pod: ${label}`);
+        for (const c of synap.containers) {
+          console.log(`    - ${c}`);
+        }
+      }
+      try {
+        const hermesStatus = execSync(
+          'docker inspect eve-builder-hermes --format "{{.State.Status}}" 2>/dev/null',
+          { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+        ).trim();
+        const mark = hermesStatus === "running" ? "\u2713" : "\u26A0";
+        console.log(`${mark} Hermes (agent): ${hermesStatus || "not found"}`);
+      } catch {
+        console.log("\u26A0\uFE0F Hermes (agent): not found");
+      }
+      const ollama = new OllamaService();
+      const ollamaStatus = await ollama.getStatus();
+      if (ollamaStatus.running) {
+        console.log("AI Models");
+        if (ollamaStatus.modelsInstalled.length > 0) {
+          for (const model of ollamaStatus.modelsInstalled) {
+            const current = model === ollamaStatus.currentModel ? " (current)" : "";
+            console.log(`  \u2022 ${model}${current}`);
+          }
+        } else {
+          console.log("  No models installed");
+          console.log("  Run: eve brain init --with-ai --model <model>");
+        }
+      }
+    } catch (error) {
+      console.error("Failed to check brain status:", error);
+      process.exit(1);
+    }
+  });
+}
+function reconnectSynapToEveNetwork() {
+  try {
+    const name = execSync2(
+      `docker ps --filter "label=com.docker.compose.project=synap-backend" --filter "label=com.docker.compose.service=backend" --format "{{.Names}}"`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    ).trim().split("\n")[0]?.trim();
+    if (!name) return;
+    const inspect = execSync2(
+      `docker inspect --format "{{json .NetworkSettings.Networks}}" ${name}`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    ).trim();
+    const networks = JSON.parse(inspect);
+    const eve = networks["eve-network"];
+    if (eve && (eve.Aliases ?? []).includes("eve-brain-synap")) return;
+    if (eve) {
+      try {
+        execSync2(`docker network disconnect eve-network ${name}`, { stdio: ["pipe", "pipe", "ignore"] });
+      } catch {
+      }
+    }
+    execSync2(`docker network connect --alias eve-brain-synap eve-network ${name}`, { stdio: ["pipe", "pipe", "ignore"] });
+    console.log(`  Connected ${name} \u2192 eve-network (alias: eve-brain-synap)`);
+  } catch {
+  }
+}
+function getSynapContainerIds(runningOnly = false) {
+  try {
+    const flag = runningOnly ? "" : "-a";
+    const out = execSync2(
+      `docker ps ${flag} --filter "label=com.docker.compose.project=synap-backend" --format "{{.Names}}"`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    ).trim();
+    return out.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+var SynapService = class {
+  delegate() {
+    return resolveSynapDelegate();
+  }
+  requireDelegate() {
+    const d = this.delegate();
+    if (!d) {
+      throw new Error(
+        "Synap repo not found. Pass --synap-repo <path> or set SYNAP_REPO_ROOT to a synap-backend checkout.\nTried: SYNAP_REPO_ROOT env, saved state, /opt/synap, /opt/synap-backend."
+      );
+    }
+    return d;
+  }
+  async install() {
+    this.requireDelegate();
+    console.log(
+      "Synap install is managed via the official synap CLI. Use `eve brain init --synap-repo <path>` or `eve setup --profile data_pod`."
+    );
+  }
+  async start() {
+    const d = this.delegate();
+    if (d) {
+      console.log("Starting Synap stack via synap CLI...");
+      await execa("bash", [d.synapScript, "start"], {
+        cwd: d.repoRoot,
+        env: { ...process.env, SYNAP_DEPLOY_DIR: d.deployDir },
+        stdio: "inherit"
+      });
+      reconnectSynapToEveNetwork();
+      return;
+    }
+    const containers = getSynapContainerIds();
+    if (containers.length === 0) {
+      console.log("Synap Data Pod not found \u2014 installing from Docker image...\n");
+      const { installSynapFromImage: installSynapFromImage2 } = await import("./synap-image-install-X36REYQ5-UGO4MAOP.js");
+      const result = await installSynapFromImage2();
+      if (result.bootstrapToken) {
+        console.log(`
+  Admin bootstrap token: ${result.bootstrapToken}`);
+        console.log(`  Use at: http://localhost:4000/admin/bootstrap`);
+      }
+      reconnectSynapToEveNetwork();
+      return;
+    }
+    console.log(`Starting ${containers.length} synap-backend container(s) directly...`);
+    for (const name of containers) {
+      const result = spawnSync("docker", ["start", name], { stdio: "inherit" });
+      if (result.status !== 0) {
+        throw new Error(`Failed to start container: ${name}`);
+      }
+    }
+    reconnectSynapToEveNetwork();
+  }
+  async stop() {
+    const d = this.delegate();
+    if (d) {
+      console.log("Stopping Synap stack via synap CLI...");
+      await execa("bash", [d.synapScript, "stop"], {
+        cwd: d.repoRoot,
+        env: { ...process.env, SYNAP_DEPLOY_DIR: d.deployDir },
+        stdio: "inherit"
+      });
+      return;
+    }
+    const containers = getSynapContainerIds(true);
+    if (containers.length === 0) {
+      console.log("No running synap-backend containers found.");
+      return;
+    }
+    console.log(`Stopping ${containers.length} synap-backend container(s) directly...`);
+    for (const name of containers) {
+      spawnSync("docker", ["stop", name], { stdio: "inherit" });
+    }
+  }
+  async isHealthy() {
+    this.requireDelegate();
+    try {
+      const res = await fetch("http://127.0.0.1:4000/health", { signal: AbortSignal.timeout(3e3) });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  async getVersion() {
+    this.requireDelegate();
+    return "synap-compose";
+  }
+};
+function startCommand(program) {
+  program.command("start").description("Start Synap backend container").action(async () => {
+    const synap = new SynapService();
+    await synap.start();
+  });
+}
+function stopCommand(program) {
+  program.command("stop").description("Stop Synap backend container").action(async () => {
+    const synap = new SynapService();
+    await synap.stop();
+  });
+}
+async function hubGet(podUrl, apiKey, path) {
+  const res = await fetch(`${podUrl.replace(/\/$/, "")}/api/hub/${path}`, {
+    headers: { Authorization: `Bearer ${apiKey}` },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Pod responded ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+async function hubPost(podUrl, apiKey, path, body) {
+  const res = await fetch(`${podUrl.replace(/\/$/, "")}/api/hub/${path}`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    body: body !== void 0 ? JSON.stringify(body) : void 0,
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Pod responded ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+async function hubDelete(podUrl, apiKey, path) {
+  const res = await fetch(`${podUrl.replace(/\/$/, "")}/api/hub/${path}`, {
+    method: "DELETE",
+    headers: { Authorization: `Bearer ${apiKey}` },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Pod responded ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+async function resolveAuth(cwd) {
+  const secrets = await readEveSecrets(cwd);
+  const podUrl = resolveSynapUrl(secrets) ?? process.env.SYNAP_POD_URL;
+  if (!podUrl) throw new Error("Pod URL not configured. Run `eve setup` first.");
+  const apiKey = await readAgentKeyOrLegacy("eve", cwd) || process.env.SYNAP_HUB_API_KEY || "";
+  if (!apiKey) throw new Error("Eve agent API key not configured. Run `eve setup` or `eve auth` first, or set SYNAP_HUB_API_KEY.");
+  return { podUrl, apiKey };
+}
+function providersCommand(brain) {
+  const providers = brain.command("providers").description("Manage AI provider configs on the pod (synced to IS on change)");
+  providers.command("list").description("List all providers registered on the pod").option("--json", "Output raw JSON").action(async (opts) => {
+    try {
+      const { podUrl, apiKey } = await resolveAuth(process.env.EVE_HOME ?? process.cwd());
+      const { providers: rows } = await hubGet(podUrl, apiKey, "ai-providers");
+      if (opts.json) {
+        console.log(JSON.stringify(rows, null, 2));
+        return;
+      }
+      if (rows.length === 0) {
+        console.log("No providers configured. Use `eve brain providers add` to register one.");
+        return;
+      }
+      const table = new Table({
+        head: ["ID", "Name", "Base URL", "Priority", "Enabled", "Key", "Models"],
+        style: { head: ["cyan"] }
+      });
+      for (const p of rows.sort((a, b) => a.priority - b.priority)) {
+        table.push([
+          p.providerId,
+          p.name,
+          p.baseUrl.replace(/^https?:\/\//, ""),
+          String(p.priority),
+          p.enabled ? "\u2713" : "\u2014",
+          p.hasApiKey ? "\u25CF" : "\u25CB",
+          p.models.length > 0 ? p.models.slice(0, 3).map((m) => m.id).join(", ") + (p.models.length > 3 ? "\u2026" : "") : "\u2014"
+        ]);
+      }
+      console.log(table.toString());
+      console.log(`
+\u25CF = API key stored  \u25CB = no key (uses env var ${rows[0]?.apiKeyEnvVar ?? ""})`);
+    } catch (err) {
+      console.error("Error:", String(err));
+      process.exit(1);
+    }
+  });
+  const KNOWN_PROVIDERS = {
+    openrouter: {
+      name: "OpenRouter",
+      url: "https://openrouter.ai/api/v1",
+      envVar: "OPENROUTER_API_KEY",
+      priority: 10,
+      models: [
+        { id: "deepseek/deepseek-v4-flash:free", tier: "balanced", contextWindow: 1e6 },
+        { id: "deepseek/deepseek-v4-flash:free", tier: "free", contextWindow: 1e6 },
+        { id: "nvidia/nemotron-3-super-120b-a12b:free", tier: "advanced", contextWindow: 1e6 },
+        { id: "openai/gpt-oss-20b:free", tier: "complex", contextWindow: 131072 }
+      ]
+    },
+    groq: {
+      name: "Groq",
+      url: "https://api.groq.com/openai/v1",
+      envVar: "GROQ_API_KEY",
+      priority: 20,
+      models: [{ id: "llama-3.3-70b-versatile", tier: "balanced" }]
+    },
+    cerebras: {
+      name: "Cerebras",
+      url: "https://api.cerebras.ai/v1",
+      envVar: "CEREBRAS_API_KEY",
+      priority: 30,
+      models: [{ id: "llama3.1-70b", tier: "balanced" }]
+    },
+    anthropic: {
+      name: "Anthropic",
+      url: "https://api.anthropic.com/v1",
+      envVar: "ANTHROPIC_API_KEY",
+      priority: 40,
+      models: [
+        { id: "claude-sonnet-4-6", tier: "balanced" },
+        { id: "claude-opus-4-8", tier: "advanced" }
+      ]
+    }
+  };
+  providers.command("add [providerId]").description("Add or update a provider on the pod. Known providers (openrouter, groq, cerebras, anthropic) have sensible defaults.").option("--id <providerId>", "Provider ID (overrides positional arg)").option("--name <name>", "Display name (defaults filled for known providers)").option("--url <baseUrl>", "OpenAI-compatible base URL (defaults filled for known providers)").option("--env-var <apiKeyEnvVar>", "Env var name for the API key on the IS").option("--key <apiKey>", "API key (alias for --api-key)").option("--api-key <apiKey>", "API key (encrypted and stored on pod, sent inline to IS)").option("--priority <n>", "Routing priority (lower = higher)").option("--disable", "Add in disabled state").action(async (positionalId, opts) => {
+    try {
+      const id = opts.id ?? positionalId;
+      if (!id) {
+        console.error("Error: provider ID required \u2014 pass as positional arg or --id");
+        console.error("Example: eve brain providers add openrouter --key <api-key>");
+        process.exit(1);
+      }
+      const defaults = KNOWN_PROVIDERS[id];
+      const name = opts.name ?? defaults?.name ?? id;
+      const url = opts.url ?? defaults?.url;
+      if (!url) {
+        console.error(`Error: --url required for unknown provider "${id}"`);
+        process.exit(1);
+      }
+      const { podUrl, apiKey } = await resolveAuth(process.env.EVE_HOME ?? process.cwd());
+      const result = await upsertPodProvider(podUrl, apiKey, {
+        providerId: id,
+        name,
+        baseUrl: url,
+        apiKeyEnvVar: opts.envVar ?? defaults?.envVar ?? "PROVIDER_API_KEY",
+        ...opts.key || opts.apiKey ? { apiKey: opts.key ?? opts.apiKey } : {},
+        priority: opts.priority ? parseInt(opts.priority, 10) : defaults?.priority ?? 10,
+        enabled: !opts.disable,
+        ...defaults?.models ? { models: defaults.models } : {}
+      });
+      console.log(describePodProviderResult(result));
+    } catch (err) {
+      console.error("Error:", String(err));
+      process.exit(1);
+    }
+  });
+  providers.command("enable <providerId>").description("Enable a provider and sync to IS").action(async (providerId) => {
+    try {
+      const { podUrl, apiKey } = await resolveAuth(process.env.EVE_HOME ?? process.cwd());
+      console.log(
+        describePodProviderResult(
+          await setPodProviderEnabled(podUrl, apiKey, providerId, true)
+        )
+      );
+    } catch (err) {
+      console.error("Error:", String(err));
+      process.exit(1);
+    }
+  });
+  providers.command("disable <providerId>").description("Disable a provider and sync to IS").action(async (providerId) => {
+    try {
+      const { podUrl, apiKey } = await resolveAuth(process.env.EVE_HOME ?? process.cwd());
+      console.log(
+        describePodProviderResult(
+          await setPodProviderEnabled(podUrl, apiKey, providerId, false)
+        )
+      );
+    } catch (err) {
+      console.error("Error:", String(err));
+      process.exit(1);
+    }
+  });
+  providers.command("remove <providerId>").description("Remove a provider from the pod and sync to IS").option("-y, --yes", "Skip confirmation").action(async (providerId, opts) => {
+    try {
+      if (!opts.yes) {
+        const readline = await import("readline");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const confirmed = await new Promise((resolve) => {
+          rl.question(`Remove provider "${providerId}"? (y/N) `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y");
+          });
+        });
+        if (!confirmed) {
+          console.log("Aborted.");
+          return;
+        }
+      }
+      const { podUrl, apiKey } = await resolveAuth(process.env.EVE_HOME ?? process.cwd());
+      await hubDelete(podUrl, apiKey, `ai-providers/${providerId}`);
+      console.log(`\u2713 Provider "${providerId}" removed.`);
+    } catch (err) {
+      console.error("Error:", String(err));
+      process.exit(1);
+    }
+  });
+  providers.command("test <providerId>").description("Probe a provider via the IS (live connectivity test)").action(async (providerId) => {
+    try {
+      const { podUrl, apiKey } = await resolveAuth(process.env.EVE_HOME ?? process.cwd());
+      console.log(`Probing "${providerId}" via IS\u2026`);
+      const result = await hubPost(podUrl, apiKey, `ai-providers/${providerId}/probe`);
+      if (result.ok) {
+        console.log(`\u2713 Reachable (${result.latencyMs}ms) \u2014 ${result.models.length} models`);
+        if (result.models.length > 0) {
+          console.log("  " + result.models.slice(0, 10).join("\n  "));
+          if (result.models.length > 10) console.log(`  \u2026 and ${result.models.length - 10} more`);
+        }
+      } else {
+        console.error(`\u2717 Probe failed: ${result.error ?? "unknown error"}`);
+        process.exit(1);
+      }
+    } catch (err) {
+      console.error("Error:", String(err));
+      process.exit(1);
+    }
+  });
+  providers.command("sync").description("Re-push all providers from the pod to the IS (safe after IS redeploy)").action(async () => {
+    try {
+      const { podUrl, apiKey } = await resolveAuth(process.env.EVE_HOME ?? process.cwd());
+      const result = await hubPost(podUrl, apiKey, "ai-providers/sync");
+      console.log(`\u2713 Synced ${result.count} provider(s) to IS.`);
+    } catch (err) {
+      console.error("Error:", String(err));
+      process.exit(1);
+    }
+  });
+}
+var ModelService = class {
+  ollamaContainer = "eve-brain-ollama";
+  /** ── Ollama ────────────────────────────────────────────── */
+  /** Check whether the Ollama container is running. */
+  async isOllamaRunning() {
+    try {
+      const { stdout } = await execa("docker", [
+        "ps",
+        "--filter",
+        `name=${this.ollamaContainer}`,
+        "--filter",
+        "status=running",
+        "--format",
+        "{{.Names}}"
+      ]);
+      return stdout.trim() === this.ollamaContainer;
+    } catch {
+      return false;
+    }
+  }
+  /** List Ollama model names via `docker exec ollama list`. */
+  async listOllamaModels() {
+    try {
+      const httpModels = await this.listOllamaModelsHttp();
+      if (httpModels.length > 0) return httpModels;
+    } catch {
+    }
+    try {
+      const { stdout } = await execa("docker", [
+        "exec",
+        this.ollamaContainer,
+        "ollama",
+        "list"
+      ]);
+      const lines = stdout.trim().split("\n").slice(1);
+      return lines.map((l) => l.split(/\s+/)[0]).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  async listOllamaModelsHttp() {
+    try {
+      const res = await fetch("http://127.0.0.1:11434/api/tags", { signal: AbortSignal.timeout(3e3) });
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.models ?? []).map((m) => m.name).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  /** ── Hermes gateway ────────────────────────────────────── */
+  /** Check whether the Hermes container is running. */
+  async isHermesRunning() {
+    try {
+      const { stdout } = await execa("docker", [
+        "ps",
+        "--filter",
+        "name=eve-builder-hermes",
+        "--filter",
+        "status=running",
+        "--format",
+        "{{.Names}}"
+      ]);
+      return stdout.trim() === "eve-builder-hermes";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Query Hermes gateway's /v1/models endpoint.
+   * @param apiKey — optional Bearer token (API_SERVER_KEY from secrets)
+   */
+  async listHermesModels(apiKey) {
+    if (!await this.isHermesRunning()) return [];
+    try {
+      const headers = {};
+      if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+      const res = await fetch("http://localhost:8642/v1/models", {
+        headers,
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) return [];
+      const data = await res.json();
+      const items = Array.isArray(data.data) ? data.data : [];
+      return items.filter((m) => m?.id).map((m) => m.id);
+    } catch {
+      return [];
+    }
+  }
+  /** ── Cloud providers (OpenAI-compatible /v1/models) ───── */
+  /**
+   * Query a provider's /v1/models endpoint using its apiKey + baseUrl.
+   * Returns model IDs, or empty array if unreachable / no key.
+   */
+  async listCloudModels(options) {
+    if (!options.apiKey) return [];
+    const url = `${options.baseUrl.replace(/\/+$/, "")}/v1/models`;
+    try {
+      const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${options.apiKey}` },
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) return [];
+      const data = await res.json();
+      const items = Array.isArray(data.data) ? data.data : [];
+      return items.filter((m) => m?.id).map((m) => m.id);
+    } catch {
+      return [];
+    }
+  }
+  /** ── Unified discovery ─────────────────────────────────── */
+  /**
+   * Discover models from all sources and return a grouped list.
+   *
+   * @param cloudProviders — optional list of { id, name, baseUrl, apiKey, defaultModel, models }
+   * @param hermesApiKey — optional API_SERVER_KEY for authenticated Hermes model discovery
+   * @returns ProviderModels sorted: Ollama first, then Hermes, then cloud providers
+   */
+  async discoverAll(cloudProviders, hermesApiKey) {
+    const results = [];
+    const ollamaRunning = await this.isOllamaRunning();
+    const ollamaModels = ollamaRunning ? await this.listOllamaModels() : [];
+    if (ollamaModels.length > 0 || ollamaRunning) {
+      results.push({
+        providerId: "ollama",
+        displayName: "Ollama (local)",
+        models: ollamaModels.map((name) => ({ name, isDefault: ollamaModels[0] === name })),
+        available: ollamaRunning
+      });
+    }
+    const hermesRunning = await this.isHermesRunning();
+    const hermesModels = hermesRunning ? await this.listHermesModels(hermesApiKey) : [];
+    if (hermesModels.length > 0 || hermesRunning) {
+      results.push({
+        providerId: "hermes",
+        displayName: "Hermes Gateway",
+        models: hermesModels.map((name) => ({ name, isDefault: hermesModels[0] === name })),
+        available: hermesRunning
+      });
+    }
+    if (cloudProviders) {
+      for (const cp of cloudProviders) {
+        const canDiscover = !!(cp.baseUrl && cp.apiKey);
+        const hasCachedModels = cp.models && cp.models.length > 0;
+        if (!canDiscover && !hasCachedModels) continue;
+        let models = [];
+        let available = false;
+        if (canDiscover) {
+          models = await this.listCloudModels({
+            baseUrl: cp.baseUrl ?? "",
+            apiKey: cp.apiKey,
+            providerId: cp.id
+          });
+          available = true;
+        }
+        if (models.length === 0 && hasCachedModels) {
+          models = cp.models ?? [];
+          available = false;
+        }
+        results.push({
+          providerId: cp.id,
+          displayName: cp.name ?? cp.id,
+          models: models.map((name) => ({ name, isDefault: name === cp.defaultModel })),
+          available
+        });
+      }
+    }
+    return results;
+  }
+};
+async function runInferenceInit(options = {}) {
+  const withGateway = options.withGateway !== false;
+  const internalOnly = Boolean(options.internalOllamaOnly);
+  await ensureNetwork();
+  const ollama = new OllamaService();
+  await ollama.install();
+  await ollama.start({ publishToHost: !internalOnly });
+  const model = options.model ?? "llama3.1:8b";
+  await ollama.pullModel(model, { publishToHost: !internalOnly });
+  if (withGateway) {
+    const gw = new InferenceGateway();
+    const result = await gw.ensure();
+    console.log("\nInference gateway (Traefik)");
+    console.log(`  URL:      ${result.publicUrl}`);
+    console.log(`  User:     ${result.username}`);
+    console.log(`  Password: ${result.password}`);
+    console.log(`  Secrets:  ${result.secretsFile}`);
+    console.log(`  Test:     curl -u '${result.username}:${result.password}' ${result.publicUrl}/api/tags`);
+    const stateManager2 = new EntityStateManager();
+    await stateManager2.updateOrgan("legs", "ready");
+  }
+  const stateManager = new EntityStateManager();
+  await stateManager.setAIModel("ollama");
+  await stateManager.updateOrgan("brain", "ready");
+  console.log("\nInference profile ready.");
+}
+function registerBrainCommands(brain) {
+  initCommand(brain);
+  statusCommand(brain);
+  startCommand(brain);
+  stopCommand(brain);
+  providersCommand(brain);
+}
+
+export {
+  execa,
+  ensureNetwork,
+  OllamaService,
+  runBrainInit,
+  initCommand,
+  statusCommand,
+  SynapService,
+  startCommand,
+  stopCommand,
+  providersCommand,
+  ModelService,
+  runInferenceInit,
+  registerBrainCommands
+};
+//# sourceMappingURL=chunk-22RIHU4J.js.map