@pipeline-builder/pipeline-manager 0.0.1

package/dist/utils/output-utils.d.ts

@@ -0,0 +1,40 @@
+import { type OutputFormat } from '../config/cli.constants.js';
+/**
+ * Options for outputData function
+ */
+export interface OutputOptions {
+    format?: OutputFormat;
+    file?: string;
+    pretty?: boolean;
+    silent?: boolean;
+    append?: boolean;
+}
+/**
+ * Table column configuration
+ */
+export interface TableColumn {
+    header: string;
+    key: string;
+    width?: number;
+    align?: 'left' | 'center' | 'right';
+    formatter?: (value: unknown) => string;
+}
+export declare function printSuccess(message: string, data?: unknown): void;
+export declare function printInfo(message: string, data?: unknown): void;
+export declare function printWarning(message: string, data?: unknown): void;
+export declare function printError(message: string, data?: unknown): void;
+export declare function printDebug(message: string, data?: unknown): void;
+/**
+ * Output data in specified format (console or file)
+ */
+export declare function outputData(data: unknown, options?: OutputOptions): void;
+export declare function formatTable(data: unknown[], columns?: TableColumn[]): string;
+export declare function ensureOutputDirectory(outputPath: string): void;
+export declare function fileExists(filePath: string): boolean;
+export declare function printSection(title: string, subtitle?: string): void;
+export declare function printKeyValue(data: Record<string, unknown>, options?: {
+    indent?: number;
+    separator?: string;
+}): void;
+export declare function printDivider(char?: string, width?: number): void;
+//# sourceMappingURL=output-utils.d.ts.map

package/dist/utils/output-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-utils.d.ts","sourceRoot":"","sources":["../../src/utils/output-utils.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,4BAA4B,CAAC;AAMpC;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;CACxC;AAmCD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAyC;AAC5G,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAsC;AACtG,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAsC;AACzG,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAuC;AAExG,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAEhE;AAID;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,aAAkB,GAAG,IAAI,CAuC3E;AAID,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,WAAW,EAAE,GAAG,MAAM,CA4D5E;AAgED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAY9D;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEpD;AAID,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAOnE;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACpD,IAAI,CAWN;AAED,wBAAgB,YAAY,CAAC,IAAI,GAAE,MAAY,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAGrE"}

package/dist/utils/output-utils.js

