@celilo/e2e 0.5.1 → 0.6.0

package/src/cli/build.ts

@@ -0,0 +1,204 @@
+/**
+ * cele2e build — build Docker images and package .netapp modules.
+ *
+ * Steps:
+ *   1. Package each specified module directory as a .netapp file
+ *   2. Build all Docker images from the @celilo/e2e docker/ directory
+ *   3. Optionally save images to tarball (--save)
+ */
+
+import { execSync, spawnSync } from 'node:child_process';
+import { existsSync, readdirSync, mkdirSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+
+/** Walk up from pkgDir to find the monorepo root (contains a `modules/` dir). */
+function findMonorepoRoot(pkgDir: string): string | null {
+  let dir = pkgDir;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, 'modules'))) return dir;
+    const parent = resolve(dir, '..');
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/** Return paths to all modules that have a manifest.yml. */
+function discoverModuleDirs(repoRoot: string): string[] {
+  const modulesDir = join(repoRoot, 'modules');
+  return readdirSync(modulesDir)
+    .map((name) => join(modulesDir, name))
+    .filter((dir) => existsSync(join(dir, 'manifest.yml')));
+}
+
+const bold = '\x1b[1m';
+const dim = '\x1b[2m';
+const green = '\x1b[32m';
+const red = '\x1b[31m';
+const reset = '\x1b[0m';
+
+interface BuildOptions {
+  pkgDir: string;
+  moduleDirs: string[];
+  save: boolean;
+  skipModules: boolean;
+}
+
+function packageNetapp(moduleDir: string, netappsDir: string): void {
+  const absDir = resolve(moduleDir);
+  if (!existsSync(absDir)) {
+    console.error(`  ${red}skip${reset}  ${moduleDir}  ${dim}(not found)${reset}`);
+    return;
+  }
+
+  const name = basename(absDir);
+  const out = join(netappsDir, `${name}.netapp`);
+
+  process.stdout.write(`  ${String(name).padEnd(20)} `);
+  const start = Date.now();
+
+  // Find celilo CLI by locating the monorepo root from the module's directory.
+  const repoRoot = findMonorepoRoot(absDir);
+  const celiloWrapper = repoRoot ? join(repoRoot, 'celilo') : null;
+  const celiloTs = repoRoot ? join(repoRoot, 'apps/celilo/src/cli/index.ts') : null;
+
+  let result: ReturnType<typeof spawnSync>;
+  if (celiloWrapper && existsSync(celiloWrapper)) {
+    result = spawnSync(celiloWrapper, ['package', absDir, '--output', out], { stdio: 'pipe' });
+  } else if (celiloTs && existsSync(celiloTs)) {
+    result = spawnSync('bun', ['run', celiloTs, 'package', absDir, '--output', out], {
+      stdio: 'pipe',
+    });
+  } else {
+    console.error(`  ${red}skip${reset}  ${name}  ${dim}(celilo CLI not found)${reset}`);
+    return;
+  }
+
+  const elapsed = Math.round((Date.now() - start) / 1000);
+  if (result.status !== 0) {
+    console.log(`${red}✗${reset}  ${dim}${result.stderr?.toString().trim()}${reset}`);
+    return;
+  }
+
+  const size = (() => {
+    try {
+      return execSync(`du -h "${out}"`).toString().split('\t')[0];
+    } catch {
+      return '?';
+    }
+  })();
+
+  console.log(`${green}✔${reset}  ${dim}${elapsed}s  ${size}${reset}`);
+}
+
+function buildDockerImages(pkgDir: string): void {
+  const dockerDir = join(pkgDir, 'docker');
+  if (!existsSync(dockerDir)) {
+    console.error(`${red}Docker directory not found: ${dockerDir}${reset}`);
+    process.exit(1);
+  }
+
+  const dockerfiles = readdirSync(dockerDir)
+    .filter((f) => f.startsWith('Dockerfile.'))
+    .sort();
+
+  if (dockerfiles.length === 0) {
+    console.log(`${dim}No Dockerfiles found in ${dockerDir}${reset}`);
+    return;
+  }
+
+  const total = dockerfiles.length;
+  const buildStart = Date.now();
+
+  for (let i = 0; i < total; i++) {
+    const file = dockerfiles[i];
+    const name = file.replace('Dockerfile.', '');
+    const tag = `celilo-e2e/${name}`;
+
+    process.stdout.write(`  [${i + 1}/${total}] ${String(name).padEnd(25)} `);
+
+    const start = Date.now();
+    const result = spawnSync(
+      'docker',
+      ['build', '-t', tag, '-f', join(dockerDir, file), '.'],
+      { cwd: pkgDir, stdio: 'pipe' },
+    );
+    const elapsed = Math.round((Date.now() - start) / 1000);
+
+    if (result.status !== 0) {
+      console.log(`${red}✗${reset}  ${dim}${elapsed}s${reset}`);
+      console.error(result.stderr?.toString());
+      process.exit(1);
+    }
+
+    console.log(`${green}✔${reset}  ${dim}${elapsed}s${reset}`);
+  }
+
+  const totalElapsed = Math.round((Date.now() - buildStart) / 1000);
+  console.log(`\n${green}All ${total} images built in ${totalElapsed}s${reset}`);
+}
+
+function saveImages(pkgDir: string): void {
+  const cacheDir = join(pkgDir, '.docker-cache');
+  mkdirSync(cacheDir, { recursive: true });
+  const tarball = join(cacheDir, 'celilo-e2e-images.tar');
+
+  console.log(`\n${bold}Saving images to tarball...${reset}`);
+
+  const images = execSync('docker images --filter "reference=celilo-e2e/*" --format "{{.Repository}}:{{.Tag}}"')
+    .toString()
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .sort();
+
+  if (images.length === 0) {
+    console.error(`${red}No celilo-e2e/* images found to save${reset}`);
+    return;
+  }
+
+  const result = spawnSync('docker', ['save', ...images, '-o', tarball], { stdio: 'inherit' });
+  if (result.status !== 0) process.exit(1);
+
+  const size = (() => {
+    try {
+      return execSync(`du -h "${tarball}"`).toString().split('\t')[0];
+    } catch {
+      return '?';
+    }
+  })();
+
+  console.log(`${green}Saved to ${tarball} (${size})${reset}`);
+  console.log(`\nTo restore after colima restart:\n  cele2e load`);
+}
+
+export function runBuild(options: BuildOptions): void {
+  const { pkgDir, moduleDirs, save, skipModules } = options;
+  const netappsDir = join(pkgDir, 'netapps');
+  mkdirSync(netappsDir, { recursive: true });
+
+  if (!skipModules) {
+    // Explicit dirs take precedence; fall back to auto-discovering all modules.
+    const dirs = moduleDirs.length > 0
+      ? moduleDirs
+      : (() => {
+          const root = findMonorepoRoot(pkgDir);
+          return root ? discoverModuleDirs(root) : [];
+        })();
+
+    if (dirs.length > 0) {
+      console.log(`${bold}Packaging modules...${reset}\n`);
+      for (const dir of dirs) {
+        packageNetapp(dir, netappsDir);
+      }
+      console.log('');
+    }
+  }
+
+  console.log(`${bold}Building E2E Docker images...${reset}\n`);
+  buildDockerImages(pkgDir);
+
+  if (save) {
+    saveImages(pkgDir);
+  }
+}

