scripts-orchestrator 2.12.0 → 2.13.0

package/index.js

@@ -39,6 +39,18 @@ const argv = yargs(hideBin(process.argv))
     type: 'boolean',
     description: 'Force execution even if git state is unchanged',
   })
+  .option('metrics', {
+    type: 'string',
+    description: 'Comma-separated metrics to collect and report: time, memory',
+  })
+  .option('json-results', {
+    type: 'string',
+    description: 'Write results JSON to this path; use "-" for stdout only',
+  })
+  .option('html-results', {
+    type: 'string',
+    description: 'Write HTML report to this path; use "-" for stdout only',
+  })
   .help()
   .alias('h', 'help')
   .parse();
@@ -52,6 +64,8 @@ const phases = argv.phases ? argv.phases.split(',').map(p => p.trim()) : null;
 const sequential = argv.sequential || false;
 const force = argv.force || false;
 
+const validMetrics = ['time', 'memory'];
+
 // Validate config file exists
 if (!fs.existsSync(configPath)) {
   log.error(`Error: Config file not found at ${configPath}`);
@@ -74,13 +88,46 @@ if (!logFolder && commandsConfig.log_folder) {
   logFolder = commandsConfig.log_folder;
 }
 
+// Metrics: CLI overrides config
+let metrics = [];
+if (argv.metrics != null && argv.metrics !== '') {
+  metrics = argv.metrics.split(',').map((m) => m.trim()).filter((m) => validMetrics.includes(m));
+} else if (commandsConfig.metrics != null) {
+  const fromConfig = Array.isArray(commandsConfig.metrics)
+    ? commandsConfig.metrics
+    : String(commandsConfig.metrics).split(',').map((m) => m.trim());
+  metrics = fromConfig.filter((m) => validMetrics.includes(m));
+}
+
+// JSON results path: CLI overrides config
+const jsonResultsPath =
+  argv.jsonResults != null
+    ? argv.jsonResults
+    : (commandsConfig.json_results ?? commandsConfig.json_results_path ?? null);
+
+// HTML results path: CLI overrides config (optional)
+const htmlResultsPath =
+  argv.htmlResults != null
+    ? argv.htmlResults
+    : (commandsConfig.html_results ?? commandsConfig.html_results_path ?? null);
+
 // Set the log folder for the main orchestrator logs if specified
 if (logFolder) {
   log.setLogFolder(logFolder);
 }
 
 // Create and run the orchestrator
-const orchestrator = new Orchestrator(commandsConfig, startPhase, logFolder, phases, sequential, force);
+const orchestrator = new Orchestrator(
+  commandsConfig,
+  startPhase,
+  logFolder,
+  phases,
+  sequential,
+  force,
+  metrics,
+  jsonResultsPath,
+  htmlResultsPath,
+);
 
 // Enhanced signal handlers
 const handleSignal = async (signal) => {

package/lib/orchestrator.js

@@ -1,3 +1,4 @@
+import fs from 'fs';
 import { processManager } from './process-manager.js';
 import { healthCheck } from './health-check.js';
 import { log } from './logger.js';
@@ -12,6 +13,9 @@ export class Orchestrator {
     phases = null,
     sequential = false,
     force = false,
+    metrics = [],
+    jsonResultsPath = null,
+    htmlResultsPath = null,
   ) {
     this.config = config;
     this.startPhase = startPhase;
@@ -19,13 +23,17 @@ export class Orchestrator {
     this.phases = phases;
     this.sequential = sequential;
     this.force = force;
+    this.metrics = Array.isArray(metrics) ? metrics : [];
+    this.jsonResultsPath = jsonResultsPath ?? null;
+    this.htmlResultsPath = htmlResultsPath ?? null;
     this.processManager = processManager;
     this.healthCheck = healthCheck;
     this.logger = log;
     this.failedCommands = [];
     this.skippedCommands = [];
     this.skipReasons = new Map(); // Track why commands were skipped
-    this.commandTimings = new Map();
+    this.commandTimings = new Map(); // command -> { durationMs, memoryKb? }
+    this.phaseResults = []; // { name, success, durationMs } per phase run
     this.gitCache = new GitCache(logFolder);
 
     // Set the log folder in process manager
@@ -80,13 +88,17 @@ export class Orchestrator {
 
     const startTime = Date.now();
 
+    const setTiming = (durationMs, memoryKb = null) => {
+      this.commandTimings.set(command, { durationMs, memoryKb });
+    };
+
     // Check for circular dependencies
     if (visited.has(command)) {
       this.logger.error(
         `Circular dependency detected: ${Array.from(visited).join(' -> ')} -> ${command}`,
       );
       this.failedCommands.push(command);
-      this.commandTimings.set(command, Date.now() - startTime);
+      setTiming(Date.now() - startTime);
       return false;
     }
     visited.add(command);
@@ -96,7 +108,7 @@ export class Orchestrator {
       this.logger.warn(`Skipping: npm run ${command} (status: disabled)`);
       this.skippedCommands.push(command);
       this.skipReasons.set(command, 'disabled');
-      this.commandTimings.set(command, Date.now() - startTime);
+      setTiming(Date.now() - startTime);
       visited.delete(command);
       return true;
     }
@@ -127,7 +139,7 @@ export class Orchestrator {
           process_tracking,
           kill_command,
         });
-        this.commandTimings.set(command, Date.now() - startTime);
+        setTiming(Date.now() - startTime);
         visited.delete(command);
         return true;
       }
@@ -140,7 +152,7 @@ export class Orchestrator {
         this.logger.error(`Skipping ${command} due to failed dependency`);
         this.skippedCommands.push(command);
         this.skipReasons.set(command, 'failed_dependency');
-        this.commandTimings.set(command, Date.now() - startTime);
+        setTiming(Date.now() - startTime);
         visited.delete(command);
         return false;
       }
@@ -154,7 +166,7 @@ export class Orchestrator {
         if (!urlAvailable) {
           this.skippedCommands.push(command);
           this.skipReasons.set(command, 'failed_dependency');
-          this.commandTimings.set(command, Date.now() - startTime);
+          setTiming(Date.now() - startTime);
           visited.delete(command);
           return false;
         }
@@ -176,6 +188,7 @@ export class Orchestrator {
     let result = false;
     let commandOutput = '';
     let commandFailed = false;
+    let lastRunResult = null;
 
     for (let attempt = 1; attempt <= attempts; attempt++) {
       if (attempt > 1) {
@@ -185,7 +198,7 @@ export class Orchestrator {
         await new Promise((resolve) => setTimeout(resolve, 1000));
       }
 
-      const { success, output } = await this.processManager.runCommand({
+      const runResult = await this.processManager.runCommand({
         cmd: attempt === 1 ? command : retry_command || command,
         logFile: log || logFile, // Prefer 'log' key over 'logFile' for backwards compatibility
         background,
@@ -193,7 +206,11 @@ export class Orchestrator {
         kill_command,
         isRetry: attempt > 1,
         env,
+        reportTime: this.metrics.includes('time'),
+        reportMemory: this.metrics.includes('memory'),
       });
+      lastRunResult = runResult;
+      const { success, output } = runResult;
       commandOutput = output;
       result = success;
 
@@ -239,7 +256,8 @@ export class Orchestrator {
       }
     }
 
-    this.commandTimings.set(command, Date.now() - startTime);
+    const totalDurationMs = Date.now() - startTime;
+    setTiming(totalDurationMs, lastRunResult?.memoryKb ?? null);
     visited.delete(command);
     return result;
   }
@@ -269,6 +287,217 @@ export class Orchestrator {
     }
   }
 
+  writeJsonResults(hasFailures) {
+    const overallDurationMs =
+      this.metrics.includes('time') && this.startTime
+        ? Date.now() - this.startTime
+        : undefined;
+
+    const commands = [];
+    if (Array.isArray(this.config)) {
+      this.config.forEach(({ command }) => {
+        const timing = this.commandTimings.get(command);
+        const skipReason = this.skippedCommands.includes(command)
+          ? this.skipReasons.get(command) ?? null
+          : null;
+        const success =
+          !this.failedCommands.includes(command) &&
+          (skipReason === null ||
+            skipReason === 'disabled' ||
+            skipReason === 'optional_phase_not_requested' ||
+            skipReason === 'before_start_phase');
+        const entry = {
+          command,
+          success,
+          ...(timing?.durationMs != null && this.metrics.includes('time')
+            ? { durationMs: timing.durationMs }
+            : {}),
+          ...(this.metrics.includes('memory')
+            ? { memoryKb: timing?.memoryKb ?? null }
+            : {}),
+          ...(skipReason ? { skipReason } : {}),
+        };
+        commands.push(entry);
+      });
+    } else if (this.config.phases) {
+      this.config.phases.forEach((phase) => {
+        (phase.parallel || []).forEach(({ command }) => {
+          const timing = this.commandTimings.get(command);
+          const skipReason = this.skippedCommands.includes(command)
+            ? this.skipReasons.get(command) ?? null
+            : null;
+          const success =
+            !this.failedCommands.includes(command) &&
+            (skipReason === null ||
+              skipReason === 'disabled' ||
+              skipReason === 'optional_phase_not_requested' ||
+              skipReason === 'before_start_phase');
+          const entry = {
+            command,
+            phase: phase.name,
+            success,
+            ...(timing?.durationMs != null && this.metrics.includes('time')
+              ? { durationMs: timing.durationMs }
+              : {}),
+            ...(this.metrics.includes('memory')
+              ? { memoryKb: timing?.memoryKb ?? null }
+              : {}),
+            ...(skipReason ? { skipReason } : {}),
+          };
+          commands.push(entry);
+        });
+      });
+    }
+
+    const payload = {
+      success: !hasFailures,
+      timestamp: new Date().toISOString(),
+      ...(overallDurationMs != null ? { overallDurationMs } : {}),
+      commands,
+      ...(this.config.phases && this.phaseResults.length > 0
+        ? { phases: this.phaseResults }
+        : {}),
+    };
+
+    const json = JSON.stringify(payload, null, 2);
+    if (this.jsonResultsPath === '-') {
+      console.log(json);
+    } else {
+      const outPath = this.jsonResultsPath || './scripts-orchestrator-results.json';
+      fs.writeFileSync(outPath, json, 'utf8');
+      this.logger.verbose(`Wrote results to ${outPath}`);
+    }
+
+    if (this.htmlResultsPath != null) {
+      this.writeHtmlResults(payload);
+    }
+  }
+
+  formatMs(ms) {
+    if (ms == null || ms === 0) return '—';
+    if (ms < 1000) return `${ms}ms`;
+    const s = (ms / 1000).toFixed(1);
+    return `${s}s`;
+  }
+
+  writeHtmlResults(payload) {
+    const escapeHtml = (s) => {
+      if (s == null) return '';
+      return String(s)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+    };
+    const { success, timestamp, overallDurationMs, commands = [], phases = [] } = payload;
+    const maxDuration = Math.max(0, ...commands.map((c) => c.durationMs || 0), ...phases.map((p) => p.durationMs || 0));
+    const maxMemory = Math.max(0, ...commands.map((c) => c.memoryKb || 0));
+
+    const row = (c) => {
+      const durationPct = maxDuration > 0 && c.durationMs != null ? (c.durationMs / maxDuration) * 100 : 0;
+      const memoryPct = maxMemory > 0 && c.memoryKb != null ? (c.memoryKb / maxMemory) * 100 : 0;
+      const statusClass = c.success ? 'ok' : 'fail';
+      const statusLabel = c.success ? 'OK' : (c.skipReason || 'Failed');
+      return `
+        <tr class="${statusClass}">
+          <td><code>${escapeHtml(c.command)}</code></td>
+          <td>${c.phase != null ? escapeHtml(c.phase) : '—'}</td>
+          <td><span class="badge ${statusClass}">${escapeHtml(statusLabel)}</span></td>
+          <td>${this.formatMs(c.durationMs)}</td>
+          <td>${c.memoryKb != null ? `${(c.memoryKb / 1024).toFixed(1)} MB` : '—'}</td>
+          <td class="bar-cell"><div class="bar" style="width:${durationPct}%"></div></td>
+          <td class="bar-cell"><div class="bar mem" style="width:${memoryPct}%"></div></td>
+        </tr>`;
+    };
+
+    const phaseRow = (p) => {
+      const durationPct = maxDuration > 0 && p.durationMs != null ? (p.durationMs / maxDuration) * 100 : 0;
+      const statusClass = p.success ? 'ok' : 'fail';
+      return `
+        <tr class="${statusClass}">
+          <td>${escapeHtml(p.name)}</td>
+          <td><span class="badge ${statusClass}">${p.success ? 'OK' : 'Failed'}</span></td>
+          <td>${this.formatMs(p.durationMs)}</td>
+          <td class="bar-cell"><div class="bar" style="width:${durationPct}%"></div></td>
+        </tr>`;
+    };
+
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Scripts Orchestrator Report</title>
+  <style>
+    * { box-sizing: border-box; }
+    body { font-family: system-ui, sans-serif; margin: 1rem 2rem; background: #1a1a1a; color: #e0e0e0; }
+    h1 { font-size: 1.5rem; margin-bottom: 0.5rem; }
+    .summary { display: flex; gap: 1.5rem; flex-wrap: wrap; margin-bottom: 1.5rem; }
+    .summary .card { background: #2a2a2a; padding: 1rem 1.25rem; border-radius: 8px; min-width: 140px; }
+    .summary .card.success { border-left: 4px solid #22c55e; }
+    .summary .card.fail { border-left: 4px solid #ef4444; }
+    .summary .label { font-size: 0.75rem; text-transform: uppercase; color: #888; }
+    .summary .value { font-size: 1.25rem; font-weight: 600; }
+    section { margin-bottom: 1.5rem; }
+    section h2 { font-size: 1.1rem; color: #a0a0a0; margin-bottom: 0.5rem; }
+    table { width: 100%; border-collapse: collapse; background: #2a2a2a; border-radius: 8px; overflow: hidden; }
+    th, td { padding: 0.5rem 0.75rem; text-align: left; }
+    th { background: #333; color: #888; font-weight: 600; font-size: 0.8rem; }
+    tr.fail { background: rgba(239,68,68,0.08); }
+    .badge { padding: 0.2rem 0.5rem; border-radius: 4px; font-size: 0.8rem; }
+    .badge.ok { background: #22c55e; color: #0f0f0f; }
+    .badge.fail { background: #ef4444; color: #fff; }
+    .bar-cell { width: 120px; }
+    .bar { height: 8px; background: #3b82f6; border-radius: 4px; min-width: 2px; }
+    .bar.mem { background: #8b5cf6; }
+    code { font-size: 0.9em; background: #333; padding: 0.1rem 0.3rem; border-radius: 4px; }
+  </style>
+</head>
+<body>
+  <h1>Scripts Orchestrator Report</h1>
+  <div class="summary">
+    <div class="card ${success ? 'success' : 'fail'}">
+      <div class="label">Status</div>
+      <div class="value">${success ? 'Success' : 'Failed'}</div>
+    </div>
+    <div class="card">
+      <div class="label">Timestamp</div>
+      <div class="value" style="font-size:0.9rem">${escapeHtml(timestamp)}</div>
+    </div>
+    ${overallDurationMs != null ? `
+    <div class="card">
+      <div class="label">Total time</div>
+      <div class="value">${this.formatMs(overallDurationMs)}</div>
+    </div>` : ''}
+  </div>
+
+  ${phases.length > 0 ? `
+  <section>
+    <h2>Phases</h2>
+    <table>
+      <thead><tr><th>Phase</th><th>Status</th><th>Duration</th><th></th></tr></thead>
+      <tbody>${phases.map(phaseRow).join('')}</tbody>
+    </table>
+  </section>` : ''}
+
+  <section>
+    <h2>Commands</h2>
+    <table>
+      <thead><tr><th>Command</th><th>Phase</th><th>Status</th><th>Duration</th><th>Memory</th><th>Time</th><th>Memory</th></tr></thead>
+      <tbody>${commands.map(row).join('')}</tbody>
+    </table>
+  </section>
+</body>
+</html>`;
+
+    if (this.htmlResultsPath === '-') {
+      console.log(html);
+    } else {
+      const outPath = this.htmlResultsPath || './scripts-orchestrator-results.html';
+      fs.writeFileSync(outPath, html, 'utf8');
+      this.logger.verbose(`Wrote HTML report to ${outPath}`);
+    }
+  }
+
   async run() {
     this.startTime = Date.now();
     try {
@@ -328,7 +557,7 @@ export class Orchestrator {
               phase.parallel.forEach(({ command }) => {
                 this.skippedCommands.push(command);
                 this.skipReasons.set(command, 'before_start_phase');
-                this.commandTimings.set(command, 0);
+                this.commandTimings.set(command, { durationMs: 0, memoryKb: null });
               });
               continue;
             }
@@ -347,7 +576,7 @@ export class Orchestrator {
             phase.parallel.forEach(({ command }) => {
               this.skippedCommands.push(command);
               this.skipReasons.set(command, 'optional_phase_not_requested');
-              this.commandTimings.set(command, 0);
+              this.commandTimings.set(command, { durationMs: 0, memoryKb: null });
             });
             continue;
           }
@@ -357,7 +586,7 @@ export class Orchestrator {
             phase.parallel.forEach(({ command }) => {
               this.skippedCommands.push(command);
               this.skipReasons.set(command, 'after_phase_failure');
-              this.commandTimings.set(command, 0);
+              this.commandTimings.set(command, { durationMs: 0, memoryKb: null });
             });
             continue;
           }
@@ -385,9 +614,16 @@ export class Orchestrator {
           }
 
           const phaseHasFailures = results.some((result) => !result);
-          const phaseDurationStr = `(${this.formatDuration(
-            Date.now() - phaseStartTime,
-          )})`;
+          const phaseDurationMs = Date.now() - phaseStartTime;
+          const phaseDurationStr = this.metrics.includes('time')
+            ? `(${this.formatDuration(phaseDurationMs)})`
+            : '';
+
+          this.phaseResults.push({
+            name: phase.name,
+            success: !phaseHasFailures,
+            durationMs: this.metrics.includes('time') ? phaseDurationMs : undefined,
+          });
 
           if (phaseHasFailures) {
             hasFailures = true;
@@ -450,8 +686,8 @@ export class Orchestrator {
         this.logger.error(`Cleanup failed: ${error.message}`);
       }
 
-      // Log overall time after cleanup has finished
-      if (this.startTime) {
+      // Log overall time after cleanup has finished (only when metrics include time)
+      if (this.startTime && this.metrics.includes('time')) {
         const overallDuration = Date.now() - this.startTime;
         this.logger.printMessage(() =>
           console.log(
@@ -462,6 +698,11 @@ export class Orchestrator {
         );
       }
 
+      // Write JSON results if requested
+      if (this.jsonResultsPath != null) {
+        this.writeJsonResults(hasFailures);
+      }
+
       // Update git cache on successful execution
       if (!hasFailures) {
         await this.gitCache.updateCache();

package/lib/process-manager.js

@@ -55,6 +55,32 @@ export class ProcessManager {
     });
   }
 
+  parseGnuTimeOutput(filePath) {
+    try {
+      if (!fs.existsSync(filePath)) return null;
+      const text = fs.readFileSync(filePath, 'utf8');
+      const m = text.match(/Maximum resident set size \(kbytes\):\s*(\d+)/i);
+      const kbytes = m ? parseInt(m[1], 10) : null;
+      try {
+        fs.unlinkSync(filePath);
+      } catch {
+        // ignore
+      }
+      return Number.isFinite(kbytes) ? kbytes : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Parse macOS BSD time -l output (bytes) from text; returns memory in KB or null. */
+  parseBsdTimeOutput(text) {
+    if (!text || typeof text !== 'string') return null;
+    const m = text.match(/(\d+)\s+maximum resident set size/i);
+    if (!m) return null;
+    const bytes = parseInt(m[1], 10);
+    return Number.isFinite(bytes) ? Math.round(bytes / 1024) : null;
+  }
+
   async runCommand({
     cmd,
     logFile,
@@ -63,6 +89,8 @@ export class ProcessManager {
     kill_command = null,
     isRetry = false,
     env = null,
+    reportTime = false,
+    reportMemory = false,
   }) {
     const baseDir = this.logFolder
       ? path.resolve(this.logFolder)
@@ -88,11 +116,17 @@ export class ProcessManager {
       }
     } catch (error) {
       this.logger.error(`Failed to setup log file: ${error.message}`);
-      return Promise.resolve({ success: false, output: '' });
+      return Promise.resolve({
+        success: false,
+        output: '',
+        durationMs: 0,
+        memoryKb: null,
+      });
     }
 
     return new Promise((resolve) => {
       const startTime = Date.now();
+      let timeOutputPath = null;
       // Build command with environment variables if provided
       let fullCommand = `npm run ${cmd}`;
       if (env && Object.keys(env).length > 0) {
@@ -101,6 +135,14 @@ export class ProcessManager {
           .join(' ');
         fullCommand = `${envStr} npm run ${cmd}`;
       }
+      const useTimeWrapper =
+        reportMemory && !background && (process.platform === 'linux' || process.platform === 'darwin');
+      if (useTimeWrapper && process.platform === 'linux') {
+        timeOutputPath = path.join(LOGS_DIR, `.time-${logName}-${startTime}.txt`);
+        fullCommand = `/usr/bin/time -v -o ${JSON.stringify(timeOutputPath)} sh -c ${JSON.stringify(fullCommand)}`;
+      } else if (useTimeWrapper && process.platform === 'darwin') {
+        fullCommand = `/usr/bin/time -l sh -c ${JSON.stringify(fullCommand)}`;
+      }
 
       this.logger.startTask(cmd, fullCommand);
 
@@ -126,8 +168,12 @@ export class ProcessManager {
         processInstance.on('error', (error) => {
           this.logger.stopTask(cmd);
           this.logger.error(`Failed to start process: ${error.message}`);
-          //this.logger.verbose(`Process error details: ${JSON.stringify(error, null, 2)}`);
-          resolve({ success: false, output: '' });
+          resolve({
+            success: false,
+            output: '',
+            durationMs: Date.now() - startTime,
+            memoryKb: null,
+          });
         });
 
         if (background) {
@@ -189,7 +235,12 @@ export class ProcessManager {
                       `Failed to read log file: ${error.message}`,
                     );
                   }
-                  return { success: false, output };
+                  return {
+                    success: false,
+                    output,
+                    durationMs: Date.now() - startTime,
+                    memoryKb: null,
+                  };
                 }
 
                 this.logger.verbose(
@@ -216,7 +267,12 @@ export class ProcessManager {
                       `Failed to read log file: ${error.message}`,
                     );
                   }
-                  return { success: false, output };
+                  return {
+                    success: false,
+                    output,
+                    durationMs: Date.now() - startTime,
+                    memoryKb: null,
+                  };
                 }
 
                 this.backgroundProcesses.push(processGroupId);
@@ -236,7 +292,12 @@ export class ProcessManager {
                 this.logger.verbose(
                   `Background process started: npm run ${cmd} (PGID: ${processGroupId})`,
                 );
-                return { success: true, output: '' };
+                return {
+                  success: true,
+                  output: '',
+                  durationMs: Date.now() - startTime,
+                  memoryKb: null,
+                };
               } catch (error) {
                 if (attempt === maxAttempts) {
                   this.logger.error(
@@ -245,7 +306,12 @@ export class ProcessManager {
                   this.logger.verbose(
                     `Final verification attempt failed: ${error.message}`,
                   );
-                  return { success: false, output: '' };
+                  return {
+                    success: false,
+                    output: '',
+                    durationMs: Date.now() - startTime,
+                    memoryKb: null,
+                  };
                 }
                 this.logger.verbose(
                   `Verification attempt ${attempt} failed: ${error.message}`,
@@ -258,7 +324,12 @@ export class ProcessManager {
                 );
               }
             }
-            return { success: false, output: '' };
+            return {
+              success: false,
+              output: '',
+              durationMs: Date.now() - startTime,
+              memoryKb: null,
+            };
           };
 
           verifyProcess().then(resolve);
@@ -293,26 +364,50 @@ export class ProcessManager {
 
             this.logger.stopTask(cmd);
 
-            const duration = Date.now() - startTime;
-            const durationStr = ` (${this.formatDuration(duration)})`;
+            const durationMs = Date.now() - startTime;
+            const durationStr = reportTime
+              ? ` (${this.formatDuration(durationMs)})`
+              : '';
+            let memoryKb = null;
+            if (reportMemory) {
+              if (timeOutputPath) {
+                memoryKb = this.parseGnuTimeOutput(timeOutputPath);
+              } else if (process.platform === 'darwin') {
+                memoryKb = this.parseBsdTimeOutput(output);
+              }
+            }
 
             if (code !== 0) {
               this.logger.error(
                 `Failed: npm run ${cmd} ❌${durationStr} (exit code: ${code})`,
               );
               this.logger.verbose(`Process output: ${output}`);
-              resolve({ success: false, output });
+              resolve({
+                success: false,
+                output,
+                durationMs,
+                memoryKb,
+              });
             } else {
               this.logger.success(`Completed: npm run ${cmd} ✅${durationStr}`);
-              resolve({ success: true, output });
+              resolve({
+                success: true,
+                output,
+                durationMs,
+                memoryKb,
+              });
             }
           });
         }
       } catch (error) {
         this.logger.stopTask(cmd);
         this.logger.error(`Failed to spawn process: ${error.message}`);
-        //this.logger.verbose(`Spawn error details: ${JSON.stringify(error, null, 2)}`);
-        resolve({ success: false, output: '' });
+        resolve({
+          success: false,
+          output: '',
+          durationMs: Date.now() - startTime,
+          memoryKb: null,
+        });
       }
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scripts-orchestrator",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "description": "A powerful script orchestrator for running parallel commands with dependency management, background processes, and health checks",
   "main": "lib/index.js",
   "type": "module",

package/scripts-orchestrator.config.js

@@ -1,4 +1,10 @@
 export default {
+  // Optional: metrics to report (time, memory). CLI --metrics overrides.
+  // metrics: ['time'],
+  // Optional: path for JSON results, or '-' for stdout. CLI --json-results overrides.
+  // json_results: './scripts-orchestrator-results.json',
+  // Optional: path for HTML report. CLI --html-results overrides.
+  // html_results: './scripts-orchestrator-results.html',
   phases: [
     {
       name: 'build',