@@ -0,0 +1,250 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import fs from 'node:fs';
+import path from 'node:path';
+import pico from 'picocolors';
+import YAML from 'yaml';
+import { formatFileSize, TABLE_OPTIONS, } from '../config/cli.constants.js';
+const { bold, cyan, green, yellow, red, dim, magenta, white } = pico;
+// --- Logging functions ---
+function logOutput(level, message, data) {
+    const colors = { info: cyan, success: green, warn: yellow, error: red, debug: magenta };
+    const prefixes = { info: 'ℹ', success: '✓', warn: '⚠', error: '✗', debug: '●' };
+    const writers = { error: console.error, warn: console.warn, info: console.log, success: console.log, debug: console.log };
+    // Fall back to console.log + raw message if a caller leaks an unknown level
+    // (e.g. an `as LogLevel` cast on user input). The whole point of the logger
+    // is to surface errors — failing inside the logger and masking the real
+    // error with a TypeError defeats it.
+    const color = colors[level] ?? ((s) => s);
+    const prefix = prefixes[level] ?? '?';
+    const write = writers[level] ?? console.log;
+    write(`${color(prefix)} ${message}`);
+    if (data !== undefined)
+        write(dim(formatDataForLog(data)));
+}
+function formatDataForLog(data) {
+    if (typeof data === 'string')
+        return data;
+    if (typeof data === 'object' && data !== null) {
+        const entries = Object.entries(data);
+        if (entries.length <= 5) {
+            return '\n' + entries.map(([key, value]) => {
+                const valueStr = typeof value === 'object' ? JSON.stringify(value) : String(value);
+                return `  ${key}: ${valueStr}`;
+            }).join('\n');
+        }
+    }
+    return JSON.stringify(data, null, 2);
+}
+export function printSuccess(message, data) { logOutput('success', message, data); }
+export function printInfo(message, data) { logOutput('info', message, data); }
+export function printWarning(message, data) { logOutput('warn', message, data); }
+export function printError(message, data) { logOutput('error', message, data); }
+export function printDebug(message, data) {
+    if (process.env.DEBUG === 'true')
+        logOutput('debug', message, data);
+}
+// --- Data output ---
+/**
+ * Output data in specified format (console or file)
+ */
+export function outputData(data, options = {}) {
+    const { format = 'json', file, pretty = true, silent = false, append = false } = options;
+    let output;
+    switch (format) {
+        case 'table':
+            if (!silent)
+                printInfo('Rendering as table');
+            if (Array.isArray(data) && data.length > 0) {
+                console.log(formatTable(data));
+            }
+            else if (typeof data === 'object' && data !== null) {
+                console.log(formatTable([data]));
+            }
+            else {
+                console.table(Array.isArray(data) ? data : [data]);
+            }
+            return;
+        case 'csv':
+            if (!silent)
+                printInfo('Rendering as CSV');
+            output = formatCsv(data);
+            break;
+        case 'yaml':
+            if (!silent)
+                printInfo('Rendering as YAML');
+            output = YAML.stringify(data);
+            break;
+        case 'json':
+        default:
+            if (!silent)
+                printInfo('Rendering as JSON');
+            output = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+            break;
+    }
+    if (file) {
+        writeToFile(file, output, format, append);
+    }
+    else {
+        console.log(output);
+    }
+}
+// --- Table formatting ---
+export function formatTable(data, columns) {
+    if (!Array.isArray(data) || data.length === 0)
+        return dim('(No data to display)');
+    const firstItem = data[0];
+    if (typeof firstItem !== 'object' || firstItem === null)
+        return JSON.stringify(data, null, 2);
+    const cols = columns || Object.keys(firstItem).map(key => ({ header: key, key }));
+    const colWidths = cols.map(col => {
+        if (col.width)
+            return col.width;
+        const headerWidth = col.header.length;
+        const dataWidth = Math.max(...data.map(item => {
+            const value = col.formatter
+                ? col.formatter(item[col.key])
+                : String(item[col.key] ?? '');
+            return value.length;
+        }));
+        return Math.max(headerWidth, dataWidth, 3);
+    });
+    const { border } = TABLE_OPTIONS;
+    const horizontalLine = (left, middle, right) => 
+    // Fill with the HORIZONTAL rule glyph (`─`), not `bodyJoin` (`│`) — the latter
+    // rendered every rule as `┌│││││┬…` instead of `┌─────┬…`.
+    left + colWidths.map(w => border.topBody.repeat((w ?? 0) + 2)).join(middle) + right;
+    const topLine = horizontalLine(border.topLeft, border.topJoin, border.topRight);
+    const midLine = horizontalLine(border.joinLeft, border.joinJoin, border.joinRight);
+    const bottomLine = horizontalLine(border.bottomLeft, border.bottomJoin, border.bottomRight);
+    const formatCell = (value, width, align = 'left') => {
+        if (value.length > width)
+            return value.substring(0, width - 3) + '...';
+        if (align === 'center') {
+            const leftPad = Math.floor((width - value.length) / 2);
+            return ' '.repeat(leftPad) + value + ' '.repeat(width - value.length - leftPad);
+        }
+        return align === 'right' ? value.padStart(width) : value.padEnd(width);
+    };
+    const headerRow = border.bodyLeft + ' ' +
+        cols.map((col, i) => cyan(bold(formatCell(col.header, colWidths[i] ?? 0)))).join(` ${border.bodyJoin} `) +
+        ` ${border.bodyRight}`;
+    let table = cyan(topLine) + '\n' + headerRow + '\n' + cyan(midLine) + '\n';
+    data.forEach(item => {
+        const row = border.bodyLeft + ' ' +
+            cols.map((col, i) => {
+                const value = col.formatter
+                    ? col.formatter(item[col.key])
+                    : String(item[col.key] ?? '');
+                return formatCell(value, colWidths[i] ?? 0, col.align);
+            }).join(` ${border.bodyJoin} `) +
+            ` ${border.bodyRight}`;
+        table += row + '\n';
+    });
+    table += cyan(bottomLine);
+    return table;
+}
+// --- CSV formatting ---
+function formatCsv(data) {
+    if (!Array.isArray(data) || data.length === 0)
+        return '';
+    const firstItem = data[0];
+    if (typeof firstItem !== 'object' || firstItem === null)
+        return data.join(',');
+    const headers = Object.keys(firstItem);
+    const rows = [headers.map(h => escapeCsvValue(h)).join(',')];
+    data.forEach(item => {
+        rows.push(headers.map(h => escapeCsvValue(item[h])).join(','));
+    });
+    return rows.join('\n');
+}
+function escapeCsvValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    const str = String(value);
+    if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+        return `"${str.replace(/"/g, '""')}"`;
+    }
+    return str;
+}
+// --- File operations ---
+/**
+ * Validate that a file path resolves within the current working directory.
+ * Prevents path traversal attacks (e.g., --output ../../etc/passwd).
+ */
+function validateOutputPath(filePath) {
+    const resolved = path.resolve(filePath);
+    const cwd = path.resolve(process.cwd());
+    if (!resolved.startsWith(cwd + path.sep) && resolved !== cwd) {
+        throw new Error(`Path traversal rejected: "${filePath}" resolves outside the current directory`);
+    }
+    return resolved;
+}
+function writeToFile(filePath, content, format, append = false) {
+    try {
+        const safePath = validateOutputPath(filePath);
+        const dir = path.dirname(safePath);
+        if (dir !== '.')
+            ensureOutputDirectory(dir);
+        if (append) {
+            fs.appendFileSync(safePath, content + '\n', 'utf-8');
+            printSuccess('Output appended to file', { path: safePath, format });
+        }
+        else {
+            fs.writeFileSync(safePath, content, 'utf-8');
+            const stats = fs.statSync(safePath);
+            printSuccess('Output saved to file', { path: safePath, format, size: formatFileSize(stats.size) });
+        }
+    }
+    catch (error) {
+        printError('Failed to write file', {
+            path: filePath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}
+export function ensureOutputDirectory(outputPath) {
+    if (fs.existsSync(outputPath))
+        return;
+    try {
+        fs.mkdirSync(outputPath, { recursive: true });
+        printDebug('Directory created', { path: outputPath });
+    }
+    catch (error) {
+        printError('Failed to create directory', {
+            path: outputPath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}
+export function fileExists(filePath) {
+    return fs.existsSync(filePath);
+}
+// --- Display helpers ---
+export function printSection(title, subtitle) {
+    const width = process.stdout.columns || 80;
+    console.log('');
+    console.log(cyan('═'.repeat(width)));
+    console.log(cyan(bold(title)));
+    if (subtitle)
+        console.log(dim(subtitle));
+    console.log(cyan('═'.repeat(width)));
+}
+export function printKeyValue(data, options = {}) {
+    const { indent = 0, separator = '│' } = options;
+    const maxKeyLength = Math.max(...Object.keys(data).map(k => k.length));
+    const indentStr = ' '.repeat(indent);
+    Object.entries(data).forEach(([key, value]) => {
+        const paddedKey = key.padEnd(maxKeyLength);
+        const formattedValue = typeof value === 'object' && value !== null
+            ? JSON.stringify(value) : String(value);
+        console.log(`${indentStr}${dim(paddedKey)} ${cyan(separator)} ${white(formattedValue)}`);
+    });
+}
+export function printDivider(char = '─', width) {
+    const effectiveWidth = width || process.stdout.columns || 80;
+    console.log(dim(char.repeat(effectiveWidth)));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"output-utils.js","sourceRoot":"","sources":["../../src/utils/output-utils.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport pico from 'picocolors';\nimport YAML from 'yaml';\nimport {\n  type OutputFormat,\n  formatFileSize,\n  TABLE_OPTIONS,\n} from '../config/cli.constants.js';\n\nconst { bold, cyan, green, yellow, red, dim, magenta, white } = pico;\n\ntype LogLevel = 'info' | 'success' | 'warn' | 'error' | 'debug';\n\n/**\n * Options for outputData function\n */\nexport interface OutputOptions {\n  format?: OutputFormat;\n  file?: string;\n  pretty?: boolean;\n  silent?: boolean;\n  append?: boolean;\n}\n\n/**\n * Table column configuration\n */\nexport interface TableColumn {\n  header: string;\n  key: string;\n  width?: number;\n  align?: 'left' | 'center' | 'right';\n  formatter?: (value: unknown) => string;\n}\n\n// --- Logging functions ---\n\nfunction logOutput(level: LogLevel, message: string, data?: unknown): void {\n  const colors = { info: cyan, success: green, warn: yellow, error: red, debug: magenta };\n  const prefixes = { info: 'ℹ', success: '✓', warn: '⚠', error: '✗', debug: '●' };\n  const writers = { error: console.error, warn: console.warn, info: console.log, success: console.log, debug: console.log };\n\n  // Fall back to console.log + raw message if a caller leaks an unknown level\n  // (e.g. an `as LogLevel` cast on user input). The whole point of the logger\n  // is to surface errors — failing inside the logger and masking the real\n  // error with a TypeError defeats it.\n  const color = colors[level] ?? ((s: string) => s);\n  const prefix = prefixes[level] ?? '?';\n  const write = writers[level] ?? console.log;\n\n  write(`${color(prefix)} ${message}`);\n  if (data !== undefined) write(dim(formatDataForLog(data)));\n}\n\nfunction formatDataForLog(data: unknown): string {\n  if (typeof data === 'string') return data;\n  if (typeof data === 'object' && data !== null) {\n    const entries = Object.entries(data);\n    if (entries.length <= 5) {\n      return '\\n' + entries.map(([key, value]) => {\n        const valueStr = typeof value === 'object' ? JSON.stringify(value) : String(value);\n        return `  ${key}: ${valueStr}`;\n      }).join('\\n');\n    }\n  }\n  return JSON.stringify(data, null, 2);\n}\n\nexport function printSuccess(message: string, data?: unknown): void { logOutput('success', message, data); }\nexport function printInfo(message: string, data?: unknown): void { logOutput('info', message, data); }\nexport function printWarning(message: string, data?: unknown): void { logOutput('warn', message, data); }\nexport function printError(message: string, data?: unknown): void { logOutput('error', message, data); }\n\nexport function printDebug(message: string, data?: unknown): void {\n  if (process.env.DEBUG === 'true') logOutput('debug', message, data);\n}\n\n// --- Data output ---\n\n/**\n * Output data in specified format (console or file)\n */\nexport function outputData(data: unknown, options: OutputOptions = {}): void {\n  const { format = 'json', file, pretty = true, silent = false, append = false } = options;\n\n  let output: string;\n\n  switch (format) {\n    case 'table':\n      if (!silent) printInfo('Rendering as table');\n      if (Array.isArray(data) && data.length > 0) {\n        console.log(formatTable(data));\n      } else if (typeof data === 'object' && data !== null) {\n        console.log(formatTable([data]));\n      } else {\n        console.table(Array.isArray(data) ? data : [data]);\n      }\n      return;\n\n    case 'csv':\n      if (!silent) printInfo('Rendering as CSV');\n      output = formatCsv(data);\n      break;\n\n    case 'yaml':\n      if (!silent) printInfo('Rendering as YAML');\n      output = YAML.stringify(data);\n      break;\n\n    case 'json':\n    default:\n      if (!silent) printInfo('Rendering as JSON');\n      output = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);\n      break;\n  }\n\n  if (file) {\n    writeToFile(file, output, format, append);\n  } else {\n    console.log(output);\n  }\n}\n\n// --- Table formatting ---\n\nexport function formatTable(data: unknown[], columns?: TableColumn[]): string {\n  if (!Array.isArray(data) || data.length === 0) return dim('(No data to display)');\n\n  const firstItem = data[0];\n  if (typeof firstItem !== 'object' || firstItem === null) return JSON.stringify(data, null, 2);\n\n  const cols: TableColumn[] = columns || Object.keys(firstItem).map(key => ({ header: key, key }));\n\n  const colWidths: number[] = cols.map(col => {\n    if (col.width) return col.width;\n    const headerWidth = col.header.length;\n    const dataWidth = Math.max(...data.map(item => {\n      const value = col.formatter\n        ? col.formatter((item as Record<string, unknown>)[col.key])\n        : String((item as Record<string, unknown>)[col.key] ?? '');\n      return value.length;\n    }));\n    return Math.max(headerWidth, dataWidth, 3);\n  });\n\n  const { border } = TABLE_OPTIONS;\n\n  const horizontalLine = (left: string, middle: string, right: string) =>\n    // Fill with the HORIZONTAL rule glyph (`─`), not `bodyJoin` (`│`) — the latter\n    // rendered every rule as `┌│││││┬…` instead of `┌─────┬…`.\n    left + colWidths.map(w => border.topBody.repeat((w ?? 0) + 2)).join(middle) + right;\n\n  const topLine = horizontalLine(border.topLeft, border.topJoin, border.topRight);\n  const midLine = horizontalLine(border.joinLeft, border.joinJoin, border.joinRight);\n  const bottomLine = horizontalLine(border.bottomLeft, border.bottomJoin, border.bottomRight);\n\n  const formatCell = (value: string, width: number, align: 'left' | 'center' | 'right' = 'left'): string => {\n    if (value.length > width) return value.substring(0, width - 3) + '...';\n    if (align === 'center') {\n      const leftPad = Math.floor((width - value.length) / 2);\n      return ' '.repeat(leftPad) + value + ' '.repeat(width - value.length - leftPad);\n    }\n    return align === 'right' ? value.padStart(width) : value.padEnd(width);\n  };\n\n  const headerRow = border.bodyLeft + ' ' +\n    cols.map((col, i) => cyan(bold(formatCell(col.header, colWidths[i] ?? 0)))).join(` ${border.bodyJoin} `) +\n    ` ${border.bodyRight}`;\n\n  let table = cyan(topLine) + '\\n' + headerRow + '\\n' + cyan(midLine) + '\\n';\n\n  data.forEach(item => {\n    const row = border.bodyLeft + ' ' +\n      cols.map((col, i) => {\n        const value = col.formatter\n          ? col.formatter((item as Record<string, unknown>)[col.key])\n          : String((item as Record<string, unknown>)[col.key] ?? '');\n        return formatCell(value, colWidths[i] ?? 0, col.align);\n      }).join(` ${border.bodyJoin} `) +\n      ` ${border.bodyRight}`;\n    table += row + '\\n';\n  });\n\n  table += cyan(bottomLine);\n  return table;\n}\n\n// --- CSV formatting ---\n\nfunction formatCsv(data: unknown): string {\n  if (!Array.isArray(data) || data.length === 0) return '';\n  const firstItem = data[0];\n  if (typeof firstItem !== 'object' || firstItem === null) return data.join(',');\n\n  const headers = Object.keys(firstItem);\n  const rows: string[] = [headers.map(h => escapeCsvValue(h)).join(',')];\n  data.forEach(item => {\n    rows.push(headers.map(h => escapeCsvValue((item as Record<string, unknown>)[h])).join(','));\n  });\n  return rows.join('\\n');\n}\n\nfunction escapeCsvValue(value: unknown): string {\n  if (value === null || value === undefined) return '';\n  const str = String(value);\n  if (str.includes(',') || str.includes('\"') || str.includes('\\n')) {\n    return `\"${str.replace(/\"/g, '\"\"')}\"`;\n  }\n  return str;\n}\n\n// --- File operations ---\n\n/**\n * Validate that a file path resolves within the current working directory.\n * Prevents path traversal attacks (e.g., --output ../../etc/passwd).\n */\nfunction validateOutputPath(filePath: string): string {\n  const resolved = path.resolve(filePath);\n  const cwd = path.resolve(process.cwd());\n  if (!resolved.startsWith(cwd + path.sep) && resolved !== cwd) {\n    throw new Error(`Path traversal rejected: \"${filePath}\" resolves outside the current directory`);\n  }\n  return resolved;\n}\n\nfunction writeToFile(filePath: string, content: string, format: OutputFormat, append: boolean = false): void {\n  try {\n    const safePath = validateOutputPath(filePath);\n    const dir = path.dirname(safePath);\n    if (dir !== '.') ensureOutputDirectory(dir);\n\n    if (append) {\n      fs.appendFileSync(safePath, content + '\\n', 'utf-8');\n      printSuccess('Output appended to file', { path: safePath, format });\n    } else {\n      fs.writeFileSync(safePath, content, 'utf-8');\n      const stats = fs.statSync(safePath);\n      printSuccess('Output saved to file', { path: safePath, format, size: formatFileSize(stats.size) });\n    }\n  } catch (error) {\n    printError('Failed to write file', {\n      path: filePath,\n      error: error instanceof Error ? error.message : String(error),\n    });\n    throw error;\n  }\n}\n\nexport function ensureOutputDirectory(outputPath: string): void {\n  if (fs.existsSync(outputPath)) return;\n  try {\n    fs.mkdirSync(outputPath, { recursive: true });\n    printDebug('Directory created', { path: outputPath });\n  } catch (error) {\n    printError('Failed to create directory', {\n      path: outputPath,\n      error: error instanceof Error ? error.message : String(error),\n    });\n    throw error;\n  }\n}\n\nexport function fileExists(filePath: string): boolean {\n  return fs.existsSync(filePath);\n}\n\n// --- Display helpers ---\n\nexport function printSection(title: string, subtitle?: string): void {\n  const width = process.stdout.columns || 80;\n  console.log('');\n  console.log(cyan('═'.repeat(width)));\n  console.log(cyan(bold(title)));\n  if (subtitle) console.log(dim(subtitle));\n  console.log(cyan('═'.repeat(width)));\n}\n\nexport function printKeyValue(\n  data: Record<string, unknown>,\n  options: { indent?: number; separator?: string } = {},\n): void {\n  const { indent = 0, separator = '│' } = options;\n  const maxKeyLength = Math.max(...Object.keys(data).map(k => k.length));\n  const indentStr = ' '.repeat(indent);\n\n  Object.entries(data).forEach(([key, value]) => {\n    const paddedKey = key.padEnd(maxKeyLength);\n    const formattedValue = typeof value === 'object' && value !== null\n      ? JSON.stringify(value) : String(value);\n    console.log(`${indentStr}${dim(paddedKey)} ${cyan(separator)} ${white(formattedValue)}`);\n  });\n}\n\nexport function printDivider(char: string = '─', width?: number): void {\n  const effectiveWidth = width || process.stdout.columns || 80;\n  console.log(dim(char.repeat(effectiveWidth)));\n}\n"]}

package/dist/utils/pipeline-config.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared pipeline-config resolution used by both `synth` and `deploy` so the two
+ * commands fetch, plugin-resolve, registry-bake, and template-preview identically
+ * (they previously kept near-duplicate copies that could drift).
+ */
+import type { ApiClient } from './api-client.js';
+import type { Pipeline } from '../types/pipeline.js';
+export interface FetchedPipeline {
+    /** The raw pipeline record (id/org/project/flags) as returned by the platform. */
+    readonly pipeline: Pipeline;
+    /** props + pipelineId (+ orgId) + resolvedPlugins, with the registry pull-host baked in. */
+    readonly propsWithIds: Record<string, unknown>;
+    /** The resolved platform base URL the config was fetched against. */
+    readonly baseUrl: string;
+}
+/**
+ * Fetch a pipeline by id and build the synth/deploy props:
+ *  - GET the pipeline and validate it has `props`,
+ *  - assemble `propsWithIds` (props + pipelineId + orgId),
+ *  - pre-resolve plugins so the template ships real CodeBuild image URIs
+ *    (otherwise CDK falls back to standard:7.0 at deploy time),
+ *  - bake the registry pull-host from the platform URL (no-op when
+ *    IMAGE_REGISTRY_PULL_HOST is set).
+ */
+export declare function fetchPipelineProps(client: ApiClient, pipelineId: string): Promise<FetchedPipeline>;
+/**
+ * Apply pass-1 self-referencing template resolution to `propsWithIds` and print it
+ * to stdout (used by `synth --show-resolved` / `deploy --show-resolved`). Exits with
+ * code 1 if resolution reports errors. `resolveSelfReferencing` mutates the object
+ * in place, so the printed JSON reflects the expanded templates.
+ */
+export declare function printResolvedOrExit(propsWithIds: Record<string, unknown>): Promise<void>;
+//# sourceMappingURL=pipeline-config.d.ts.map

package/dist/utils/pipeline-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-config.d.ts","sourceRoot":"","sources":["../../src/utils/pipeline-config.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAKjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,4FAA4F;IAC5F,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/C,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAsBxG;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAW9F"}

package/dist/utils/pipeline-config.js

@@ -0,0 +1,55 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { printInfo } from './output-utils.js';
+import { resolvePluginsForProps } from './plugin-resolver.js';
+import { bakePlatformRegistry } from './registry.js';
+import { extractSingleResponse } from './response-utils.js';
+/**
+ * Fetch a pipeline by id and build the synth/deploy props:
+ *  - GET the pipeline and validate it has `props`,
+ *  - assemble `propsWithIds` (props + pipelineId + orgId),
+ *  - pre-resolve plugins so the template ships real CodeBuild image URIs
+ *    (otherwise CDK falls back to standard:7.0 at deploy time),
+ *  - bake the registry pull-host from the platform URL (no-op when
+ *    IMAGE_REGISTRY_PULL_HOST is set).
+ */
+export async function fetchPipelineProps(client, pipelineId) {
+    const config = client.getConfig();
+    const response = await client.get(`${config.api.pipelineUrl}/${pipelineId}`);
+    const pipeline = extractSingleResponse(response, 'pipeline', 'props');
+    if (!pipeline?.props) {
+        throw new Error(`Failed to retrieve pipeline props for ID: ${pipelineId}`);
+    }
+    const propsWithIds = {
+        ...pipeline.props,
+        ...(pipeline.orgId ? { orgId: pipeline.orgId } : {}),
+        pipelineId: pipeline.id || pipelineId,
+    };
+    const resolvedPlugins = await resolvePluginsForProps(client, propsWithIds);
+    if (Object.keys(resolvedPlugins).length > 0) {
+        propsWithIds.resolvedPlugins = resolvedPlugins;
+        printInfo('Pre-resolved plugins', { count: Object.keys(resolvedPlugins).length });
+    }
+    bakePlatformRegistry(propsWithIds, config.api.baseUrl);
+    return { pipeline, propsWithIds, baseUrl: config.api.baseUrl };
+}
+/**
+ * Apply pass-1 self-referencing template resolution to `propsWithIds` and print it
+ * to stdout (used by `synth --show-resolved` / `deploy --show-resolved`). Exits with
+ * code 1 if resolution reports errors. `resolveSelfReferencing` mutates the object
+ * in place, so the printed JSON reflects the expanded templates.
+ */
+export async function printResolvedOrExit(propsWithIds) {
+    const { resolveSelfReferencing } = await import('@pipeline-builder/pipeline-core');
+    const scope = { metadata: propsWithIds.metadata ?? {}, vars: propsWithIds.vars ?? {} };
+    const isTpl = (f) => f === 'projectName' || f.startsWith('metadata.') || f.startsWith('vars.');
+    const result = resolveSelfReferencing(propsWithIds, scope, isTpl, (f) => (isTpl(f) ? f : null), 'pipeline');
+    if (result.errors.length) {
+        console.error('Resolution errors:');
+        for (const e of result.errors)
+            console.error(`  [${e.field ?? '?'}] ${e.message}`);
+        process.exit(1);
+    }
+    console.log(JSON.stringify(propsWithIds, null, 2));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/platform-secret.d.ts

@@ -0,0 +1,27 @@
+/** Login/secret options shared across the platform-secret helpers. */
+export interface PlatformSecretOptions {
+    /** Login identifier (username OR email) — matches `auth login` / `auth pat`. */
+    readonly identifier?: string;
+    readonly password?: string;
+    readonly verifySsl?: boolean;
+}
+/**
+ * Derive the platform secret path from a JWT's organizationId.
+ * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.
+ * @throws if the token carries no organizationId (caller should fall back to PLATFORM_SECRET_NAME).
+ */
+export declare function resolveSecretName(token: string): string;
+/**
+ * Ensure `process.env.PLATFORM_TOKEN` is set. No-op if it already is. Otherwise,
+ * if login creds are available (`--identifier/--password` or `PLATFORM_IDENTIFIER`/
+ * `PLATFORM_PASSWORD` env — the env path lets `provision` pass creds without
+ * putting the password on the command line), log in and set PLATFORM_TOKEN.
+ */
+export declare function ensurePlatformToken(options: PlatformSecretOptions): Promise<void>;
+/**
+ * Resolve the platform secret name: an explicit `PLATFORM_SECRET_NAME` env wins;
+ * otherwise log in if needed and derive it from the platform token's org — the
+ * same token `init-platform.sh` (register) mints, so writer and reader agree.
+ */
+export declare function resolvePlatformSecretName(options: PlatformSecretOptions): Promise<string>;
+//# sourceMappingURL=platform-secret.d.ts.map

package/dist/utils/platform-secret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-secret.d.ts","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"AAkBA,sEAAsE;AACtE,MAAM,WAAW,qBAAqB;IACpC,gFAAgF;IAChF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOvD;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0CvF;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,CAY/F"}

package/dist/utils/platform-secret.js

@@ -0,0 +1,92 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Shared platform-token → secret-name resolution, used by both `store-token`
+ * (which WRITES the JWT to Secrets Manager) and `setup-events` (which deploys the
+ * Lambda that READS it). Both must agree on the same secret path, so the logic
+ * lives here once: derive `{SECRETS_PATH_PREFIX}/{orgId}/platform` from the JWT's
+ * organizationId, logging in first if needed to obtain the token.
+ */
+import { CoreConstants } from '@pipeline-builder/pipeline-core';
+import axios from 'axios';
+import { decodeTokenPayload } from './auth-guard.js';
+import { getApiConfig } from './config-loader.js';
+import { printInfo, printSection, printSuccess, printWarning } from './output-utils.js';
+import { assertSslDisableAllowed } from './tls.js';
+/**
+ * Derive the platform secret path from a JWT's organizationId.
+ * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.
+ * @throws if the token carries no organizationId (caller should fall back to PLATFORM_SECRET_NAME).
+ */
+export function resolveSecretName(token) {
+    const payload = decodeTokenPayload(token);
+    const orgId = payload?.organizationId;
+    if (!orgId) {
+        throw new Error('Token does not contain organizationId — cannot derive secret name. Set PLATFORM_SECRET_NAME to specify it explicitly.');
+    }
+    return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/platform`;
+}
+/**
+ * Ensure `process.env.PLATFORM_TOKEN` is set. No-op if it already is. Otherwise,
+ * if login creds are available (`--identifier/--password` or `PLATFORM_IDENTIFIER`/
+ * `PLATFORM_PASSWORD` env — the env path lets `provision` pass creds without
+ * putting the password on the command line), log in and set PLATFORM_TOKEN.
+ */
+export async function ensurePlatformToken(options) {
+    if (process.env.PLATFORM_TOKEN)
+        return;
+    const loginIdentifier = options.identifier || process.env.PLATFORM_IDENTIFIER;
+    const loginPassword = options.password || process.env.PLATFORM_PASSWORD;
+    if (!loginIdentifier || !loginPassword)
+        return;
+    if (options.password) {
+        printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');
+    }
+    printSection('Login');
+    printInfo('Authenticating with identifier/password...');
+    // Resolve the base URL WITHOUT demanding a token — this login step runs
+    // pre-auth (no PLATFORM_TOKEN yet), so `getConfig()` would throw here. The
+    // token-optional loader still honors config files + PLATFORM_BASE_URL/TLS env.
+    const apiConfig = getApiConfig();
+    // SECURITY: this inline login POSTs the password. Refuse to disable cert
+    // verification in production (mirrors config-loader / login) so a MITM can't
+    // harvest it; honored in non-production for self-signed dev platforms.
+    if (options.verifySsl === false) {
+        assertSslDisableAllowed('inline login');
+    }
+    const rejectUnauthorized = options.verifySsl === false ? false : apiConfig.api.rejectUnauthorized;
+    const loginResponse = await axios.post(`${apiConfig.api.baseUrl}/api/auth/login`, 
+    // The server's loginSchema requires `identifier` (email OR username), not
+    // `email` — sending `email` fails zod validation with a 400. Mirror the
+    // canonical `postLogin` body.
+    { identifier: loginIdentifier, password: loginPassword }, {
+        httpsAgent: rejectUnauthorized === false
+            ? new (await import('https')).Agent({ rejectUnauthorized: false })
+            : undefined,
+    });
+    const loginData = loginResponse.data?.data ?? loginResponse.data;
+    const loginToken = loginData?.accessToken;
+    if (!loginToken || typeof loginToken !== 'string') {
+        throw new Error('Login failed — no access token in response');
+    }
+    process.env.PLATFORM_TOKEN = loginToken;
+    printSuccess('Login successful');
+}
+/**
+ * Resolve the platform secret name: an explicit `PLATFORM_SECRET_NAME` env wins;
+ * otherwise log in if needed and derive it from the platform token's org — the
+ * same token `init-platform.sh` (register) mints, so writer and reader agree.
+ */
+export async function resolvePlatformSecretName(options) {
+    const explicit = process.env.PLATFORM_SECRET_NAME;
+    if (explicit)
+        return explicit;
+    await ensurePlatformToken(options);
+    if (!process.env.PLATFORM_TOKEN) {
+        throw new Error('Cannot derive the platform secret name: no PLATFORM_TOKEN and no login creds. '
+            + 'Set PLATFORM_SECRET_NAME, or provide login creds '
+            + '(--identifier/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD).');
+    }
+    return resolveSecretName(process.env.PLATFORM_TOKEN);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform-secret.js","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared platform-token → secret-name resolution, used by both `store-token`\n * (which WRITES the JWT to Secrets Manager) and `setup-events` (which deploys the\n * Lambda that READS it). Both must agree on the same secret path, so the logic\n * lives here once: derive `{SECRETS_PATH_PREFIX}/{orgId}/platform` from the JWT's\n * organizationId, logging in first if needed to obtain the token.\n */\n\nimport { CoreConstants } from '@pipeline-builder/pipeline-core';\nimport axios from 'axios';\nimport { decodeTokenPayload } from './auth-guard.js';\nimport { getApiConfig } from './config-loader.js';\nimport { printInfo, printSection, printSuccess, printWarning } from './output-utils.js';\nimport { assertSslDisableAllowed } from './tls.js';\n\n/** Login/secret options shared across the platform-secret helpers. */\nexport interface PlatformSecretOptions {\n  /** Login identifier (username OR email) — matches `auth login` / `auth pat`. */\n  readonly identifier?: string;\n  readonly password?: string;\n  readonly verifySsl?: boolean;\n}\n\n/**\n * Derive the platform secret path from a JWT's organizationId.\n * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.\n * @throws if the token carries no organizationId (caller should fall back to PLATFORM_SECRET_NAME).\n */\nexport function resolveSecretName(token: string): string {\n  const payload = decodeTokenPayload(token);\n  const orgId = payload?.organizationId;\n  if (!orgId) {\n    throw new Error('Token does not contain organizationId — cannot derive secret name. Set PLATFORM_SECRET_NAME to specify it explicitly.');\n  }\n  return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/platform`;\n}\n\n/**\n * Ensure `process.env.PLATFORM_TOKEN` is set. No-op if it already is. Otherwise,\n * if login creds are available (`--identifier/--password` or `PLATFORM_IDENTIFIER`/\n * `PLATFORM_PASSWORD` env — the env path lets `provision` pass creds without\n * putting the password on the command line), log in and set PLATFORM_TOKEN.\n */\nexport async function ensurePlatformToken(options: PlatformSecretOptions): Promise<void> {\n  if (process.env.PLATFORM_TOKEN) return;\n  const loginIdentifier = options.identifier || process.env.PLATFORM_IDENTIFIER;\n  const loginPassword = options.password || process.env.PLATFORM_PASSWORD;\n  if (!loginIdentifier || !loginPassword) return;\n\n  if (options.password) {\n    printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');\n  }\n\n  printSection('Login');\n  printInfo('Authenticating with identifier/password...');\n  // Resolve the base URL WITHOUT demanding a token — this login step runs\n  // pre-auth (no PLATFORM_TOKEN yet), so `getConfig()` would throw here. The\n  // token-optional loader still honors config files + PLATFORM_BASE_URL/TLS env.\n  const apiConfig = getApiConfig();\n  // SECURITY: this inline login POSTs the password. Refuse to disable cert\n  // verification in production (mirrors config-loader / login) so a MITM can't\n  // harvest it; honored in non-production for self-signed dev platforms.\n  if (options.verifySsl === false) {\n    assertSslDisableAllowed('inline login');\n  }\n  const rejectUnauthorized = options.verifySsl === false ? false : apiConfig.api.rejectUnauthorized;\n  const loginResponse = await axios.post(\n    `${apiConfig.api.baseUrl}/api/auth/login`,\n    // The server's loginSchema requires `identifier` (email OR username), not\n    // `email` — sending `email` fails zod validation with a 400. Mirror the\n    // canonical `postLogin` body.\n    { identifier: loginIdentifier, password: loginPassword },\n    {\n      httpsAgent: rejectUnauthorized === false\n        ? new (await import('https')).Agent({ rejectUnauthorized: false })\n        : undefined,\n    },\n  );\n  const loginData = loginResponse.data?.data ?? loginResponse.data;\n  const loginToken = loginData?.accessToken;\n  if (!loginToken || typeof loginToken !== 'string') {\n    throw new Error('Login failed — no access token in response');\n  }\n  process.env.PLATFORM_TOKEN = loginToken;\n  printSuccess('Login successful');\n}\n\n/**\n * Resolve the platform secret name: an explicit `PLATFORM_SECRET_NAME` env wins;\n * otherwise log in if needed and derive it from the platform token's org — the\n * same token `init-platform.sh` (register) mints, so writer and reader agree.\n */\nexport async function resolvePlatformSecretName(options: PlatformSecretOptions): Promise<string> {\n  const explicit = process.env.PLATFORM_SECRET_NAME;\n  if (explicit) return explicit;\n  await ensurePlatformToken(options);\n  if (!process.env.PLATFORM_TOKEN) {\n    throw new Error(\n      'Cannot derive the platform secret name: no PLATFORM_TOKEN and no login creds. '\n      + 'Set PLATFORM_SECRET_NAME, or provide login creds '\n      + '(--identifier/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD).',\n    );\n  }\n  return resolveSecretName(process.env.PLATFORM_TOKEN);\n}\n"]}

package/dist/utils/plugin-resolver.d.ts

@@ -0,0 +1,17 @@
+import { ApiClient } from './api-client.js';
+/**
+ * Pre-resolve plugins by calling the same `POST /api/plugins/lookup` endpoint
+ * the deploy-time custom resource Lambda uses. Returning the full Plugin
+ * record at synth time is what allows the resulting CFN template to ship
+ * with real CodeBuild image URIs (`<host>/<ns>/<name>:<version>`) rather than
+ * the `aws/codebuild/standard:7.0` fallback that the synth-time token path
+ * forces.
+ *
+ * Failures are non-fatal: a missing plugin or unreachable API logs a warning
+ * and falls through to the deploy-time custom resource path so partial
+ * platform outages don't block synth/deploy.
+ *
+ * Keyed by `alias || name` to match `PluginLookup.plugin()`.
+ */
+export declare function resolvePluginsForProps(client: ApiClient, props: Record<string, unknown>): Promise<Record<string, unknown>>;
+//# sourceMappingURL=plugin-resolver.d.ts.map

package/dist/utils/plugin-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-resolver.d.ts","sourceRoot":"","sources":["../../src/utils/plugin-resolver.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAoD5C;;;;;;;;;;;;;GAaG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA2ClC"}