package/src/cli/command-registry.ts

@@ -0,0 +1,99 @@
+/**
+ * Command registry — single source of truth for cele2e's command structure.
+ * Used by completion, help, and coverage tests.
+ */
+
+export interface CommandDef {
+  name: string;
+  description: string;
+  subcommands?: SubcommandDef[];
+  flags?: FlagDef[];
+}
+
+export interface SubcommandDef {
+  name: string;
+  description: string;
+}
+
+export interface FlagDef {
+  name: string;
+  description: string;
+}
+
+export const COMMANDS: CommandDef[] = [
+  {
+    name: 'run',
+    description: 'Run e2e tests (pattern filters by test file name)',
+    flags: [
+      { name: '--keep', description: 'Keep network running after tests' },
+      { name: '--reuse', description: 'Reuse existing network if running' },
+      { name: '--live', description: 'Use live (non-simulated) internet' },
+      { name: '--published', description: 'Use published .netapp packages' },
+    ],
+  },
+  {
+    name: 'up',
+    description: 'Start interactive test network',
+    subcommands: [
+      { name: '--caddy', description: 'Start with caddy machine in DMZ' },
+      { name: '--full-stack', description: 'Start with caddy, IDP, and DB machines' },
+      { name: '--infrastructure', description: 'Start infrastructure only (default)' },
+    ],
+  },
+  {
+    name: 'down',
+    description: 'Tear down running network',
+    flags: [
+      { name: '--keep', description: 'Stop containers but preserve volumes' },
+      { name: '--all', description: 'Also stop competing module containers' },
+    ],
+  },
+  {
+    name: 'build-infra',
+    description: 'Rebuild Docker images and package all modules as .netapps',
+    flags: [
+      { name: '--save', description: 'Save Docker images to tarball after build' },
+      { name: '--skip-modules', description: 'Skip .netapp packaging (only rebuild Docker images)' },
+    ],
+  },
+  {
+    name: 'clear-timing',
+    description: 'Clear saved timing history for test ETAs',
+  },
+  {
+    name: 'shell',
+    description: 'Shell into a running container (default: management)',
+  },
+  {
+    name: 'status',
+    description: 'Show network status and DNS health',
+  },
+  {
+    name: 'load',
+    description: 'Load cached Docker images from tarball',
+  },
+  {
+    name: 'scaffold',
+    description: 'Generate a new test file from template',
+  },
+  {
+    name: 'version',
+    description: 'Show cele2e version',
+  },
+  {
+    name: 'completion',
+    description: 'Generate shell completion script',
+    subcommands: [
+      { name: 'zsh', description: 'Generate zsh completion script' },
+      { name: 'bash', description: 'Generate bash completion script' },
+    ],
+  },
+];
+
+export const UP_PRESETS = ['--caddy', '--full-stack', '--infrastructure'];
+
+export const RUN_FLAGS = ['--keep', '--reuse', '--live', '--published'];
+
+export const DOWN_FLAGS = ['--keep', '--all'];
+
+export const BUILD_INFRA_FLAGS = ['--save'];

