@celilo/cli 0.1.7 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {
@@ -47,7 +47,7 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1024.0",
     "@celilo/capabilities": "^0.1.4",
-    "@celilo/cli-display": "0.1.0",
+    "@celilo/cli-display": "0.1.4",
     "@clack/prompts": "^1.1.0",
     "ajv": "^8.18.0",
     "drizzle-orm": "^0.36.4",

package/src/cli/command-registry.ts

@@ -283,6 +283,12 @@ export const COMMANDS: CommandDef[] = [
             description: 'Run pre-flight validation only (no deployment)',
             takesValue: false,
           },
+          {
+            name: 'verbose',
+            description:
+              'Keep all sub-events visible (no collapse-on-success); useful for debugging slow steps',
+            takesValue: false,
+          },
         ],
       },
       {

package/src/cli/commands/module-deploy.ts

@@ -14,7 +14,7 @@ import type { CommandResult } from '../types';
  * Handle module deploy command
  *
  * Usage:
- *   celilo module deploy <module-id> [--no-interactive] [--debug] [--preflight]
+ *   celilo module deploy <module-id> [--no-interactive] [--debug] [--preflight] [--verbose]
  *
  * @param args - Command arguments
  * @param flags - Command flags
@@ -52,8 +52,9 @@ export async function handleModuleDeploy(
 
   const noInteractive = hasFlag(flags, 'no-interactive');
   const debug = hasFlag(flags, 'debug');
+  const verbose = hasFlag(flags, 'verbose');
 
-  const result = await deployModule(moduleId, db, { noInteractive, debug });
+  const result = await deployModule(moduleId, db, { noInteractive, debug, verbose });
 
   if (!result.success) {
     return {

package/src/cli/fuel-gauge.ts

@@ -197,12 +197,10 @@ export class FuelGauge {
       if (success) {
         display.doneStep();
       } else {
+        // failStep no longer collapses sub-events, so the lines we'd
+        // re-print as "last output" are already visible above the
+        // "✗ msg" line. Just call failStep and let them stand.
         display.failStep(this.title);
-        // Surface the last few output lines so the user can see what broke.
-        const errorLines = this.outputLines.slice(-this.errorDisplayLines);
-        for (const line of errorLines) {
-          if (line.trim()) display.subEvent(line);
-        }
       }
       return;
     }

package/src/cli/prompts.ts

@@ -3,23 +3,14 @@
  * Beautiful interactive prompts using @clack/prompts
  */
 
-import type { ProgressDisplay } from '@celilo/cli-display';
+import { getActiveDisplay, setActiveDisplay } from '@celilo/cli-display';
 import * as p from '@clack/prompts';
 
-let activeDisplay: ProgressDisplay | null = null;
-
-/**
- * When set, log.* calls route through the ProgressDisplay instead of @clack/prompts.
- * Callers (e.g. module deploy) set this for the duration of a long-running operation
- * so all the sub-services they call emit through one coherent display.
- */
-export function setActiveDisplay(display: ProgressDisplay | null): void {
-  activeDisplay = display;
-}
-
-export function getActiveDisplay(): ProgressDisplay | null {
-  return activeDisplay;
-}
+// Re-export so existing imports from `../cli/prompts` keep working.
+// The singleton itself lives in @celilo/cli-display so module code
+// running in-process (capability functions, hook scripts) can reach
+// it via @celilo/capabilities's re-export.
+export { getActiveDisplay, setActiveDisplay };
 
 /**
  * Interactive prompt wrapper with celilo branding
@@ -130,23 +121,28 @@ export function showNote(message: string, title?: string): void {
  */
 export const log = {
   success: (message: string) => {
-    if (activeDisplay) return activeDisplay.subEvent(`\x1b[32m✓\x1b[0m ${message}`);
+    const d = getActiveDisplay();
+    if (d) return d.subEvent(`\x1b[32m✓\x1b[0m ${message}`);
     p.log.success(message);
   },
   error: (message: string) => {
-    if (activeDisplay) return activeDisplay.subEvent(`\x1b[31m✗\x1b[0m ${message}`);
+    const d = getActiveDisplay();
+    if (d) return d.subEvent(`\x1b[31m✗\x1b[0m ${message}`);
     p.log.error(message);
   },
   warn: (message: string) => {
-    if (activeDisplay) return activeDisplay.subEvent(`\x1b[33m⚠\x1b[0m ${message}`);
+    const d = getActiveDisplay();
+    if (d) return d.subEvent(`\x1b[33m⚠\x1b[0m ${message}`);
     p.log.warn(message);
   },
   info: (message: string) => {
-    if (activeDisplay) return activeDisplay.instantEvent(message);
+    const d = getActiveDisplay();
+    if (d) return d.instantEvent(message);
     p.log.info(message);
   },
   message: (message: string) => {
-    if (activeDisplay) return activeDisplay.subEvent(message);
+    const d = getActiveDisplay();
+    if (d) return d.subEvent(message);
     p.log.message(message);
   },
 };

package/src/module/packaging/build.ts

@@ -82,6 +82,8 @@ const FRAMEWORK_OWNED_PATHS = new Set(['celilo/types.d.ts']);
  * hooks aren't silently broken by a runtime that ships a different
  * version of `@celilo/capabilities` than the one on npm.
  */
+const BUNDLED_CELILO_PACKAGES = new Set(['capabilities', 'cli-display']);
+
 function shouldExclude(filePath: string): boolean {
   if (FRAMEWORK_OWNED_PATHS.has(filePath)) return true;
 
@@ -93,15 +95,18 @@ function shouldExclude(filePath: string): boolean {
 
   const nmIdx = segments.indexOf('node_modules');
   if (nmIdx >= 0) {
-    // `node_modules` itself: descend so we can pick out @celilo/capabilities.
-    // The capabilities scope is the only thing we ship — it's the framework
-    // SDK the module was authored against. Everything else is regular npm
-    // cruft we'd just re-install on the target (or test-only deps inside
-    // packages like `@celilo/e2e` we don't want to drag in).
+    // `node_modules` itself: descend so we can pick out @celilo/* SDK
+    // packages. capabilities is the public surface the module was
+    // authored against; cli-display is its transitive dep (the
+    // ProgressDisplay singleton that capability functions reach for to
+    // route output through the parent celilo's display). Everything
+    // else is regular npm cruft we'd just re-install on the target
+    // (or test-only deps inside packages like `@celilo/e2e` we don't
+    // want to drag in).
     if (nmIdx + 1 >= segments.length) return false; // node_modules dir itself
     if (segments[nmIdx + 1] !== '@celilo') return true;
     if (nmIdx + 2 >= segments.length) return false; // node_modules/@celilo dir itself
-    return segments[nmIdx + 2] !== 'capabilities';
+    return !BUNDLED_CELILO_PACKAGES.has(segments[nmIdx + 2]);
   }
 
   const name = basename(filePath);

package/src/services/deploy-ansible.ts

@@ -7,7 +7,7 @@
 import { appendFile, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { log } from '../cli/prompts';
+import { getActiveDisplay, log } from '../cli/prompts';
 import { getVaultPassword } from '../secrets/vault';
 import { shellEscape } from '../utils/shell';
 import { executeBuildWithProgress } from './build-stream';
@@ -29,8 +29,15 @@ const ANSI_ESCAPE = /\x1b\[[0-9;]*m/g;
  * Emit structured progress markers to stdout for each Ansible play/task.
  * Uses console.log (same channel as log.info) so the e2e runner sees them
  * in real-time. The runner matches [ansible:play] / [ansible:task] patterns.
+ *
+ * When an active ProgressDisplay is handling the output, skip emission
+ * entirely: parseAnsibleLine is already routing the same play/task lines
+ * through display.subEvent (which emits [progress:sub] markers for
+ * cele2e or renders directly for an interactive terminal). Emitting
+ * both would duplicate every task on the user's screen.
  */
 function emitAnsibleProgress(rawChunk: string): void {
+  if (getActiveDisplay()) return;
   // In non-TTY mode (e.g. inside a Docker exec) write to stdout, which is
   // line-buffered by stdbuf. stderr may arrive batched or out-of-order through
   // docker exec -T, so stdout gives the e2e runner reliable real-time delivery.
@@ -52,6 +59,41 @@ function emitAnsibleProgress(rawChunk: string): void {
   }
 }
 
+/**
+ * Reformat an Ansible PLAY RECAP host line into a compact summary.
+ *
+ * Input  (raw, ~100 columns):
+ *   www                        : ok=11   changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
+ *
+ * Output (compact, ~40 columns, ✓ on success / ✗ on any failure or
+ * unreachable host, zero-value fields dropped):
+ *   ✓ www  ok=11 changed=2
+ */
+function formatAnsibleRecap(stripped: string): string {
+  const match = stripped.match(/^(\S+)\s*:\s*(.+)$/);
+  if (!match) return `    ${stripped}`;
+  const host = match[1];
+  const stats = match[2];
+
+  const counts: Record<string, number> = {};
+  for (const m of stats.matchAll(/(\w+)=(\d+)/g)) {
+    counts[m[1]] = Number.parseInt(m[2], 10);
+  }
+
+  const failures = (counts.failed ?? 0) + (counts.unreachable ?? 0);
+  const icon = failures > 0 ? '✗' : '✓';
+
+  // Order matters: ok / changed first (good news), then anything bad.
+  // Skipped is dropped — it's noise from `when:` clauses.
+  const fieldOrder = ['ok', 'changed', 'failed', 'unreachable', 'rescued', 'ignored'];
+  const parts: string[] = [];
+  for (const f of fieldOrder) {
+    if (counts[f]) parts.push(`${f}=${counts[f]}`);
+  }
+
+  return `  ${icon} ${host}  ${parts.join(' ')}`;
+}
+
 function parseAnsibleLine(line: string): string | null {
   const stripped = line.replace(ANSI_ESCAPE, '').trim();
 
@@ -67,13 +109,20 @@ function parseAnsibleLine(line: string): string | null {
     const name = stripped.replace(/^RUNNING HANDLER \[/, '').replace(/\].*$/, '');
     return `  ↺ handler: ${name}`;
   }
-  if (/^ok:/.test(stripped)) return '    ok';
+  // `ok:` and `skipping:` are pure noise — every successful task emits one
+  // and the cele2e runner already drops them. Keep `changed`/`failed`/`fatal`
+  // because they're the lines a user actually wants to see scrolling by.
+  if (/^ok:/.test(stripped)) return null;
+  if (/^skipping:/.test(stripped)) return null;
   if (/^changed:/.test(stripped)) return '    changed';
-  if (/^skipping:/.test(stripped)) return '    skipped';
   if (/^failed:/.test(stripped)) return '    FAILED';
   if (/^fatal:/.test(stripped)) return `    FATAL: ${stripped.slice(7)}`;
-  if (/^PLAY RECAP/.test(stripped)) return '  recap:';
-  if (/^\w[\w.-]+ *:/.test(stripped) && stripped.includes('ok=')) return `    ${stripped}`;
+  // The "PLAY RECAP" header is redundant — the per-host summary line
+  // that follows already names the host and the counts.
+  if (/^PLAY RECAP/.test(stripped)) return null;
+  if (/^\w[\w.-]+ *:/.test(stripped) && stripped.includes('ok=')) {
+    return formatAnsibleRecap(stripped);
+  }
 
   // Suppress decorative separator lines (all * or = chars)
   if (/^[*=\s]+$/.test(stripped)) return null;

package/src/services/deploy-terraform.ts

@@ -432,6 +432,10 @@ export async function parseTerraformOutputs(
     cwd: terraformDir,
     title: 'Reading Terraform outputs',
     env: { TF_IN_AUTOMATION: '1' },
+    // The raw JSON is for parsing into a Record, not for display.
+    // Suppress every line from the gauge/display while still capturing
+    // result.output for JSON.parse below.
+    filterOutput: () => null,
   });
 
   if (!result.success) {

package/src/services/module-build.test.ts

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test';
 import { existsSync } from 'node:fs';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
 import { eq } from 'drizzle-orm';
+import { log } from '../cli/prompts';
 import { type DbClient, createDbClient } from '../db/client';
 import { moduleBuilds, modules } from '../db/schema';
 import { buildModuleFromSource, getModuleBuildStatus, verifyArtifactsExist } from './module-build';
@@ -131,21 +132,25 @@ describe('Module Build Service', () => {
         })
         .run();
 
-      // Mock console.log to capture output
-      const consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {});
+      // Mock log.info / log.warn to capture output (module-build.ts now
+      // routes through these instead of console.log so output flows through
+      // the active ProgressDisplay during a real deploy).
+      const logInfoSpy = spyOn(log, 'info').mockImplementation(() => {});
+      const logWarnSpy = spyOn(log, 'warn').mockImplementation(() => {});
 
       const _result = await buildModuleFromSource('nix-module', db);
 
       // Verify Nix detection or fallback message was logged
-      // If nix is available: "ℹ Entering Nix environment"
-      // If nix not available: "⚠️  flake.nix detected but nix command not available"
-      const logCalls = consoleLogSpy.mock.calls.map((call) => call[0]);
-      const hasNixMessage = logCalls.some(
+      // If nix is available: "Entering Nix environment"
+      // If nix not available: "flake.nix detected but nix command not available"
+      const calls = [...logInfoSpy.mock.calls, ...logWarnSpy.mock.calls].map((c) => c[0]);
+      const hasNixMessage = calls.some(
         (msg) => msg.includes('Nix environment') || msg.includes('flake.nix detected'),
       );
       expect(hasNixMessage).toBe(true);
 
-      consoleLogSpy.mockRestore();
+      logInfoSpy.mockRestore();
+      logWarnSpy.mockRestore();
 
       // Build result depends on whether Nix is installed
       // We're just testing that detection happens (message logged)

package/src/services/module-build.ts

@@ -269,9 +269,9 @@ export async function buildModuleFromSource(moduleId: string, db: DbClient): Pro
   const environment: 'nix' | 'system' = useNix ? 'nix' : 'system';
 
   if (useNix) {
-    console.log('ℹ Entering Nix environment (flake.nix detected)...');
+    log.info('Entering Nix environment (flake.nix detected)...');
   } else if (nixDetected && !nixAvailable) {
-    console.log('⚠️  flake.nix detected but nix command not available - using system Ansible');
+    log.warn('flake.nix detected but nix command not available - using system Ansible');
   }
 
   try {

package/src/services/module-deploy.ts

@@ -91,6 +91,14 @@ async function updateMachineAssignment(
 export interface DeployOptions {
   noInteractive?: boolean;
   debug?: boolean;
+  /**
+   * Keep all sub-events visible during the deploy. With this off (the
+   * default), the ProgressDisplay collapses each "… doing" block into
+   * a single "✔ done" line on completion. Verbose mode disables that
+   * collapse so the user can see every line that flowed through —
+   * useful for debugging slow or hanging steps.
+   */
+  verbose?: boolean;
 }
 
 /**
@@ -243,8 +251,19 @@ export async function deployModule(
 ): Promise<DeployResult> {
   const phases: DeployResult['phases'] = {};
 
+  // --no-interactive emits structured [progress:*] markers (for cele2e
+  // to parse). --verbose forces render mode but with isTTY=false, which
+  // disables cursor magic — every sub-event stays visible after each
+  // step completes (no collapse-on-success). When neither is set, mode
+  // is 'auto' and the display picks based on the real stdout's isTTY.
+  // --no-interactive wins if both are set (protocol output is what
+  // cele2e expects regardless of verbosity).
+  const displayMode = options.noInteractive ? 'protocol' : options.verbose ? 'render' : 'auto';
   const display = new ProgressDisplay({
-    mode: options.noInteractive ? 'protocol' : 'auto',
+    mode: displayMode,
+    out: options.verbose
+      ? { write: process.stdout.write.bind(process.stdout), isTTY: false }
+      : undefined,
   });
   setActiveDisplay(display);