@pipeline-builder/pipeline-manager 3.1.0

package/dist/utils/command-utils.js

@@ -0,0 +1,138 @@
+"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.printCommandHeader = printCommandHeader;
+exports.printExecutionSummary = printExecutionSummary;
+exports.printSslWarning = printSslWarning;
+exports.resolveToken = resolveToken;
+exports.createAuthenticatedClientAsync = createAuthenticatedClientAsync;
+exports.createAuthenticatedClient = createAuthenticatedClient;
+exports.validateEntityId = validateEntityId;
+const picocolors_1 = __importDefault(require("picocolors"));
+const api_client_1 = require("./api-client");
+const aws_secrets_1 = require("./aws-secrets");
+const config_loader_1 = require("./config-loader");
+const output_utils_1 = require("./output-utils");
+const cli_constants_1 = require("../config/cli.constants");
+const { bold, cyan, green, magenta } = picocolors_1.default;
+/**
+ * Print command header with section title and execution ID.
+ * Returns the execution ID for use in error handlers and summaries.
+ */
+function printCommandHeader(title, subtitle) {
+    const executionId = (0, cli_constants_1.generateExecutionId)();
+    (0, output_utils_1.printSection)(title);
+    console.log(`${magenta(`[EXE-${executionId}]`)} ${cyan(bold(subtitle || title))}`);
+    console.log('');
+    return executionId;
+}
+/**
+ * Print execution summary with ID, duration, and status.
+ */
+function printExecutionSummary(executionId, duration) {
+    console.log('');
+    (0, output_utils_1.printKeyValue)({
+        'Execution ID': executionId,
+        'Duration': (0, cli_constants_1.formatDuration)(duration),
+        'Status': green('✓ Success'),
+    });
+}
+/**
+ * Warn if SSL verification is disabled.
+ */
+function printSslWarning(verifySsl) {
+    if (verifySsl === false) {
+        (0, output_utils_1.printWarning)('SSL certificate verification is DISABLED');
+        console.log('');
+    }
+}
+/**
+ * Resolve a platform auth token using two methods (in priority order):
+ *
+ * 1. PLATFORM_TOKEN env var
+ * 2. --store-tokens flag → fetch credentials from AWS Secrets Manager, then authenticate
+ *
+ * @returns JWT token string
+ */
+async function resolveToken(options) {
+    // Path 1: PLATFORM_TOKEN env var
+    if (process.env.PLATFORM_TOKEN) {
+        (0, output_utils_1.printInfo)('Using PLATFORM_TOKEN from environment');
+        return process.env.PLATFORM_TOKEN;
+    }
+    // Path 2: --store-tokens → read PLATFORM_SECRET_NAME from Secrets Manager
+    if (options.storeTokens) {
+        const secretName = process.env.PLATFORM_SECRET_NAME;
+        if (!secretName) {
+            throw new Error('PLATFORM_SECRET_NAME env var is required with --store-tokens');
+        }
+        (0, output_utils_1.printInfo)('Fetching secret from Secrets Manager', { secret: secretName });
+        const secretJson = await (0, aws_secrets_1.getSecretValue)(secretName, { region: options.region, profile: options.profile });
+        const secret = JSON.parse(secretJson);
+        (0, output_utils_1.printSuccess)('Secret retrieved from Secrets Manager');
+        if (!secret.accessToken) {
+            throw new Error('Secret missing accessToken — run "pipeline-manager store-token" to generate');
+        }
+        (0, output_utils_1.printInfo)('Using stored JWT token');
+        return secret.accessToken;
+    }
+    throw new Error('Authentication required. Use one of:\n' +
+        '  - Set PLATFORM_TOKEN environment variable\n' +
+        '  - Pass --store-tokens with PLATFORM_SECRET_NAME env var');
+}
+/**
+ * Initialize and return an authenticated API client.
+ *
+ * Supports two auth methods:
+ * 1. PLATFORM_TOKEN env var
+ * 2. --store-tokens + PLATFORM_SECRET_NAME env var → fetch token from Secrets Manager
+ */
+async function createAuthenticatedClientAsync(options) {
+    // Resolve token and set it in env so ApiClient/getConfig can find it
+    if (!process.env.PLATFORM_TOKEN) {
+        const token = await resolveToken(options);
+        process.env.PLATFORM_TOKEN = token;
+    }
+    return createAuthenticatedClient(options);
+}
+/**
+ * Initialize and return an authenticated API client (sync — requires PLATFORM_TOKEN).
+ * Use createAuthenticatedClientAsync for --store-tokens support.
+ */
+function createAuthenticatedClient(options) {
+    const config = (0, config_loader_1.getConfigWithOptions)(options);
+    (0, output_utils_1.printInfo)('Initializing API client', { baseUrl: config.api.baseUrl });
+    const client = new api_client_1.ApiClient(config);
+    if (!client.isAuthenticated()) {
+        (0, output_utils_1.printError)('Not authenticated', { hint: 'Set PLATFORM_TOKEN or use --store-tokens' });
+        throw new Error('Authentication required');
+    }
+    (0, output_utils_1.printSuccess)('API client initialized');
+    return client;
+}
+/**
+ * Validate a required entity ID (ULID or UUID format).
+ * Returns trimmed ID.
+ *
+ * @throws Error if ID is empty
+ */
+function validateEntityId(id, entityName) {
+    if (!id || typeof id !== 'string' || id.trim().length === 0) {
+        (0, output_utils_1.printError)(`Invalid ${entityName} ID`, { provided: id });
+        throw new Error(`${entityName} ID must be a non-empty string`);
+    }
+    const trimmed = id.trim();
+    if (trimmed.length !== 26 && trimmed.length !== 36) {
+        (0, output_utils_1.printWarning)(`${entityName} ID format may be invalid`, {
+            provided: trimmed,
+            expectedLength: '26 characters (ULID) or 36 characters (UUID)',
+            actualLength: trimmed.length,
+        });
+    }
+    return trimmed;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"command-utils.js","sourceRoot":"","sources":["../../src/utils/command-utils.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport pico from 'picocolors';\nimport { ApiClient } from './api-client';\nimport { getSecretValue } from './aws-secrets';\nimport { Config, getConfigWithOptions } from './config-loader';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from './output-utils';\nimport { formatDuration, generateExecutionId } from '../config/cli.constants';\n\nconst { bold, cyan, green, magenta } = pico;\n\n/**\n * Print command header with section title and execution ID.\n * Returns the execution ID for use in error handlers and summaries.\n */\nexport function printCommandHeader(title: string, subtitle?: string): string {\n  const executionId = generateExecutionId();\n  printSection(title);\n  console.log(`${magenta(`[EXE-${executionId}]`)} ${cyan(bold(subtitle || title))}`);\n  console.log('');\n  return executionId;\n}\n\n/**\n * Print execution summary with ID, duration, and status.\n */\nexport function printExecutionSummary(executionId: string, duration: number): void {\n  console.log('');\n  printKeyValue({\n    'Execution ID': executionId,\n    'Duration': formatDuration(duration),\n    'Status': green('✓ Success'),\n  });\n}\n\n/**\n * Warn if SSL verification is disabled.\n */\nexport function printSslWarning(verifySsl?: boolean): void {\n  if (verifySsl === false) {\n    printWarning('SSL certificate verification is DISABLED');\n    console.log('');\n  }\n}\n\n/**\n * Resolve a platform auth token using two methods (in priority order):\n *\n * 1. PLATFORM_TOKEN env var\n * 2. --store-tokens flag → fetch credentials from AWS Secrets Manager, then authenticate\n *\n * @returns JWT token string\n */\nexport async function resolveToken(options: {\n  storeTokens?: boolean;\n  verifySsl?: boolean;\n  region?: string;\n  profile?: string;\n}): Promise<string> {\n  // Path 1: PLATFORM_TOKEN env var\n  if (process.env.PLATFORM_TOKEN) {\n    printInfo('Using PLATFORM_TOKEN from environment');\n    return process.env.PLATFORM_TOKEN;\n  }\n\n  // Path 2: --store-tokens → read PLATFORM_SECRET_NAME from Secrets Manager\n  if (options.storeTokens) {\n    const secretName = process.env.PLATFORM_SECRET_NAME;\n    if (!secretName) {\n      throw new Error('PLATFORM_SECRET_NAME env var is required with --store-tokens');\n    }\n\n    printInfo('Fetching secret from Secrets Manager', { secret: secretName });\n\n    const secretJson = await getSecretValue(secretName, { region: options.region, profile: options.profile });\n    const secret = JSON.parse(secretJson) as Record<string, string>;\n    printSuccess('Secret retrieved from Secrets Manager');\n\n    if (!secret.accessToken) {\n      throw new Error('Secret missing accessToken — run \"pipeline-manager store-token\" to generate');\n    }\n\n    printInfo('Using stored JWT token');\n    return secret.accessToken;\n  }\n\n  throw new Error(\n    'Authentication required. Use one of:\\n' +\n    '  - Set PLATFORM_TOKEN environment variable\\n' +\n    '  - Pass --store-tokens with PLATFORM_SECRET_NAME env var',\n  );\n}\n\n/**\n * Initialize and return an authenticated API client.\n *\n * Supports two auth methods:\n * 1. PLATFORM_TOKEN env var\n * 2. --store-tokens + PLATFORM_SECRET_NAME env var → fetch token from Secrets Manager\n */\nexport async function createAuthenticatedClientAsync(options: {\n  storeTokens?: boolean;\n  verifySsl?: boolean;\n  region?: string;\n  profile?: string;\n}): Promise<ApiClient> {\n  // Resolve token and set it in env so ApiClient/getConfig can find it\n  if (!process.env.PLATFORM_TOKEN) {\n    const token = await resolveToken(options);\n    process.env.PLATFORM_TOKEN = token;\n  }\n\n  return createAuthenticatedClient(options);\n}\n\n/**\n * Initialize and return an authenticated API client (sync — requires PLATFORM_TOKEN).\n * Use createAuthenticatedClientAsync for --store-tokens support.\n */\nexport function createAuthenticatedClient(options: { verifySsl?: boolean }): ApiClient {\n  const config: Config = getConfigWithOptions(options);\n  printInfo('Initializing API client', { baseUrl: config.api.baseUrl });\n  const client = new ApiClient(config);\n\n  if (!client.isAuthenticated()) {\n    printError('Not authenticated', { hint: 'Set PLATFORM_TOKEN or use --store-tokens' });\n    throw new Error('Authentication required');\n  }\n\n  printSuccess('API client initialized');\n  return client;\n}\n\n/**\n * Validate a required entity ID (ULID or UUID format).\n * Returns trimmed ID.\n *\n * @throws Error if ID is empty\n */\nexport function validateEntityId(id: string | undefined, entityName: string): string {\n  if (!id || typeof id !== 'string' || id.trim().length === 0) {\n    printError(`Invalid ${entityName} ID`, { provided: id });\n    throw new Error(`${entityName} ID must be a non-empty string`);\n  }\n\n  const trimmed = id.trim();\n\n  if (trimmed.length !== 26 && trimmed.length !== 36) {\n    printWarning(`${entityName} ID format may be invalid`, {\n      provided: trimmed,\n      expectedLength: '26 characters (ULID) or 36 characters (UUID)',\n      actualLength: trimmed.length,\n    });\n  }\n\n  return trimmed;\n}\n\n"]}

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

