@ibm/ixora 0.1.0

package/dist/index.js

@@ -0,0 +1,1779 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/lib/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var SCRIPT_VERSION = "0.1.0";
+var HEALTH_TIMEOUT = 30;
+var IXORA_DIR = join(homedir(), ".ixora");
+var COMPOSE_FILE = join(IXORA_DIR, "docker-compose.yml");
+var SYSTEMS_CONFIG = join(IXORA_DIR, "ixora-systems.yaml");
+var ENV_FILE = join(IXORA_DIR, ".env");
+var PROFILES = {
+  full: {
+    name: "full",
+    label: "Full",
+    description: "All agents, teams, and workflows (3 agents, 2 teams, 1 workflow)"
+  },
+  "sql-services": {
+    name: "sql-services",
+    label: "SQL Services",
+    description: "SQL Services agent for database queries and performance monitoring"
+  },
+  security: {
+    name: "security",
+    label: "Security",
+    description: "Security agent, multi-system security team, and assessment workflow"
+  },
+  knowledge: {
+    name: "knowledge",
+    label: "Knowledge",
+    description: "Knowledge agent only \u2014 documentation retrieval (lightest)"
+  }
+};
+var VALID_PROFILES = Object.keys(PROFILES);
+var PROVIDERS = {
+  anthropic: {
+    name: "anthropic",
+    label: "Anthropic",
+    agentModel: "anthropic:claude-sonnet-4-6",
+    teamModel: "anthropic:claude-haiku-4-5",
+    apiKeyVar: "ANTHROPIC_API_KEY",
+    description: "Claude Sonnet 4.6 / Haiku 4.5 (recommended)"
+  },
+  openai: {
+    name: "openai",
+    label: "OpenAI",
+    agentModel: "openai:gpt-4o",
+    teamModel: "openai:gpt-4o-mini",
+    apiKeyVar: "OPENAI_API_KEY",
+    description: "GPT-4o / GPT-4o-mini"
+  },
+  google: {
+    name: "google",
+    label: "Google",
+    agentModel: "google:gemini-2.5-pro",
+    teamModel: "google:gemini-2.5-flash",
+    apiKeyVar: "GOOGLE_API_KEY",
+    description: "Gemini 2.5 Pro / Gemini 2.5 Flash"
+  },
+  ollama: {
+    name: "ollama",
+    label: "Ollama",
+    agentModel: "ollama:llama3.1",
+    teamModel: "ollama:llama3.1",
+    apiKeyVar: "",
+    description: "Local models via Ollama (no API key needed)"
+  },
+  custom: {
+    name: "custom",
+    label: "Custom",
+    agentModel: "",
+    teamModel: "",
+    apiKeyVar: "",
+    description: "Enter provider:model strings"
+  }
+};
+var ALL_AGENTS = [
+  "ibmi-security-assistant",
+  "ibmi-system-health",
+  "ibmi-db-explorer",
+  "ibmi-db-performance",
+  "ibmi-work-management",
+  "ibmi-system-config",
+  "ibmi-sql-service-guide",
+  "ibmi-knowledge-agent"
+];
+var OPS_AGENTS = [
+  "ibmi-system-health",
+  "ibmi-db-explorer",
+  "ibmi-db-performance",
+  "ibmi-work-management",
+  "ibmi-system-config",
+  "ibmi-sql-service-guide"
+];
+var AGENT_PRESETS = {
+  all: [...ALL_AGENTS],
+  "security-ops": ["ibmi-security-assistant", ...OPS_AGENTS],
+  security: ["ibmi-security-assistant"],
+  operations: [...OPS_AGENTS],
+  knowledge: ["ibmi-knowledge-agent"]
+};
+
+// src/commands/version.ts
+import { existsSync as existsSync4 } from "fs";
+import chalk2 from "chalk";
+
+// src/lib/env.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from "fs";
+import { dirname } from "path";
+function sqEscape(value) {
+  return value.replace(/'/g, "'\\''");
+}
+function envGet(key, envFile = ENV_FILE) {
+  if (!existsSync(envFile)) return "";
+  const content = readFileSync(envFile, "utf-8");
+  for (const line of content.split("\n")) {
+    if (line.startsWith(`${key}=`)) {
+      let val = line.slice(key.length + 1);
+      if (val.startsWith("'") && val.endsWith("'") || val.startsWith('"') && val.endsWith('"')) {
+        val = val.slice(1, -1);
+      }
+      return val;
+    }
+  }
+  return "";
+}
+var KNOWN_KEYS = [
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "GOOGLE_API_KEY",
+  "OLLAMA_HOST",
+  "DB2i_HOST",
+  "DB2i_USER",
+  "DB2i_PASS",
+  "DB2_PORT",
+  "IXORA_PROFILE",
+  "IXORA_VERSION",
+  "IXORA_AGENT_MODEL",
+  "IXORA_TEAM_MODEL"
+];
+function writeEnvFile(config, envFile = ENV_FILE) {
+  mkdirSync(dirname(envFile), { recursive: true });
+  let extra = "";
+  if (existsSync(envFile)) {
+    const existing = readFileSync(envFile, "utf-8");
+    const extraLines = existing.split("\n").filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) return false;
+      const lineKey = trimmed.split("=")[0];
+      return !KNOWN_KEYS.includes(lineKey);
+    });
+    extra = extraLines.join("\n");
+  }
+  let content = `# Model provider
+IXORA_AGENT_MODEL='${sqEscape(config.agentModel)}'
+IXORA_TEAM_MODEL='${sqEscape(config.teamModel)}'
+`;
+  if (config.apiKeyVar && config.apiKeyValue) {
+    content += `${config.apiKeyVar}='${sqEscape(config.apiKeyValue)}'
+`;
+  }
+  if (config.ollamaHost) {
+    content += `OLLAMA_HOST='${sqEscape(config.ollamaHost)}'
+`;
+  }
+  content += `
+# IBM i connection
+DB2i_HOST='${sqEscape(config.db2Host)}'
+DB2i_USER='${sqEscape(config.db2User)}'
+DB2i_PASS='${sqEscape(config.db2Pass)}'
+
+# Deployment
+IXORA_PROFILE='${sqEscape(config.profile)}'
+IXORA_VERSION='${sqEscape(config.version)}'
+`;
+  if (extra) {
+    content += `
+# Preserved user settings
+${extra}
+`;
+  }
+  writeFileSync(envFile, content, "utf-8");
+  chmodSync(envFile, 384);
+}
+function updateEnvKey(key, value, envFile = ENV_FILE) {
+  const escaped = sqEscape(value);
+  if (existsSync(envFile)) {
+    const content = readFileSync(envFile, "utf-8");
+    const lines = content.split("\n");
+    let found = false;
+    const updated = lines.map((line) => {
+      if (line.startsWith(`${key}=`)) {
+        found = true;
+        return `${key}='${escaped}'`;
+      }
+      return line;
+    });
+    if (found) {
+      writeFileSync(envFile, updated.join("\n"), "utf-8");
+    } else {
+      const existing = readFileSync(envFile, "utf-8");
+      const suffix = existing.endsWith("\n") ? "" : "\n";
+      writeFileSync(
+        envFile,
+        `${existing}${suffix}${key}='${escaped}'
+`,
+        "utf-8"
+      );
+    }
+  } else {
+    mkdirSync(dirname(envFile), { recursive: true });
+    writeFileSync(envFile, `${key}='${escaped}'
+`, "utf-8");
+  }
+  chmodSync(envFile, 384);
+}
+
+// src/lib/compose.ts
+import { execa as execa2 } from "execa";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { writeFileSync as writeFileSync3 } 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/systems.ts
+import {
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  chmodSync as chmodSync2
+} from "fs";
+import { dirname as dirname2 } from "path";
+function readSystems(configFile = SYSTEMS_CONFIG) {
+  if (!existsSync2(configFile)) return [];
+  const content = readFileSync2(configFile, "utf-8");
+  const systems = [];
+  let current = null;
+  for (const line of content.split("\n")) {
+    const idMatch = line.match(/^ {2}- id: (.+)$/);
+    if (idMatch) {
+      if (current?.id) {
+        systems.push({
+          id: current.id,
+          name: current.name ?? current.id,
+          agents: current.agents ?? []
+        });
+      }
+      current = { id: idMatch[1] };
+      continue;
+    }
+    if (!current) continue;
+    const nameMatch = line.match(/name: *'?([^']*)'?/);
+    if (nameMatch) {
+      current.name = nameMatch[1];
+      continue;
+    }
+    const agentsMatch = line.match(/agents: *\[([^\]]*)\]/);
+    if (agentsMatch) {
+      current.agents = agentsMatch[1].split(",").map((a) => a.trim()).filter(Boolean);
+    }
+  }
+  if (current?.id) {
+    systems.push({
+      id: current.id,
+      name: current.name ?? current.id,
+      agents: current.agents ?? []
+    });
+  }
+  return systems;
+}
+function systemCount(configFile = SYSTEMS_CONFIG) {
+  return readSystems(configFile).length;
+}
+function systemIdExists(id, configFile = SYSTEMS_CONFIG) {
+  return readSystems(configFile).some((s) => s.id === id);
+}
+function totalSystemCount(envFile = ENV_FILE, configFile = SYSTEMS_CONFIG) {
+  const additional = systemCount(configFile);
+  const primaryHost = envGet("DB2i_HOST", envFile);
+  return primaryHost ? additional + 1 : additional;
+}
+function addSystem(system, envFile = ENV_FILE, configFile = SYSTEMS_CONFIG) {
+  const idUpper = system.id.toUpperCase().replace(/-/g, "_");
+  updateEnvKey(`SYSTEM_${idUpper}_HOST`, system.host, envFile);
+  updateEnvKey(`SYSTEM_${idUpper}_PORT`, system.port, envFile);
+  updateEnvKey(`SYSTEM_${idUpper}_USER`, system.user, envFile);
+  updateEnvKey(`SYSTEM_${idUpper}_PASS`, system.pass, envFile);
+  const escapedName = system.name.replace(/'/g, "'\\''");
+  const agentsList = system.agents.join(", ");
+  const entry = `  - id: ${system.id}
+    name: '${escapedName}'
+    agents: [${agentsList}]
+`;
+  mkdirSync2(dirname2(configFile), { recursive: true });
+  if (!existsSync2(configFile) || systemCount(configFile) === 0) {
+    const content = `# yaml-language-server: $schema=
+# Ixora Systems Configuration
+# Manage with: ixora system add|remove|list
+# Credentials stored in .env (SYSTEM_<ID>_USER, SYSTEM_<ID>_PASS)
+systems:
+${entry}`;
+    writeFileSync2(configFile, content, "utf-8");
+  } else {
+    const existing = readFileSync2(configFile, "utf-8");
+    writeFileSync2(configFile, `${existing}${entry}`, "utf-8");
+  }
+  chmodSync2(configFile, 384);
+}
+function removeSystem(id, envFile = ENV_FILE, configFile = SYSTEMS_CONFIG) {
+  if (!existsSync2(configFile)) {
+    throw new Error("No systems configured");
+  }
+  if (!systemIdExists(id, configFile)) {
+    throw new Error(`System '${id}' not found`);
+  }
+  const content = readFileSync2(configFile, "utf-8");
+  const lines = content.split("\n");
+  const output = [];
+  let skip = false;
+  for (const line of lines) {
+    if (line === `  - id: ${id}`) {
+      skip = true;
+      continue;
+    }
+    if (line.match(/^ {2}- id: /)) {
+      skip = false;
+    }
+    if (!skip) {
+      output.push(line);
+    }
+  }
+  writeFileSync2(configFile, output.join("\n"), "utf-8");
+  chmodSync2(configFile, 384);
+  if (existsSync2(envFile)) {
+    const idUpper = id.toUpperCase().replace(/-/g, "_");
+    const envContent = readFileSync2(envFile, "utf-8");
+    const filtered = envContent.split("\n").filter((line) => !line.startsWith(`SYSTEM_${idUpper}_`)).join("\n");
+    writeFileSync2(envFile, filtered, "utf-8");
+    chmodSync2(envFile, 384);
+  }
+}
+
+// src/lib/templates/single-compose.ts
+function generateSingleCompose() {
+  return `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
+
+  ibmi-mcp-server:
+    image: ghcr.io/ibmi-agi/ixora-mcp-server:\${IXORA_VERSION:-latest}
+    restart: unless-stopped
+    ports:
+      - "3010:3010"
+    environment:
+      DB2i_HOST: \${DB2i_HOST}
+      DB2i_USER: \${DB2i_USER}
+      DB2i_PASS: \${DB2i_PASS}
+      DB2_PORT: \${DB2_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_RATE_LIMIT_ENABLED: "true"
+      MCP_RATE_LIMIT_MAX_REQUESTS: "5000"
+      MCP_RATE_LIMIT_WINDOW_MS: "60000"
+      MCP_RATE_LIMIT_SKIP_DEV: "true"
+      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
+
+  api:
+    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:
+      - "8000: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://ibmi-mcp-server:3010/mcp
+      IAASSIST_DEPLOYMENT_CONFIG: app/config/deployments/\${IXORA_PROFILE:-full}.yaml
+      DATA_DIR: /data
+      RUNTIME_ENV: docker
+      WAIT_FOR_DB: "True"
+      RAG_API_URL: \${RAG_API_URL:-}
+      RAG_API_TIMEOUT: \${RAG_API_TIMEOUT:-120}
+      AUTH_ENABLED: "false"
+      MCP_AUTH_MODE: "none"
+      CORS_ORIGINS: \${CORS_ORIGINS:-*}
+      IXORA_ENABLE_BUILDER: "true"
+      DB2i_HOST: \${DB2i_HOST}
+      DB2i_USER: \${DB2i_USER}
+      DB2i_PASS: \${DB2i_PASS}
+      DB2_PORT: \${DB2_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
+      ibmi-mcp-server:
+        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
+
+  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:
+      api:
+        condition: service_healthy
+
+volumes:
+  pgdata:
+  agentos-data:
+`;
+}
+
+// src/lib/templates/multi-compose.ts
+function generateMultiCompose(envFile = ENV_FILE, configFile = SYSTEMS_CONFIG) {
+  const version = envGet("IXORA_VERSION", envFile) || "latest";
+  const dbImage = process.env["IXORA_DB_IMAGE"] ?? "agnohq/pgvector:18";
+  let content = `# Auto-generated for multi-system deployment
+# Regenerated on every start. Edit ixora-systems.yaml instead.
+services:
+  agentos-db:
+    image: ${dbImage}
+    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 = "";
+  const allSystems = [];
+  const primaryHost = envGet("DB2i_HOST", envFile);
+  if (primaryHost) {
+    updateEnvKey("SYSTEM_DEFAULT_HOST", primaryHost, envFile);
+    updateEnvKey(
+      "SYSTEM_DEFAULT_PORT",
+      envGet("DB2_PORT", envFile) || "8076",
+      envFile
+    );
+    updateEnvKey("SYSTEM_DEFAULT_USER", envGet("DB2i_USER", envFile), envFile);
+    updateEnvKey("SYSTEM_DEFAULT_PASS", envGet("DB2i_PASS", envFile), envFile);
+    allSystems.push({ id: "default", name: primaryHost });
+  }
+  const additionalSystems = readSystems(configFile);
+  for (const sys of additionalSystems) {
+    allSystems.push({ id: sys.id, name: sys.name });
+  }
+  for (const sys of allSystems) {
+    const idUpper = sys.id.toUpperCase().replace(/-/g, "_");
+    content += `  mcp-${sys.id}:
+    image: ghcr.io/ibmi-agi/ixora-mcp-server:\${IXORA_VERSION:-${version}}
+    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:-${version}}
+    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/\${IXORA_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"
+      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:-${version}}
+    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) {
+  mkdirSync3(IXORA_DIR, { recursive: true });
+  const total = totalSystemCount(envFile);
+  let content;
+  if (total > 1) {
+    content = generateMultiCompose(envFile);
+  } else {
+    content = generateSingleCompose();
+  }
+  writeFileSync3(COMPOSE_FILE, content, "utf-8");
+}
+function requireInstalled() {
+  if (!existsSync3(ENV_FILE)) {
+    throw new Error("ixora is not installed. Run: ixora install");
+  }
+}
+function requireComposeFile() {
+  if (!existsSync3(COMPOSE_FILE)) {
+    throw new Error("ixora is not installed. Run: ixora install");
+  }
+}
+function resolveService(input3) {
+  return input3.replace(/^ixora-/, "").replace(/-\d+$/, "");
+}
+
+// src/commands/version.ts
+async function cmdVersion(opts) {
+  console.log(`ixora ${SCRIPT_VERSION}`);
+  if (!existsSync4(ENV_FILE)) return;
+  const version = envGet("IXORA_VERSION") || "latest";
+  const agentModel = envGet("IXORA_AGENT_MODEL") || "anthropic:claude-sonnet-4-6";
+  console.log(`  images:  ${version}`);
+  console.log(`  model:   ${agentModel}`);
+  if (existsSync4(COMPOSE_FILE)) {
+    try {
+      const composeCmd = await detectComposeCmd(opts?.runtime);
+      const output = await runComposeCapture(composeCmd, [
+        "images",
+        "--format",
+        "json"
+      ]);
+      if (output.trim()) {
+        const images = parseComposeImages(output);
+        if (images.length > 0) {
+          console.log();
+          console.log(`  ${chalk2.bold("Running containers:")}`);
+          for (const img of images) {
+            const tag = img.Tag || "unknown";
+            const id = img.ID ? dim(` (${img.ID.slice(0, 12)})`) : "";
+            const imageStr = tag === "latest" ? `${img.Repository || ""}:latest${id}` : `${img.Repository || ""}:${tag}`;
+            console.log(
+              `    ${(img.Service || "").padEnd(22)} ${dim(imageStr)}`
+            );
+          }
+        }
+      }
+    } catch {
+    }
+  }
+}
+function parseComposeImages(output) {
+  const trimmed = output.trim();
+  if (!trimmed) return [];
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) return parsed;
+    return [parsed];
+  } catch {
+    return trimmed.split("\n").filter((line) => line.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+}
+
+// src/commands/status.ts
+import chalk3 from "chalk";
+async function cmdStatus(opts) {
+  try {
+    requireComposeFile();
+  } catch (e) {
+    die(e.message);
+  }
+  let composeCmd;
+  try {
+    composeCmd = await detectComposeCmd(opts.runtime);
+    await verifyRuntimeRunning(composeCmd);
+  } catch (e) {
+    die(e.message);
+  }
+  detectPlatform();
+  const profile = envGet("IXORA_PROFILE") || "full";
+  const version = envGet("IXORA_VERSION") || "latest";
+  console.log();
+  console.log(`  ${chalk3.bold("Profile:")}  ${profile}`);
+  console.log(`  ${chalk3.bold("Version:")}  ${version}`);
+  console.log(`  ${chalk3.bold("Config:")}   ${IXORA_DIR}`);
+  console.log();
+  await runCompose(composeCmd, ["ps"]);
+  try {
+    const output = await runComposeCapture(composeCmd, [
+      "images",
+      "--format",
+      "json"
+    ]);
+    if (output.trim()) {
+      const images = parseComposeImages2(output);
+      if (images.length > 0) {
+        console.log();
+        console.log(`  ${chalk3.bold("Images:")}`);
+        for (const img of images) {
+          const tag = img.Tag || "unknown";
+          const id = img.ID ? ` (${img.ID.slice(0, 12)})` : "";
+          const tagDisplay = tag === "latest" ? `${tag}${dim(id)}` : tag;
+          console.log(
+            `    ${dim(`${img.Repository || ""}:`)}${tagDisplay}`
+          );
+        }
+        console.log();
+      }
+    }
+  } catch {
+  }
+}
+function parseComposeImages2(output) {
+  const trimmed = output.trim();
+  if (!trimmed) return [];
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) return parsed;
+    return [parsed];
+  } catch {
+    return trimmed.split("\n").filter((line) => line.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+}
+
+// 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/start.ts
+async function cmdStart(opts) {
+  try {
+    requireInstalled();
+  } catch (e) {
+    die(e.message);
+  }
+  let composeCmd;
+  try {
+    composeCmd = await detectComposeCmd(opts.runtime);
+    await verifyRuntimeRunning(composeCmd);
+  } catch (e) {
+    die(e.message);
+  }
+  detectPlatform();
+  if (opts.profile) {
+    if (!VALID_PROFILES.includes(opts.profile)) {
+      die(
+        `Invalid profile: ${opts.profile} (choose: ${VALID_PROFILES.join(", ")})`
+      );
+    }
+    info(`Setting profile: ${opts.profile}`);
+    updateEnvKey("IXORA_PROFILE", opts.profile);
+  }
+  writeComposeFile();
+  success("Wrote docker-compose.yml");
+  info("Starting ixora services...");
+  await runCompose(composeCmd, ["up", "-d"]);
+  await waitForHealthy(composeCmd);
+  const profile = envGet("IXORA_PROFILE") || "full";
+  const total = totalSystemCount();
+  console.log();
+  success("ixora is running!");
+  console.log(`  ${bold("UI:")}      http://localhost:3000`);
+  console.log(`  ${bold("API:")}     http://localhost:8000`);
+  console.log(`  ${bold("Profile:")} ${profile}`);
+  if (total > 1) {
+    console.log(`  ${bold("Systems:")} ${total}`);
+    let port = 8e3;
+    const primaryHost = envGet("DB2i_HOST");
+    if (primaryHost) {
+      console.log(`    ${dim(`:${port} \u2192 default (${primaryHost})`)}`);
+      port++;
+    }
+    const systems = readSystems();
+    for (const sys of systems) {
+      const idUpper = sys.id.toUpperCase().replace(/-/g, "_");
+      const sysHost = envGet(`SYSTEM_${idUpper}_HOST`);
+      console.log(`    ${dim(`:${port} \u2192 ${sys.id} (${sysHost})`)}`);
+      port++;
+    }
+    console.log(
+      `  ${dim("Note: UI connects to primary system (:8000) only. Use API ports for other systems.")}`
+    );
+  }
+  console.log();
+}
+
+// src/commands/stop.ts
+async function cmdStop(opts) {
+  try {
+    requireComposeFile();
+  } catch (e) {
+    die(e.message);
+  }
+  let composeCmd;
+  try {
+    composeCmd = await detectComposeCmd(opts.runtime);
+    await verifyRuntimeRunning(composeCmd);
+  } catch (e) {
+    die(e.message);
+  }
+  detectPlatform();
+  info("Stopping ixora services...");
+  await runCompose(composeCmd, ["down"]);
+  success("Services stopped");
+}
+
+// src/commands/restart.ts
+async function cmdRestart(opts, service) {
+  try {
+    requireComposeFile();
+  } catch (e) {
+    die(e.message);
+  }
+  let composeCmd;
+  try {
+    composeCmd = await detectComposeCmd(opts.runtime);
+    await verifyRuntimeRunning(composeCmd);
+  } catch (e) {
+    die(e.message);
+  }
+  detectPlatform();
+  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"]);
+    await waitForHealthy(composeCmd);
+    console.log();
+    success("All services restarted");
+  }
+}
+
+// src/commands/logs.ts
+async function cmdLogs(opts, service) {
+  try {
+    requireComposeFile();
+  } catch (e) {
+    die(e.message);
+  }
+  let composeCmd;
+  try {
+    composeCmd = await detectComposeCmd(opts.runtime);
+    await verifyRuntimeRunning(composeCmd);
+  } catch (e) {
+    die(e.message);
+  }
+  detectPlatform();
+  if (service) {
+    const svc = resolveService(service);
+    await runCompose(composeCmd, ["logs", "-f", svc]);
+  } else {
+    await runCompose(composeCmd, ["logs", "-f"]);
+  }
+}
+
+// src/commands/upgrade.ts
+async function cmdUpgrade(opts) {
+  try {
+    requireInstalled();
+  } catch (e) {
+    die(e.message);
+  }
+  let composeCmd;
+  try {
+    composeCmd = await detectComposeCmd(opts.runtime);
+    await verifyRuntimeRunning(composeCmd);
+  } catch (e) {
+    die(e.message);
+  }
+  detectPlatform();
+  const previousVersion = envGet("IXORA_VERSION") || "latest";
+  info("Upgrading ixora...");
+  writeComposeFile();
+  success("Wrote docker-compose.yml");
+  if (opts.imageVersion) {
+    info(`Pinning version: ${previousVersion} \u2192 ${opts.imageVersion}`);
+    updateEnvKey("IXORA_VERSION", opts.imageVersion);
+  }
+  if (opts.profile) {
+    if (!VALID_PROFILES.includes(opts.profile)) {
+      die(
+        `Invalid profile: ${opts.profile} (choose: ${VALID_PROFILES.join(", ")})`
+      );
+    }
+    info(`Setting profile: ${opts.profile}`);
+    updateEnvKey("IXORA_PROFILE", opts.profile);
+  }
+  if (opts.pull !== false) {
+    info("Pulling latest images...");
+    await runCompose(composeCmd, ["pull"]);
+  }
+  info("Restarting services...");
+  await runCompose(composeCmd, ["up", "-d"]);
+  await waitForHealthy(composeCmd);
+  const newVersion = envGet("IXORA_VERSION") || "latest";
+  const profile = envGet("IXORA_PROFILE") || "full";
+  console.log();
+  success("Upgrade complete!");
+  console.log(`  ${bold("Version:")} ${newVersion}`);
+  console.log(`  ${bold("Profile:")} ${profile}`);
+  if (opts.imageVersion && previousVersion !== opts.imageVersion) {
+    console.log(`  ${dim(`(was ${previousVersion})`)}`);
+  }
+  console.log();
+}
+
+// src/commands/uninstall.ts
+import { existsSync as existsSync5, rmSync } from "fs";
+import { confirm } from "@inquirer/prompts";
+import chalk4 from "chalk";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+async function cmdUninstall(opts) {
+  let composeCmd;
+  try {
+    composeCmd = await detectComposeCmd(opts.runtime);
+    await verifyRuntimeRunning(composeCmd);
+  } catch (e) {
+    die(e.message);
+  }
+  detectPlatform();
+  if (opts.purge) {
+    console.log(
+      chalk4.yellow(
+        "This will remove all containers, images, volumes, and configuration."
+      )
+    );
+    console.log(
+      chalk4.yellow(
+        "All agent data (sessions, memory) will be permanently deleted."
+      )
+    );
+  } else {
+    console.log(
+      chalk4.yellow("This will stop containers and remove images.")
+    );
+    console.log(
+      dim(
+        `Configuration in ${IXORA_DIR} will be preserved. Run 'ixora start' to re-pull and restart.`
+      )
+    );
+  }
+  const confirmed = await confirm({
+    message: "Continue?",
+    default: false
+  });
+  if (!confirmed) {
+    info("Cancelled");
+    return;
+  }
+  if (existsSync5(COMPOSE_FILE)) {
+    info("Stopping services and removing images...");
+    try {
+      if (opts.purge) {
+        await runCompose(composeCmd, ["down", "--rmi", "all", "-v"]);
+      } else {
+        await runCompose(composeCmd, ["down", "--rmi", "all"]);
+      }
+    } catch {
+    }
+  }
+  if (opts.purge) {
+    info(`Removing ${IXORA_DIR}...`);
+    rmSync(IXORA_DIR, { recursive: true, force: true });
+  }
+  success("ixora has been uninstalled");
+  if (!opts.purge) {
+    console.log(`  Configuration preserved in ${dim(IXORA_DIR)}`);
+    console.log(`  Run ${bold("ixora start")} to re-pull images and restart.`);
+    console.log(
+      `  Run ${bold("ixora uninstall --purge")} to remove everything.`
+    );
+  }
+  const binPath = join2(homedir2(), ".local", "bin", "ixora");
+  if (existsSync5(binPath)) {
+    console.log(
+      `  The ${bold("ixora")} command is still available at ${dim(binPath)}`
+    );
+    console.log(`  To remove it: ${bold(`rm ${binPath}`)}`);
+  }
+}
+
+// src/commands/install.ts
+import { existsSync as existsSync6 } from "fs";
+import {
+  input,
+  password,
+  select
+} from "@inquirer/prompts";
+async function promptModelProvider() {
+  const curAgentModel = envGet("IXORA_AGENT_MODEL");
+  let defaultProvider = "anthropic";
+  if (curAgentModel.startsWith("openai:")) defaultProvider = "openai";
+  else if (curAgentModel.startsWith("google:")) defaultProvider = "google";
+  else if (curAgentModel.startsWith("ollama:")) defaultProvider = "ollama";
+  const provider = await select({
+    message: "Select a model provider",
+    choices: [
+      {
+        name: `Anthropic     ${dim("Claude Sonnet 4.6 / Haiku 4.5 (recommended)")}`,
+        value: "anthropic"
+      },
+      {
+        name: `OpenAI        ${dim("GPT-4o / GPT-4o-mini")}`,
+        value: "openai"
+      },
+      {
+        name: `Google        ${dim("Gemini 2.5 Pro / Gemini 2.5 Flash")}`,
+        value: "google"
+      },
+      {
+        name: `Ollama        ${dim("Local models via Ollama (no API key needed)")}`,
+        value: "ollama"
+      },
+      {
+        name: `Custom        ${dim("Enter provider:model strings")}`,
+        value: "custom"
+      }
+    ],
+    default: defaultProvider
+  });
+  const providerDef = PROVIDERS[provider];
+  let agentModel = providerDef.agentModel;
+  let teamModel = providerDef.teamModel;
+  let apiKeyVar = providerDef.apiKeyVar;
+  let apiKeyValue = "";
+  let ollamaHost;
+  if (provider === "ollama") {
+    console.log();
+    info("Ollama Setup");
+    console.log();
+    console.log(
+      `  ${dim("Ollama must be running on your machine and listening on all interfaces.")}`
+    );
+    console.log(
+      `  ${dim("Default URL works for macOS and Windows (Docker Desktop).")}`
+    );
+    console.log(
+      `  ${dim("Linux users: use your host IP (e.g., http://172.17.0.1:11434).")}`
+    );
+    console.log();
+    const curOllamaHost = envGet("OLLAMA_HOST");
+    ollamaHost = await input({
+      message: "Ollama URL",
+      default: curOllamaHost || "http://host.docker.internal:11434"
+    });
+    const curModel = curAgentModel.startsWith("ollama:") ? curAgentModel.slice(7) : "llama3.1";
+    const modelName = await input({
+      message: "Model name",
+      default: curModel
+    });
+    agentModel = `ollama:${modelName}`;
+    teamModel = `ollama:${modelName}`;
+    try {
+      let testUrl = ollamaHost;
+      if (testUrl.includes("host.docker.internal")) {
+        testUrl = testUrl.replace("host.docker.internal", "localhost");
+      }
+      const response = await fetch(`${testUrl}/api/tags`, {
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (response.ok) {
+        success("Ollama is reachable");
+      } else {
+        warn(`Could not reach Ollama at ${testUrl}`);
+        console.log(
+          "  Make sure Ollama is running and accessible from Docker containers."
+        );
+      }
+    } catch {
+      warn(`Could not reach Ollama at ${ollamaHost}`);
+      console.log(
+        "  Make sure Ollama is running and accessible from Docker containers."
+      );
+    }
+  } else if (provider === "custom") {
+    const curAm = envGet("IXORA_AGENT_MODEL");
+    const curTm = envGet("IXORA_TEAM_MODEL");
+    agentModel = await input({
+      message: "Agent model (provider:model)",
+      default: curAm || "anthropic:claude-sonnet-4-6"
+    });
+    teamModel = await input({
+      message: "Team model (provider:model)",
+      default: curTm || "anthropic:claude-haiku-4-5"
+    });
+    apiKeyVar = await input({
+      message: "API key env var name (e.g., ANTHROPIC_API_KEY)"
+    });
+  }
+  if (apiKeyVar) {
+    const curKey = envGet(apiKeyVar);
+    apiKeyValue = await password({
+      message: apiKeyVar,
+      validate: (value) => {
+        if (!value && !curKey) return `${apiKeyVar} is required`;
+        return true;
+      }
+    });
+    if (!apiKeyValue && curKey) apiKeyValue = curKey;
+  }
+  success(`Provider: ${provider} (${agentModel})`);
+  return { provider, agentModel, teamModel, apiKeyVar, apiKeyValue, ollamaHost };
+}
+async function promptIbmiConnection() {
+  info("IBM i Connection");
+  console.log();
+  const curHost = envGet("DB2i_HOST");
+  const curUser = envGet("DB2i_USER");
+  const curPass = envGet("DB2i_PASS");
+  const host = await input({
+    message: "IBM i hostname",
+    default: curHost || void 0,
+    validate: (value) => value.trim() ? true : "IBM i hostname is required"
+  });
+  const user = await input({
+    message: "IBM i username",
+    default: curUser || void 0,
+    validate: (value) => value.trim() ? true : "IBM i username is required"
+  });
+  const pass = await password({
+    message: "IBM i password",
+    validate: (value) => {
+      if (!value && !curPass) return "IBM i password is required";
+      return true;
+    }
+  });
+  return { host: host.trim(), user: user.trim(), pass: pass || curPass };
+}
+async function promptProfile() {
+  const curProfile = envGet("IXORA_PROFILE") || "full";
+  const profile = await select({
+    message: "Select an agent profile",
+    choices: VALID_PROFILES.map((p) => ({
+      name: `${PROFILES[p].name.padEnd(14)} ${dim(PROFILES[p].description)}`,
+      value: p
+    })),
+    default: curProfile
+  });
+  success(`Profile: ${profile}`);
+  return profile;
+}
+async function cmdInstall(opts) {
+  info(`Installing ixora (v${SCRIPT_VERSION})`);
+  console.log();
+  let composeCmd;
+  try {
+    composeCmd = await detectComposeCmd(opts.runtime);
+    await verifyRuntimeRunning(composeCmd);
+  } catch (e) {
+    die(e.message);
+  }
+  detectPlatform();
+  info(`Using: ${composeCmd}`);
+  console.log();
+  if (existsSync6(IXORA_DIR)) {
+    warn(`Existing installation found at ${IXORA_DIR}`);
+    const action = await select({
+      message: "What would you like to do?",
+      choices: [
+        { name: "Reconfigure \u2014 re-run setup prompts (overwrites current config)", value: "reconfigure" },
+        { name: "Cancel \u2014 keep existing installation", value: "cancel" }
+      ],
+      default: "reconfigure"
+    });
+    if (action === "cancel") {
+      info("Cancelled");
+      return;
+    }
+    info("Reconfiguring...");
+    console.log();
+  }
+  const { agentModel, teamModel, apiKeyVar, apiKeyValue, ollamaHost } = await promptModelProvider();
+  console.log();
+  const { host, user, pass } = await promptIbmiConnection();
+  console.log();
+  const profile = opts.profile ? opts.profile : await promptProfile();
+  console.log();
+  const version = opts.imageVersion ?? envGet("IXORA_VERSION") ?? "latest";
+  const envConfig = {
+    agentModel,
+    teamModel,
+    apiKeyVar: apiKeyVar || void 0,
+    apiKeyValue: apiKeyValue || void 0,
+    ollamaHost,
+    db2Host: host,
+    db2User: user,
+    db2Pass: pass,
+    profile,
+    version
+  };
+  writeEnvFile(envConfig);
+  success("Wrote .env");
+  writeComposeFile();
+  success("Wrote docker-compose.yml");
+  if (opts.pull !== false) {
+    info("Pulling images...");
+    await runCompose(composeCmd, ["pull"]);
+  }
+  info("Starting services...");
+  await runCompose(composeCmd, ["up", "-d"]);
+  await waitForHealthy(composeCmd);
+  console.log();
+  success("ixora is running!");
+  console.log();
+  console.log(`  ${bold("UI:")}   http://localhost:3000`);
+  console.log(`  ${bold("API:")}  http://localhost:8000`);
+  console.log(`  ${bold("Profile:")} ${profile}`);
+  console.log();
+  console.log(
+    `  Manage with: ${bold("ixora start|stop|restart|status|upgrade|config|logs")}`
+  );
+  console.log(`  Config dir:  ${dim(IXORA_DIR)}`);
+  console.log();
+}
+
+// src/commands/config.ts
+import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
+import { execa as execa4 } from "execa";
+import chalk5 from "chalk";
+function cmdConfigShow() {
+  if (!existsSync7(ENV_FILE)) {
+    die("ixora is not installed. Run: ixora install");
+  }
+  console.log();
+  console.log(`  ${chalk5.bold("Configuration")}  ${ENV_FILE}`);
+  console.log();
+  section("Model");
+  const agentModel = envGet("IXORA_AGENT_MODEL") || "anthropic:claude-sonnet-4-6";
+  const teamModel = envGet("IXORA_TEAM_MODEL") || "anthropic:claude-haiku-4-5";
+  const anthKey = envGet("ANTHROPIC_API_KEY");
+  const oaiKey = envGet("OPENAI_API_KEY");
+  const googKey = envGet("GOOGLE_API_KEY");
+  const ollamaHost = envGet("OLLAMA_HOST");
+  console.log(`  ${cyan("IXORA_AGENT_MODEL")}   ${agentModel}`);
+  console.log(`  ${cyan("IXORA_TEAM_MODEL")}    ${teamModel}`);
+  if (anthKey) console.log(`  ${cyan("ANTHROPIC_API_KEY")}   ${maskValue(anthKey)}`);
+  if (oaiKey) console.log(`  ${cyan("OPENAI_API_KEY")}      ${maskValue(oaiKey)}`);
+  if (googKey) console.log(`  ${cyan("GOOGLE_API_KEY")}      ${maskValue(googKey)}`);
+  if (ollamaHost) console.log(`  ${cyan("OLLAMA_HOST")}         ${ollamaHost}`);
+  console.log();
+  section("IBM i Connection");
+  const db2Host = envGet("DB2i_HOST");
+  const db2User = envGet("DB2i_USER");
+  const db2Pass = envGet("DB2i_PASS");
+  const db2Port = envGet("DB2_PORT");
+  console.log(`  ${cyan("DB2i_HOST")}           ${db2Host || dim("(not set)")}`);
+  console.log(`  ${cyan("DB2i_USER")}           ${db2User || dim("(not set)")}`);
+  console.log(`  ${cyan("DB2i_PASS")}           ${maskValue(db2Pass)}`);
+  console.log(`  ${cyan("DB2_PORT")}            ${db2Port || "8076"}`);
+  console.log();
+  section("Deployment");
+  const profile = envGet("IXORA_PROFILE") || "full";
+  const version = envGet("IXORA_VERSION") || "latest";
+  console.log(`  ${cyan("IXORA_PROFILE")}       ${profile}`);
+  console.log(`  ${cyan("IXORA_VERSION")}       ${version}`);
+  console.log();
+  const knownKeys = /* @__PURE__ */ new Set([
+    "ANTHROPIC_API_KEY",
+    "OPENAI_API_KEY",
+    "GOOGLE_API_KEY",
+    "OLLAMA_HOST",
+    "DB2i_HOST",
+    "DB2i_USER",
+    "DB2i_PASS",
+    "DB2_PORT",
+    "IXORA_PROFILE",
+    "IXORA_VERSION",
+    "IXORA_AGENT_MODEL",
+    "IXORA_TEAM_MODEL"
+  ]);
+  const content = readFileSync3(ENV_FILE, "utf-8");
+  const extraLines = content.split("\n").filter((line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return false;
+    const key = trimmed.split("=")[0];
+    return !knownKeys.has(key);
+  });
+  if (extraLines.length > 0) {
+    section("Other");
+    for (const line of extraLines) {
+      const [key, ...rest] = line.split("=");
+      let val = rest.join("=").replace(/^['"]|['"]$/g, "");
+      if (isSensitiveKey(key)) {
+        console.log(`  ${cyan(key)}  ${maskValue(val)}`);
+      } else {
+        console.log(`  ${cyan(key)}  ${val}`);
+      }
+    }
+    console.log();
+  }
+  console.log(`  ${dim("Edit with: ixora config edit")}`);
+  console.log(`  ${dim("Set a value: ixora config set KEY VALUE")}`);
+  console.log();
+}
+function cmdConfigSet(key, value) {
+  if (!existsSync7(ENV_FILE)) {
+    die("ixora is not installed. Run: ixora install");
+  }
+  updateEnvKey(key, value);
+  success(`Set ${key}`);
+  console.log(`  Restart to apply: ${bold("ixora restart")}`);
+}
+async function cmdConfigEdit() {
+  if (!existsSync7(ENV_FILE)) {
+    die("ixora is not installed. Run: ixora install");
+  }
+  const editor = process.env["EDITOR"] ?? process.env["VISUAL"] ?? "";
+  let editorCmd = editor;
+  if (!editorCmd) {
+    for (const candidate of ["vim", "vi", "nano"]) {
+      try {
+        await execa4("which", [candidate]);
+        editorCmd = candidate;
+        break;
+      } catch {
+        continue;
+      }
+    }
+  }
+  if (!editorCmd) {
+    die("No editor found. Set $EDITOR or install vim/nano.");
+  }
+  info(`Opening ${editorCmd}...`);
+  await execa4(editorCmd, [ENV_FILE], { stdio: "inherit" });
+  console.log();
+  success("Config saved");
+  console.log(`  Restart to apply: ${bold("ixora restart")}`);
+}
+
+// src/commands/system.ts
+import { input as input2, password as password2, select as select2 } from "@inquirer/prompts";
+import chalk6 from "chalk";
+async function cmdSystemAdd() {
+  info("Add an IBM i system");
+  console.log();
+  const id = await input2({
+    message: "System ID (short name, e.g., dev, prod)",
+    validate: (value) => {
+      const cleaned = value.toLowerCase().replace(/[^a-z0-9-]/g, "");
+      if (!cleaned) return "System ID must contain alphanumeric characters";
+      if (cleaned === "default")
+        return "System ID 'default' is reserved for the primary system";
+      if (systemIdExists(cleaned))
+        return `System '${cleaned}' already exists`;
+      return true;
+    },
+    transformer: (value) => value.toLowerCase().replace(/[^a-z0-9-]/g, "")
+  });
+  const cleanId = id.toLowerCase().replace(/[^a-z0-9-]/g, "");
+  const name = await input2({
+    message: "Display name",
+    default: cleanId
+  });
+  const host = await input2({
+    message: "IBM i hostname",
+    validate: (value) => value.trim() ? true : "Hostname is required"
+  });
+  const port = await input2({
+    message: "IBM i Mapepire port",
+    default: "8076"
+  });
+  const user = await input2({
+    message: "IBM i username",
+    validate: (value) => value.trim() ? true : "Username is required"
+  });
+  const pass = await password2({
+    message: "IBM i password",
+    validate: (value) => value ? true : "Password is required"
+  });
+  const agentChoice = await select2({
+    message: "Select agents for this system",
+    choices: [
+      {
+        name: "All agents (security, operations, knowledge)",
+        value: "all"
+      },
+      { name: "Security + Operations", value: "security-ops" },
+      { name: "Security only", value: "security" },
+      {
+        name: "Operations only (health, database, work mgmt, config)",
+        value: "operations"
+      },
+      { name: "Knowledge only", value: "knowledge" }
+    ],
+    default: "all"
+  });
+  const agents = AGENT_PRESETS[agentChoice];
+  addSystem({
+    id: cleanId,
+    name,
+    agents: [...agents],
+    host: host.trim(),
+    port: port.trim(),
+    user: user.trim(),
+    pass
+  });
+  console.log();
+  success(`Added system '${cleanId}' (${host.trim()})`);
+  console.log(`  Credentials stored in ${dim(ENV_FILE)}`);
+  console.log(`  Systems: ${systemCount()}`);
+  console.log(`  Restart to apply: ${bold("ixora restart")}`);
+  console.log();
+}
+function cmdSystemRemove(id) {
+  try {
+    removeSystem(id);
+  } catch (e) {
+    die(e.message);
+  }
+  success(`Removed system '${id}'`);
+  console.log(`  Systems: ${systemCount()}`);
+  console.log(`  Restart to apply: ${bold("ixora restart")}`);
+}
+function cmdSystemList() {
+  const primaryHost = envGet("DB2i_HOST");
+  console.log();
+  console.log(`  ${chalk6.bold("IBM i Systems")}`);
+  console.log();
+  if (primaryHost) {
+    console.log(
+      `  ${cyan("*")}  ${"default".padEnd(12)}  ${primaryHost.padEnd(30)}  ${dim("(primary \u2014 from install)")}`
+    );
+  }
+  const systems = readSystems();
+  for (const sys of systems) {
+    const idUpper = sys.id.toUpperCase().replace(/-/g, "_");
+    const sysHost = envGet(`SYSTEM_${idUpper}_HOST`) || dim("(no host)");
+    const agentsStr = sys.agents.join(", ");
+    console.log(
+      `  ${cyan(" ")}  ${sys.id.padEnd(12)}  ${String(sysHost).padEnd(30)}  ${agentsStr}`
+    );
+  }
+  if (!primaryHost && systems.length === 0) {
+    console.log(`  ${dim(`No systems configured. Run: ${bold("ixora install")}`)}`);
+  }
+  console.log();
+  const total = systems.length + (primaryHost ? 1 : 0);
+  if (total > 1) {
+    console.log(
+      `  ${dim("Multi-system mode: each system runs on its own port (8000, 8001, ...)")}`
+    );
+  }
+  console.log(
+    `  ${dim("Add: ixora system add  |  Remove: ixora system remove <id>")}`
+  );
+  console.log();
+}
+
+// src/cli.ts
+function createProgram() {
+  const program2 = new Command().name("ixora").description("Manage ixora AI agent deployments on IBM i").version(SCRIPT_VERSION, "-V, --cli-version", "Show CLI version number").option(
+    "--profile <name>",
+    "Agent profile (full|sql-services|security|knowledge)"
+  ).option("--image-version <tag>", "Pin image version (e.g., v1.2.0)").option("--no-pull", "Skip pulling images").option("--purge", "Remove volumes too (with uninstall)").option(
+    "--runtime <name>",
+    "Force container runtime (docker or podman)"
+  );
+  program2.command("install").description("First-time setup (interactive)").action(async () => {
+    const opts = program2.opts();
+    await cmdInstall(opts);
+  });
+  program2.command("start").description("Start services").action(async () => {
+    const opts = program2.opts();
+    await cmdStart(opts);
+  });
+  program2.command("stop").description("Stop services").action(async () => {
+    const opts = program2.opts();
+    await cmdStop(opts);
+  });
+  program2.command("restart").argument("[service]", "Service to restart (omit for all)").description("Restart all services, or a specific service by name").action(async (service) => {
+    const opts = program2.opts();
+    await cmdRestart(opts, service);
+  });
+  program2.command("status").description("Show service status and deployed profile").action(async () => {
+    const opts = program2.opts();
+    await cmdStatus(opts);
+  });
+  program2.command("upgrade").description("Pull latest images and restart").action(async () => {
+    const opts = program2.opts();
+    await cmdUpgrade(opts);
+  });
+  program2.command("uninstall").description("Stop services and remove images").action(async () => {
+    const opts = program2.opts();
+    await cmdUninstall(opts);
+  });
+  program2.command("logs").argument("[service]", "Service to show logs for (omit for all)").description("Tail service logs").action(async (service) => {
+    const opts = program2.opts();
+    await cmdLogs(opts, service);
+  });
+  program2.command("version").description("Show CLI and image versions").action(async () => {
+    const opts = program2.opts();
+    await cmdVersion(opts);
+  });
+  const configCmd = program2.command("config").description("View and edit deployment configuration");
+  configCmd.command("show", { isDefault: true }).description("Show current configuration").action(() => {
+    cmdConfigShow();
+  });
+  configCmd.command("set").argument("<key>", "Configuration key").argument("<value>", "Configuration value").description("Set a configuration value").action((key, value) => {
+    cmdConfigSet(key, value);
+  });
+  configCmd.command("edit").description("Open configuration in your editor").action(async () => {
+    await cmdConfigEdit();
+  });
+  const systemCmd = program2.command("system").description("Manage IBM i systems (add, remove, list)");
+  systemCmd.command("add").description("Add an IBM i system").action(async () => {
+    await cmdSystemAdd();
+  });
+  systemCmd.command("remove").argument("<id>", "System ID to remove").description("Remove a system by ID").action((id) => {
+    cmdSystemRemove(id);
+  });
+  systemCmd.command("list", { isDefault: true }).description("List configured systems").action(() => {
+    cmdSystemList();
+  });
+  return program2;
+}
+
+// src/index.ts
+var program = createProgram();
+process.on("unhandledRejection", (err) => {
+  error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+program.parseAsync().catch((err) => {
+  error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});