@celilo/cli 0.1.5 → 0.1.6

package/src/services/audit/undeployed-modules.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from 'bun:test';
+import { auditUndeployedModules } from './undeployed-modules';
+
+describe('auditUndeployedModules', () => {
+  test('skips INSTALLED and VERIFIED modules', async () => {
+    const result = await auditUndeployedModules({
+      modules: [
+        { id: 'caddy', state: 'INSTALLED' },
+        { id: 'iptables', state: 'VERIFIED' },
+      ],
+    });
+    expect(result).toEqual([]);
+  });
+
+  test('flags IMPORTED modules with actionable deploy command', async () => {
+    const result = await auditUndeployedModules({
+      modules: [{ id: 'authentik', state: 'IMPORTED' }],
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      category: 'undeployed_modules',
+      severity: 'drift',
+      code: 'module_undeployed',
+      remediation: 'celilo module deploy authentik',
+      actionable: true,
+      subject: 'authentik',
+    });
+  });
+
+  test('also flags VALIDATED, CONFIGURED', async () => {
+    const result = await auditUndeployedModules({
+      modules: [
+        { id: 'a', state: 'VALIDATED' },
+        { id: 'b', state: 'CONFIGURED' },
+      ],
+    });
+    expect(result).toHaveLength(2);
+    expect(result.every((f) => f.code === 'module_undeployed')).toBe(true);
+  });
+
+  test('skips transient states (DEPLOYING, GENERATING, UNINSTALLING)', async () => {
+    const result = await auditUndeployedModules({
+      modules: [
+        { id: 'a', state: 'DEPLOYING' },
+        { id: 'b', state: 'GENERATING' },
+        { id: 'c', state: 'UNINSTALLING' },
+      ],
+    });
+    expect(result).toEqual([]);
+  });
+
+  test('ERROR state surfaces as blocked, non-actionable, with investigation guidance', async () => {
+    const result = await auditUndeployedModules({
+      modules: [{ id: 'broken', state: 'ERROR' }],
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      category: 'undeployed_modules',
+      severity: 'blocked',
+      code: 'module_in_error_state',
+      actionable: false,
+      subject: 'broken',
+    });
+    expect(result[0].details).toContain('Investigate');
+  });
+});

package/src/services/audit/undeployed-modules.ts

@@ -0,0 +1,72 @@
+/**
+ * Undeployed-modules check.
+ *
+ * Modules in the local DB whose state isn't INSTALLED or VERIFIED
+ * have been imported (and possibly configured / generated) but
+ * never made it to a running deployment. The audit surfaces them
+ * one finding per module with a runnable `celilo module deploy <id>`
+ * remediation so the user can deploy directly from the TUI.
+ *
+ * `ERROR` and `UNINSTALLING` states are reported separately — the
+ * remediation isn't simply "deploy"; the user has to investigate
+ * the prior failure first. We still flag them so they aren't
+ * forgotten.
+ */
+
+import type { DriftFinding } from './types';
+
+export interface UndeployedModule {
+  id: string;
+  /** Lifecycle state from the modules table (IMPORTED, VALIDATED, …). */
+  state: string;
+}
+
+export interface UndeployedModulesAuditDeps {
+  modules: UndeployedModule[];
+}
+
+const READY_STATES = new Set(['INSTALLED', 'VERIFIED']);
+
+/** States that should NOT be flagged here — they're either deployed or in transit. */
+const TRANSIENT_STATES = new Set(['DEPLOYING', 'GENERATING', 'UNINSTALLING']);
+
+export async function auditUndeployedModules(
+  deps: UndeployedModulesAuditDeps,
+): Promise<DriftFinding[]> {
+  const findings: DriftFinding[] = [];
+
+  for (const m of deps.modules) {
+    if (READY_STATES.has(m.state)) continue;
+    if (TRANSIENT_STATES.has(m.state)) continue;
+
+    if (m.state === 'ERROR') {
+      findings.push({
+        category: 'undeployed_modules',
+        severity: 'blocked',
+        code: 'module_in_error_state',
+        message: `${m.id}: previous deploy failed (state: ERROR)`,
+        details:
+          'Investigate the prior failure (check `celilo module status` and the' +
+          ' module logs) before retrying — re-deploying without diagnosing the' +
+          ' root cause may recreate the same broken state.',
+        // Investigatory; not actionable as a one-liner.
+        actionable: false,
+        subject: m.id,
+        remediation: `celilo module status ${m.id}`,
+      });
+      continue;
+    }
+
+    findings.push({
+      category: 'undeployed_modules',
+      severity: 'drift',
+      code: 'module_undeployed',
+      message: `${m.id}: imported but not deployed (state: ${m.state})`,
+      remediation: `celilo module deploy ${m.id}`,
+      actionable: true,
+      subject: m.id,
+    });
+  }
+
+  return findings;
+}

package/src/services/build-stream.ts

