@ibm/ixora 0.1.1 → 0.1.3

package/dist/chunk-4XGJZZ73.js

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+import {
+  COMPOSE_FILE,
+  ENV_FILE,
+  HEALTH_TIMEOUT,
+  IXORA_DIR,
+  SYSTEMS_CONFIG,
+  readSystems
+} from "./chunk-VCQRSQ4F.js";
+
+// src/lib/compose.ts
+import { execa as execa2 } from "execa";
+import { existsSync, mkdirSync } from "fs";
+import { writeFileSync } from "fs";
+
+// src/lib/platform.ts
+import { arch } from "os";
+import { execa } from "execa";
+async function detectComposeCmd(optRuntime) {
+  if (optRuntime) {
+    switch (optRuntime) {
+      case "docker":
+        return "docker compose";
+      case "podman":
+        return "podman compose";
+      default:
+        throw new Error(
+          `Unknown runtime: ${optRuntime} (choose: docker, podman)`
+        );
+    }
+  }
+  try {
+    await execa("docker", ["compose", "version"]);
+    return "docker compose";
+  } catch {
+  }
+  try {
+    await execa("podman", ["compose", "version"]);
+    return "podman compose";
+  } catch {
+  }
+  try {
+    await execa("docker-compose", ["version"]);
+    return "docker-compose";
+  } catch {
+  }
+  throw new Error(
+    "Neither 'docker compose', 'podman compose', nor 'docker-compose' found.\nPlease install Docker or Podman first."
+  );
+}
+async function verifyRuntimeRunning(composeCmd) {
+  const runtime = composeCmd.startsWith("docker") ? "docker" : "podman";
+  try {
+    await execa(runtime, ["info"]);
+  } catch {
+    const name = runtime === "docker" ? "Docker Desktop" : "Podman";
+    throw new Error(`${name} is not running. Please start it and try again.`);
+  }
+}
+function detectPlatform() {
+  const cpuArch = arch();
+  if (cpuArch === "ppc64") {
+    return {
+      dbImage: process.env["IXORA_DB_IMAGE"] ?? `ghcr.io/ibmi-agi/ixora-db:${process.env["IXORA_VERSION"] ?? "latest"}`
+    };
+  }
+  return {};
+}
+function getComposeParts(cmd) {
+  if (cmd === "docker-compose") {
+    return ["docker-compose", []];
+  }
+  const [bin, sub] = cmd.split(" ");
+  return [bin, [sub]];
+}
+function getRuntimeBin(cmd) {
+  return cmd.startsWith("docker") ? "docker" : "podman";
+}
+
+// src/lib/templates/multi-compose.ts
+function generateMultiCompose(envFile = ENV_FILE, configFile = SYSTEMS_CONFIG) {
+  const systems = readSystems(configFile);
+  let content = `# Auto-generated compose file
+# Regenerated on every start. Edit ixora-systems.yaml instead.
+services:
+  agentos-db:
+    image: \${IXORA_DB_IMAGE:-agnohq/pgvector:18}
+    restart: unless-stopped
+    ports:
+      - "\${DB_PORT:-5432}:5432"
+    environment:
+      POSTGRES_USER: \${DB_USER:-ai}
+      POSTGRES_PASSWORD: \${DB_PASS:-ai}
+      POSTGRES_DB: \${DB_DATABASE:-ai}
+    volumes:
+      - pgdata:/var/lib/postgresql
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U \${DB_USER:-ai}"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+`;
+  let apiPort = 8e3;
+  let firstApi = "";
+  for (const sys of systems) {
+    const idUpper = sys.id.toUpperCase().replace(/-/g, "_");
+    content += `  mcp-${sys.id}:
+    image: ghcr.io/ibmi-agi/ixora-mcp-server:\${IXORA_VERSION:-latest}
+    restart: unless-stopped
+    environment:
+      DB2i_HOST: \${SYSTEM_${idUpper}_HOST}
+      DB2i_USER: \${SYSTEM_${idUpper}_USER}
+      DB2i_PASS: \${SYSTEM_${idUpper}_PASS}
+      DB2_PORT: \${SYSTEM_${idUpper}_PORT:-8076}
+      MCP_TRANSPORT_TYPE: http
+      MCP_SESSION_MODE: stateless
+      YAML_AUTO_RELOAD: "true"
+      TOOLS_YAML_PATH: /usr/src/app/tools
+      YAML_ALLOW_DUPLICATE_SOURCES: "true"
+      IBMI_ENABLE_EXECUTE_SQL: "true"
+      IBMI_ENABLE_DEFAULT_TOOLS: "true"
+      MCP_AUTH_MODE: "none"
+      IBMI_HTTP_AUTH_ENABLED: "false"
+      MCP_POOL_QUERY_TIMEOUT_MS: "120000"
+    healthcheck:
+      test: ["CMD-SHELL", "node -e \\"fetch('http://localhost:3010/healthz').then(function(r){process.exit(r.ok?0:1)}).catch(function(){process.exit(1)})\\""]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+      start_period: 3s
+
+`;
+    content += `  api-${sys.id}:
+    image: ghcr.io/ibmi-agi/ixora-api:\${IXORA_VERSION:-latest}
+    command: uvicorn app.main:app --host 0.0.0.0 --port 8000
+    restart: unless-stopped
+    ports:
+      - "${apiPort}:8000"
+    environment:
+      ANTHROPIC_API_KEY: \${ANTHROPIC_API_KEY:-}
+      OPENAI_API_KEY: \${OPENAI_API_KEY:-}
+      GOOGLE_API_KEY: \${GOOGLE_API_KEY:-}
+      OLLAMA_HOST: \${OLLAMA_HOST:-http://host.docker.internal:11434}
+      IXORA_AGENT_MODEL: \${IXORA_AGENT_MODEL:-anthropic:claude-sonnet-4-6}
+      IXORA_TEAM_MODEL: \${IXORA_TEAM_MODEL:-anthropic:claude-haiku-4-5}
+      DB_HOST: agentos-db
+      DB_PORT: "5432"
+      DB_USER: \${DB_USER:-ai}
+      DB_PASS: \${DB_PASS:-ai}
+      DB_DATABASE: \${DB_DATABASE:-ai}
+      MCP_URL: http://mcp-${sys.id}:3010/mcp
+      IXORA_SYSTEM_ID: ${sys.id}
+      IXORA_SYSTEM_NAME: ${sys.name}
+      IAASSIST_DEPLOYMENT_CONFIG: app/config/deployments/${sys.profile || "full"}.yaml
+      DATA_DIR: /data
+      RUNTIME_ENV: docker
+      WAIT_FOR_DB: "True"
+      CORS_ORIGINS: \${CORS_ORIGINS:-*}
+      AUTH_ENABLED: "false"
+      MCP_AUTH_MODE: "none"
+      IXORA_ENABLE_BUILDER: "true"
+      A2A_INTERFACE: \${A2A_INTERFACE:-false}
+      DB2i_HOST: \${SYSTEM_${idUpper}_HOST}
+      DB2i_USER: \${SYSTEM_${idUpper}_USER}
+      DB2i_PASS: \${SYSTEM_${idUpper}_PASS}
+      DB2_PORT: \${SYSTEM_${idUpper}_PORT:-8076}
+    volumes:
+      - agentos-data:/data
+      - type: bind
+        source: \${HOME}/.ixora/user_tools
+        target: /data/user_tools
+        bind:
+          create_host_path: true
+    depends_on:
+      agentos-db:
+        condition: service_healthy
+      mcp-${sys.id}:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD-SHELL", "python -c \\"import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8000/health', timeout=3).getcode()==200 else 1)\\""]
+      interval: 10s
+      timeout: 5s
+      retries: 6
+      start_period: 30s
+
+`;
+    if (!firstApi) firstApi = `api-${sys.id}`;
+    apiPort++;
+  }
+  content += `  ui:
+    image: ghcr.io/ibmi-agi/ixora-ui:\${IXORA_VERSION:-latest}
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    environment:
+      NEXT_PUBLIC_API_URL: http://localhost:8000
+    depends_on:
+      ${firstApi}:
+        condition: service_healthy
+
+volumes:
+  pgdata:
+  agentos-data:
+`;
+  return content;
+}
+
+// src/lib/ui.ts
+import chalk from "chalk";
+function info(message) {
+  console.log(`${chalk.blue("==>")} ${chalk.bold(message)}`);
+}
+function success(message) {
+  console.log(`${chalk.green("==>")} ${chalk.bold(message)}`);
+}
+function warn(message) {
+  console.log(`${chalk.yellow("Warning:")} ${message}`);
+}
+function error(message) {
+  console.error(`${chalk.red("Error:")} ${message}`);
+}
+function die(message) {
+  error(message);
+  process.exit(1);
+}
+function maskValue(value) {
+  if (!value) return chalk.dim("(not set)");
+  if (value.length <= 4) return "****";
+  return `${value.slice(0, 4)}****`;
+}
+function isSensitiveKey(key) {
+  const upper = key.toUpperCase();
+  return /KEY|TOKEN|PASS|SECRET|ENCRYPT/.test(upper);
+}
+function dim(message) {
+  return chalk.dim(message);
+}
+function bold(message) {
+  return chalk.bold(message);
+}
+function cyan(message) {
+  return chalk.cyan(message);
+}
+function section(title) {
+  console.log(
+    `  ${chalk.dim(`\u2500\u2500 ${title} ${"\u2500".repeat(Math.max(0, 49 - title.length))}`)}`
+  );
+}
+
+// src/lib/compose.ts
+async function runCompose(composeCmd, args, options = {}) {
+  const [bin, subArgs] = getComposeParts(composeCmd);
+  const fullArgs = [
+    ...subArgs,
+    "-p",
+    "ixora",
+    "-f",
+    COMPOSE_FILE,
+    "--env-file",
+    ENV_FILE,
+    ...args
+  ];
+  try {
+    const result = await execa2(bin, fullArgs, {
+      stdio: "inherit",
+      ...options
+    });
+    return {
+      stdout: String(result.stdout ?? ""),
+      stderr: String(result.stderr ?? ""),
+      exitCode: result.exitCode ?? 0
+    };
+  } catch (err) {
+    const exitCode = err && typeof err === "object" && "exitCode" in err ? err.exitCode : 1;
+    error(`Command failed: ${composeCmd} ${args.join(" ")}`);
+    console.log(`  Check ${bold("ixora logs")} for details.`);
+    process.exit(exitCode);
+  }
+}
+async function runComposeCapture(composeCmd, args) {
+  const [bin, subArgs] = getComposeParts(composeCmd);
+  const fullArgs = [
+    ...subArgs,
+    "-p",
+    "ixora",
+    "-f",
+    COMPOSE_FILE,
+    "--env-file",
+    ENV_FILE,
+    ...args
+  ];
+  const result = await execa2(bin, fullArgs, { stdio: "pipe" });
+  return result.stdout;
+}
+function writeComposeFile(envFile = ENV_FILE) {
+  mkdirSync(IXORA_DIR, { recursive: true });
+  const content = generateMultiCompose(envFile);
+  writeFileSync(COMPOSE_FILE, content, "utf-8");
+}
+function requireInstalled() {
+  if (!existsSync(ENV_FILE)) {
+    throw new Error("ixora is not installed. Run: ixora install");
+  }
+}
+function requireComposeFile() {
+  if (!existsSync(COMPOSE_FILE)) {
+    throw new Error("ixora is not installed. Run: ixora install");
+  }
+}
+function resolveService(input) {
+  return input.replace(/^ixora-/, "").replace(/-\d+$/, "");
+}
+
+// src/lib/health.ts
+import { execa as execa3 } from "execa";
+import ora from "ora";
+async function waitForHealthy(composeCmd, timeout = HEALTH_TIMEOUT) {
+  const spinner = ora("Waiting for services to become healthy...").start();
+  const runtime = getRuntimeBin(composeCmd);
+  let apiContainer = "";
+  try {
+    const output = await runComposeCapture(composeCmd, [
+      "ps",
+      "--format",
+      "{{.Name}}"
+    ]);
+    const containers = output.split("\n").filter(Boolean);
+    apiContainer = containers.find((c) => c.includes("ixora-api-")) ?? "";
+  } catch {
+  }
+  if (!apiContainer) {
+    spinner.stop();
+    warn("Could not find API container \u2014 skipping health check");
+    return true;
+  }
+  spinner.text = `Waiting for services to become healthy (up to ${timeout}s)...`;
+  let elapsed = 0;
+  while (elapsed < timeout) {
+    try {
+      const stateResult = await execa3(runtime, [
+        "inspect",
+        "--format",
+        "{{.State.Status}}",
+        apiContainer
+      ]);
+      const state = stateResult.stdout.trim();
+      if (state === "exited" || state === "dead") {
+        spinner.fail("API container failed to start");
+        console.log(`
+  Run ${bold("ixora logs api")} to investigate.`);
+        return false;
+      }
+      const healthResult = await execa3(runtime, [
+        "inspect",
+        "--format",
+        "{{.State.Health.Status}}",
+        apiContainer
+      ]);
+      const health = healthResult.stdout.trim();
+      if (health === "healthy") {
+        spinner.succeed("Services are healthy");
+        return true;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+    elapsed += 2;
+    spinner.text = `Waiting for services to become healthy (${elapsed}s/${timeout}s)...`;
+  }
+  spinner.warn(
+    `Services did not become healthy within ${timeout}s \u2014 they may still be starting`
+  );
+  console.log(`  Run ${bold("ixora logs api")} to investigate.`);
+  return false;
+}
+
+// src/commands/restart.ts
+async function cmdRestart(opts, service) {
+  try {
+    requireInstalled();
+  } catch (e) {
+    die(e.message);
+  }
+  let composeCmd;
+  try {
+    composeCmd = await detectComposeCmd(opts.runtime);
+    await verifyRuntimeRunning(composeCmd);
+  } catch (e) {
+    die(e.message);
+  }
+  detectPlatform();
+  writeComposeFile();
+  if (service) {
+    const svc = resolveService(service);
+    info(`Restarting ${svc}...`);
+    await runCompose(composeCmd, [
+      "up",
+      "-d",
+      "--force-recreate",
+      "--no-deps",
+      svc
+    ]);
+    success(`Restarted ${svc}`);
+  } else {
+    info("Restarting all services...");
+    await runCompose(composeCmd, [
+      "up",
+      "-d",
+      "--force-recreate",
+      "--remove-orphans"
+    ]);
+    await waitForHealthy(composeCmd);
+    console.log();
+    success("All services restarted");
+  }
+}
+
+export {
+  detectComposeCmd,
+  verifyRuntimeRunning,
+  detectPlatform,
+  info,
+  success,
+  warn,
+  error,
+  die,
+  maskValue,
+  isSensitiveKey,
+  dim,
+  bold,
+  cyan,
+  section,
+  runCompose,
+  runComposeCapture,
+  writeComposeFile,
+  requireInstalled,
+  requireComposeFile,
+  resolveService,
+  waitForHealthy,
+  cmdRestart
+};