@arkhera30/cli 0.2.4 → 0.3.0

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command10 } from "commander";
-import chalk10 from "chalk";
+import { Command as Command11 } from "commander";
+import chalk11 from "chalk";
 
 // src/commands/setup.ts
 import { Command as Command2 } from "commander";
@@ -570,7 +570,7 @@ Run '${runtime.name} compose logs <service>' from ~/Horus/ to investigate.`
 Run '${runtime.name} compose logs' from ~/Horus/ to investigate.`
       );
     }
-    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+    await new Promise((resolve3) => setTimeout(resolve3, intervalMs));
   }
 }
 
@@ -1650,12 +1650,16 @@ var upCommand = new Command3("up").description("Start the Horus stack").option("
     process.exit(1);
   }
   if (opts.pull) {
-    const pullSpinner = ora3("Pulling latest images...").start();
+    console.log("");
+    console.log(chalk3.bold("Pulling latest images..."));
     try {
-      await composeStreaming(runtime, runtime.name === "podman" ? ["pull"] : ["pull", "--ignore-pull-failures"]);
-      pullSpinner.succeed("Images up to date");
+      await composeStreaming(runtime, ["pull"]);
+      console.log("");
+      console.log(chalk3.green("\u2713 Pull complete"));
     } catch {
-      pullSpinner.warn("Could not pull images, using cached");
+      console.log("");
+      console.log(chalk3.yellow("\u26A0  Warning: failed to pull one or more images \u2014 using cached versions."));
+      console.log(chalk3.dim("   Run `docker compose pull` to see which services failed."));
     }
   }
   console.log("");
@@ -2642,8 +2646,487 @@ backupCommand.command("restore <file>").description("Restore Horus data from a b
   await restoreBackup(file, opts.yes);
 });
 
