@pipeline-builder/pipeline-manager 3.1.0

package/dist/utils/output-utils.js

@@ -0,0 +1,320 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printSuccess = printSuccess;
+exports.printInfo = printInfo;
+exports.printWarning = printWarning;
+exports.printError = printError;
+exports.printDebug = printDebug;
+exports.outputData = outputData;
+exports.formatTable = formatTable;
+exports.ensureOutputDirectory = ensureOutputDirectory;
+exports.fileExists = fileExists;
+exports.printSection = printSection;
+exports.printKeyValue = printKeyValue;
+exports.printDivider = printDivider;
+exports.unwrapEnvelope = unwrapEnvelope;
+exports.extractSingleResponse = extractSingleResponse;
+exports.extractListResponse = extractListResponse;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const yaml_1 = __importDefault(require("yaml"));
+const cli_constants_1 = require("../config/cli.constants");
+const { bold, cyan, green, yellow, red, dim, magenta, white } = picocolors_1.default;
+// --- 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 };
+    const styledMessage = `${colors[level](prefixes[level])} ${message}`;
+    const write = writers[level];
+    write(styledMessage);
+    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);
+}
+function printSuccess(message, data) { logOutput('success', message, data); }
+function printInfo(message, data) { logOutput('info', message, data); }
+function printWarning(message, data) { logOutput('warn', message, data); }
+function printError(message, data) { logOutput('error', message, data); }
+function printDebug(message, data) {
+    if (process.env.DEBUG === 'true')
+        logOutput('debug', message, data);
+}
+// --- Data output ---
+/**
+ * Output data in specified format (console or file)
+ */
+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_1.default.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 ---
+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 } = cli_constants_1.TABLE_OPTIONS;
+    const horizontalLine = (left, middle, right) => left + colWidths.map(w => border.bodyJoin.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 = node_path_1.default.resolve(filePath);
+    const cwd = node_path_1.default.resolve(process.cwd());
+    if (!resolved.startsWith(cwd + node_path_1.default.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 = node_path_1.default.dirname(safePath);
+        if (dir !== '.')
+            ensureOutputDirectory(dir);
+        if (append) {
+            node_fs_1.default.appendFileSync(safePath, content + '\n', 'utf-8');
+            printSuccess('Output appended to file', { path: safePath, format });
+        }
+        else {
+            node_fs_1.default.writeFileSync(safePath, content, 'utf-8');
+            const stats = node_fs_1.default.statSync(safePath);
+            printSuccess('Output saved to file', { path: safePath, format, size: (0, cli_constants_1.formatFileSize)(stats.size) });
+        }
+    }
+    catch (error) {
+        printError('Failed to write file', {
+            path: filePath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}
+function ensureOutputDirectory(outputPath) {
+    if (node_fs_1.default.existsSync(outputPath))
+        return;
+    try {
+        node_fs_1.default.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;
+    }
+}
+function fileExists(filePath) {
+    return node_fs_1.default.existsSync(filePath);
+}
+// --- Display helpers ---
+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)));
+}
+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)}`);
+    });
+}
+function printDivider(char = '─', width) {
+    const effectiveWidth = width || process.stdout.columns || 80;
+    console.log(dim(char.repeat(effectiveWidth)));
+}
+// --- Response parsing ---
+/**
+ * Unwrap a sendSuccess API envelope: { success, statusCode, data: { ... } }
+ * Returns the inner `data` object, or the original response if not wrapped.
+ */
+function unwrapEnvelope(response) {
+    if (response && typeof response === 'object') {
+        const obj = response;
+        if ('success' in obj && 'data' in obj && obj.data && typeof obj.data === 'object') {
+            return obj.data;
+        }
+        return obj;
+    }
+    return {};
+}
+/**
+ * Extract a single entity from an API response, handling envelope formats.
+ * Tries: payload[entityKey], payload directly (if identifierKey exists), or undefined.
+ */
+function extractSingleResponse(response, entityKey, identifierKey) {
+    const payload = unwrapEnvelope(response);
+    // Direct entity: payload has the identifier (e.g. payload.id, payload.props, payload.name)
+    if (identifierKey in payload)
+        return payload;
+    // Nested under entity key: payload.pipeline, payload.plugin
+    const nested = payload[entityKey];
+    if (nested && typeof nested === 'object' && identifierKey in nested)
+        return nested;
+    return undefined;
+}
+/**
+ * Extract items from an API list response, handling multiple response formats.
+ * Supports: `{ <key>: T[] }`, `{ items: T[] }`, `T[]`, or invalid formats.
+ */
+function extractListResponse(response, itemsKey) {
+    if (Array.isArray(response)) {
+        return { items: response, total: undefined, hasMore: false };
+    }
+    if (response && typeof response === 'object') {
+        const obj = unwrapEnvelope(response);
+        // Extract pagination metadata if present
+        const pagination = obj.pagination;
+        const total = (pagination?.total ?? obj.total);
+        const hasMore = (pagination?.hasMore ?? obj.hasMore) || false;
+        // Try primary key (e.g. 'pipelines', 'plugins')
+        if (itemsKey in obj && Array.isArray(obj[itemsKey])) {
+            return { items: obj[itemsKey], total, hasMore };
+        }
+        // Try generic 'items' key
+        if ('items' in obj && Array.isArray(obj.items)) {
+            return { items: obj.items, total, hasMore };
+        }
+        printWarning('Unexpected response format, attempting to handle');
+        return { items: [], total: undefined, hasMore: false };
+    }
+    printError('Invalid response format from API');
+    throw new Error('Unexpected API response format');
+}
+//# 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  OutputFormat,\n  formatFileSize,\n  TABLE_OPTIONS,\n} from '../config/cli.constants';\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  const styledMessage = `${colors[level](prefixes[level])} ${message}`;\n  const write = writers[level];\n\n  write(styledMessage);\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    left + colWidths.map(w => border.bodyJoin.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\n// --- Response parsing ---\n\n/**\n * Unwrap a sendSuccess API envelope: { success, statusCode, data: { ... } }\n * Returns the inner `data` object, or the original response if not wrapped.\n */\nexport function unwrapEnvelope(response: unknown): Record<string, unknown> {\n  if (response && typeof response === 'object') {\n    const obj = response as Record<string, unknown>;\n    if ('success' in obj && 'data' in obj && obj.data && typeof obj.data === 'object') {\n      return obj.data as Record<string, unknown>;\n    }\n    return obj;\n  }\n  return {};\n}\n\n/**\n * Extract a single entity from an API response, handling envelope formats.\n * Tries: payload[entityKey], payload directly (if identifierKey exists), or undefined.\n */\nexport function extractSingleResponse<T>(response: unknown, entityKey: string, identifierKey: string): T | undefined {\n  const payload = unwrapEnvelope(response);\n  // Direct entity: payload has the identifier (e.g. payload.id, payload.props, payload.name)\n  if (identifierKey in payload) return payload as unknown as T;\n  // Nested under entity key: payload.pipeline, payload.plugin\n  const nested = payload[entityKey] as Record<string, unknown> | undefined;\n  if (nested && typeof nested === 'object' && identifierKey in nested) return nested as unknown as T;\n  return undefined;\n}\n\nexport interface ListResponseResult<T> {\n  items: T[];\n  total?: number;\n  hasMore: boolean;\n}\n\n/**\n * Extract items from an API list response, handling multiple response formats.\n * Supports: `{ <key>: T[] }`, `{ items: T[] }`, `T[]`, or invalid formats.\n */\nexport function extractListResponse<T>(response: unknown, itemsKey: string): ListResponseResult<T> {\n  if (Array.isArray(response)) {\n    return { items: response, total: undefined, hasMore: false };\n  }\n\n  if (response && typeof response === 'object') {\n    const obj = unwrapEnvelope(response);\n\n    // Extract pagination metadata if present\n    const pagination = obj.pagination as Record<string, unknown> | undefined;\n    const total = (pagination?.total ?? obj.total) as number | undefined;\n    const hasMore = ((pagination?.hasMore ?? obj.hasMore) as boolean) || false;\n\n    // Try primary key (e.g. 'pipelines', 'plugins')\n    if (itemsKey in obj && Array.isArray(obj[itemsKey])) {\n      return { items: obj[itemsKey] as T[], total, hasMore };\n    }\n\n    // Try generic 'items' key\n    if ('items' in obj && Array.isArray(obj.items)) {\n      return { items: obj.items as T[], total, hasMore };\n    }\n\n    printWarning('Unexpected response format, attempting to handle');\n    return { items: [], total: undefined, hasMore: false };\n  }\n\n  printError('Invalid response format from API');\n  throw new Error('Unexpected API response format');\n}\n"]}

package/dist/utils/rate-limiter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Check if auth attempts are currently rate-limited.
+ * @returns null if allowed, or a message string if blocked.
+ */
+export declare function checkAuthRateLimit(): string | null;
+/**
+ * Record a successful auth — resets the failure counter.
+ */
+export declare function recordAuthSuccess(): void;
+/**
+ * Record a failed auth attempt. After MAX_FAILURES, locks out for COOLDOWN_MS.
+ */
+export declare function recordAuthFailure(): void;
+//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/utils/rate-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../../src/utils/rate-limiter.ts"],"names":[],"mappings":"AAsCA;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,GAAG,IAAI,CAelD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAWxC"}

package/dist/utils/rate-limiter.js

@@ -0,0 +1,73 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAuthRateLimit = checkAuthRateLimit;
+exports.recordAuthSuccess = recordAuthSuccess;
+exports.recordAuthFailure = recordAuthFailure;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Simple file-based rate limiter for auth operations.
+ * Tracks failed attempts and enforces a cooldown period after too many failures.
+ * State is persisted in a temp file so it survives across CLI invocations.
+ */
+const STATE_FILE = path_1.default.join(os_1.default.tmpdir(), '.pipeline-manager-auth-state.json');
+const MAX_FAILURES = 5;
+const COOLDOWN_MS = 60_000; // 1 minute
+function readState() {
+    try {
+        if (fs_1.default.existsSync(STATE_FILE)) {
+            return JSON.parse(fs_1.default.readFileSync(STATE_FILE, 'utf-8'));
+        }
+    }
+    catch { /* ignore corrupt state */ }
+    return { failures: 0, lastFailure: 0, lockedUntil: 0 };
+}
+function writeState(state) {
+    try {
+        fs_1.default.writeFileSync(STATE_FILE, JSON.stringify(state), { mode: 0o600 });
+    }
+    catch { /* best-effort */ }
+}
+/**
+ * Check if auth attempts are currently rate-limited.
+ * @returns null if allowed, or a message string if blocked.
+ */
+function checkAuthRateLimit() {
+    const state = readState();
+    const now = Date.now();
+    if (state.lockedUntil > now) {
+        const waitSec = Math.ceil((state.lockedUntil - now) / 1000);
+        return `Too many failed login attempts. Try again in ${waitSec}s.`;
+    }
+    // Reset if cooldown has passed
+    if (now - state.lastFailure > COOLDOWN_MS) {
+        writeState({ failures: 0, lastFailure: 0, lockedUntil: 0 });
+    }
+    return null;
+}
+/**
+ * Record a successful auth — resets the failure counter.
+ */
+function recordAuthSuccess() {
+    writeState({ failures: 0, lastFailure: 0, lockedUntil: 0 });
+}
+/**
+ * Record a failed auth attempt. After MAX_FAILURES, locks out for COOLDOWN_MS.
+ */
+function recordAuthFailure() {
+    const state = readState();
+    const now = Date.now();
+    state.failures += 1;
+    state.lastFailure = now;
+    if (state.failures >= MAX_FAILURES) {
+        state.lockedUntil = now + COOLDOWN_MS;
+    }
+    writeState(state);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,144 @@
+{
+  "name": "@pipeline-builder/pipeline-manager",
+  "description": "CLI for Pipeline Builder — self-service AWS CodePipeline platform with 124 reusable containerized plugins, per-org compliance enforcement, and multi-tenant isolation.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mwashburn160/pipeline-builder.git"
+  },
+  "bin": {
+    "pipeline-manager": "./dist/cli.js"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2",
+    "@types/figlet": "1.7.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24",
+    "@types/progress": "2.0.7",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "copyfiles": "2.4.1",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^30.2.0",
+    "jest-junit": "^16",
+    "ts-jest": "^29.4.6",
+    "typescript": "5.9.3"
+  },
+  "dependencies": {
+    "@aws-sdk/client-cloudformation": "3.821.0",
+    "@aws-sdk/client-lambda": "3.821.0",
+    "@aws-sdk/client-secrets-manager": "3.821.0",
+    "@aws-sdk/client-sts": "3.821.0",
+    "aws-cdk-lib": "2.240.0",
+    "axios": "1.13.5",
+    "commander": "14.0.3",
+    "figlet": "1.10.0",
+    "form-data": "4.0.5",
+    "ora": "9.3.0",
+    "picocolors": "1.1.1",
+    "progress": "2.0.3",
+    "typescript": "5.9.3",
+    "yaml": "2.8.2",
+    "@pipeline-builder/pipeline-core": "3.1.0"
+  },
+  "keywords": [
+    "aws",
+    "codepipeline",
+    "codebuild",
+    "cicd",
+    "ci-cd",
+    "devops",
+    "cdk",
+    "aws-cdk",
+    "cloudformation",
+    "pipeline",
+    "pipeline-as-code",
+    "containerized",
+    "docker",
+    "kubernetes",
+    "plugins",
+    "typescript",
+    "self-service",
+    "multi-tenant",
+    "compliance",
+    "automation",
+    "infrastructure-as-code",
+    "iac",
+    "cli"
+  ],
+  "engines": {
+    "node": ">= 24.14.0"
+  },
+  "license": "Apache-2.0",
+  "homepage": "https://mwashburn160.github.io/pipeline-builder/",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "version": "3.1.0",
+  "bugs": {
+    "url": "https://github.com/mwashburn160/pipeline-builder/issues"
+  },
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).[jt]s?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.[jt]s?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    },
+    "moduleNameMapper": {
+      "^uuid$": "<rootDir>/../../jest-uuid-stub.js"
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"pnpm dlx projen\".",
+  "scripts": {
+    "audit": "pnpm dlx projen audit",
+    "build": "pnpm dlx projen build",
+    "compile": "pnpm dlx projen compile",
+    "default": "pnpm dlx projen default",
+    "eslint": "pnpm dlx projen eslint",
+    "package": "pnpm dlx projen package",
+    "post-compile": "pnpm dlx projen post-compile",
+    "pre-compile": "pnpm dlx projen pre-compile",
+    "test": "pnpm dlx projen test",
+    "test:watch": "pnpm dlx projen test:watch",
+    "watch": "pnpm dlx projen watch",
+    "projen": "pnpm dlx projen"
+  }
+}