@@ -1,7 +1,9 @@
 /**
  * Build Stream Executor
  *
- * Executes build commands with streaming output and fuel-gauge progress indicator
+ * Executes build commands with streaming output and fuel-gauge progress indicator.
+ * Interactive (TTY) mode: FuelGauge animation with scrolling preview.
+ * Non-interactive mode: raw streaming to stdout/stderr, no FuelGauge instantiated.
  */
 
 import { spawn } from 'node:child_process';
@@ -13,9 +15,11 @@ export interface BuildStreamOptions {
   cwd: string;
   env?: Record<string, string>;
   stdin?: string;
-  onOutput?: (line: string) => void;
-  title?: string; // Custom title for progress indicator (defaults to "Building module")
-  noInteractive?: boolean; // Skip animation, stream output directly
+  onOutput?: (chunk: string) => void;
+  /** Transform each output line before display. Return null to suppress. Raw output is always captured for logs. */
+  filterOutput?: (line: string) => string | null;
+  title?: string;
+  noInteractive?: boolean;
 }
 
 export interface BuildStreamResult {
@@ -23,179 +27,175 @@ export interface BuildStreamResult {
   exitCode: number;
   output: string;
   error?: string;
-  backgrounded?: boolean; // True if user pressed ESC to background
+  backgrounded?: boolean;
+}
+
+function spawnChild(options: BuildStreamOptions) {
+  const { command, args, cwd, env, stdin } = options;
+  const child = spawn(command, args, {
+    cwd,
+    env: { ...process.env, ...env },
+    stdio: [stdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+    shell: true,
+  });
+  if (stdin && child.stdin) {
+    child.stdin.write(stdin);
+    child.stdin.end();
+  }
+  return child;
 }
 
 /**
- * Execute build command with fuel-gauge progress indicator
- *
- * Features:
- * - Cylon-style back-and-forth progress bar
- * - Scrolling output preview (3-4 lines)
- * - On success: clean terminal
- * - On error: show last 8 lines of output
- *
- * @param options - Build execution options
- * @returns Build result with success status and output
+ * Non-interactive path: no FuelGauge, raw streaming to stdout/stderr.
+ * onOutput is still called so callers can emit structured markers.
  */
-export async function executeBuildWithProgress(
-  options: BuildStreamOptions,
-): Promise<BuildStreamResult> {
-  const {
-    command,
-    args,
-    cwd,
-    env,
-    stdin,
-    onOutput,
-    title = 'Building module',
-    noInteractive,
-  } = options;
+function executeStreaming(options: BuildStreamOptions): Promise<BuildStreamResult> {
+  const { onOutput, filterOutput } = options;
 
   return new Promise((resolve) => {
     const outputLines: string[] = [];
     const errorLines: string[] = [];
-    let backgrounded = false;
 
-    // Skip animation in tests/non-TTY or when --no-interactive
-    const skipAnimation = !process.stdout.isTTY || !!noInteractive;
+    const child = spawnChild(options);
+
+    const sigintHandler = () => {
+      if (!child.killed) child.kill('SIGINT');
+    };
+    process.on('SIGINT', sigintHandler);
+
+    if (child.stdout) {
+      child.stdout.on('data', (data: Buffer) => {
+        const text = data.toString();
+        outputLines.push(text);
+
+        if (filterOutput) {
+          for (const line of text.split('\n')) {
+            if (!line.trim()) continue;
+            const display = filterOutput(line);
+            if (display !== null) process.stdout.write(`${display}\n`);
+          }
+        } else {
+          process.stdout.write(text);
+        }
+
+        onOutput?.(text);
+      });
+    }
+
+    if (child.stderr) {
+      child.stderr.on('data', (data: Buffer) => {
+        const text = data.toString();
+        errorLines.push(text);
+        process.stderr.write(text);
+        onOutput?.(text);
+      });
+    }
+
+    child.on('close', (exitCode) => {
+      process.off('SIGINT', sigintHandler);
+      const output = outputLines.join('') + errorLines.join('');
+      if (exitCode === 0) {
+        resolve({ success: true, exitCode: 0, output });
+      } else {
+        resolve({
+          success: false,
+          exitCode: exitCode ?? 1,
+          output,
+          error: `Build exited with code ${exitCode}`,
+        });
+      }
+    });
+
+    child.on('error', (error) => {
+      process.off('SIGINT', sigintHandler);
+      resolve({ success: false, exitCode: 1, output: outputLines.join(''), error: error.message });
+    });
+  });
+}
+
+/**
+ * Interactive path: FuelGauge animation with Cylon-style progress bar.
+ */
+function executeWithGauge(options: BuildStreamOptions): Promise<BuildStreamResult> {
+  const { onOutput, filterOutput, title = 'Building module' } = options;
+
+  return new Promise((resolve) => {
+    const outputLines: string[] = [];
+    const errorLines: string[] = [];
+    let backgrounded = false;
 
-    // Start fuel-gauge progress indicator
     const gauge = new FuelGauge(title, {
-      skipAnimation, // Skip animation in tests/non-TTY/no-interactive
       onBackground: () => {
-        // User pressed ESC - return control immediately
         backgrounded = true;
-        // Clean up signal handler when backgrounding
         process.off('SIGINT', sigintHandler);
-        resolve({
-          success: true,
-          exitCode: 0,
-          output: '',
-          backgrounded: true,
-        });
+        resolve({ success: true, exitCode: 0, output: '', backgrounded: true });
       },
     });
     gauge.start();
 
-    // Spawn child process
-    // Use shell: true to support script wrappers (e.g., tfenv's terraform script)
-    const child = spawn(command, args, {
-      cwd,
-      env: { ...process.env, ...env },
-      stdio: [stdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
-      shell: true,
-    });
+    const child = spawnChild(options);
 
-    // Forward SIGINT (Ctrl+C) to child process
     const sigintHandler = () => {
-      if (child && !child.killed) {
-        child.kill('SIGINT');
-      }
+      if (!child.killed) child.kill('SIGINT');
     };
     process.on('SIGINT', sigintHandler);
 
-    // Pass stdin data if provided
-    if (stdin && child.stdin) {
-      child.stdin.write(stdin);
-      child.stdin.end();
-    }
-
-    // Capture stdout - feed to fuel-gauge for display
     if (child.stdout) {
-      child.stdout.on('data', (data) => {
-        if (backgrounded) return; // Don't process output after backgrounding
-
+      child.stdout.on('data', (data: Buffer) => {
+        if (backgrounded) return;
         const text = data.toString();
         outputLines.push(text);
 
-        // In non-interactive mode, stream directly to stdout
-        if (skipAnimation) {
-          process.stdout.write(text);
-        }
-
-        // Feed lines to fuel-gauge for scrolling display
-        const lines = text.split('\n').filter((l: string) => l.trim());
-        for (const line of lines) {
-          gauge.addOutput(line);
+        for (const line of text.split('\n')) {
+          if (!line.trim()) continue;
+          const display = filterOutput ? filterOutput(line) : line;
+          if (display !== null) gauge.addOutput(display);
         }
 
-        if (onOutput) {
-          onOutput(text);
-        }
+        onOutput?.(text);
       });
     }
 
-    // Capture stderr - also feed to fuel-gauge
     if (child.stderr) {
-      child.stderr.on('data', (data) => {
-        if (backgrounded) return; // Don't process output after backgrounding
-
+      child.stderr.on('data', (data: Buffer) => {
+        if (backgrounded) return;
         const text = data.toString();
         errorLines.push(text);
-
-        // In non-interactive mode, stream directly to stderr
-        if (skipAnimation) {
-          process.stderr.write(text);
-        }
-
-        // Show stderr in fuel-gauge too
-        const lines = text.split('\n').filter((l: string) => l.trim());
-        for (const line of lines) {
+        for (const line of text.split('\n').filter((l: string) => l.trim())) {
           gauge.addOutput(line);
         }
-
-        if (onOutput) {
-          onOutput(text);
-        }
+        onOutput?.(text);
       });
     }
 
-    // Handle completion
-    child.on('close', (exitCode: number | null) => {
-      if (backgrounded) return; // Already resolved when backgrounded
-
-      // Clean up signal handler
+    child.on('close', (exitCode) => {
+      if (backgrounded) return;
       process.off('SIGINT', sigintHandler);
-
-      const output = outputLines.join('');
-      const errorOutput = errorLines.join('');
-
+      const output = outputLines.join('') + errorLines.join('');
       if (exitCode === 0) {
-        // Success: clean terminal, no output left behind
         gauge.stop(true);
-        resolve({
-          success: true,
-          exitCode: exitCode || 0,
-          output: output + errorOutput,
-        });
+        resolve({ success: true, exitCode: 0, output });
       } else {
-        // Error: show full output for debugging
         gauge.stop(false);
         resolve({
           success: false,
-          exitCode: exitCode || 1,
-          output: output + errorOutput,
+          exitCode: exitCode ?? 1,
+          output,
           error: `Build exited with code ${exitCode}`,
         });
       }
     });
 
-    // Handle spawn errors
     child.on('error', (error) => {
-      if (backgrounded) return; // Already resolved when backgrounded
-
-      // Clean up signal handler
+      if (backgrounded) return;
       process.off('SIGINT', sigintHandler);
-
-      // Error: show output for debugging
       gauge.stop(false);
-      resolve({
-        success: false,
-        exitCode: 1,
-        output: outputLines.join(''),
-        error: error.message,
-      });
+      resolve({ success: false, exitCode: 1, output: outputLines.join(''), error: error.message });
     });
   });
 }
+
+export function executeBuildWithProgress(options: BuildStreamOptions): Promise<BuildStreamResult> {
+  const nonInteractive = !process.stdout.isTTY || !!options.noInteractive;
+  return nonInteractive ? executeStreaming(options) : executeWithGauge(options);
+}