package/src/cli/command-tree-parser.ts

@@ -0,0 +1,52 @@
+/**
+ * Discovers cele2e commands by parsing --help output.
+ * Used by completion coverage tests to verify registry ↔ help sync.
+ */
+
+import { execSync } from 'node:child_process';
+import { resolve } from 'node:path';
+
+const CLI = resolve(import.meta.dir, '../..', 'src/cli/index.ts');
+
+function runHelp(args = ''): string {
+  try {
+    return execSync(`bun ${CLI} ${args} --help 2>&1`, { encoding: 'utf-8' });
+  } catch (e: unknown) {
+    return (e as { stdout?: string }).stdout?.toString() ?? '';
+  }
+}
+
+function parseCommandsFromHelp(text: string): string[] {
+  const commands: string[] = [];
+  let inCommandsSection = false;
+
+  for (const line of text.split('\n')) {
+    if (/^\s*Commands?:\s*$/i.test(line)) { inCommandsSection = true; continue; }
+    if (inCommandsSection && /^\s*(Options|Examples|Usage):/i.test(line)) { inCommandsSection = false; continue; }
+    if (!inCommandsSection) continue;
+
+    // Match "  command-name" at 2-3 spaces indent, followed by space/bracket/end
+    const match = line.match(/^ {2,3}([a-z][a-z0-9-]+)(\s|$)/);
+    if (match) commands.push(match[1]);
+  }
+
+  return commands;
+}
+
+export interface CommandNode {
+  name: string;
+  subcommands: string[];
+}
+
+/**
+ * Discovers top-level commands from --help output.
+ * cele2e doesn't implement per-command --help pages, so subcommand
+ * discovery is not attempted — use the COMMANDS registry for that.
+ */
+export function discoverCommands(): Map<string, CommandNode> {
+  const tree = new Map<string, CommandNode>();
+  for (const name of parseCommandsFromHelp(runHelp())) {
+    tree.set(name, { name, subcommands: [] });
+  }
+  return tree;
+}

package/src/cli/completion.ts