@@ -0,0 +1,27 @@
+import { Config } from '../types';
+export type { Config };
+/**
+ * Load configuration from files and environment.
+ *
+ * Priority (last wins):
+ * 1. Built-in defaults
+ * 2. User config file: ~/.pipeline-manager/config.yml
+ * 3. Project config file: CLI_CONFIG_PATH or ./config.yml
+ * 4. Environment variables
+ *
+ * Auth token MUST come from PLATFORM_TOKEN env var (never from config file).
+ */
+export declare function getConfig(): Config;
+/**
+ * Return a copy of `config` with SSL verification disabled.
+ */
+export declare function withSSLDisabled(config: Config): Config;
+/**
+ * Load configuration, optionally disabling SSL based on command options.
+ * Replaces the repeated pattern:
+ *   `options.verifySsl === false ? withSSLDisabled(getConfig()) : getConfig()`
+ */
+export declare function getConfigWithOptions(options: {
+    verifySsl?: boolean;
+}): Config;
+//# sourceMappingURL=config-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../../src/utils/config-loader.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,YAAY,EAAE,MAAM,EAAE,CAAC;AA4CvB;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,IAAI,MAAM,CA0DlC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKtD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAG7E"}

package/dist/utils/config-loader.js

@@ -0,0 +1,166 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = getConfig;
+exports.withSSLDisabled = withSSLDisabled;
+exports.getConfigWithOptions = getConfigWithOptions;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("yaml"));
+const output_utils_1 = require("./output-utils");
+/**
+ * Default configuration — API endpoint paths and connection settings.
+ */
+const defaultConfig = {
+    api: {
+        baseUrl: 'https://localhost:8443',
+        timeout: 30_000,
+        pipelineUrl: '/api/pipeline',
+        pipelineListUrl: '/api/pipelines',
+        pluginUrl: '/api/plugin',
+        pluginListUrl: '/api/plugins',
+        pluginUploadUrl: '/api/plugin/upload',
+        rejectUnauthorized: true,
+    },
+};
+/** User config file path: ~/.pipeline-manager/config.yml */
+const USER_CONFIG_PATH = path.join(os.homedir(), '.pipeline-manager', 'config.yml');
+/**
+ * Load a YAML config file and merge its `api` section into the config.
+ * Returns the merged config or the original if file doesn't exist or fails.
+ */
+function loadConfigFile(filePath, config) {
+    if (!fs.existsSync(filePath))
+        return config;
+    try {
+        (0, output_utils_1.printDebug)('Loading configuration', { path: filePath });
+        const parsed = yaml.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (parsed?.auth) {
+            (0, output_utils_1.printWarning)('Auth section in config file is ignored — use PLATFORM_TOKEN env var');
+        }
+        return { api: { ...config.api, ...parsed?.api } };
+    }
+    catch (error) {
+        (0, output_utils_1.printWarning)('Failed to load config file, using defaults', {
+            path: filePath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return config;
+    }
+}
+/**
+ * Load configuration from files and environment.
+ *
+ * Priority (last wins):
+ * 1. Built-in defaults
+ * 2. User config file: ~/.pipeline-manager/config.yml
+ * 3. Project config file: CLI_CONFIG_PATH or ./config.yml
+ * 4. Environment variables
+ *
+ * Auth token MUST come from PLATFORM_TOKEN env var (never from config file).
+ */
+function getConfig() {
+    const projectConfigPath = process.env.CLI_CONFIG_PATH || path.join(__dirname, '../config.yml');
+    // Layer 1: defaults → Layer 2: user config → Layer 3: project config
+    let config = loadConfigFile(USER_CONFIG_PATH, { ...defaultConfig });
+    config = loadConfigFile(projectConfigPath, config);
+    // Layer 4: environment variable overrides
+    // Layer 4: environment variable overrides
+    if (process.env.PLATFORM_BASE_URL) {
+        config.api.baseUrl = process.env.PLATFORM_BASE_URL;
+        (0, output_utils_1.printDebug)('Using PLATFORM_BASE_URL from environment', { baseUrl: config.api.baseUrl });
+    }
+    if (process.env.TLS_REJECT_UNAUTHORIZED !== undefined) {
+        const disable = process.env.TLS_REJECT_UNAUTHORIZED === '0';
+        if (disable && process.env.NODE_ENV === 'production') {
+            (0, output_utils_1.printWarning)('Ignoring TLS_REJECT_UNAUTHORIZED=0 in production — SSL verification remains enabled');
+        }
+        else {
+            config.api.rejectUnauthorized = !disable;
+            if (disable) {
+                (0, output_utils_1.printWarning)('SSL certificate validation disabled via TLS_REJECT_UNAUTHORIZED=0');
+            }
+        }
+    }
+    if (process.env.UPLOAD_TIMEOUT) {
+        const parsed = parseInt(process.env.UPLOAD_TIMEOUT, 10);
+        if (!isNaN(parsed) && parsed > 0) {
+            config.api.uploadTimeout = parsed;
+            (0, output_utils_1.printDebug)('Using UPLOAD_TIMEOUT from environment', { uploadTimeout: `${parsed}ms` });
+        }
+        else {
+            (0, output_utils_1.printWarning)('Invalid UPLOAD_TIMEOUT value, using default', { provided: process.env.UPLOAD_TIMEOUT });
+        }
+    }
+    // Token is REQUIRED from environment
+    const token = process.env.PLATFORM_TOKEN;
+    if (!token) {
+        (0, output_utils_1.printError)('PLATFORM_TOKEN environment variable is not set');
+        throw new Error('PLATFORM_TOKEN environment variable is required');
+    }
+    if (token.trim().length === 0) {
+        throw new Error('PLATFORM_TOKEN must be a non-empty string');
+    }
+    if (token.includes(' ')) {
+        (0, output_utils_1.printWarning)('PLATFORM_TOKEN contains whitespace — this may cause issues');
+    }
+    (0, output_utils_1.printDebug)('Configuration loaded successfully');
+    return {
+        ...config,
+        auth: { token },
+    };
+}
+/**
+ * Return a copy of `config` with SSL verification disabled.
+ */
+function withSSLDisabled(config) {
+    return {
+        ...config,
+        api: { ...config.api, rejectUnauthorized: false },
+    };
+}
+/**
+ * Load configuration, optionally disabling SSL based on command options.
+ * Replaces the repeated pattern:
+ *   `options.verifySsl === false ? withSSLDisabled(getConfig()) : getConfig()`
+ */
+function getConfigWithOptions(options) {
+    const config = getConfig();
+    return options.verifySsl === false ? withSSLDisabled(config) : config;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-loader.js","sourceRoot":"","sources":["../../src/utils/config-loader.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport * as yaml from 'yaml';\nimport { Config } from '../types';\nimport { printDebug, printError, printWarning } from './output-utils';\n\nexport type { Config };\n\n/**\n * Default configuration — API endpoint paths and connection settings.\n */\nconst defaultConfig: Omit<Config, 'auth'> = {\n  api: {\n    baseUrl: 'https://localhost:8443',\n    timeout: 30_000,\n    pipelineUrl: '/api/pipeline',\n    pipelineListUrl: '/api/pipelines',\n    pluginUrl: '/api/plugin',\n    pluginListUrl: '/api/plugins',\n    pluginUploadUrl: '/api/plugin/upload',\n    rejectUnauthorized: true,\n  },\n};\n\n/** User config file path: ~/.pipeline-manager/config.yml */\nconst USER_CONFIG_PATH = path.join(os.homedir(), '.pipeline-manager', 'config.yml');\n\n/**\n * Load a YAML config file and merge its `api` section into the config.\n * Returns the merged config or the original if file doesn't exist or fails.\n */\nfunction loadConfigFile(filePath: string, config: Omit<Config, 'auth'>): Omit<Config, 'auth'> {\n  if (!fs.existsSync(filePath)) return config;\n\n  try {\n    printDebug('Loading configuration', { path: filePath });\n    const parsed = yaml.parse(fs.readFileSync(filePath, 'utf-8'));\n    if (parsed?.auth) {\n      printWarning('Auth section in config file is ignored — use PLATFORM_TOKEN env var');\n    }\n    return { api: { ...config.api, ...parsed?.api } };\n  } catch (error) {\n    printWarning('Failed to load config file, using defaults', {\n      path: filePath,\n      error: error instanceof Error ? error.message : String(error),\n    });\n    return config;\n  }\n}\n\n/**\n * Load configuration from files and environment.\n *\n * Priority (last wins):\n * 1. Built-in defaults\n * 2. User config file: ~/.pipeline-manager/config.yml\n * 3. Project config file: CLI_CONFIG_PATH or ./config.yml\n * 4. Environment variables\n *\n * Auth token MUST come from PLATFORM_TOKEN env var (never from config file).\n */\nexport function getConfig(): Config {\n  const projectConfigPath = process.env.CLI_CONFIG_PATH || path.join(__dirname, '../config.yml');\n\n  // Layer 1: defaults → Layer 2: user config → Layer 3: project config\n  let config = loadConfigFile(USER_CONFIG_PATH, { ...defaultConfig });\n  config = loadConfigFile(projectConfigPath, config);\n\n  // Layer 4: environment variable overrides\n  // Layer 4: environment variable overrides\n  if (process.env.PLATFORM_BASE_URL) {\n    config.api.baseUrl = process.env.PLATFORM_BASE_URL;\n    printDebug('Using PLATFORM_BASE_URL from environment', { baseUrl: config.api.baseUrl });\n  }\n\n  if (process.env.TLS_REJECT_UNAUTHORIZED !== undefined) {\n    const disable = process.env.TLS_REJECT_UNAUTHORIZED === '0';\n    if (disable && process.env.NODE_ENV === 'production') {\n      printWarning('Ignoring TLS_REJECT_UNAUTHORIZED=0 in production — SSL verification remains enabled');\n    } else {\n      config.api.rejectUnauthorized = !disable;\n      if (disable) {\n        printWarning('SSL certificate validation disabled via TLS_REJECT_UNAUTHORIZED=0');\n      }\n    }\n  }\n\n  if (process.env.UPLOAD_TIMEOUT) {\n    const parsed = parseInt(process.env.UPLOAD_TIMEOUT, 10);\n    if (!isNaN(parsed) && parsed > 0) {\n      config.api.uploadTimeout = parsed;\n      printDebug('Using UPLOAD_TIMEOUT from environment', { uploadTimeout: `${parsed}ms` });\n    } else {\n      printWarning('Invalid UPLOAD_TIMEOUT value, using default', { provided: process.env.UPLOAD_TIMEOUT });\n    }\n  }\n\n  // Token is REQUIRED from environment\n  const token = process.env.PLATFORM_TOKEN;\n\n  if (!token) {\n    printError('PLATFORM_TOKEN environment variable is not set');\n    throw new Error('PLATFORM_TOKEN environment variable is required');\n  }\n\n  if (token.trim().length === 0) {\n    throw new Error('PLATFORM_TOKEN must be a non-empty string');\n  }\n\n  if (token.includes(' ')) {\n    printWarning('PLATFORM_TOKEN contains whitespace — this may cause issues');\n  }\n\n  printDebug('Configuration loaded successfully');\n\n  return {\n    ...config,\n    auth: { token },\n  };\n}\n\n/**\n * Return a copy of `config` with SSL verification disabled.\n */\nexport function withSSLDisabled(config: Config): Config {\n  return {\n    ...config,\n    api: { ...config.api, rejectUnauthorized: false },\n  };\n}\n\n/**\n * Load configuration, optionally disabling SSL based on command options.\n * Replaces the repeated pattern:\n *   `options.verifySsl === false ? withSSLDisabled(getConfig()) : getConfig()`\n */\nexport function getConfigWithOptions(options: { verifySsl?: boolean }): Config {\n  const config = getConfig();\n  return options.verifySsl === false ? withSSLDisabled(config) : config;\n}\n"]}

package/dist/utils/error-handler.d.ts

@@ -0,0 +1,29 @@
+import { ERROR_CODES, ErrorCode, ErrorHandlerOptions } from '../types';
+export { ERROR_CODES };
+export type { ErrorCode };
+/**
+ * Format and handle errors with colored output
+ */
+export declare function handleError(err: unknown, code?: ErrorCode, options?: ErrorHandlerOptions): never;
+/**
+ * Validation error class
+ */
+export declare class ValidationError extends Error {
+    field?: string | undefined;
+    value?: unknown | undefined;
+    rule?: string | undefined;
+    expected?: string | undefined;
+    constructor(message: string, field?: string | undefined, value?: unknown | undefined, rule?: string | undefined, expected?: string | undefined);
+}
+/**
+ * Network error class
+ */
+export declare class NetworkError extends Error {
+    url?: string | undefined;
+    cause?: Error | undefined;
+    timeout?: number | undefined;
+    requestMade: boolean;
+    responseReceived: boolean;
+    constructor(message: string, url?: string | undefined, cause?: Error | undefined, timeout?: number | undefined, requestMade?: boolean, responseReceived?: boolean);
+}
+//# sourceMappingURL=error-handler.d.ts.map

package/dist/utils/error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../src/utils/error-handler.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,WAAW,EACX,SAAS,EACT,mBAAmB,EAEpB,MAAM,UAAU,CAAC;AAKlB,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B;;GAEG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,OAAO,EACZ,IAAI,GAAE,SAA+B,EACrC,OAAO,GAAE,mBAAwB,GAChC,KAAK,CA0GP;AAID;;GAEG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IAG/B,KAAK,CAAC,EAAE,MAAM;IACd,KAAK,CAAC,EAAE,OAAO;IACf,IAAI,CAAC,EAAE,MAAM;IACb,QAAQ,CAAC,EAAE,MAAM;gBAJxB,OAAO,EAAE,MAAM,EACR,KAAK,CAAC,EAAE,MAAM,YAAA,EACd,KAAK,CAAC,EAAE,OAAO,YAAA,EACf,IAAI,CAAC,EAAE,MAAM,YAAA,EACb,QAAQ,CAAC,EAAE,MAAM,YAAA;CAM3B;AAED;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;IAG5B,GAAG,CAAC,EAAE,MAAM;IACZ,KAAK,CAAC,EAAE,KAAK;IACb,OAAO,CAAC,EAAE,MAAM;IAChB,WAAW,EAAE,OAAO;IACpB,gBAAgB,EAAE,OAAO;gBALhC,OAAO,EAAE,MAAM,EACR,GAAG,CAAC,EAAE,MAAM,YAAA,EACZ,KAAK,CAAC,EAAE,KAAK,YAAA,EACb,OAAO,CAAC,EAAE,MAAM,YAAA,EAChB,WAAW,GAAE,OAAc,EAC3B,gBAAgB,GAAE,OAAe;CAM3C"}