@celilo/e2e 0.2.1 → 0.4.0

package/bin/e2e-down

@@ -1,10 +1,13 @@
 #!/bin/bash
-# Tear down ALL E2E test artifacts — interactive sessions AND orphaned test runs.
+# Tear down E2E test artifacts:
+# - Persistent test networks (from `e2e-run --keep`)
+# - Interactive sessions (from `e2e-up`)
+# - Orphaned test runs
 #
 # Usage:
-#   ./bin/e2e-down           # Stop and remove everything
-#   ./bin/e2e-down --keep    # Stop containers but keep volumes (faster restart)
-#   ./bin/e2e-down --all     # Also stop module containers (authentik, etc.) that compete for resources
+#   ./bin/e2e-down           # tear down everything e2e-related
+#   ./bin/e2e-down --keep    # stop containers but keep volumes
+#   ./bin/e2e-down --all     # also stop module containers that compete for resources
 
 set -e
 SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
@@ -19,20 +22,42 @@ for arg in "$@"; do
   esac
 done
 
-# 1. Stop the interactive session (if running)
+# 1. Tear down any persistent test networks (look for marker files in common test dirs)
+for dir in "$(pwd)" "$(pwd)/../../e2e" "$(pwd)/../../../e2e"; do
+  MARKER="$dir/.e2e-persistent.json"
+  if [ -f "$MARKER" ]; then
+    PROJECT=$(bun -e "console.log(JSON.parse(require('fs').readFileSync('$MARKER', 'utf-8')).projectName)" 2>/dev/null || echo "")
+    if [ -n "$PROJECT" ]; then
+      echo "Tearing down persistent network: $PROJECT"
+      docker compose -f docker-compose.test.yml -p "$PROJECT" down --volumes --remove-orphans 2>/dev/null || true
+    fi
+    rm -f "$MARKER"
+  fi
+done
+
+# Also check E2E_TEST_DIR if set
+if [ -n "$E2E_TEST_DIR" ] && [ -f "$E2E_TEST_DIR/.e2e-persistent.json" ]; then
+  PROJECT=$(bun -e "console.log(JSON.parse(require('fs').readFileSync('$E2E_TEST_DIR/.e2e-persistent.json', 'utf-8')).projectName)" 2>/dev/null || echo "")
+  if [ -n "$PROJECT" ]; then
+    echo "Tearing down persistent network: $PROJECT"
+    docker compose -f docker-compose.test.yml -p "$PROJECT" down --volumes --remove-orphans 2>/dev/null || true
+  fi
+  rm -f "$E2E_TEST_DIR/.e2e-persistent.json"
+fi
+
+# 2. Stop the interactive session (if running)
 echo "Stopping interactive session..."
-docker compose -p "conductor-e2e-interactive" down --remove-orphans 2>/dev/null || true
+docker compose -p "celilo-e2e-interactive" down --remove-orphans 2>/dev/null || true
 
-# 2. Kill ALL containers matching conductor-e2e-* (orphaned test runs)
-CONTAINERS=$(docker ps -a --filter "name=conductor-e2e" --format "{{.ID}}" 2>/dev/null)
+# 3. Kill ALL containers matching celilo-e2e-* (orphaned test runs)
+CONTAINERS=$(docker ps -a --filter "name=celilo-e2e" --format "{{.ID}}" 2>/dev/null)
 if [ -n "$CONTAINERS" ]; then
   COUNT=$(echo "$CONTAINERS" | wc -l | tr -d ' ')
   echo "Removing $COUNT orphaned e2e containers..."
   echo "$CONTAINERS" | xargs docker rm -f 2>/dev/null || true
 fi
 
-# 3. Stop module containers that compete for resources (--all flag)
-# These come from local docker-compose runs, not from e2e, but starve the VM.
+# 4. Stop module containers that compete for resources (--all flag)
 if [ "$STOP_ALL" = true ]; then
   MODULE_PATTERNS="authentik- caddy- build-your-own-internet-"
   for pattern in $MODULE_PATTERNS; do