@@ -0,0 +1,171 @@
+/**
+ * Shell completion support for cele2e.
+ * All completions are static (no DB lookups needed).
+ */
+
+import {
+  BUILD_INFRA_FLAGS,
+  COMMANDS,
+  DOWN_FLAGS,
+  RUN_FLAGS,
+  UP_PRESETS,
+} from './command-registry';
+
+export function getCompletions(words: string[], current: number): string[] {
+  const args = words[0] === 'cele2e' ? words.slice(1) : words;
+  const currentIndex = words[0] === 'cele2e' ? current - 1 : current;
+
+  if (currentIndex === 0) {
+    return filterSuggestions(
+      COMMANDS.map((c) => c.name),
+      args[0] || '',
+    );
+  }
+
+  const command = args[0];
+
+  if (command === 'run' && currentIndex >= 1) {
+    const used = new Set(args.slice(1));
+    return filterSuggestions(
+      RUN_FLAGS.filter((f) => !used.has(f)),
+      args[currentIndex] || '',
+    );
+  }
+
+  if (command === 'up' && currentIndex === 1) {
+    return filterSuggestions(UP_PRESETS, args[1] || '');
+  }
+
+  if (command === 'down' && currentIndex >= 1) {
+    const used = new Set(args.slice(1));
+    return filterSuggestions(
+      DOWN_FLAGS.filter((f) => !used.has(f)),
+      args[currentIndex] || '',
+    );
+  }
+
+  if (command === 'build-infra' && currentIndex >= 1) {
+    const used = new Set(args.slice(1).filter((a) => a.startsWith('--')));
+    return filterSuggestions(
+      BUILD_INFRA_FLAGS.filter((f) => !used.has(f)),
+      args[currentIndex] || '',
+    );
+  }
+
+  if (command === 'completion' && currentIndex === 1) {
+    return filterSuggestions(['zsh', 'bash'], args[1] || '');
+  }
+
+  return [];
+}
+
+export function filterSuggestions(options: string[], current: string): string[] {
+  if (!current) return options;
+  return options.filter((opt) => opt.startsWith(current));
+}
+
+export function generateBashCompletion(): string {
+  return `# cele2e bash completion
+_cele2e_completion() {
+    local cur prev words cword
+    _init_completion || return
+
+    local completions
+    completions=$(cele2e --get-completions "\${COMP_WORDS[@]}" "\${COMP_CWORD}")
+
+    COMPREPLY=( $(compgen -W "$completions" -- "$cur") )
+    return 0
+}
+
+complete -F _cele2e_completion cele2e
+`;
+}
+
+export function generateZshCompletion(): string {
+  return `#compdef cele2e
+
+_cele2e() {
+  local curcontext="$curcontext" state line
+  typeset -A opt_args
+
+  _arguments -C \\
+    '1: :_cele2e_commands' \\
+    '*::arg:->args'
+
+  case $state in
+    args)
+      case $line[1] in
+        run)
+          _arguments \\
+            '--keep[Keep network running after tests]' \\
+            '--reuse[Reuse existing network if running]' \\
+            '--live[Use live (non-simulated) internet]' \\
+            '--published[Use published .netapp packages]' \\
+            '*:test pattern:'
+          ;;
+        up)
+          _arguments '1: :_cele2e_up_presets'
+          ;;
+        down)
+          _arguments \\
+            '--keep[Stop containers but preserve volumes]' \\
+            '--all[Also stop competing module containers]'
+          ;;
+        build-infra)
+          _arguments \\
+            '--save[Save Docker images to tarball after build]' \\
+            '*:module directory:_directories'
+          ;;
+        shell)
+          _arguments '1:container name:'
+          ;;
+        scaffold)
+          _arguments '1:test name:'
+          ;;
+        completion)
+          _arguments '1: :_cele2e_completion_shells'
+          ;;
+        status|load|clear-timing)
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_cele2e_commands() {
+  local commands=(
+    'run:Run e2e tests (pattern filters by test file name)'
+    'up:Start interactive test network'
+    'down:Tear down running network'
+    'build-infra:Rebuild @celilo/e2e Docker images and standard module .netapps'
+    'clear-timing:Clear saved timing history for test ETAs'
+    'shell:Shell into a running container (default: management)'
+    'status:Show network status and DNS health'
+    'load:Load cached Docker images from tarball'
+    'scaffold:Generate a new test file from template'
+    'version:Show cele2e version'
+    'completion:Generate shell completion script (zsh|bash)'
+  )
+  _describe 'command' commands
+}
+
+_cele2e_up_presets() {
+  local presets=(
+    '--caddy:Start with caddy machine in DMZ'
+    '--full-stack:Start with caddy, IDP, and DB machines'
+    '--infrastructure:Start infrastructure only (default)'
+  )
+  _describe 'preset' presets
+}
+
+_cele2e_completion_shells() {
+  local shells=(
+    'zsh:Generate zsh completion script'
+    'bash:Generate bash completion script'
+  )
+  _describe 'shell' shells
+}
+
+_cele2e "$@"
+`;
+}