@pipeline-builder/pipeline-manager 0.0.1

package/dist/utils/command-utils.js

@@ -0,0 +1,155 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import {} from 'commander';
+import pico from 'picocolors';
+import { ApiClient } from './api-client.js';
+import { getSecretValue } from './aws-secrets.js';
+import { getConfigWithOptions } from './config-loader.js';
+import { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from './output-utils.js';
+import { formatDuration, generateExecutionId } from '../config/cli.constants.js';
+const { bold, cyan, green, magenta } = pico;
+/**
+ * Print command header with section title and execution ID.
+ * Returns the execution ID for use in error handlers and summaries.
+ *
+ * Pass `{ quiet: true }` to suppress the decorative output while still getting the
+ * id — used both by `--quiet` callers and by `--json` commands (so the banner
+ * doesn't land on stdout ahead of the JSON payload and break `… --json | jq`).
+ */
+export function printCommandHeader(title, subtitle, opts) {
+    const executionId = generateExecutionId();
+    if (!opts?.quiet) {
+        printSection(title);
+        console.log(`${magenta(`[EXE-${executionId}]`)} ${cyan(bold(subtitle || title))}`);
+        console.log('');
+    }
+    return executionId;
+}
+/** Attach the standard `--verify-ssl` / `--no-verify-ssl` pair. The two together
+ *  give Commander an explicit tri-state `options.verifySsl` (true/false/undefined).
+ *  Returns the command so it composes: `withSslOptions(program.command('x'))…`. */
+export function withSslOptions(cmd) {
+    return cmd
+        .option('--verify-ssl', 'Enable SSL certificate verification')
+        .option('--no-verify-ssl', 'Disable SSL certificate verification');
+}
+/** Attach the standard `--region <region>` option (one canonical description).
+ *  Region resolution (flag → AWS_REGION → CDK_DEFAULT_REGION → us-east-1) lives in
+ *  aws-env.resolveAwsRegion. */
+export function withRegionOption(cmd) {
+    return cmd.option('--region <region>', 'AWS region (defaults to AWS_REGION / CDK_DEFAULT_REGION / us-east-1)');
+}
+/** Attach the standard `--profile <profile>` option (one canonical description).
+ *  No default is pinned so the AWS default credential chain (env vars, SSO, roles)
+ *  works out of the box; --profile only selects a shared profile when set. */
+export function withProfileOption(cmd) {
+    return cmd.option('--profile <profile>', 'AWS CLI profile (defaults to the standard AWS credential chain)');
+}
+/**
+ * Print execution summary with ID, duration, and status.
+ */
+export function printExecutionSummary(executionId, duration) {
+    console.log('');
+    printKeyValue({
+        'Execution ID': executionId,
+        'Duration': formatDuration(duration),
+        'Status': green('✓ Success'),
+    });
+}
+/**
+ * Warn if SSL verification is disabled.
+ */
+export function printSslWarning(verifySsl) {
+    if (verifySsl === false) {
+        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
+ */
+export async function resolveToken(options) {
+    // Path 1: PLATFORM_TOKEN env var
+    if (process.env.PLATFORM_TOKEN) {
+        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');
+        }
+        printInfo('Fetching secret from Secrets Manager', { secret: secretName });
+        const secretJson = await getSecretValue(secretName, { region: options.region, profile: options.profile });
+        const secret = JSON.parse(secretJson);
+        printSuccess('Secret retrieved from Secrets Manager');
+        // store-token writes the JWT to the `password` field (schema: { username: orgId,
+        // password: JWT } — satisfies CodeBuild's secretsManagerCredentials), not `accessToken`.
+        if (!secret.password) {
+            throw new Error('Secret missing password (JWT) — run "pipeline-manager infra store-token" to generate');
+        }
+        printInfo('Using stored JWT token');
+        return secret.password;
+    }
+    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
+ */
+export 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.
+ */
+export function createAuthenticatedClient(options) {
+    const config = getConfigWithOptions(options);
+    printInfo('Initializing API client', { baseUrl: config.api.baseUrl });
+    const client = new ApiClient(config);
+    if (!client.isAuthenticated()) {
+        printError('Not authenticated', { hint: 'Set PLATFORM_TOKEN or use --store-tokens' });
+        throw new Error('Authentication required');
+    }
+    printSuccess('API client initialized');
+    return client;
+}
+/**
+ * Validate a required entity ID (ULID or UUID format).
+ * Returns trimmed ID.
+ *
+ * @throws Error if ID is empty
+ */
+export function validateEntityId(id, entityName) {
+    if (!id || typeof id !== 'string' || id.trim().length === 0) {
+        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) {
+        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 { type Command } from 'commander';\nimport pico from 'picocolors';\nimport { ApiClient } from './api-client.js';\nimport { getSecretValue } from './aws-secrets.js';\nimport { type Config, getConfigWithOptions } from './config-loader.js';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from './output-utils.js';\nimport { formatDuration, generateExecutionId } from '../config/cli.constants.js';\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 *\n * Pass `{ quiet: true }` to suppress the decorative output while still getting the\n * id — used both by `--quiet` callers and by `--json` commands (so the banner\n * doesn't land on stdout ahead of the JSON payload and break `… --json | jq`).\n */\nexport function printCommandHeader(title: string, subtitle?: string, opts?: { quiet?: boolean }): string {\n  const executionId = generateExecutionId();\n  if (!opts?.quiet) {\n    printSection(title);\n    console.log(`${magenta(`[EXE-${executionId}]`)} ${cyan(bold(subtitle || title))}`);\n    console.log('');\n  }\n  return executionId;\n}\n\n/** Attach the standard `--verify-ssl` / `--no-verify-ssl` pair. The two together\n *  give Commander an explicit tri-state `options.verifySsl` (true/false/undefined).\n *  Returns the command so it composes: `withSslOptions(program.command('x'))…`. */\nexport function withSslOptions<T extends Command>(cmd: T): T {\n  return cmd\n    .option('--verify-ssl', 'Enable SSL certificate verification')\n    .option('--no-verify-ssl', 'Disable SSL certificate verification') as T;\n}\n\n/** Attach the standard `--region <region>` option (one canonical description).\n *  Region resolution (flag → AWS_REGION → CDK_DEFAULT_REGION → us-east-1) lives in\n *  aws-env.resolveAwsRegion. */\nexport function withRegionOption<T extends Command>(cmd: T): T {\n  return cmd.option('--region <region>', 'AWS region (defaults to AWS_REGION / CDK_DEFAULT_REGION / us-east-1)') as T;\n}\n\n/** Attach the standard `--profile <profile>` option (one canonical description).\n *  No default is pinned so the AWS default credential chain (env vars, SSO, roles)\n *  works out of the box; --profile only selects a shared profile when set. */\nexport function withProfileOption<T extends Command>(cmd: T): T {\n  return cmd.option('--profile <profile>', 'AWS CLI profile (defaults to the standard AWS credential chain)') as T;\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    // store-token writes the JWT to the `password` field (schema: { username: orgId,\n    // password: JWT } — satisfies CodeBuild's secretsManagerCredentials), not `accessToken`.\n    if (!secret.password) {\n      throw new Error('Secret missing password (JWT) — run \"pipeline-manager infra store-token\" to generate');\n    }\n\n    printInfo('Using stored JWT token');\n    return secret.password;\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,33 @@
+import { type Config } from '../types/index.js';
+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).
+ */
+/**
+ * Resolve the API/connection config (base URL, SSL, timeouts) from files and
+ * environment WITHOUT requiring `PLATFORM_TOKEN`.
+ *
+ * This is the token-optional slice of {@link getConfig}. The pre-auth login step
+ * (`ensurePlatformToken`) needs the resolved base URL to POST `/api/auth/login`
+ * *before* any token exists — calling `getConfig()` there would throw on the
+ * missing token and make inline-login dead-on-arrival.
+ */
+export declare function getApiConfig(): Omit<Config, 'auth'>;
+export declare function getConfig(): 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":"AAUA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAKhD,YAAY,EAAE,MAAM,EAAE,CAAC;AA6CvB;;;;;;;;;;GAUG;AACH;;;;;;;;GAQG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAoCnD;AAED,wBAAgB,SAAS,IAAI,MAAM,CAyBlC;AAaD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAU7E"}

package/dist/utils/config-loader.js

@@ -0,0 +1,154 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import * as fs from 'fs';
+import { fileURLToPath } from 'node:url';
+import * as os from 'os';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import { printDebug, printError, printWarning } from './output-utils.js';
+import { assertSslDisableAllowed, isProductionEnv } from './tls.js';
+import {} from '../types/index.js';
+// ESM has no __dirname; derive it from this module's URL.
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Default configuration — API endpoint paths and connection settings.
+ */
+const defaultConfig = {
+    api: {
+        baseUrl: 'https://localhost:8443',
+        timeout: 30_000,
+        pipelineUrl: '/api/pipeline',
+        pipelineListUrl: '/api/pipelines',
+        pipelineTemplateUrl: '/api/pipeline-templates',
+        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 {
+        printDebug('Loading configuration', { path: filePath });
+        const parsed = yaml.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (parsed?.auth) {
+            printWarning('Auth section in config file is ignored — use PLATFORM_TOKEN env var');
+        }
+        return { api: { ...config.api, ...parsed?.api } };
+    }
+    catch (error) {
+        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).
+ */
+/**
+ * Resolve the API/connection config (base URL, SSL, timeouts) from files and
+ * environment WITHOUT requiring `PLATFORM_TOKEN`.
+ *
+ * This is the token-optional slice of {@link getConfig}. The pre-auth login step
+ * (`ensurePlatformToken`) needs the resolved base URL to POST `/api/auth/login`
+ * *before* any token exists — calling `getConfig()` there would throw on the
+ * missing token and make inline-login dead-on-arrival.
+ */
+export function getApiConfig() {
+    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
+    if (process.env.PLATFORM_BASE_URL) {
+        config.api.baseUrl = process.env.PLATFORM_BASE_URL;
+        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 && isProductionEnv()) {
+            printWarning('Ignoring TLS_REJECT_UNAUTHORIZED=0 in production — SSL verification remains enabled');
+        }
+        else {
+            config.api.rejectUnauthorized = !disable;
+            if (disable) {
+                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;
+            printDebug('Using UPLOAD_TIMEOUT from environment', { uploadTimeout: `${parsed}ms` });
+        }
+        else {
+            printWarning('Invalid UPLOAD_TIMEOUT value, using default', { provided: process.env.UPLOAD_TIMEOUT });
+        }
+    }
+    return config;
+}
+export function getConfig() {
+    const config = getApiConfig();
+    // Token is REQUIRED from environment
+    const token = process.env.PLATFORM_TOKEN;
+    if (!token) {
+        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(' ')) {
+        printWarning('PLATFORM_TOKEN contains whitespace — this may cause issues');
+    }
+    printDebug('Configuration loaded successfully');
+    return {
+        ...config,
+        auth: { token },
+    };
+}
+/**
+ * Return a copy of `config` with SSL verification disabled. Module-private — the
+ * only caller is `getConfigWithOptions` below.
+ */
+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()`
+ */
+export function getConfigWithOptions(options) {
+    const config = getConfig();
+    if (options.verifySsl === false) {
+        // Every authenticated command flows its token through here — refuse to
+        // disable cert verification in production (mirrors the login/renewal guards)
+        // so a MITM can't harvest the Bearer JWT. No-op in non-production.
+        assertSslDisableAllowed('authenticated API client (--no-verify-ssl)');
+        return withSSLDisabled(config);
+    }
+    return config;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-loader.js","sourceRoot":"","sources":["../../src/utils/config-loader.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACzE,OAAO,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AACpE,OAAO,EAAe,MAAM,mBAAmB,CAAC;AAEhD,0DAA0D;AAC1D,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAI/D;;GAEG;AACH,MAAM,aAAa,GAAyB;IAC1C,GAAG,EAAE;QACH,OAAO,EAAE,wBAAwB;QACjC,OAAO,EAAE,MAAM;QACf,WAAW,EAAE,eAAe;QAC5B,eAAe,EAAE,gBAAgB;QACjC,mBAAmB,EAAE,yBAAyB;QAC9C,SAAS,EAAE,aAAa;QACxB,aAAa,EAAE,cAAc;QAC7B,eAAe,EAAE,oBAAoB;QACrC,kBAAkB,EAAE,IAAI;KACzB;CACF,CAAC;AAEF,4DAA4D;AAC5D,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,mBAAmB,EAAE,YAAY,CAAC,CAAC;AAEpF;;;GAGG;AACH,SAAS,cAAc,CAAC,QAAgB,EAAE,MAA4B;IACpE,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC;QAAE,OAAO,MAAM,CAAC;IAE5C,IAAI,CAAC;QACH,UAAU,CAAC,uBAAuB,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QACxD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;QAC9D,IAAI,MAAM,EAAE,IAAI,EAAE,CAAC;YACjB,YAAY,CAAC,qEAAqE,CAAC,CAAC;QACtF,CAAC;QACD,OAAO,EAAE,GAAG,EAAE,EAAE,GAAG,MAAM,CAAC,GAAG,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC;IACpD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,YAAY,CAAC,4CAA4C,EAAE;YACzD,IAAI,EAAE,QAAQ;YACd,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;SAC9D,CAAC,CAAC;QACH,OAAO,MAAM,CAAC;IAChB,CAAC;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY;IAC1B,MAAM,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;IAE/F,qEAAqE;IACrE,IAAI,MAAM,GAAG,cAAc,CAAC,gBAAgB,EAAE,EAAE,GAAG,aAAa,EAAE,CAAC,CAAC;IACpE,MAAM,GAAG,cAAc,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;IAEnD,0CAA0C;IAC1C,IAAI,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,CAAC;QAClC,MAAM,CAAC,GAAG,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC;QACnD,UAAU,CAAC,0CAA0C,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;IAC1F,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,CAAC,uBAAuB,KAAK,SAAS,EAAE,CAAC;QACtD,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,uBAAuB,KAAK,GAAG,CAAC;QAC5D,IAAI,OAAO,IAAI,eAAe,EAAE,EAAE,CAAC;YACjC,YAAY,CAAC,qFAAqF,CAAC,CAAC;QACtG,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,GAAG,CAAC,kBAAkB,GAAG,CAAC,OAAO,CAAC;YACzC,IAAI,OAAO,EAAE,CAAC;gBACZ,YAAY,CAAC,mEAAmE,CAAC,CAAC;YACpF,CAAC;QACH,CAAC;IACH,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;QACxD,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;YACjC,MAAM,CAAC,GAAG,CAAC,aAAa,GAAG,MAAM,CAAC;YAClC,UAAU,CAAC,uCAAuC,EAAE,EAAE,aAAa,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC,CAAC;QACxF,CAAC;aAAM,CAAC;YACN,YAAY,CAAC,6CAA6C,EAAE,EAAE,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,CAAC;QACxG,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,SAAS;IACvB,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAE9B,qCAAqC;IACrC,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;IAEzC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,UAAU,CAAC,gDAAgD,CAAC,CAAC;QAC7D,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IACrE,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC/D,CAAC;IAED,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,YAAY,CAAC,4DAA4D,CAAC,CAAC;IAC7E,CAAC;IAED,UAAU,CAAC,mCAAmC,CAAC,CAAC;IAEhD,OAAO;QACL,GAAG,MAAM;QACT,IAAI,EAAE,EAAE,KAAK,EAAE;KAChB,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,eAAe,CAAC,MAAc;IACrC,OAAO;QACL,GAAG,MAAM;QACT,GAAG,EAAE,EAAE,GAAG,MAAM,CAAC,GAAG,EAAE,kBAAkB,EAAE,KAAK,EAAE;KAClD,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAAgC;IACnE,MAAM,MAAM,GAAG,SAAS,EAAE,CAAC;IAC3B,IAAI,OAAO,CAAC,SAAS,KAAK,KAAK,EAAE,CAAC;QAChC,uEAAuE;QACvE,6EAA6E;QAC7E,mEAAmE;QACnE,uBAAuB,CAAC,4CAA4C,CAAC,CAAC;QACtE,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC;IACjC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as fs from 'fs';\nimport { fileURLToPath } from 'node:url';\nimport * as os from 'os';\nimport * as path from 'path';\nimport * as yaml from 'yaml';\nimport { printDebug, printError, printWarning } from './output-utils.js';\nimport { assertSslDisableAllowed, isProductionEnv } from './tls.js';\nimport { type Config } from '../types/index.js';\n\n// ESM has no __dirname; derive it from this module's URL.\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\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    pipelineTemplateUrl: '/api/pipeline-templates',\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 */\n/**\n * Resolve the API/connection config (base URL, SSL, timeouts) from files and\n * environment WITHOUT requiring `PLATFORM_TOKEN`.\n *\n * This is the token-optional slice of {@link getConfig}. The pre-auth login step\n * (`ensurePlatformToken`) needs the resolved base URL to POST `/api/auth/login`\n * *before* any token exists — calling `getConfig()` there would throw on the\n * missing token and make inline-login dead-on-arrival.\n */\nexport function getApiConfig(): Omit<Config, 'auth'> {\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  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 && isProductionEnv()) {\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  return config;\n}\n\nexport function getConfig(): Config {\n  const config = getApiConfig();\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. Module-private — the\n * only caller is `getConfigWithOptions` below.\n */\nfunction 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  if (options.verifySsl === false) {\n    // Every authenticated command flows its token through here — refuse to\n    // disable cert verification in production (mirrors the login/renewal guards)\n    // so a MITM can't harvest the Bearer JWT. No-op in non-production.\n    assertSslDisableAllowed('authenticated API client (--no-verify-ssl)');\n    return withSSLDisabled(config);\n  }\n  return config;\n}\n"]}

package/dist/utils/cron.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Convert a standard 5-field cron expression into an AWS EventBridge cron
+ * expression, and guard against schedules that fire more often than every
+ * 15 minutes.
+ *
+ * Standard cron:    `minute hour day-of-month month day-of-week`
+ * EventBridge cron: `cron(minute hour day-of-month month day-of-week year)`
+ *
+ * The non-obvious differences EventBridge imposes:
+ *  - a 6th field (year), which we always set to `*`;
+ *  - day-of-month and day-of-week may NOT both be `*` — exactly one must be `?`;
+ *  - day-of-week is 1–7 with 1 = Sunday, whereas standard cron is 0–6 (or 7)
+ *    with 0/7 = Sunday — so numeric day-of-week values must be remapped.
+ */
+/** Minimum allowed spacing between fires, in minutes. */
+export declare const MIN_SCHEDULE_INTERVAL_MIN = 15;
+/**
+ * Throw if `fiveField` would fire more often than every {@link MIN_SCHEDULE_INTERVAL_MIN}
+ * minutes. Conservative: the smallest cyclic gap in the minute field is the worst-case
+ * spacing (it's only ever larger once the hour/day fields restrict things further).
+ */
+export declare function assertScheduleInterval(fiveField: string): void;
+/**
+ * Convert a validated 5-field cron expression to an AWS EventBridge `cron(...)`
+ * expression. Also enforces the 15-minute guard.
+ */
+export declare function toEventBridgeCron(fiveField: string): string;
+//# sourceMappingURL=cron.d.ts.map

package/dist/utils/cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["../../src/utils/cron.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AAEH,yDAAyD;AACzD,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAoC5C;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAuB9D;AAaD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAmB3D"}

package/dist/utils/cron.js

@@ -0,0 +1,119 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Convert a standard 5-field cron expression into an AWS EventBridge cron
+ * expression, and guard against schedules that fire more often than every
+ * 15 minutes.
+ *
+ * Standard cron:    `minute hour day-of-month month day-of-week`
+ * EventBridge cron: `cron(minute hour day-of-month month day-of-week year)`
+ *
+ * The non-obvious differences EventBridge imposes:
+ *  - a 6th field (year), which we always set to `*`;
+ *  - day-of-month and day-of-week may NOT both be `*` — exactly one must be `?`;
+ *  - day-of-week is 1–7 with 1 = Sunday, whereas standard cron is 0–6 (or 7)
+ *    with 0/7 = Sunday — so numeric day-of-week values must be remapped.
+ */
+/** Minimum allowed spacing between fires, in minutes. */
+export const MIN_SCHEDULE_INTERVAL_MIN = 15;
+/** Expand a cron minute field (wildcard, step "/n", ranges "a-b", lists "a,b") to the sorted set of minutes it fires on. */
+function expandMinuteField(field) {
+    const out = new Set();
+    for (const part of field.split(',')) {
+        const slash = part.split('/');
+        const rangePart = slash[0] ?? '';
+        const stepPart = slash[1];
+        const step = stepPart !== undefined ? parseInt(stepPart, 10) : 1;
+        if (stepPart !== undefined && (!Number.isInteger(step) || step < 1)) {
+            throw new Error(`Invalid step in minute field: "${part}"`);
+        }
+        let lo;
+        let hi;
+        if (rangePart === '*') {
+            lo = 0;
+            hi = 59;
+        }
+        else if (rangePart.includes('-')) {
+            const ends = rangePart.split('-');
+            lo = parseInt(ends[0] ?? '', 10);
+            hi = parseInt(ends[1] ?? '', 10);
+        }
+        else {
+            lo = parseInt(rangePart, 10);
+            // With a step (`n/step`), cron's implicit range runs to the end of the field,
+            // so `0/5` fires at 0,5,…,55 — expand to [n, 59] so the interval guard sees
+            // the true spacing. Without a step, a bare number is a single minute.
+            hi = stepPart !== undefined ? 59 : lo;
+        }
+        if (!Number.isInteger(lo) || !Number.isInteger(hi) || lo < 0 || hi > 59 || lo > hi) {
+            throw new Error(`Invalid minute field: "${part}"`);
+        }
+        for (let m = lo; m <= hi; m += step)
+            out.add(m);
+    }
+    return [...out].sort((a, b) => a - b);
+}
+/**
+ * Throw if `fiveField` would fire more often than every {@link MIN_SCHEDULE_INTERVAL_MIN}
+ * minutes. Conservative: the smallest cyclic gap in the minute field is the worst-case
+ * spacing (it's only ever larger once the hour/day fields restrict things further).
+ */
+export function assertScheduleInterval(fiveField) {
+    const parts = fiveField.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Schedule must be a 5-field cron ("minute hour day-of-month month day-of-week"), got: "${fiveField}"`);
+    }
+    const minutes = expandMinuteField(parts[0]);
+    if (minutes.length === 0)
+        throw new Error(`Minute field matches nothing: "${parts[0]}"`);
+    // Smallest cyclic gap across the hour boundary (e.g. {0,50} → gaps 50 and 10).
+    let minGap = 60;
+    if (minutes.length > 1) {
+        for (let i = 0; i < minutes.length; i++) {
+            const cur = minutes[i];
+            const next = minutes[(i + 1) % minutes.length];
+            const gap = (next - cur + 60) % 60 || 60;
+            minGap = Math.min(minGap, gap);
+        }
+    }
+    if (minGap < MIN_SCHEDULE_INTERVAL_MIN) {
+        throw new Error(`Schedule "${fiveField}" fires every ${minGap} minute(s); the minimum is ${MIN_SCHEDULE_INTERVAL_MIN}. ` +
+            'Use a sparser schedule (e.g. "0 0 * * *" for daily, "*/15 * * * *" for the densest allowed).');
+    }
+}
+/** Remap a standard cron day-of-week token (0–7, 0/7=Sun) to EventBridge (1–7, 1=Sun). Passes through names and `*`/`?`. */
+function remapDayOfWeek(field) {
+    if (field === '*' || field === '?')
+        return field;
+    // Token may contain lists/ranges/steps of numbers and/or 3-letter names.
+    return field.replace(/\d+/g, (n) => {
+        const v = parseInt(n, 10);
+        if (v < 0 || v > 7)
+            throw new Error(`Invalid day-of-week value: "${n}"`);
+        return String((v % 7) + 1); // 0→1 (Sun), 6→7 (Sat), 7→1 (Sun)
+    });
+}
+/**
+ * Convert a validated 5-field cron expression to an AWS EventBridge `cron(...)`
+ * expression. Also enforces the 15-minute guard.
+ */
+export function toEventBridgeCron(fiveField) {
+    assertScheduleInterval(fiveField); // also validates the 5-field shape
+    const f = fiveField.trim().split(/\s+/);
+    const [minute, hour, domRaw, month, dowRaw] = [f[0], f[1], f[2], f[3], f[4]];
+    let dom = domRaw;
+    let dow = remapDayOfWeek(dowRaw);
+    // EventBridge: exactly one of day-of-month / day-of-week must be `?`.
+    if (dom === '*' && dow === '*') {
+        dow = '?'; // unrestricted both → pin day-of-week to ?
+    }
+    else if (dom !== '*' && dow === '*') {
+        dow = '?'; // specific day-of-month → day-of-week must be ?
+    }
+    else if (dom === '*' && dow !== '*') {
+        dom = '?'; // specific day-of-week → day-of-month must be ?
+    }
+    // (both specific is left as-is; EventBridge rejects it, surfacing a clear error)
+    return `cron(${minute} ${hour} ${dom} ${month} ${dow} *)`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cron.js","sourceRoot":"","sources":["../../src/utils/cron.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;GAaG;AAEH,yDAAyD;AACzD,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,CAAC;AAE5C,4HAA4H;AAC5H,SAAS,iBAAiB,CAAC,KAAa;IACtC,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACpC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC9B,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACjC,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAC1B,MAAM,IAAI,GAAG,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjE,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,EAAE,CAAC;YACpE,MAAM,IAAI,KAAK,CAAC,kCAAkC,IAAI,GAAG,CAAC,CAAC;QAC7D,CAAC;QACD,IAAI,EAAU,CAAC;QACf,IAAI,EAAU,CAAC;QACf,IAAI,SAAS,KAAK,GAAG,EAAE,CAAC;YACtB,EAAE,GAAG,CAAC,CAAC;YAAC,EAAE,GAAG,EAAE,CAAC;QAClB,CAAC;aAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAClC,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;YACjC,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;QACnC,CAAC;aAAM,CAAC;YACN,EAAE,GAAG,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;YAC7B,8EAA8E;YAC9E,4EAA4E;YAC5E,sEAAsE;YACtE,EAAE,GAAG,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACxC,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;YACnF,MAAM,IAAI,KAAK,CAAC,0BAA0B,IAAI,GAAG,CAAC,CAAC;QACrD,CAAC;QACD,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI;YAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AACxC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,SAAiB;IACtD,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC5C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,yFAAyF,SAAS,GAAG,CAAC,CAAC;IACzH,CAAC;IACD,MAAM,OAAO,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAE,CAAC,CAAC;IAC7C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,kCAAkC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACzF,+EAA+E;IAC/E,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,CAAE,CAAC;YACxB,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAE,CAAC;YAChD,MAAM,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC;YACzC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IACD,IAAI,MAAM,GAAG,yBAAyB,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CACb,aAAa,SAAS,iBAAiB,MAAM,8BAA8B,yBAAyB,IAAI;YACxG,8FAA8F,CAC/F,CAAC;IACJ,CAAC;AACH,CAAC;AAED,4HAA4H;AAC5H,SAAS,cAAc,CAAC,KAAa;IACnC,IAAI,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,GAAG;QAAE,OAAO,KAAK,CAAC;IACjD,yEAAyE;IACzE,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE;QACjC,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,GAAG,CAAC,CAAC;QACzE,OAAO,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,kCAAkC;IAChE,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,SAAiB;IACjD,sBAAsB,CAAC,SAAS,CAAC,CAAC,CAAC,mCAAmC;IACtE,MAAM,CAAC,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACxC,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAE,EAAE,CAAC,CAAC,CAAC,CAAE,EAAE,CAAC,CAAC,CAAC,CAAE,EAAE,CAAC,CAAC,CAAC,CAAE,EAAE,CAAC,CAAC,CAAC,CAAE,CAAC,CAAC;IAElF,IAAI,GAAG,GAAG,MAAM,CAAC;IACjB,IAAI,GAAG,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;IAEjC,sEAAsE;IACtE,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,EAAE,CAAC;QAC/B,GAAG,GAAG,GAAG,CAAC,CAAC,2CAA2C;IACxD,CAAC;SAAM,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,EAAE,CAAC;QACtC,GAAG,GAAG,GAAG,CAAC,CAAC,gDAAgD;IAC7D,CAAC;SAAM,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,EAAE,CAAC;QACtC,GAAG,GAAG,GAAG,CAAC,CAAC,gDAAgD;IAC7D,CAAC;IACD,iFAAiF;IAEjF,OAAO,QAAQ,MAAM,IAAI,IAAI,IAAI,GAAG,IAAI,KAAK,IAAI,GAAG,KAAK,CAAC;AAC5D,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Convert a standard 5-field cron expression into an AWS EventBridge cron\n * expression, and guard against schedules that fire more often than every\n * 15 minutes.\n *\n * Standard cron:    `minute hour day-of-month month day-of-week`\n * EventBridge cron: `cron(minute hour day-of-month month day-of-week year)`\n *\n * The non-obvious differences EventBridge imposes:\n *  - a 6th field (year), which we always set to `*`;\n *  - day-of-month and day-of-week may NOT both be `*` — exactly one must be `?`;\n *  - day-of-week is 1–7 with 1 = Sunday, whereas standard cron is 0–6 (or 7)\n *    with 0/7 = Sunday — so numeric day-of-week values must be remapped.\n */\n\n/** Minimum allowed spacing between fires, in minutes. */\nexport const MIN_SCHEDULE_INTERVAL_MIN = 15;\n\n/** Expand a cron minute field (wildcard, step \"/n\", ranges \"a-b\", lists \"a,b\") to the sorted set of minutes it fires on. */\nfunction expandMinuteField(field: string): number[] {\n  const out = new Set<number>();\n  for (const part of field.split(',')) {\n    const slash = part.split('/');\n    const rangePart = slash[0] ?? '';\n    const stepPart = slash[1];\n    const step = stepPart !== undefined ? parseInt(stepPart, 10) : 1;\n    if (stepPart !== undefined && (!Number.isInteger(step) || step < 1)) {\n      throw new Error(`Invalid step in minute field: \"${part}\"`);\n    }\n    let lo: number;\n    let hi: number;\n    if (rangePart === '*') {\n      lo = 0; hi = 59;\n    } else if (rangePart.includes('-')) {\n      const ends = rangePart.split('-');\n      lo = parseInt(ends[0] ?? '', 10);\n      hi = parseInt(ends[1] ?? '', 10);\n    } else {\n      lo = parseInt(rangePart, 10);\n      // With a step (`n/step`), cron's implicit range runs to the end of the field,\n      // so `0/5` fires at 0,5,…,55 — expand to [n, 59] so the interval guard sees\n      // the true spacing. Without a step, a bare number is a single minute.\n      hi = stepPart !== undefined ? 59 : lo;\n    }\n    if (!Number.isInteger(lo) || !Number.isInteger(hi) || lo < 0 || hi > 59 || lo > hi) {\n      throw new Error(`Invalid minute field: \"${part}\"`);\n    }\n    for (let m = lo; m <= hi; m += step) out.add(m);\n  }\n  return [...out].sort((a, b) => a - b);\n}\n\n/**\n * Throw if `fiveField` would fire more often than every {@link MIN_SCHEDULE_INTERVAL_MIN}\n * minutes. Conservative: the smallest cyclic gap in the minute field is the worst-case\n * spacing (it's only ever larger once the hour/day fields restrict things further).\n */\nexport function assertScheduleInterval(fiveField: string): void {\n  const parts = fiveField.trim().split(/\\s+/);\n  if (parts.length !== 5) {\n    throw new Error(`Schedule must be a 5-field cron (\"minute hour day-of-month month day-of-week\"), got: \"${fiveField}\"`);\n  }\n  const minutes = expandMinuteField(parts[0]!);\n  if (minutes.length === 0) throw new Error(`Minute field matches nothing: \"${parts[0]}\"`);\n  // Smallest cyclic gap across the hour boundary (e.g. {0,50} → gaps 50 and 10).\n  let minGap = 60;\n  if (minutes.length > 1) {\n    for (let i = 0; i < minutes.length; i++) {\n      const cur = minutes[i]!;\n      const next = minutes[(i + 1) % minutes.length]!;\n      const gap = (next - cur + 60) % 60 || 60;\n      minGap = Math.min(minGap, gap);\n    }\n  }\n  if (minGap < MIN_SCHEDULE_INTERVAL_MIN) {\n    throw new Error(\n      `Schedule \"${fiveField}\" fires every ${minGap} minute(s); the minimum is ${MIN_SCHEDULE_INTERVAL_MIN}. ` +\n      'Use a sparser schedule (e.g. \"0 0 * * *\" for daily, \"*/15 * * * *\" for the densest allowed).',\n    );\n  }\n}\n\n/** Remap a standard cron day-of-week token (0–7, 0/7=Sun) to EventBridge (1–7, 1=Sun). Passes through names and `*`/`?`. */\nfunction remapDayOfWeek(field: string): string {\n  if (field === '*' || field === '?') return field;\n  // Token may contain lists/ranges/steps of numbers and/or 3-letter names.\n  return field.replace(/\\d+/g, (n) => {\n    const v = parseInt(n, 10);\n    if (v < 0 || v > 7) throw new Error(`Invalid day-of-week value: \"${n}\"`);\n    return String((v % 7) + 1); // 0→1 (Sun), 6→7 (Sat), 7→1 (Sun)\n  });\n}\n\n/**\n * Convert a validated 5-field cron expression to an AWS EventBridge `cron(...)`\n * expression. Also enforces the 15-minute guard.\n */\nexport function toEventBridgeCron(fiveField: string): string {\n  assertScheduleInterval(fiveField); // also validates the 5-field shape\n  const f = fiveField.trim().split(/\\s+/);\n  const [minute, hour, domRaw, month, dowRaw] = [f[0]!, f[1]!, f[2]!, f[3]!, f[4]!];\n\n  let dom = domRaw;\n  let dow = remapDayOfWeek(dowRaw);\n\n  // EventBridge: exactly one of day-of-month / day-of-week must be `?`.\n  if (dom === '*' && dow === '*') {\n    dow = '?'; // unrestricted both → pin day-of-week to ?\n  } else if (dom !== '*' && dow === '*') {\n    dow = '?'; // specific day-of-month → day-of-week must be ?\n  } else if (dom === '*' && dow !== '*') {\n    dom = '?'; // specific day-of-week → day-of-month must be ?\n  }\n  // (both specific is left as-is; EventBridge rejects it, surfacing a clear error)\n\n  return `cron(${minute} ${hour} ${dom} ${month} ${dow} *)`;\n}\n"]}

package/dist/utils/deploy-runner.d.ts

@@ -0,0 +1,38 @@
+import { type Pipeline } from '../types/index.js';
+/** Minimal platform client shape needed to register a deployed ARN. */
+interface RegistryClient {
+    post: (url: string, body: unknown) => Promise<unknown>;
+}
+/** Inputs for {@link runDeploy} — an already-resolved pipeline + props. */
+export interface RunDeployInput {
+    /** The pipeline being deployed (id/orgId/name/project/org drive registration). */
+    pipeline: Pick<Pipeline, 'id' | 'orgId' | 'pipelineName' | 'project' | 'organization'>;
+    /** Fully-resolved props (plugins pre-resolved, registry host baked, ids included). */
+    propsWithIds: Record<string, unknown>;
+    /** AWS profile / region for the deploy + registry payload. */
+    profile?: string;
+    region?: string;
+    /** `cdk deploy --require-approval` level and `--output` dir. */
+    requireApproval: string;
+    output: string;
+    debug?: boolean;
+    /** For the command header / summary line. */
+    executionId: string;
+    /** Registry callback — omit (e.g. --local-spec) to skip ARN registration. */
+    platformClient?: RegistryClient;
+    platformPipelineUrl?: string;
+    platformBaseUrl?: string;
+}
+/**
+ * Run `cdk deploy` for an already-resolved pipeline, then register the deployed
+ * ARN for event reporting (best-effort). Shared by `pipeline deploy` and
+ * `pipeline create --deploy` so the two entry points never drift.
+ *
+ * THROWS on CDK failure (the caller maps it to a non-zero exit and, for the
+ * create path, keeps the created record and prints the `deploy --id` retry).
+ * Registry failures are NON-fatal — they're queued to a pending-intent file for
+ * `pipeline register` to drain later.
+ */
+export declare function runDeploy(input: RunDeployInput): Promise<void>;
+export {};
+//# sourceMappingURL=deploy-runner.d.ts.map

package/dist/utils/deploy-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy-runner.d.ts","sourceRoot":"","sources":["../../src/utils/deploy-runner.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AASlD,uEAAuE;AACvE,UAAU,cAAc;IACtB,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxD;AAED,2EAA2E;AAC3E,MAAM,WAAW,cAAc;IAC7B,kFAAkF;IAClF,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,GAAG,OAAO,GAAG,cAAc,GAAG,SAAS,GAAG,cAAc,CAAC,CAAC;IACvF,sFAAsF;IACtF,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CA8FpE"}