@@ -45,23 +70,23 @@ if [ "$STOP_ALL" = true ]; then
   done
 fi
 
-# 3. Remove all conductor-e2e networks
-NETWORKS=$(docker network ls --filter "name=conductor-e2e" --format "{{.ID}}" 2>/dev/null)
+# 5. Remove all celilo-e2e networks
+NETWORKS=$(docker network ls --filter "name=celilo-e2e" --format "{{.ID}}" 2>/dev/null)
 if [ -n "$NETWORKS" ]; then
   echo "Removing e2e networks..."
   echo "$NETWORKS" | xargs docker network rm 2>/dev/null || true
 fi
 
-# 4. Remove volumes (unless --keep)
+# 6. Remove volumes (unless --keep)
 if [ "$KEEP_VOLUMES" = false ]; then
-  VOLUMES=$(docker volume ls --filter "name=conductor-e2e" --format "{{.Name}}" 2>/dev/null)
+  VOLUMES=$(docker volume ls --filter "name=celilo-e2e" --format "{{.Name}}" 2>/dev/null)
   if [ -n "$VOLUMES" ]; then
     echo "Removing e2e volumes..."
     echo "$VOLUMES" | xargs docker volume rm 2>/dev/null || true
   fi
 fi
 
-# 5. Clean up generated compose file
+# 7. Clean up generated compose files
 rm -f docker-compose.test.yml
 
 echo "E2E environment cleaned."

package/config/dns/iamtheinternet.org.zone

@@ -2,14 +2,14 @@ $ORIGIN iamtheinternet.org.
 $TTL 300
 
 @ IN SOA ns1.iamtheinternet.org. admin.iamtheinternet.org. (
-    2024010764 300 60 604800 300
+    2024010772 300 60 604800 300
 )
 
 @       IN NS   ns1.iamtheinternet.org.
 ns1     IN A    100.64.0.55
 @    IN A    0.0.0.0
 caddy    IN A    100.100.0.100
-www    IN A    10.0.10.10
+www    IN A    100.100.0.100
 deathstar    IN A    100.100.0.100
 test    IN A    0.0.0.0
 auth    IN A    100.100.0.100

package/docker/Dockerfile.management

@@ -22,9 +22,12 @@ RUN update-ca-certificates
 # Point apt at the simulated apt cache proxy (for runtime apt usage)
 RUN echo 'Acquire::http::Proxy "http://100.64.0.2:3142";' > /etc/apt/apt.conf.d/00proxy
 
+# Install celilo CLI from npm — provides the `celilo` command
+RUN bun add -g @celilo/cli@0.1.4
+
 COPY config/ssh/generate-keys.sh /config/ssh/generate-keys.sh
 COPY config/routing/management-routes.sh /startup.sh
 RUN chmod +x /startup.sh /config/ssh/generate-keys.sh
 