+// src/commands/test-env.ts
+import { Command as Command10 } from "commander";
+import chalk10 from "chalk";
+import ora8 from "ora";
+import { join as join8 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2 } from "path";
+
+// src/lib/test-env.ts
+import {
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync6,
+  rmSync,
+  readdirSync as readdirSync3,
+  cpSync
+} from "fs";
+import { join as join7 } from "path";
+import { parse as parseYaml3 } from "yaml";
+import { execa as execa3 } from "execa";
+function getTestEnvRoot(dataDir) {
+  return join7(dataDir, "test-env");
+}
+function getLockPath(dataDir, slot) {
+  return join7(getTestEnvRoot(dataDir), `slot-${slot}.lock`);
+}
+function getSlotDataPath(dataDir, slot) {
+  return join7(getTestEnvRoot(dataDir), `slot-${slot}`);
+}
+function getTestEnvConfigPath(dataDir) {
+  return join7(dataDir, "config", "test-env.yaml");
+}
+var DEFAULT_CONFIG = {
+  max_slots: 1,
+  timeout_minutes: 10,
+  base_port: 9100
+};
+var PORT_OFFSETS = {
+  anvil: 0,
+  typesense: 8,
+  vault_svc: 1,
+  vault_router: 50,
+  vault_mcp: 100,
+  forge: 150,
+  ui: 160
+};
+function loadTestEnvConfig(dataDir) {
+  const configPath = getTestEnvConfigPath(dataDir);
+  if (!existsSync9(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = readFileSync6(configPath, "utf-8");
+    const parsed = parseYaml3(raw);
+    const cfg = parsed?.test_env ?? {};
+    return {
+      max_slots: cfg.max_slots ?? DEFAULT_CONFIG.max_slots,
+      timeout_minutes: cfg.timeout_minutes ?? DEFAULT_CONFIG.timeout_minutes,
+      base_port: cfg.base_port ?? DEFAULT_CONFIG.base_port
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function calcPorts(slot, basePort) {
+  const base = basePort + slot * 300;
+  return {
+    anvil: base + PORT_OFFSETS.anvil,
+    typesense: base + PORT_OFFSETS.typesense,
+    vault_svc: base + PORT_OFFSETS.vault_svc,
+    vault_router: base + PORT_OFFSETS.vault_router,
+    vault_mcp: base + PORT_OFFSETS.vault_mcp,
+    forge: base + PORT_OFFSETS.forge,
+    ui: base + PORT_OFFSETS.ui
+  };
+}
+function readLock(dataDir, slot) {
+  const lockPath = getLockPath(dataDir, slot);
+  if (!existsSync9(lockPath)) return null;
+  try {
+    return JSON.parse(readFileSync6(lockPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeLock(dataDir, lock) {
+  mkdirSync6(getTestEnvRoot(dataDir), { recursive: true });
+  writeFileSync6(getLockPath(dataDir, lock.slot), JSON.stringify(lock, null, 2), "utf-8");
+}
+function removeLock(dataDir, slot) {
+  const lockPath = getLockPath(dataDir, slot);
+  if (existsSync9(lockPath)) {
+    rmSync(lockPath);
+  }
+}
+function isLockExpired(lock, timeoutMinutes) {
+  const acquired = new Date(lock.acquiredAt).getTime();
+  return Date.now() - acquired > timeoutMinutes * 60 * 1e3;
+}
+function getAllSlotStatuses(dataDir, cfg) {
+  return Array.from({ length: cfg.max_slots }, (_, slot) => {
+    const lock = readLock(dataDir, slot);
+    if (!lock) {
+      return { slot, state: "free" };
+    }
+    const expired = isLockExpired(lock, cfg.timeout_minutes);
+    const elapsed = (Date.now() - new Date(lock.acquiredAt).getTime()) / 6e4;
+    return {
+      slot,
+      state: expired ? "expired" : "acquired",
+      lock,
+      ports: lock.ports,
+      dataPath: lock.dataPath,
+      acquiredAt: lock.acquiredAt,
+      elapsedMinutes: Math.round(elapsed)
+    };
+  });
+}
+function findFreeSlot(dataDir, cfg) {
+  for (let slot = 0; slot < cfg.max_slots; slot++) {
+    const lock = readLock(dataDir, slot);
+    if (!lock) return slot;
+    if (isLockExpired(lock, cfg.timeout_minutes)) {
+      removeLock(dataDir, slot);
+      return slot;
+    }
+  }
+  return null;
+}
+function createSlotDirs(slotDataPath) {
+  const dirs = [
+    "notes",
+    join7("vaults", "personal"),
+    "registry",
+    "workspaces",
+    "sessions",
+    "typesense-data"
+  ];
+  for (const dir of dirs) {
+    mkdirSync6(join7(slotDataPath, dir), { recursive: true });
+  }
+}
+function removeSlotDirs(slotDataPath) {
+  if (existsSync9(slotDataPath)) {
+    rmSync(slotDataPath, { recursive: true, force: true });
+  }
+}
+function buildComposeEnv(runtime, ports, slotDataPath) {
+  return {
+    ...process.env,
+    HORUS_RUNTIME: runtime.name,
+    TEST_DATA_PATH: slotDataPath,
+    TEST_PORT_ANVIL: String(ports.anvil),
+    TEST_PORT_TYPESENSE: String(ports.typesense),
+    TEST_PORT_VAULT_SVC: String(ports.vault_svc),
+    TEST_PORT_VAULT_ROUTER: String(ports.vault_router),
+    TEST_PORT_VAULT_MCP: String(ports.vault_mcp),
+    TEST_PORT_FORGE: String(ports.forge),
+    TEST_PORT_UI: String(ports.ui)
+  };
+}
+async function composeUp(runtime, projectName2, ports, slotDataPath) {
+  const env = buildComposeEnv(runtime, ports, slotDataPath);
+  const result = await execa3(
+    runtime.name,
+    [
+      "compose",
+      "-p",
+      projectName2,
+      "-f",
+      join7(HORUS_DIR, "docker-compose.yml"),
+      "-f",
+      join7(HORUS_DIR, "docker-compose.test.yml"),
+      "up",
+      "-d"
+    ],
+    { cwd: HORUS_DIR, env, reject: false }
+  );
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Failed to start shadow stack (project ${projectName2}):
+${result.stderr}`
+    );
+  }
+}
+async function composeDown(runtime, projectName2, ports, slotDataPath) {
+  const env = buildComposeEnv(runtime, ports, slotDataPath);
+  await execa3(
+    runtime.name,
+    ["compose", "-p", projectName2, "down", "--volumes", "--remove-orphans"],
+    { cwd: HORUS_DIR, env, reject: false }
+  );
+}
+var HEALTH_SERVICES = ["anvil", "forge", "vault-mcp", "typesense"];
+async function checkContainerHealthByProject(runtime, projectName2, service) {
+  const candidates = [
+    `${projectName2}-${service}-1`,
+    `${projectName2}_${service}_1`
+  ];
+  for (const name of candidates) {
+    try {
+      const result = await execa3(
+        runtime.name,
+        ["inspect", "--format", "{{.State.Health.Status}}", name],
+        { reject: false }
+      );
+      if (result.exitCode === 0) {
+        const status = result.stdout.toString().trim().toLowerCase();
+        if (status === "healthy") return "healthy";
+        if (status === "unhealthy") return "unhealthy";
+        return "starting";
+      }
+    } catch {
+      continue;
+    }
+  }
+  return "starting";
+}
+async function waitForShadowStackHealthy(runtime, projectName2, timeoutMs = 12e4, intervalMs = 3e3, onUpdate) {
+  const start = Date.now();
+  while (true) {
+    const statuses = {};
+    await Promise.all(
+      HEALTH_SERVICES.map(async (svc) => {
+        statuses[svc] = await checkContainerHealthByProject(runtime, projectName2, svc);
+      })
+    );
+    if (onUpdate) onUpdate(statuses);
+    const allHealthy = Object.values(statuses).every((s) => s === "healthy");
+    if (allHealthy) return;
+    const anyUnhealthy = Object.values(statuses).some((s) => s === "unhealthy");
+    if (anyUnhealthy) {
+      const failed = Object.entries(statuses).filter(([, s]) => s === "unhealthy").map(([n]) => n).join(", ");
+      throw new Error(`Shadow stack services failed health check: ${failed}`);
+    }
+    if (Date.now() - start >= timeoutMs) {
+      const notReady = Object.entries(statuses).filter(([, s]) => s !== "healthy").map(([n, s]) => `${n}(${s})`).join(", ");
+      throw new Error(`Timed out after ${timeoutMs / 1e3}s waiting for: ${notReady}`);
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+}
+function seedFromFixtures(fixturesPath, slotDataPath) {
+  if (!existsSync9(fixturesPath)) {
+    throw new Error(`Fixtures not found at ${fixturesPath}. Run from the Horus repo root.`);
+  }
+  const dirs = readdirSync3(fixturesPath);
+  for (const dir of dirs) {
+    const src = join7(fixturesPath, dir);
+    const dest = join7(slotDataPath, dir);
+    cpSync(src, dest, { recursive: true });
+  }
+}
+function seedFromLive(dataDir, slotDataPath) {
+  const liveDirs = ["notes", "vaults", "registry"];
+  for (const dir of liveDirs) {
+    const src = join7(dataDir, dir);
+    const dest = join7(slotDataPath, dir);
+    if (existsSync9(src)) {
+      cpSync(src, dest, { recursive: true });
+    }
+  }
+}
+function projectName(slot) {
+  return `horus-test-${slot}`;
+}
+
+// src/commands/test-env.ts
+var testEnvCommand = new Command10("test-env").description("Manage isolated shadow stacks for integration testing");
+testEnvCommand.command("acquire").description("Start a shadow stack on alternate ports with isolated data").option("--timeout <seconds>", "Max wait for health checks (default: 120)", "120").action(async (opts) => {
+  const config = loadConfig();
+  const dataDir = config.data_dir;
+  const testCfg = loadTestEnvConfig(dataDir);
+  const spinner = ora8("Detecting runtime...").start();
+  let runtime;
+  try {
+    runtime = await detectRuntime(config.runtime);
+    spinner.succeed(`Using ${chalk10.cyan(runtime.name)}`);
+  } catch (error) {
+    spinner.fail("No container runtime found");
+    console.error(error.message);
+    process.exit(1);
+  }
+  const slot = findFreeSlot(dataDir, testCfg);
+  if (slot === null) {
+    console.error(chalk10.red(
+      `All ${testCfg.max_slots} slot(s) are in use. Run ${chalk10.bold("horus test-env status")} to see active slots, or ${chalk10.bold("horus test-env release")} to free one.`
+    ));
+    process.exit(1);
+  }
+  const ports = calcPorts(slot, testCfg.base_port);
+  const slotDataPath = getSlotDataPath(dataDir, slot);
+  const project = projectName(slot);
+  const dirSpinner = ora8(`Creating slot-${slot} data directories...`).start();
+  createSlotDirs(slotDataPath);
+  dirSpinner.succeed(`Data directory: ${chalk10.dim(slotDataPath)}`);
+  writeLock(dataDir, {
+    slot,
+    pid: process.pid,
+    acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ports,
+    dataPath: slotDataPath
+  });
+  const upSpinner = ora8(`Starting shadow stack (project ${chalk10.cyan(project)})...`).start();
+  try {
+    await composeUp(runtime, project, ports, slotDataPath);
+    upSpinner.succeed(`Shadow stack started`);
+  } catch (error) {
+    upSpinner.fail("Failed to start shadow stack");
+    removeLock(dataDir, slot);
+    removeSlotDirs(slotDataPath);
+    console.error(error.message);
+    process.exit(1);
+  }
+  const healthSpinner = ora8("Waiting for services to be healthy...").start();
+  const timeoutMs = parseInt(opts.timeout, 10) * 1e3;
+  try {
+    await waitForShadowStackHealthy(runtime, project, timeoutMs, 3e3, (statuses) => {
+      const parts = Object.entries(statuses).map(([svc, s]) => `${svc}:${s === "healthy" ? chalk10.green(s) : chalk10.yellow(s)}`).join("  ");
+      healthSpinner.text = `Waiting for services... ${parts}`;
+    });
+    healthSpinner.succeed("All services healthy");
+  } catch (error) {
+    healthSpinner.fail("Health check failed");
+    await composeDown(runtime, project, ports, slotDataPath);
+    removeLock(dataDir, slot);
+    removeSlotDirs(slotDataPath);
+    console.error(error.message);
+    process.exit(1);
+  }
+  console.log("");
+  console.log(chalk10.bold.green(`\u2713 Slot ${slot} acquired`));
+  console.log("");
+  console.log(chalk10.bold("Connection info:"));
+  console.log(`  Slot:       ${chalk10.cyan(slot)}`);
+  console.log(`  Project:    ${chalk10.cyan(project)}`);
+  console.log(`  Data:       ${chalk10.dim(slotDataPath)}`);
+  console.log("");
+  console.log(chalk10.bold("Ports:"));
+  console.log(`  Anvil:        http://localhost:${chalk10.cyan(ports.anvil)}`);
+  console.log(`  Forge:        http://localhost:${chalk10.cyan(ports.forge)}`);
+  console.log(`  Vault MCP:    http://localhost:${chalk10.cyan(ports.vault_mcp)}`);
+  console.log(`  Vault Router: http://localhost:${chalk10.cyan(ports.vault_router)}`);
+  console.log(`  Typesense:    http://localhost:${chalk10.cyan(ports.typesense)}`);
+  console.log(`  UI:           http://localhost:${chalk10.cyan(ports.ui)}`);
+  console.log("");
+  console.log(chalk10.bold("Environment:"));
+  console.log(`  export TEST_SLOT=${slot}`);
+  console.log(`  export TEST_ANVIL_URL=http://localhost:${ports.anvil}`);
+  console.log(`  export TEST_FORGE_URL=http://localhost:${ports.forge}`);
+  console.log(`  export TEST_VAULT_MCP_URL=http://localhost:${ports.vault_mcp}`);
+  console.log(`  export TEST_DATA_PATH=${slotDataPath}`);
+  console.log("");
+  console.log(chalk10.dim(`Run ${chalk10.bold(`horus test-env seed --slot ${slot}`)} to populate with fixtures.`));
+  console.log(chalk10.dim(`Run ${chalk10.bold(`horus test-env release --slot ${slot}`)} when done.`));
+});
+testEnvCommand.command("release").description("Tear down a shadow stack and remove its data").option("--slot <n>", "Slot number to release (default: auto-detect acquired slot)").action(async (opts) => {
+  const config = loadConfig();
+  const dataDir = config.data_dir;
+  const testCfg = loadTestEnvConfig(dataDir);
+  let slot;
+  if (opts.slot !== void 0) {
+    slot = parseInt(opts.slot, 10);
+  } else {
+    const statuses = getAllSlotStatuses(dataDir, testCfg);
+    const acquired = statuses.find((s) => s.state === "acquired" || s.state === "expired");
+    if (!acquired) {
+      console.log(chalk10.yellow("No active slots found."));
+      return;
+    }
+    slot = acquired.slot;
+  }
+  const lock = readLock(dataDir, slot);
+  const slotDataPath = getSlotDataPath(dataDir, slot);
+  const project = projectName(slot);
+  const ports = lock?.ports ?? calcPorts(slot, testCfg.base_port);
+  const spinner = ora8("Detecting runtime...").start();
+  let runtime;
+  try {
+    runtime = await detectRuntime(config.runtime);
+    spinner.succeed(`Using ${chalk10.cyan(runtime.name)}`);
+  } catch (error) {
+    spinner.fail("No container runtime found");
+    console.error(error.message);
+    process.exit(1);
+  }
+  const downSpinner = ora8(`Stopping ${chalk10.cyan(project)}...`).start();
+  try {
+    await composeDown(runtime, project, ports, slotDataPath);
+    downSpinner.succeed("Shadow stack stopped");
+  } catch {
+    downSpinner.warn("Failed to stop cleanly (continuing cleanup)");
+  }
+  const cleanSpinner = ora8("Removing test data...").start();
+  removeSlotDirs(slotDataPath);
+  removeLock(dataDir, slot);
+  cleanSpinner.succeed("Test data removed");
+  console.log("");
+  console.log(chalk10.bold.green(`\u2713 Slot ${slot} released`));
+});
+testEnvCommand.command("status").description("Show active shadow stack slots").action(() => {
+  const config = loadConfig();
+  const dataDir = config.data_dir;
+  const testCfg = loadTestEnvConfig(dataDir);
+  const statuses = getAllSlotStatuses(dataDir, testCfg);
+  const acquiredCount = statuses.filter((s) => s.state === "acquired").length;
+  console.log("");
+  console.log(chalk10.bold("Test Environment Status"));
+  console.log(`  Max slots:  ${testCfg.max_slots}`);
+  console.log(`  In use:     ${acquiredCount} / ${testCfg.max_slots}`);
+  console.log(`  Base port:  ${testCfg.base_port}`);
+  console.log("");
+  if (statuses.every((s) => s.state === "free")) {
+    console.log(chalk10.dim("  No active slots."));
+    console.log("");
+    return;
+  }
+  for (const s of statuses) {
+    if (s.state === "free") continue;
+    const stateLabel = s.state === "expired" ? chalk10.yellow("EXPIRED") : chalk10.green("ACTIVE");
+    console.log(`  ${chalk10.bold(`Slot ${s.slot}`)}  ${stateLabel}`);
+    if (s.acquiredAt) {
+      console.log(`    Acquired: ${s.acquiredAt} (${s.elapsedMinutes}m ago)`);
+    }
+    if (s.ports) {
+      console.log(`    Ports:    anvil=${s.ports.anvil}  forge=${s.ports.forge}  vault-mcp=${s.ports.vault_mcp}  typesense=${s.ports.typesense}`);
+    }
+    if (s.dataPath) {
+      console.log(`    Data:     ${chalk10.dim(s.dataPath)}`);
+    }
+    console.log("");
+  }
+});
+testEnvCommand.command("seed").description("Populate a slot with test fixtures (or a snapshot of live data)").option("--slot <n>", "Slot to seed (default: auto-detect)").option("--from-live", "Snapshot live data instead of using fixtures").action(async (opts) => {
+  const config = loadConfig();
+  const dataDir = config.data_dir;
+  const testCfg = loadTestEnvConfig(dataDir);
+  let slot;
+  if (opts.slot !== void 0) {
+    slot = parseInt(opts.slot, 10);
+  } else {
+    const statuses = getAllSlotStatuses(dataDir, testCfg);
+    const acquired = statuses.find((s) => s.state === "acquired");
+    if (!acquired) {
+      console.error(chalk10.red("No active slot found. Run `horus test-env acquire` first."));
+      process.exit(1);
+    }
+    slot = acquired.slot;
+  }
+  const slotDataPath = getSlotDataPath(dataDir, slot);
+  if (opts.fromLive) {
+    const spinner = ora8("Snapshotting live data into slot...").start();
+    try {
+      seedFromLive(dataDir, slotDataPath);
+      spinner.succeed("Live data snapshotted");
+    } catch (error) {
+      spinner.fail("Failed to snapshot live data");
+      console.error(error.message);
+      process.exit(1);
+    }
+  } else {
+    const here = dirname2(fileURLToPath2(import.meta.url));
+    const repoRoot = join8(here, "..", "..", "..", "..", "..");
+    const fixturesPath = join8(repoRoot, "test", "fixtures");
+    const spinner = ora8(`Seeding slot-${slot} from fixtures...`).start();
+    try {
+      seedFromFixtures(fixturesPath, slotDataPath);
+      spinner.succeed(`Slot ${slot} seeded from fixtures`);
+    } catch (error) {
+      spinner.fail("Failed to seed fixtures");
+      console.error(error.message);
+      process.exit(1);
+    }
+  }
+  console.log("");
+  console.log(chalk10.dim("Services will re-index automatically. Allow ~10s before running tests."));
+});
+
 // src/index.ts
-var program = new Command10();
+var program = new Command11();
 program.name("horus").description("CLI for managing the Horus Docker Compose stack").version(CLI_VERSION);
 program.addCommand(setupCommand);
 program.addCommand(upCommand);
@@ -2654,6 +3137,7 @@ program.addCommand(connectCommand);
 program.addCommand(updateCommand);
 program.addCommand(doctorCommand);
 program.addCommand(backupCommand);
+program.addCommand(testEnvCommand);
 program.exitOverride();
 try {
   await program.parseAsync(process.argv);
@@ -2662,9 +3146,9 @@ try {
     process.exit(0);
   }
   if (error instanceof Error) {
-    console.error(chalk10.red(`Error: ${error.message}`));
+    console.error(chalk11.red(`Error: ${error.message}`));
   } else {
-    console.error(chalk10.red("An unexpected error occurred."));
+    console.error(chalk11.red("An unexpected error occurred."));
   }
   process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkhera30/cli",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "CLI for managing the Horus AI development stack",
   "type": "module",
   "bin": {