-WORKDIR /celilo/apps/celilo
+WORKDIR /root
 CMD ["/startup.sh"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/e2e",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "E2E test infrastructure for Celilo-deployed applications. Provides a simulated internet with DNS hierarchy, ACME server, firewalls, and target machines in Docker.",
   "type": "module",
   "main": "./src/index.ts",

package/src/container-manager.ts

@@ -13,7 +13,12 @@ const PACKAGE_ROOT = join(__dirname, '..');
  * Find the Celilo project root by walking up from the package directory.
  * Looks for apps/celilo/ as the marker.
  */
-function findCeliloRoot(): string {
+/**
+ * Try to find the Celilo project root by walking up from the package directory.
+ * Returns undefined if not found — the CLI is pre-installed in Docker so this
+ * is only needed for development (mounting local source).
+ */
+function findCeliloRoot(): string | undefined {
   let dir = PACKAGE_ROOT;
   for (let i = 0; i < 10; i++) {
     if (existsSync(join(dir, 'apps', 'celilo'))) {
@@ -23,10 +28,7 @@ function findCeliloRoot(): string {
     if (parent === dir) break;
     dir = parent;
   }
-  throw new Error(
-    'Could not find Celilo project root (directory containing apps/celilo/).\n' +
-    'Set it explicitly: network().celilo("/path/to/infra").start()',
-  );
+  return undefined;
 }
 
 const COMPOSE_TIMEOUT = 120_000;
@@ -218,7 +220,7 @@ export async function startNetwork(config: NetworkConfig): Promise<NetworkHandle
 
   // Build and start per-test containers only
   console.log('[progress:start] building Docker images | images built');
-  run(`docker compose -f ${COMPOSE_FILE} -p ${projectName} build`, { cwd: composeDir, timeout: 300_000 });
+  run(`docker compose -f ${COMPOSE_FILE} -p ${projectName} build`, { cwd: composeDir, timeout: 600_000 });
 
   console.log('[progress:start] starting containers | containers running');
   run(`docker compose -f ${COMPOSE_FILE} -p ${projectName} up -d`, { cwd: composeDir, timeout: 120_000 });
@@ -296,7 +298,7 @@ export async function startNetwork(config: NetworkConfig): Promise<NetworkHandle
   // Initialize celilo
   console.log('[progress:start] initializing celilo | celilo initialized');
   const initResult = dockerExec(projectName, composeDir, 'management',
-    `cd /celilo/apps/celilo && bun run src/cli/index.ts system init --accept-defaults \
+    `celilo system init --accept-defaults \
       network.dmz.subnet=10.0.10.0/24 \
       network.app.subnet=10.0.20.0/24 \
       network.secure.subnet=10.0.30.0/24 \
@@ -308,6 +310,8 @@ export async function startNetwork(config: NetworkConfig): Promise<NetworkHandle
   }
 
   console.log('[progress:done] network ready');
+  // Emit project name so the runner can persist it if --keep is set
+  console.log(`[e2e:project] ${projectName}`);
 
   const handle: NetworkHandle = {
     projectName,
@@ -317,7 +321,7 @@ export async function startNetwork(config: NetworkConfig): Promise<NetworkHandle
       const timeoutMs = typeof optsOrTimeout === 'number' ? optsOrTimeout : (optsOrTimeout?.timeoutMs ?? 120_000);
 
       const result = await dockerExecAsync(projectName, composeDir, 'management',
-        `cd /celilo/apps/celilo && bun run src/cli/index.ts ${cmd}`, timeoutMs);
+        `celilo ${cmd}`, timeoutMs);
 
       if (check && result.exitCode !== 0) {
         throw new CeliloCommandError(cmd, result);
@@ -360,6 +364,12 @@ export async function startNetwork(config: NetworkConfig): Promise<NetworkHandle
     waitFor,
 
     async stop(): Promise<void> {
+      // Respect --keep / --reuse: don't tear down the network
+      if (process.env.CELILO_E2E_KEEP === '1' || process.env.CELILO_E2E_REUSE === '1') {
+        console.log(`[progress:done] network kept alive (project: ${projectName})`);
+        activeProjects.delete(projectName);  // don't re-teardown on exit
+        return;
+      }
       console.log('[progress:start] stopping network | network stopped');
       try {
         run(`docker compose -f ${COMPOSE_FILE} -p ${projectName} down --volumes --remove-orphans`,
@@ -373,3 +383,90 @@ export async function startNetwork(config: NetworkConfig): Promise<NetworkHandle
 
   return handle;
 }
+
+/**
+ * Reconnect to an existing test network (previously kept alive with --keep).
+ * Returns a NetworkHandle pointing to the existing Docker project. Skips
+ * all the setup (image build, container start, celilo init) — assumes the
+ * network is already running and healthy.
+ *
+ * If the project doesn't exist, throws with an actionable error.
+ */
+export function reconnectNetwork(projectName: string): NetworkHandle {
+  const composeDir = PACKAGE_ROOT;
+
+  // Verify the project actually exists
+  try {
+    const result = run(
+      `docker compose -f ${COMPOSE_FILE} -p ${projectName} ps -q`,
+      { cwd: composeDir, timeout: 10_000 },
+    );
+    if (!result.trim()) {
+      throw new Error(`No containers found for project ${projectName}`);
+    }
+  } catch (err) {
+    throw new Error(
+      `Cannot reconnect to network '${projectName}': ${err instanceof Error ? err.message : String(err)}\n` +
+      `Fix: Run without --reuse to create a fresh network, or check if containers were torn down.`,
+    );
+  }
+
+  activeProjects.add(projectName);
+  console.log(`[progress:done] reconnected to existing network (${projectName})`);
+  console.log(`[e2e:project] ${projectName}`);
+
+  return {
+    projectName,
+
+    async celilo(cmd: string, optsOrTimeout?: number | { check?: boolean; timeoutMs?: number }): Promise<ExecResult> {
+      const check = typeof optsOrTimeout === 'object' ? (optsOrTimeout.check ?? true) : true;
+      const timeoutMs = typeof optsOrTimeout === 'number' ? optsOrTimeout : (optsOrTimeout?.timeoutMs ?? 120_000);
+
+      const result = await dockerExecAsync(projectName, composeDir, 'management',
+        `celilo ${cmd}`, timeoutMs);
+
+      if (check && result.exitCode !== 0) {
+        throw new CeliloCommandError(cmd, result);
+      }
+      return result;
+    },
+
+    exec(container: string, cmd: string, timeoutMs = 60_000): Promise<ExecResult> {
+      return Promise.resolve(dockerExec(projectName, composeDir, container, cmd, timeoutMs));
+    },
+
+    async dig(name: string): Promise<string> {
+      const result = dockerExec(projectName, composeDir, 'management',
+        `dig +short ${name}`);
+      return result.stdout.trim();
+    },
+
+    async debug(container = 'management'): Promise<void> {
+      console.log(`[debug:pause] ${projectName} ${container}`);
+      const signalFile = join(composeDir, `.debug-resume-${process.pid}`);
+      const start = Date.now();
+      const timeout = 86_400_000;
+      while (!existsSync(signalFile) && Date.now() - start < timeout) {
+        await new Promise(r => setTimeout(r, 500));
+      }
+      try { require('node:fs').unlinkSync(signalFile); } catch {}
+      console.log('[debug:resumed]');
+    },
+
+    waitFor,
+
+    async stop(): Promise<void> {
+      // Respect --keep / --reuse: don't tear down
+      if (process.env.CELILO_E2E_KEEP === '1' || process.env.CELILO_E2E_REUSE === '1') {
+        console.log(`[progress:done] network kept alive (project: ${projectName})`);
+        activeProjects.delete(projectName);
+        return;
+      }
+      try {
+        run(`docker compose -f ${COMPOSE_FILE} -p ${projectName} down --volumes --remove-orphans`,
+          { cwd: composeDir, timeout: 60_000 });
+      } catch {}
+      activeProjects.delete(projectName);
+    },
+  };
+}

package/src/docker-compose-generator.ts

@@ -227,7 +227,7 @@ export function generateSharedInfraYaml(): string {
  * References the shared infrastructure's isp-external network as external.
  * Creates its own internal, dmz, app, secure networks.
  */
-export function generateTestComposeYaml(config: NetworkConfig, celiloRoot = '..'): string {
+export function generateTestComposeYaml(config: NetworkConfig, celiloRoot?: string): string {
   const networks: Record<string, unknown> = {
     internal: networkDef('192.168.0.0/24', '192.168.0.250'),
     dmz: networkDef('10.0.10.0/24', '10.0.10.250'),
@@ -259,7 +259,7 @@ export function generateTestComposeYaml(config: NetworkConfig, celiloRoot = '..'
     networks: { internal: { ipv4_address: '192.168.0.100' } },
     cap_add: ['NET_ADMIN'],
     volumes: [
-      `${celiloRoot}:/celilo`,
+      ...(celiloRoot ? [`${celiloRoot}:/celilo`] : []),
       'ssh-keys:/ssh-keys',
       ...(config.managementVolumes ?? []),
     ],
@@ -371,7 +371,7 @@ export function generateComposeYaml(config: NetworkConfig, celiloRoot = '..'): s
     networks: { internal: { ipv4_address: '192.168.0.100' } },
     cap_add: ['NET_ADMIN'],
     volumes: [
-      `${celiloRoot}:/celilo`,
+      ...(celiloRoot ? [`${celiloRoot}:/celilo`] : []),
       'ssh-keys:/ssh-keys',
       ...(config.managementVolumes ?? []),
     ],

package/src/index.ts

@@ -24,6 +24,9 @@
 // Builder API
 export { network, NetworkBuilder } from './network-builder';
 
+// Reconnect to an existing network (for --reuse mode)
+export { reconnectNetwork } from './container-manager';
+
 // Progress reporting (emit signals the test runner displays)
 export { progress } from './progress';
 

package/src/network-builder.ts

@@ -1,6 +1,36 @@
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { startNetwork } from './container-manager';
 import type { NetworkConfig, NetworkHandle, TopologyPreset } from './types';
 
+/**
+ * If a mounted path looks like a celilo module (has scripts/package.json),
+ * ensure its dependencies are installed on the host before Docker starts.
+ */
+async function ensureModuleDeps(hostPath: string): Promise<void> {
+  // Check common locations for a module's scripts dir
+  for (const scriptsDir of [
+    join(hostPath, 'scripts'),
+    join(hostPath, 'celilo', 'scripts'),
+  ]) {
+    const pkgJson = join(scriptsDir, 'package.json');
+    const nodeModules = join(scriptsDir, 'node_modules');
+    if (existsSync(pkgJson) && !existsSync(nodeModules)) {
+      console.log(`[progress:start] installing deps in ${scriptsDir} | deps installed`);
+      try {
+        execSync('bun install', { cwd: scriptsDir, timeout: 30_000, stdio: 'pipe' });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(
+          `Failed to install module dependencies in ${scriptsDir}:\n${msg}\n\n` +
+          `Fix: cd ${scriptsDir} && bun install`,
+        );
+      }
+    }
+  }
+}
+
 export class NetworkBuilder {
   private config: NetworkConfig = {
     topology: 'default',
@@ -82,6 +112,13 @@ export class NetworkBuilder {
   }
 
   async start(): Promise<NetworkHandle> {
+    // Pre-flight: ensure mounted module directories have deps installed.
+    // Without this, `module import` tries to `bun install` inside Docker
+    // through the simulated internet, which is slow or fails.
+    for (const vol of this.config.managementVolumes) {
+      const [hostPath] = vol.split(':');
+      await ensureModuleDeps(hostPath);
+    }
     return startNetwork(this.config);
   }
 }

package/src/runner.ts

@@ -27,7 +27,13 @@ const PKG_DIR = resolve(import.meta.dir, '..');
 const testDir = process.env.E2E_TEST_DIR || process.cwd();
 const testsPath = join(testDir, 'tests');
 const timingFile = join(testDir, '.e2e-timing.json');
-const patterns = process.argv.slice(2);
+const persistentFile = join(testDir, '.e2e-persistent.json');
+
+// Parse flags out of argv
+const rawArgs = process.argv.slice(2);
+const flagKeep = rawArgs.includes('--keep');
+const flagReuse = rawArgs.includes('--reuse');
+const patterns = rawArgs.filter((a) => !a.startsWith('--'));
 
 // ─── Colors ──────────────────────────────────────────────────────────
 
@@ -309,6 +315,7 @@ interface TestResult {
   duration: number;
   error?: string;
   hadDebugPause?: boolean;
+  projectName?: string;
 }
 
 async function runTest(
@@ -323,13 +330,29 @@ async function runTest(
 
   display.reset(start, expectedDuration);
   let hadDebugPause = false;
+  let capturedProjectName: string | undefined;
 
   return new Promise<TestResult>((resolveTest) => {
+    // Env vars let the test detect --keep / --reuse modes
+    const testEnv: NodeJS.ProcessEnv = { ...process.env };
+    if (flagKeep) testEnv.CELILO_E2E_KEEP = '1';
+    if (flagReuse) {
+      // Read the persistent project and pass it to the test
+      try {
+        const data = JSON.parse(readFileSync(persistentFile, 'utf-8'));
+        testEnv.CELILO_E2E_REUSE = '1';
+        testEnv.CELILO_E2E_PROJECT = data.projectName;
+      } catch {
+        console.error(`${red}✗ --reuse: no persistent network found. Run with --keep first.${reset}`);
+        process.exit(1);
+      }
+    }
+
     // 1 hour timeout per test (debug sessions can be long)
     const proc = spawn('bun', ['test', '--timeout', '3600000', file], {
       cwd: PKG_DIR,
       stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env },
+      env: testEnv,
     });
 
     let stdout = '';
@@ -393,6 +416,13 @@ async function runTest(
           continue;
         }
 
+        // Capture project name for persistent network tracking
+        const projectMatch = trimmed.match(/\[e2e:project\] (\S+)/);
+        if (projectMatch) {
+          capturedProjectName = projectMatch[1];
+          continue;
+        }
+
         parseLine(trimmed, display);
       }
     }
@@ -423,10 +453,11 @@ async function runTest(
             status: 'suspicious',
             duration,
             hadDebugPause,
+            projectName: capturedProjectName,
             error: '0 assertions — test likely exited before reaching assertions',
           });
         } else {
-          resolveTest({ name, status: 'pass', duration, hadDebugPause });
+          resolveTest({ name, status: 'pass', duration, hadDebugPause, projectName: capturedProjectName });
         }
       } else {
         resolveTest({
@@ -434,6 +465,7 @@ async function runTest(
           status: 'fail',
           duration,
           hadDebugPause,
+          projectName: capturedProjectName,
           error: extractFailureMessage(lines, code ?? 1),
         });
       }
@@ -505,15 +537,6 @@ async function main() {
   console.log(`${bold}╚══════════════════════════════════════════════════════════════╝${reset}`);
   console.log();
 
-  // Shared infra check
-  console.log(`${bold}Shared Infrastructure${reset}`);
-  if (isSharedInfraHealthy()) {
-    console.log(`  ${green}✔ already running (DNS healthy)${reset}`);
-  } else {
-    console.log(`  ${dim}Will start on first test...${reset}`);
-  }
-  console.log();
-
   const suiteStart = Date.now();
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
   const resultsDir = join(testDir, 'results', timestamp);
@@ -565,6 +588,21 @@ async function main() {
       history[name] = result.duration;
     }
 
+    // Write persistent network info if --keep was set and we captured a project
+    if (flagKeep && result.projectName) {
+      writeFileSync(
+        persistentFile,
+        JSON.stringify({
+          projectName: result.projectName,
+          testFile: file,
+          createdAt: new Date().toISOString(),
+        }, null, 2) + '\n',
+      );
+      console.log(`${dim}  Persistent network: ${result.projectName}${reset}`);
+      console.log(`${dim}  Reuse: ${basename(process.argv[1])} --reuse${reset}`);
+      console.log(`${dim}  Tear down: e2e-down${reset}`);
+    }
+
     if (result.status === 'pass') {
       console.log(`  ${green}✔ passed (${result.duration}s)${reset}`);
       passed++;