@pipeline-builder/pipeline-core 3.4.134 → 3.4.136

package/lib/cdk.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @module @pipeline-builder/pipeline-core/cdk
+ *
+ * The AWS CDK surface: the constructs that assemble a pipeline into a
+ * CodePipeline stack, the synth-time authoring types they take, and the adapters
+ * that turn plain `AWSConfig` data into CDK value objects.
+ *
+ * Everything reachable from here pulls in `aws-cdk-lib`, which is why it is a
+ * separate entry point from the package root. Import from here only in code that
+ * actually synthesizes stacks — the CLI's CDK app. Services that just need config
+ * or domain types import `@pipeline-builder/pipeline-core` instead and never load
+ * the CDK. `aws-cdk-lib` and `constructs` are peer dependencies; the consuming app
+ * supplies them, so there is exactly one copy of each on the resolution graph.
+ *
+ * **Constructs**
+ * - PipelineBuilder — top-level CDK pipeline construct
+ * - StageBuilder — pipeline stage composition
+ * - PluginLookup — plugin resolution custom resource
+ * - ArtifactManager — build artifact management
+ * - PipelineConfiguration — pipeline config resolution
+ *
+ * **Authoring types**
+ * - SourceTypes, StepTypes — pipeline source and step configuration
+ * - NetworkTypes — VPC/subnet/security-group configuration
+ *
+ * **Config adapters**
+ * - lambdaRuntime, lambdaTimeout, logRetention, ... — `AWSConfig` → CDK values
+ */
+export * from './config/aws-config-cdk.js';
+export * from './core/network-types.js';
+export * from './core/artifact-manager.js';
+export { buildConfigFromMetadata, metadataForCodePipeline, metadataForCodeBuildStep, metadataForShellStep, metadataForBuildEnvironment, } from './core/metadata-builder.js';
+export * from './pipeline/source-types.js';
+export * from './pipeline/step-types.js';
+export * from './pipeline/stage-builder.js';
+export * from './pipeline/pipeline-builder.js';
+export * from './pipeline/plugin-lookup.js';
+export { PipelineConfiguration } from './pipeline/pipeline-configuration.js';

package/lib/cdk.js

@@ -0,0 +1,44 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * @module @pipeline-builder/pipeline-core/cdk
+ *
+ * The AWS CDK surface: the constructs that assemble a pipeline into a
+ * CodePipeline stack, the synth-time authoring types they take, and the adapters
+ * that turn plain `AWSConfig` data into CDK value objects.
+ *
+ * Everything reachable from here pulls in `aws-cdk-lib`, which is why it is a
+ * separate entry point from the package root. Import from here only in code that
+ * actually synthesizes stacks — the CLI's CDK app. Services that just need config
+ * or domain types import `@pipeline-builder/pipeline-core` instead and never load
+ * the CDK. `aws-cdk-lib` and `constructs` are peer dependencies; the consuming app
+ * supplies them, so there is exactly one copy of each on the resolution graph.
+ *
+ * **Constructs**
+ * - PipelineBuilder — top-level CDK pipeline construct
+ * - StageBuilder — pipeline stage composition
+ * - PluginLookup — plugin resolution custom resource
+ * - ArtifactManager — build artifact management
+ * - PipelineConfiguration — pipeline config resolution
+ *
+ * **Authoring types**
+ * - SourceTypes, StepTypes — pipeline source and step configuration
+ * - NetworkTypes — VPC/subnet/security-group configuration
+ *
+ * **Config adapters**
+ * - lambdaRuntime, lambdaTimeout, logRetention, ... — `AWSConfig` → CDK values
+ */
+// Config adapters (plain AWSConfig data → CDK value objects)
+export * from './config/aws-config-cdk.js';
+// Infrastructure types that reference CDK values
+export * from './core/network-types.js';
+export * from './core/artifact-manager.js';
+export { buildConfigFromMetadata, metadataForCodePipeline, metadataForCodeBuildStep, metadataForShellStep, metadataForBuildEnvironment, } from './core/metadata-builder.js';
+// Pipeline authoring types and CDK constructs
+export * from './pipeline/source-types.js';
+export * from './pipeline/step-types.js';
+export * from './pipeline/stage-builder.js';
+export * from './pipeline/pipeline-builder.js';
+export * from './pipeline/plugin-lookup.js';
+export { PipelineConfiguration } from './pipeline/pipeline-configuration.js';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/config/aws-config-cdk.d.ts

@@ -0,0 +1,49 @@
+/**
+ * CDK adapters for {@link AWSConfig}.
+ *
+ * `AWSConfig` is deliberately plain data (see its doc comment): env-loaded
+ * numbers and strings, no `aws-cdk-lib` on the import graph. That keeps `Config`
+ * — which every API service reads — free of CDK. These functions are the single
+ * conversion point from that plain data into CDK value objects, and they live
+ * behind the `@pipeline-builder/pipeline-core/cdk` entry point, so only code that
+ * actually synthesizes stacks pays for `aws-cdk-lib`.
+ */
+import { Duration, RemovalPolicy } from 'aws-cdk-lib';
+import { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';
+import { RetentionDays } from 'aws-cdk-lib/aws-logs';
+import type { AWSConfig } from './config-types.js';
+/**
+ * Resolve a Lambda runtime identifier (e.g. `'nodejs24.x'`) to a CDK `Runtime`.
+ *
+ * @param runtime - runtime identifier from `Config.get('aws').lambda.runtime`
+ * @returns the CDK enum member; falls back to Node.js 24 for unknown values
+ */
+export declare function lambdaRuntime(runtime: AWSConfig['lambda']['runtime']): Runtime;
+/**
+ * Convert a Lambda timeout in seconds to a CDK `Duration`.
+ *
+ * @param seconds - timeout from `Config.get('aws').lambda.timeoutSeconds`
+ */
+export declare function lambdaTimeout(seconds: AWSConfig['lambda']['timeoutSeconds']): Duration;
+/**
+ * Resolve a Lambda architecture name to a CDK `Architecture`.
+ *
+ * @param architecture - value from `Config.get('aws').lambda.architecture`
+ */
+export declare function lambdaArchitecture(architecture: AWSConfig['lambda']['architecture']): Architecture;
+/**
+ * Convert a retention day count to CDK's `RetentionDays`.
+ *
+ * `RetentionDays` members are the day counts themselves, so the cast is exact —
+ * `infrastructure-config.ts` has already validated the value against the same
+ * set of allowed periods.
+ *
+ * @param days - value from `Config.get('aws').logging.retentionDays`
+ */
+export declare function logRetention(days: AWSConfig['logging']['retentionDays']): RetentionDays;
+/**
+ * Resolve a log-group removal policy name to a CDK `RemovalPolicy`.
+ *
+ * @param policy - value from `Config.get('aws').logging.removalPolicy`
+ */
+export declare function logRemovalPolicy(policy: AWSConfig['logging']['removalPolicy']): RemovalPolicy;

package/lib/config/aws-config-cdk.js

@@ -0,0 +1,65 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * CDK adapters for {@link AWSConfig}.
+ *
+ * `AWSConfig` is deliberately plain data (see its doc comment): env-loaded
+ * numbers and strings, no `aws-cdk-lib` on the import graph. That keeps `Config`
+ * — which every API service reads — free of CDK. These functions are the single
+ * conversion point from that plain data into CDK value objects, and they live
+ * behind the `@pipeline-builder/pipeline-core/cdk` entry point, so only code that
+ * actually synthesizes stacks pays for `aws-cdk-lib`.
+ */
+import { Duration, RemovalPolicy } from 'aws-cdk-lib';
+import { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';
+import { RetentionDays } from 'aws-cdk-lib/aws-logs';
+/** Runtime identifiers this platform supports, mapped to their CDK enum member. */
+const RUNTIMES = {
+    'nodejs24.x': Runtime.NODEJS_24_X,
+};
+/**
+ * Resolve a Lambda runtime identifier (e.g. `'nodejs24.x'`) to a CDK `Runtime`.
+ *
+ * @param runtime - runtime identifier from `Config.get('aws').lambda.runtime`
+ * @returns the CDK enum member; falls back to Node.js 24 for unknown values
+ */
+export function lambdaRuntime(runtime) {
+    return RUNTIMES[runtime] || Runtime.NODEJS_24_X;
+}
+/**
+ * Convert a Lambda timeout in seconds to a CDK `Duration`.
+ *
+ * @param seconds - timeout from `Config.get('aws').lambda.timeoutSeconds`
+ */
+export function lambdaTimeout(seconds) {
+    return Duration.seconds(seconds);
+}
+/**
+ * Resolve a Lambda architecture name to a CDK `Architecture`.
+ *
+ * @param architecture - value from `Config.get('aws').lambda.architecture`
+ */
+export function lambdaArchitecture(architecture) {
+    return architecture === 'x86_64' ? Architecture.X86_64 : Architecture.ARM_64;
+}
+/**
+ * Convert a retention day count to CDK's `RetentionDays`.
+ *
+ * `RetentionDays` members are the day counts themselves, so the cast is exact —
+ * `infrastructure-config.ts` has already validated the value against the same
+ * set of allowed periods.
+ *
+ * @param days - value from `Config.get('aws').logging.retentionDays`
+ */
+export function logRetention(days) {
+    return days;
+}
+/**
+ * Resolve a log-group removal policy name to a CDK `RemovalPolicy`.
+ *
+ * @param policy - value from `Config.get('aws').logging.removalPolicy`
+ */
+export function logRemovalPolicy(policy) {
+    return policy === 'retain' ? RemovalPolicy.RETAIN : RemovalPolicy.DESTROY;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/config/config-types.d.ts

@@ -1,8 +1,4 @@
 import type { QuotaTier, QuotaTierLimits } from '@pipeline-builder/api-core';
-import type { Duration, RemovalPolicy } from 'aws-cdk-lib';
-import type { ComputeType } from 'aws-cdk-lib/aws-codebuild';
-import type { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';
-import type { RetentionDays } from 'aws-cdk-lib/aws-logs';
 import type { Algorithm } from 'jsonwebtoken';
 /**
  * Type-safe configuration interface
@@ -180,21 +176,36 @@ export interface ComplianceConfig {
     /** Cross-pod leader-lock TTL for the digest scheduler (ms). Default: 300000. */
     readonly digestLockTtlMs: number;
 }
+/**
+ * AWS infrastructure configuration.
+ *
+ * Deliberately expressed in PLAIN DATA (numbers, strings, string unions) rather
+ * than CDK value objects (`Duration`, `Runtime`, `RetentionDays`, ...). Config is
+ * loaded by every service, but only the CDK entry point (`@pipeline-builder/
+ * pipeline-core/cdk`) builds stacks  typing this block with CDK classes put
+ * `aws-cdk-lib` on the import graph of `Config`, and therefore of every API
+ * service that reads so much as a port number. Conversion to CDK objects happens
+ * at the construct boundary in `config/aws-config-cdk.ts`.
+ */
 export interface AWSConfig {
     readonly lambda: {
-        readonly runtime: Runtime;
-        readonly timeout: Duration;
+        /** Lambda runtime identifier, e.g. `'nodejs24.x'` (env: `LAMBDA_RUNTIME`). */
+        readonly runtime: string;
+        /** Function timeout in seconds (env: `LAMBDA_TIMEOUT`). */
+        readonly timeoutSeconds: number;
         readonly memorySize: number;
-        readonly architecture: Architecture;
+        readonly architecture: 'arm64' | 'x86_64';
         readonly reservedConcurrentExecutions?: number;
     };
     readonly logging: {
         readonly groupName: string;
-        readonly retention: RetentionDays;
-        readonly removalPolicy: RemovalPolicy;
+        /** CloudWatch retention in days; `0` means never expire (env: `LOG_RETENTION`). */
+        readonly retentionDays: number;
+        readonly removalPolicy: 'retain' | 'destroy';
     };
     readonly codeBuild: {
-        readonly computeType: ComputeType;
+        /** CodeBuild compute type name, e.g. `'SMALL'` (env: `CODEBUILD_COMPUTE_TYPE`). */
+        readonly computeType: string;
         /**
          * Image used for CodeBuild steps that don't have a plugin-baked image
          * (cold-start synth bootstrap, ShellSteps with no registry, and

package/lib/config/config-types.js

@@ -1,4 +1,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-types.js","sourceRoot":"","sources":["../../src/config/config-types.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { QuotaTier, QuotaTierLimits } from '@pipeline-builder/api-core';\nimport type { Duration, RemovalPolicy } from 'aws-cdk-lib';\nimport type { ComputeType } from 'aws-cdk-lib/aws-codebuild';\nimport type { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';\nimport type { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport type { Algorithm } from 'jsonwebtoken';\n\n/**\n * Type-safe configuration interface\n */\nexport interface AppConfig {\n  readonly server: ServerConfig;\n  readonly auth: AuthConfig;\n  readonly database: DatabaseConfig;\n  readonly registry: RegistryConfig;\n  readonly redis: RedisConfig;\n  readonly pluginBuild: PluginBuildConfig;\n  readonly dockerConfig: BuildConfig;\n  readonly observability: ObservabilityConfig;\n  readonly compliance: ComplianceConfig;\n  readonly aws: AWSConfig;\n  readonly rateLimit: RateLimitConfig;\n  readonly billing: BillingConfig;\n}\n\n/** Express server configuration. */\nexport interface ServerConfig {\n  /** HTTP listen port (env: `PORT`). */\n  readonly port: number;\n  readonly cors: {\n    /** Whether to include credentials in CORS responses (env: `CORS_CREDENTIALS`). */\n    readonly credentials: boolean;\n    /** Allowed origin(s) — single string, array, or `'*'` (env: `CORS_ORIGIN`). */\n    readonly origin: string | string[];\n  };\n  /** Number of reverse proxy hops to trust (env: `TRUST_PROXY`). */\n  readonly trustProxy: number;\n  /** Frontend base URL, used as CORS fallback (env: `PLATFORM_BASE_URL`). */\n  readonly platformUrl: string;\n  readonly httpClient: {\n    /** Default HTTP request timeout in ms (env: `HTTP_CLIENT_TIMEOUT`). */\n    readonly timeout: number;\n    /** Maximum retry attempts for failed requests (env: `HTTP_CLIENT_MAX_RETRIES`). */\n    readonly maxRetries: number;\n    /** Base delay between retries in ms (env: `HTTP_CLIENT_RETRY_DELAY_MS`). */\n    readonly retryDelayMs: number;\n  };\n  readonly sse: {\n    /** Max SSE clients per request (env: `SSE_MAX_CLIENTS_PER_REQUEST`). */\n    readonly maxClientsPerRequest: number;\n    /** SSE client timeout in ms (env: `SSE_CLIENT_TIMEOUT_MS`). */\n    readonly clientTimeoutMs: number;\n    /** SSE cleanup interval in ms (env: `SSE_CLEANUP_INTERVAL_MS`). */\n    readonly cleanupIntervalMs: number;\n  };\n  readonly services: {\n    readonly pluginHost: string;\n    readonly pluginPort: number;\n    readonly pipelineHost: string;\n    readonly pipelinePort: number;\n    readonly messageHost: string;\n    readonly messagePort: number;\n    readonly platformHost: string;\n    readonly platformPort: number;\n    readonly complianceHost: string;\n    readonly compliancePort: number;\n    readonly billingHost: string;\n    readonly billingPort: number;\n    readonly billingTimeout: number;\n  };\n}\n\n/** JWT and refresh token authentication configuration. */\nexport interface AuthConfig {\n  readonly jwt: {\n    /** Signing secret for access tokens (env: `JWT_SECRET`). */\n    readonly secret: string;\n    /** Token lifetime in seconds (env: `JWT_EXPIRES_IN`). */\n    readonly expiresIn: number;\n    /** Signing algorithm, e.g. `'HS256'` (env: `JWT_ALGORITHM`). */\n    readonly algorithm: Algorithm;\n    /** bcrypt salt rounds for password hashing (env: `BCRYPT_SALT_ROUNDS`). */\n    readonly saltRounds: number;\n  };\n  readonly refreshToken: {\n    /** Signing secret for refresh tokens (env: `REFRESH_TOKEN_SECRET`). */\n    readonly secret: string;\n    /** Token lifetime in seconds (env: `REFRESH_TOKEN_EXPIRES_IN`). */\n    readonly expiresIn: number;\n  };\n}\n\n/** PostgreSQL and Drizzle ORM database configuration. */\nexport interface DatabaseConfig {\n  readonly postgres: {\n    /** PostgreSQL host (env: `DB_HOST`). */\n    readonly host: string;\n    /** PostgreSQL port (env: `DB_PORT`). */\n    readonly port: number;\n    /** Database name (env: `DATABASE`). */\n    readonly database: string;\n    /** Database user (env: `DB_USER`). */\n    readonly user: string;\n    /** Database password (env: `DB_PASSWORD`). */\n    readonly password: string;\n  };\n  readonly drizzle: {\n    /** Maximum connection pool size (env: `DRIZZLE_MAX_POOL_SIZE`). */\n    readonly maxPoolSize: number;\n    /** Idle connection timeout in ms (env: `DRIZZLE_IDLE_TIMEOUT_MILLIS`). */\n    readonly idleTimeoutMillis: number;\n    /** New connection timeout in ms (env: `DRIZZLE_CONNECTION_TIMEOUT_MILLIS`). */\n    readonly connectionTimeoutMillis: number;\n  };\n}\n\nexport interface RegistryConfig {\n  readonly host: string;\n  readonly port: number;\n  /**\n   * Host/port an OUT-OF-CLUSTER client (notably AWS CodeBuild) uses to pull\n   * plugin images, when it differs from the in-cluster `host`/`port`. The\n   * in-cluster `registry:5000` ClusterIP isn't resolvable from the VPC, so the\n   * synthesized CodeBuild image URI must point at the public gateway instead.\n   * Env: `IMAGE_REGISTRY_PULL_HOST` / `IMAGE_REGISTRY_PULL_PORT`. Optional;\n   * consumers fall back to `host`/`port` when unset (single-host /\n   * in-cluster-only deploys). `loadRegistryConfig` always populates them.\n   */\n  readonly pullHost?: string;\n  readonly pullPort?: number;\n  /** Docker network for build/push (empty string = default). */\n  readonly network: string;\n  /**\n   * BuildKit talks to the registry over plain HTTP when true; HTTPS with the\n   * system CA bundle otherwise. Env: `IMAGE_REGISTRY_HTTP` (defaults true —\n   * the in-cluster registry has no TLS).\n   */\n  readonly http: boolean;\n}\n\nexport interface RedisConfig {\n  readonly host: string;\n  readonly port: number;\n}\n\nexport interface PluginBuildConfig {\n  readonly concurrency: number;\n  readonly maxAttempts: number;\n  readonly backoffDelayMs: number;\n  readonly workerTimeoutMs: number;\n  readonly tempDirMaxAgeMs: number;\n  readonly dlqMaxAttempts: number;\n  readonly dlqBackoffBaseMs: number;\n  readonly dlqMaxSize: number;\n}\n\nexport interface BuildConfig {\n  /** Root directory for build temp files. */\n  readonly tempRoot: string;\n  /** Build timeout in milliseconds. */\n  readonly timeoutMs: number;\n  /** Push timeout in milliseconds. */\n  readonly pushTimeoutMs: number;\n  /**\n   * Path to the buildkitd socket the plugin's `buildctl` connects to. In k8s\n   * and compose this is a shared emptyDir/tmpfs volume mounted from the\n   * buildkitd sidecar.\n   */\n  readonly buildkitAddr: string;\n}\n\nexport interface ObservabilityConfig {\n  readonly logLevel: string;\n  readonly logFormat: string;\n  readonly serviceName: string;\n  readonly tracing: {\n    readonly enabled: boolean;\n    readonly endpoint: string;\n  };\n}\n\nexport interface ComplianceConfig {\n  readonly scanSchedulerIntervalMs: number;\n  /** When false, the scheduler skips scans/schedules for the system org. Default: false. */\n  readonly systemOrgScansEnabled: boolean;\n  /** Cross-pod leader-lock TTL for the scan scheduler (ms). Default: 300000. */\n  readonly scanLockTtlMs: number;\n  /** How often the digest scheduler checks for due digests (ms). Default: 3600000. */\n  readonly digestSchedulerIntervalMs: number;\n  /** Cross-pod leader-lock TTL for the digest scheduler (ms). Default: 300000. */\n  readonly digestLockTtlMs: number;\n}\n\nexport interface AWSConfig {\n  readonly lambda: {\n    readonly runtime: Runtime;\n    readonly timeout: Duration;\n    readonly memorySize: number;\n    readonly architecture: Architecture;\n    readonly reservedConcurrentExecutions?: number;\n  };\n  readonly logging: {\n    readonly groupName: string;\n    readonly retention: RetentionDays;\n    readonly removalPolicy: RemovalPolicy;\n  };\n  readonly codeBuild: {\n    readonly computeType: ComputeType;\n    /**\n     * Image used for CodeBuild steps that don't have a plugin-baked image\n     * (cold-start synth bootstrap, ShellSteps with no registry, and\n     * `metadata_only` plugins). env: `CODEBUILD_DEFAULT_IMAGE`. Default\n     * `pipeline-bootstrap:1.0` — the local tag built by\n     * `deploy/codebuild/bootstrap/Dockerfile`, with `pipeline-manager`\n     * baked in.\n     *\n     * Contract: the image MUST have `pipeline-manager` on PATH. The\n     * bootstrap synth path no longer self-heals via `npm install -g`;\n     * pointing this at an image without the tool gets exit 127 on the\n     * first cold-start build.\n     *\n     * Resolution:\n     * - Bare tag (no `/`) → auto-prefixed to\n     *   `<registry-host>:<port>/library/<tag>` using the registry config,\n     *   with the per-org platform Secret as Basic auth (same flow as\n     *   plugin images).\n     * - Fully-qualified registry URI (contains `/`) → used as-is, no\n     *   auth wired (operator owns making it pullable).\n     * - When the registry isn't configured or per-org auth isn't\n     *   available at the call site, falls back to\n     *   `aws/codebuild/standard:8.0` with a warning — cold-start synth\n     *   will then fail on `pipeline-manager: not found`, surfacing the\n     *   misconfiguration loudly instead of silently swapping images.\n     */\n    readonly defaultImage: string;\n  };\n}\n\n/** Express rate limiting configuration. */\nexport interface RateLimitConfig {\n  /** Maximum requests per window (env: `LIMITER_MAX`). */\n  readonly max: number;\n  /** Rate limit window in milliseconds (env: `LIMITER_WINDOWMS`). */\n  readonly windowMs: number;\n  /** Include legacy `X-RateLimit-*` headers. */\n  readonly legacyHeaders: boolean;\n  /** Include standard `RateLimit-*` headers (RFC 6585). */\n  readonly standardHeaders: boolean;\n}\n\n/** Price configuration for a single billing plan (in cents). */\nexport interface BillingPlanPrices {\n  readonly monthly: number;\n  readonly annual: number;\n}\n\n/** Full billing plan definition used for seeding and runtime configuration. */\nexport interface BillingPlanConfig {\n  readonly id: string;\n  readonly name: string;\n  readonly description: string;\n  readonly tier: QuotaTier;\n  readonly prices: BillingPlanPrices;\n  readonly features: readonly string[];\n  readonly isActive: boolean;\n  readonly isDefault: boolean;\n  readonly sortOrder: number;\n}\n\n/**\n * A purchasable add-on bundle: a quantity-stackable pack that ADDS to the\n * account's base (tier) limits and adds a recurring line item. See\n * docs/billing-bundles.md.\n */\nexport interface BundleConfig {\n  readonly id: string;\n  readonly name: string;\n  readonly description: string;\n  /** Per-unit deltas on `QuotaTierLimits` fields, e.g. `{ seats: 5 }`. Keys are\n   *  constrained to real quota fields so a typo is a compile error (was\n   *  `Record<string, number>`, where a misspelled key was silently unenforceable). */\n  readonly grants: Readonly<Partial<Record<keyof QuotaTierLimits, number>>>;\n  /** Feature flags granted by a feature bundle (e.g. `audit_log`). */\n  readonly features?: readonly string[];\n  /** Per-unit price (cents). Stripe multiplies by quantity. */\n  readonly prices: BillingPlanPrices;\n  /** True for stackable resource packs; false for a boolean feature bundle. */\n  readonly stackable: boolean;\n  /** Base tiers this bundle is offered to. */\n  readonly availableForTiers: readonly QuotaTier[];\n  readonly isActive: boolean;\n  readonly sortOrder: number;\n}\n\n/**\n * A combo discount: when an account holds EVERY bundle in `bundleIds`, the pair\n * is billed at `prices` (the combined price) instead of the sum of the members'\n * individual prices. Realized as a recurring usage credit for the difference —\n * never a provider coupon — consistent with the usage-credit discount model. See\n * docs/billing-bundles.md §Combo pricing.\n */\nexport interface ComboDiscountConfig {\n  readonly id: string;\n  readonly name: string;\n  /** The member bundle ids that must ALL be present for the combo to apply. */\n  readonly bundleIds: readonly string[];\n  /** Per-member minimum quantity (bundleId → count; absent ⇒ 1). Lets a stackable\n   *  capacity pack anchor a combo — e.g. `{ seat_pack: 1 }` = \"≥ 1 Seat Pack\". The\n   *  credit basis uses this minimum, so extra packs never inflate the discount. */\n  readonly minQuantities?: Readonly<Record<string, number>>;\n  /** The combined price for the minimum set (cents). The credit is\n   *  `Σ member unit price × minQty − prices`, clamped ≥ 0. */\n  readonly prices: BillingPlanPrices;\n  /** Deterministic tie-break among equal-total optimal packings when combos overlap\n   *  (lower wins). */\n  readonly sortOrder: number;\n  readonly isActive: boolean;\n}\n\n/** Billing plans + add-on bundle configuration. */\nexport interface BillingConfig {\n  readonly plans: readonly BillingPlanConfig[];\n  readonly bundles: readonly BundleConfig[];\n  readonly comboDiscounts: readonly ComboDiscountConfig[];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-types.js","sourceRoot":"","sources":["../../src/config/config-types.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { QuotaTier, QuotaTierLimits } from '@pipeline-builder/api-core';\nimport type { Algorithm } from 'jsonwebtoken';\n\n/**\n * Type-safe configuration interface\n */\nexport interface AppConfig {\n  readonly server: ServerConfig;\n  readonly auth: AuthConfig;\n  readonly database: DatabaseConfig;\n  readonly registry: RegistryConfig;\n  readonly redis: RedisConfig;\n  readonly pluginBuild: PluginBuildConfig;\n  readonly dockerConfig: BuildConfig;\n  readonly observability: ObservabilityConfig;\n  readonly compliance: ComplianceConfig;\n  readonly aws: AWSConfig;\n  readonly rateLimit: RateLimitConfig;\n  readonly billing: BillingConfig;\n}\n\n/** Express server configuration. */\nexport interface ServerConfig {\n  /** HTTP listen port (env: `PORT`). */\n  readonly port: number;\n  readonly cors: {\n    /** Whether to include credentials in CORS responses (env: `CORS_CREDENTIALS`). */\n    readonly credentials: boolean;\n    /** Allowed origin(s) — single string, array, or `'*'` (env: `CORS_ORIGIN`). */\n    readonly origin: string | string[];\n  };\n  /** Number of reverse proxy hops to trust (env: `TRUST_PROXY`). */\n  readonly trustProxy: number;\n  /** Frontend base URL, used as CORS fallback (env: `PLATFORM_BASE_URL`). */\n  readonly platformUrl: string;\n  readonly httpClient: {\n    /** Default HTTP request timeout in ms (env: `HTTP_CLIENT_TIMEOUT`). */\n    readonly timeout: number;\n    /** Maximum retry attempts for failed requests (env: `HTTP_CLIENT_MAX_RETRIES`). */\n    readonly maxRetries: number;\n    /** Base delay between retries in ms (env: `HTTP_CLIENT_RETRY_DELAY_MS`). */\n    readonly retryDelayMs: number;\n  };\n  readonly sse: {\n    /** Max SSE clients per request (env: `SSE_MAX_CLIENTS_PER_REQUEST`). */\n    readonly maxClientsPerRequest: number;\n    /** SSE client timeout in ms (env: `SSE_CLIENT_TIMEOUT_MS`). */\n    readonly clientTimeoutMs: number;\n    /** SSE cleanup interval in ms (env: `SSE_CLEANUP_INTERVAL_MS`). */\n    readonly cleanupIntervalMs: number;\n  };\n  readonly services: {\n    readonly pluginHost: string;\n    readonly pluginPort: number;\n    readonly pipelineHost: string;\n    readonly pipelinePort: number;\n    readonly messageHost: string;\n    readonly messagePort: number;\n    readonly platformHost: string;\n    readonly platformPort: number;\n    readonly complianceHost: string;\n    readonly compliancePort: number;\n    readonly billingHost: string;\n    readonly billingPort: number;\n    readonly billingTimeout: number;\n  };\n}\n\n/** JWT and refresh token authentication configuration. */\nexport interface AuthConfig {\n  readonly jwt: {\n    /** Signing secret for access tokens (env: `JWT_SECRET`). */\n    readonly secret: string;\n    /** Token lifetime in seconds (env: `JWT_EXPIRES_IN`). */\n    readonly expiresIn: number;\n    /** Signing algorithm, e.g. `'HS256'` (env: `JWT_ALGORITHM`). */\n    readonly algorithm: Algorithm;\n    /** bcrypt salt rounds for password hashing (env: `BCRYPT_SALT_ROUNDS`). */\n    readonly saltRounds: number;\n  };\n  readonly refreshToken: {\n    /** Signing secret for refresh tokens (env: `REFRESH_TOKEN_SECRET`). */\n    readonly secret: string;\n    /** Token lifetime in seconds (env: `REFRESH_TOKEN_EXPIRES_IN`). */\n    readonly expiresIn: number;\n  };\n}\n\n/** PostgreSQL and Drizzle ORM database configuration. */\nexport interface DatabaseConfig {\n  readonly postgres: {\n    /** PostgreSQL host (env: `DB_HOST`). */\n    readonly host: string;\n    /** PostgreSQL port (env: `DB_PORT`). */\n    readonly port: number;\n    /** Database name (env: `DATABASE`). */\n    readonly database: string;\n    /** Database user (env: `DB_USER`). */\n    readonly user: string;\n    /** Database password (env: `DB_PASSWORD`). */\n    readonly password: string;\n  };\n  readonly drizzle: {\n    /** Maximum connection pool size (env: `DRIZZLE_MAX_POOL_SIZE`). */\n    readonly maxPoolSize: number;\n    /** Idle connection timeout in ms (env: `DRIZZLE_IDLE_TIMEOUT_MILLIS`). */\n    readonly idleTimeoutMillis: number;\n    /** New connection timeout in ms (env: `DRIZZLE_CONNECTION_TIMEOUT_MILLIS`). */\n    readonly connectionTimeoutMillis: number;\n  };\n}\n\nexport interface RegistryConfig {\n  readonly host: string;\n  readonly port: number;\n  /**\n   * Host/port an OUT-OF-CLUSTER client (notably AWS CodeBuild) uses to pull\n   * plugin images, when it differs from the in-cluster `host`/`port`. The\n   * in-cluster `registry:5000` ClusterIP isn't resolvable from the VPC, so the\n   * synthesized CodeBuild image URI must point at the public gateway instead.\n   * Env: `IMAGE_REGISTRY_PULL_HOST` / `IMAGE_REGISTRY_PULL_PORT`. Optional;\n   * consumers fall back to `host`/`port` when unset (single-host /\n   * in-cluster-only deploys). `loadRegistryConfig` always populates them.\n   */\n  readonly pullHost?: string;\n  readonly pullPort?: number;\n  /** Docker network for build/push (empty string = default). */\n  readonly network: string;\n  /**\n   * BuildKit talks to the registry over plain HTTP when true; HTTPS with the\n   * system CA bundle otherwise. Env: `IMAGE_REGISTRY_HTTP` (defaults true —\n   * the in-cluster registry has no TLS).\n   */\n  readonly http: boolean;\n}\n\nexport interface RedisConfig {\n  readonly host: string;\n  readonly port: number;\n}\n\nexport interface PluginBuildConfig {\n  readonly concurrency: number;\n  readonly maxAttempts: number;\n  readonly backoffDelayMs: number;\n  readonly workerTimeoutMs: number;\n  readonly tempDirMaxAgeMs: number;\n  readonly dlqMaxAttempts: number;\n  readonly dlqBackoffBaseMs: number;\n  readonly dlqMaxSize: number;\n}\n\nexport interface BuildConfig {\n  /** Root directory for build temp files. */\n  readonly tempRoot: string;\n  /** Build timeout in milliseconds. */\n  readonly timeoutMs: number;\n  /** Push timeout in milliseconds. */\n  readonly pushTimeoutMs: number;\n  /**\n   * Path to the buildkitd socket the plugin's `buildctl` connects to. In k8s\n   * and compose this is a shared emptyDir/tmpfs volume mounted from the\n   * buildkitd sidecar.\n   */\n  readonly buildkitAddr: string;\n}\n\nexport interface ObservabilityConfig {\n  readonly logLevel: string;\n  readonly logFormat: string;\n  readonly serviceName: string;\n  readonly tracing: {\n    readonly enabled: boolean;\n    readonly endpoint: string;\n  };\n}\n\nexport interface ComplianceConfig {\n  readonly scanSchedulerIntervalMs: number;\n  /** When false, the scheduler skips scans/schedules for the system org. Default: false. */\n  readonly systemOrgScansEnabled: boolean;\n  /** Cross-pod leader-lock TTL for the scan scheduler (ms). Default: 300000. */\n  readonly scanLockTtlMs: number;\n  /** How often the digest scheduler checks for due digests (ms). Default: 3600000. */\n  readonly digestSchedulerIntervalMs: number;\n  /** Cross-pod leader-lock TTL for the digest scheduler (ms). Default: 300000. */\n  readonly digestLockTtlMs: number;\n}\n\n/**\n * AWS infrastructure configuration.\n *\n * Deliberately expressed in PLAIN DATA (numbers, strings, string unions) rather\n * than CDK value objects (`Duration`, `Runtime`, `RetentionDays`, ...). Config is\n * loaded by every service, but only the CDK entry point (`@pipeline-builder/\n * pipeline-core/cdk`) builds stacks  typing this block with CDK classes put\n * `aws-cdk-lib` on the import graph of `Config`, and therefore of every API\n * service that reads so much as a port number. Conversion to CDK objects happens\n * at the construct boundary in `config/aws-config-cdk.ts`.\n */\nexport interface AWSConfig {\n  readonly lambda: {\n    /** Lambda runtime identifier, e.g. `'nodejs24.x'` (env: `LAMBDA_RUNTIME`). */\n    readonly runtime: string;\n    /** Function timeout in seconds (env: `LAMBDA_TIMEOUT`). */\n    readonly timeoutSeconds: number;\n    readonly memorySize: number;\n    readonly architecture: 'arm64' | 'x86_64';\n    readonly reservedConcurrentExecutions?: number;\n  };\n  readonly logging: {\n    readonly groupName: string;\n    /** CloudWatch retention in days; `0` means never expire (env: `LOG_RETENTION`). */\n    readonly retentionDays: number;\n    readonly removalPolicy: 'retain' | 'destroy';\n  };\n  readonly codeBuild: {\n    /** CodeBuild compute type name, e.g. `'SMALL'` (env: `CODEBUILD_COMPUTE_TYPE`). */\n    readonly computeType: string;\n    /**\n     * Image used for CodeBuild steps that don't have a plugin-baked image\n     * (cold-start synth bootstrap, ShellSteps with no registry, and\n     * `metadata_only` plugins). env: `CODEBUILD_DEFAULT_IMAGE`. Default\n     * `pipeline-bootstrap:1.0` — the local tag built by\n     * `deploy/codebuild/bootstrap/Dockerfile`, with `pipeline-manager`\n     * baked in.\n     *\n     * Contract: the image MUST have `pipeline-manager` on PATH. The\n     * bootstrap synth path no longer self-heals via `npm install -g`;\n     * pointing this at an image without the tool gets exit 127 on the\n     * first cold-start build.\n     *\n     * Resolution:\n     * - Bare tag (no `/`) → auto-prefixed to\n     *   `<registry-host>:<port>/library/<tag>` using the registry config,\n     *   with the per-org platform Secret as Basic auth (same flow as\n     *   plugin images).\n     * - Fully-qualified registry URI (contains `/`) → used as-is, no\n     *   auth wired (operator owns making it pullable).\n     * - When the registry isn't configured or per-org auth isn't\n     *   available at the call site, falls back to\n     *   `aws/codebuild/standard:8.0` with a warning — cold-start synth\n     *   will then fail on `pipeline-manager: not found`, surfacing the\n     *   misconfiguration loudly instead of silently swapping images.\n     */\n    readonly defaultImage: string;\n  };\n}\n\n/** Express rate limiting configuration. */\nexport interface RateLimitConfig {\n  /** Maximum requests per window (env: `LIMITER_MAX`). */\n  readonly max: number;\n  /** Rate limit window in milliseconds (env: `LIMITER_WINDOWMS`). */\n  readonly windowMs: number;\n  /** Include legacy `X-RateLimit-*` headers. */\n  readonly legacyHeaders: boolean;\n  /** Include standard `RateLimit-*` headers (RFC 6585). */\n  readonly standardHeaders: boolean;\n}\n\n/** Price configuration for a single billing plan (in cents). */\nexport interface BillingPlanPrices {\n  readonly monthly: number;\n  readonly annual: number;\n}\n\n/** Full billing plan definition used for seeding and runtime configuration. */\nexport interface BillingPlanConfig {\n  readonly id: string;\n  readonly name: string;\n  readonly description: string;\n  readonly tier: QuotaTier;\n  readonly prices: BillingPlanPrices;\n  readonly features: readonly string[];\n  readonly isActive: boolean;\n  readonly isDefault: boolean;\n  readonly sortOrder: number;\n}\n\n/**\n * A purchasable add-on bundle: a quantity-stackable pack that ADDS to the\n * account's base (tier) limits and adds a recurring line item. See\n * docs/billing-bundles.md.\n */\nexport interface BundleConfig {\n  readonly id: string;\n  readonly name: string;\n  readonly description: string;\n  /** Per-unit deltas on `QuotaTierLimits` fields, e.g. `{ seats: 5 }`. Keys are\n   *  constrained to real quota fields so a typo is a compile error (was\n   *  `Record<string, number>`, where a misspelled key was silently unenforceable). */\n  readonly grants: Readonly<Partial<Record<keyof QuotaTierLimits, number>>>;\n  /** Feature flags granted by a feature bundle (e.g. `audit_log`). */\n  readonly features?: readonly string[];\n  /** Per-unit price (cents). Stripe multiplies by quantity. */\n  readonly prices: BillingPlanPrices;\n  /** True for stackable resource packs; false for a boolean feature bundle. */\n  readonly stackable: boolean;\n  /** Base tiers this bundle is offered to. */\n  readonly availableForTiers: readonly QuotaTier[];\n  readonly isActive: boolean;\n  readonly sortOrder: number;\n}\n\n/**\n * A combo discount: when an account holds EVERY bundle in `bundleIds`, the pair\n * is billed at `prices` (the combined price) instead of the sum of the members'\n * individual prices. Realized as a recurring usage credit for the difference —\n * never a provider coupon — consistent with the usage-credit discount model. See\n * docs/billing-bundles.md §Combo pricing.\n */\nexport interface ComboDiscountConfig {\n  readonly id: string;\n  readonly name: string;\n  /** The member bundle ids that must ALL be present for the combo to apply. */\n  readonly bundleIds: readonly string[];\n  /** Per-member minimum quantity (bundleId → count; absent ⇒ 1). Lets a stackable\n   *  capacity pack anchor a combo — e.g. `{ seat_pack: 1 }` = \"≥ 1 Seat Pack\". The\n   *  credit basis uses this minimum, so extra packs never inflate the discount. */\n  readonly minQuantities?: Readonly<Record<string, number>>;\n  /** The combined price for the minimum set (cents). The credit is\n   *  `Σ member unit price × minQty − prices`, clamped ≥ 0. */\n  readonly prices: BillingPlanPrices;\n  /** Deterministic tie-break among equal-total optimal packings when combos overlap\n   *  (lower wins). */\n  readonly sortOrder: number;\n  readonly isActive: boolean;\n}\n\n/** Billing plans + add-on bundle configuration. */\nexport interface BillingConfig {\n  readonly plans: readonly BillingPlanConfig[];\n  readonly bundles: readonly BundleConfig[];\n  readonly comboDiscounts: readonly ComboDiscountConfig[];\n}\n"]}

package/lib/config/handler-constants.js

@@ -4,10 +4,15 @@
  * Leaf constants for the PluginLookup Lambda handler.
  *
  * Deliberately dependency-free (only `process.env` reads, no imports) so the
- * handler's esbuild bundle does NOT transitively reach `app-config.ts` →
- * `infrastructure-config.ts` → `aws-cdk-lib`. Bundling all of aws-cdk-lib into
- * the Lambda OOM-kills esbuild (hundreds of MB, SIGKILL during cold-start
- * synth). The handler imports THIS module, not `CoreConstants`.
+ * handler's esbuild bundle stays small — it does not drag in the whole config
+ * machinery via `app-config.ts`. The handler imports THIS module, not
+ * `CoreConstants`.
+ *
+ * This originally guarded a much sharper edge: `app-config.ts` →
+ * `infrastructure-config.ts` → `aws-cdk-lib`, which OOM-killed esbuild
+ * (hundreds of MB, SIGKILL during cold-start synth). That chain is gone —
+ * `infrastructure-config.ts` is now CDK-free and the constructs live behind the
+ * `/cdk` entry point — but the dependency-free contract is still worth keeping.
  *
  * `CoreConstants` (app-config.ts) re-exports these so synth-side consumers
  * (api-server, server-config) keep using `CoreConstants.HANDLER_*` unchanged —
@@ -31,4 +36,4 @@ export const HANDLER_DEFAULT_BASE_URL = process.env.PLATFORM_BASE_URL || DEFAULT
 export const HANDLER_MAX_RETRIES = envInt(process.env.HANDLER_MAX_RETRIES, 2);
 /** Base backoff between handler retries (exponential). */
 export const HANDLER_RETRY_DELAY_MS = envInt(process.env.HANDLER_RETRY_DELAY_MS, 1000); // 1s
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/config/infrastructure-config.js

@@ -1,10 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import path from 'path';
-import { Duration, RemovalPolicy } from 'aws-cdk-lib';
-import { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';
-import { RetentionDays } from 'aws-cdk-lib/aws-logs';
-import { getComputeType } from '../core/pipeline-helpers.js';
 /**
  * Load Docker registry configuration from environment variables.
  *
@@ -159,52 +155,43 @@ export function loadDockerConfig() {
 export function loadAWSConfig() {
     return {
         lambda: {
-            runtime: parseRuntime(process.env.LAMBDA_RUNTIME || 'nodejs24.x'),
-            timeout: Duration.seconds(parseInt(process.env.LAMBDA_TIMEOUT || '900', 10)),
+            runtime: process.env.LAMBDA_RUNTIME || 'nodejs24.x',
+            timeoutSeconds: parseInt(process.env.LAMBDA_TIMEOUT || '900', 10),
             memorySize: parseInt(process.env.LAMBDA_MEMORY_SIZE || '512', 10),
-            architecture: process.env.LAMBDA_ARCHITECTURE === 'x86_64'
-                ? Architecture.X86_64
-                : Architecture.ARM_64,
+            architecture: process.env.LAMBDA_ARCHITECTURE === 'x86_64' ? 'x86_64' : 'arm64',
             reservedConcurrentExecutions: process.env.LAMBDA_RESERVED_CONCURRENCY
                 ? parseInt(process.env.LAMBDA_RESERVED_CONCURRENCY, 10)
                 : undefined,
         },
         logging: {
             groupName: process.env.LOG_GROUP_NAME || '/pipeline-builder/logs',
-            retention: parseRetention(process.env.LOG_RETENTION || '7'),
-            removalPolicy: process.env.LOG_REMOVAL_POLICY === 'RETAIN'
-                ? RemovalPolicy.RETAIN
-                : RemovalPolicy.DESTROY,
+            retentionDays: parseRetentionDays(process.env.LOG_RETENTION || '7'),
+            removalPolicy: process.env.LOG_REMOVAL_POLICY === 'RETAIN' ? 'retain' : 'destroy',
         },
         codeBuild: {
-            computeType: getComputeType(process.env.CODEBUILD_COMPUTE_TYPE || 'SMALL'),
+            computeType: (process.env.CODEBUILD_COMPUTE_TYPE || 'SMALL').toUpperCase(),
             defaultImage: process.env.CODEBUILD_DEFAULT_IMAGE || 'pipeline-bootstrap:1.0',
         },
     };
 }
 /**
- * Parse Lambda runtime string into a CDK Runtime enum value.
- *
- * @param runtime - Runtime string (e.g. `'nodejs24.x'`)
- * @returns CDK Runtime enum; falls back to NODEJS_24_X for unknown values
+ * Valid CloudWatch Logs retention periods, in days. Mirrors the day counts of
+ * CDK's `RetentionDays` enum (whose members ARE the day counts), but written out
+ * so this module stays free of `aws-cdk-lib`  see the note on {@link AWSConfig}.
+ * `0` is CDK's `INFINITE` (never expire).
  */
-function parseRuntime(runtime) {
-    const runtimeMap = {
-        'nodejs24.x': Runtime.NODEJS_24_X,
-    };
-    return runtimeMap[runtime] || Runtime.NODEJS_24_X;
-}
+const VALID_RETENTION_DAYS = new Set([
+    0, 1, 3, 5, 7, 14, 30, 60, 90, 120, 150, 180, 365, 400, 545, 731,
+    1096, 1827, 2192, 2557, 2922, 3288, 3653,
+]);
 /**
- * Parse log retention days string into a CDK RetentionDays enum value.
- * RetentionDays enum values are the numeric day counts themselves,
- * so we parse the string and check if it's a valid enum member.
+ * Parse a log-retention string into a valid CloudWatch retention day count.
  *
  * @param days - Retention period in days as a string (e.g. `'30'`)
- * @returns CDK RetentionDays enum; falls back to ONE_DAY for unknown values
+ * @returns the day count; falls back to 1 day for unknown/invalid values
  */
-const VALID_RETENTION_DAYS = new Set(Object.values(RetentionDays).filter((v) => typeof v === 'number'));
-function parseRetention(days) {
+function parseRetentionDays(days) {
     const parsed = parseInt(days, 10);
-    return VALID_RETENTION_DAYS.has(parsed) ? parsed : RetentionDays.ONE_DAY;
+    return VALID_RETENTION_DAYS.has(parsed) ? parsed : 1;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infrastructure-config.js","sourceRoot":"","sources":["../../src/config/infrastructure-config.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,kBAAkB;IAChC,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,UAAU,CAAC;IAC3D,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,MAAM,EAAE,EAAE,CAAC,CAAC;IACrE,4EAA4E;IAC5E,wEAAwE;IACxE,8EAA8E;IAC9E,4EAA4E;IAC5E,MAAM,QAAQ,GAAG,oBAAoB,CAAC,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IACrE,OAAO;QACL,IAAI;QACJ,IAAI;QACJ,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,wBAAwB,IAAI,QAAQ,EAAE,IAAI,IAAI,IAAI;QACxE,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,wBAAwB;YAC5C,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,EAAE,EAAE,CAAC;YACpD,CAAC,CAAC,CAAC,QAAQ,EAAE,IAAI,IAAI,IAAI,CAAC;QAC5B,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,EAAE;QACzC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB,KAAK,OAAO;KAClD,CAAC;AACJ,CAAC;AAED;;;iFAGiF;AACjF,MAAM,UAAU,oBAAoB,CAAC,GAAY;IAC/C,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,CAAC;IACtB,IAAI,CAAC;QACH,MAAM,CAAC,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;QACvB,4EAA4E;QAC5E,uEAAuE;QACvE,sBAAsB;QACtB,IAAI,CAAC,CAAC,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC;QAC7B,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAClF,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC;IACpC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO;QACL,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,WAAW;QAC3C,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,MAAM,EAAE,EAAE,CAAC;KACrD,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO;QACL,WAAW,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,IAAI,GAAG,EAAE,EAAE,CAAC;QACtE,WAAW,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,yBAAyB,IAAI,GAAG,EAAE,EAAE,CAAC;QACvE,cAAc,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,6BAA6B,IAAI,MAAM,EAAE,EAAE,CAAC;QACjF,eAAe,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,8BAA8B,IAAI,OAAO,EAAE,EAAE,CAAC;QACpF,eAAe,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,UAAU,EAAE,EAAE,CAAC;QAC5E,cAAc,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,uBAAuB,IAAI,GAAG,EAAE,EAAE,CAAC;QACxE,gBAAgB,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,0BAA0B,IAAI,QAAQ,EAAE,EAAE,CAAC;QAClF,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,IAAI,EAAE,EAAE,CAAC;KAClE,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,kBAAkB;IAChC,OAAO;QACL,QAAQ,EAAE;YACR,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,UAAU;YACvC,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,MAAM,EAAE,EAAE,CAAC;YACjD,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,kBAAkB;YACpD,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,UAAU;YACvC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,EAAE;SACxC;QACD,OAAO,EAAE;YACP,WAAW,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,IAAI,EAAE,EAAE,CAAC;YACpE,iBAAiB,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,2BAA2B,IAAI,OAAO,EAAE,EAAE,CAAC;YACnF,uBAAuB,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,iCAAiC,IAAI,OAAO,EAAE,EAAE,CAAC;SAChG;KACF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,uBAAuB;IACrC,OAAO;QACL,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,SAAS,IAAI,MAAM;QACzC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,MAAM;QAC3C,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,YAAY,IAAI,KAAK;QAC9C,OAAO,EAAE;YACP,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,oBAAoB,KAAK,MAAM;YACpD,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,2BAA2B,IAAI,iCAAiC;SACvF;KACF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,oBAAoB;IAClC,OAAO;QACL,uBAAuB,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,0BAA0B,IAAI,OAAO,EAAE,EAAE,CAAC;QACxF,qBAAqB,EAAE,OAAO,CAAC,GAAG,CAAC,wBAAwB,KAAK,MAAM;QACtE,aAAa,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,QAAQ,EAAE,EAAE,CAAC;QACrE,yBAAyB,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,4BAA4B,IAAI,SAAS,EAAE,EAAE,CAAC;QAC9F,eAAe,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,QAAQ,EAAE,EAAE,CAAC;KAC1E,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO;QACL,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,sBAAsB,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,KAAK,CAAC;QAC/E,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,uBAAuB,IAAI,QAAQ,EAAE,EAAE,CAAC;QACxE,aAAa,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,sBAAsB,IAAI,QAAQ,EAAE,EAAE,CAAC;QAC3E,YAAY,EAAE,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,qCAAqC;KACjF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO;QACL,MAAM,EAAE;YACN,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,YAAY,CAAC;YACjE,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,KAAK,EAAE,EAAE,CAAC,CAAC;YAC5E,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,KAAK,EAAE,EAAE,CAAC;YACjE,YAAY,EAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB,KAAK,QAAQ;gBACxD,CAAC,CAAC,YAAY,CAAC,MAAM;gBACrB,CAAC,CAAC,YAAY,CAAC,MAAM;YACvB,4BAA4B,EAAE,OAAO,CAAC,GAAG,CAAC,2BAA2B;gBACnE,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,2BAA2B,EAAE,EAAE,CAAC;gBACvD,CAAC,CAAC,SAAS;SACd;QAED,OAAO,EAAE;YACP,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,wBAAwB;YACjE,SAAS,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,GAAG,CAAC;YAC3D,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,kBAAkB,KAAK,QAAQ;gBACxD,CAAC,CAAC,aAAa,CAAC,MAAM;gBACtB,CAAC,CAAC,aAAa,CAAC,OAAO;SAC1B;QAED,SAAS,EAAE;YACT,WAAW,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC,sBAAsB,IAAI,OAAO,CAAC;YAC1E,YAAY,EAAE,OAAO,CAAC,GAAG,CAAC,uBAAuB,IAAI,wBAAwB;SAC9E;KACF,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,YAAY,CAAC,OAAe;IACnC,MAAM,UAAU,GAA4B;QAC1C,YAAY,EAAE,OAAO,CAAC,WAAW;KAClC,CAAC;IACF,OAAO,UAAU,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC;AACpD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC;AAErH,SAAS,cAAc,CAAC,IAAY;IAClC,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IAClC,OAAO,oBAAoB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAuB,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC;AAC5F,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport path from 'path';\nimport { Duration, RemovalPolicy } from 'aws-cdk-lib';\nimport { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport type { AWSConfig, BuildConfig, ComplianceConfig, DatabaseConfig, ObservabilityConfig, PluginBuildConfig, RedisConfig, RegistryConfig } from './config-types.js';\nimport { getComputeType } from '../core/pipeline-helpers.js';\n\n/**\n * Load Docker registry configuration from environment variables.\n *\n * Environment variables:\n * - `IMAGE_REGISTRY_HOST` — Registry hostname (default: `'registry'`)\n * - `IMAGE_REGISTRY_PORT` — Registry port (default: `5000`)\n * - `IMAGE_REGISTRY_PULL_HOST` — Host an out-of-cluster client (CodeBuild)\n *   uses to pull plugin images. When unset, derived from `PLATFORM_BASE_URL`'s\n *   host (the public endpoint CodeBuild can resolve), then `IMAGE_REGISTRY_HOST`.\n * - `IMAGE_REGISTRY_PULL_PORT` — Port for the above. When unset, derived from\n *   `PLATFORM_BASE_URL`'s port, then `IMAGE_REGISTRY_PORT`.\n * - `DOCKER_NETWORK` — Docker network for build/push (default: `''`)\n * - `IMAGE_REGISTRY_HTTP` — Use plain HTTP instead of HTTPS (default: `true`,\n *   the in-cluster registry has no TLS).\n *\n * @returns Registry configuration\n */\nexport function loadRegistryConfig(): RegistryConfig {\n  const host = process.env.IMAGE_REGISTRY_HOST || 'registry';\n  const port = parseInt(process.env.IMAGE_REGISTRY_PORT || '5000', 10);\n  // When no explicit pull host is set, derive it from PLATFORM_BASE_URL — the\n  // public platform endpoint an out-of-cluster client (AWS CodeBuild) can\n  // resolve, unlike the in-cluster `registry` ClusterIP. Only falls back to the\n  // in-cluster host when PLATFORM_BASE_URL is unset/unparseable (e.g. local).\n  const platform = parsePlatformBaseUrl(process.env.PLATFORM_BASE_URL);\n  return {\n    host,\n    port,\n    pullHost: process.env.IMAGE_REGISTRY_PULL_HOST || platform?.host || host,\n    pullPort: process.env.IMAGE_REGISTRY_PULL_PORT\n      ? parseInt(process.env.IMAGE_REGISTRY_PULL_PORT, 10)\n      : (platform?.port ?? port),\n    network: process.env.DOCKER_NETWORK || '',\n    http: process.env.IMAGE_REGISTRY_HTTP !== 'false',\n  };\n}\n\n/** Extract host + port from PLATFORM_BASE_URL (e.g. `https://pipeline-builder.com`\n *  → `{ host: 'pipeline-builder.com', port: 443 }`). Returns null when the value\n *  is unset or not a valid URL. Exported so the CLI (pipeline-manager) derives\n *  the registry pull target with the SAME parsing, instead of duplicating it. */\nexport function parsePlatformBaseUrl(raw?: string): { host: string; port: number } | null {\n  if (!raw) return null;\n  try {\n    const u = new URL(raw);\n    // A scheme-less value like `host:8443` parses with a custom protocol and an\n    // EMPTY hostname — reject it so callers fall back rather than derive a\n    // host-less endpoint.\n    if (!u.hostname) return null;\n    const port = u.port ? parseInt(u.port, 10) : (u.protocol === 'https:' ? 443 : 80);\n    return { host: u.hostname, port };\n  } catch {\n    return null;\n  }\n}\n\nexport function loadRedisConfig(): RedisConfig {\n  return {\n    host: process.env.REDIS_HOST || 'localhost',\n    port: parseInt(process.env.REDIS_PORT || '6379', 10),\n  };\n}\n\n/**\n * Load plugin build queue configuration.\n *\n * Environment variables:\n * - `PLUGIN_BUILD_CONCURRENCY` — Max concurrent plugin builds (default: `1`)\n */\nexport function loadPluginBuildConfig(): PluginBuildConfig {\n  return {\n    concurrency: parseInt(process.env.PLUGIN_BUILD_CONCURRENCY || '1', 10),\n    maxAttempts: parseInt(process.env.PLUGIN_BUILD_MAX_ATTEMPTS || '2', 10),\n    backoffDelayMs: parseInt(process.env.PLUGIN_BUILD_BACKOFF_DELAY_MS || '5000', 10),\n    workerTimeoutMs: parseInt(process.env.PLUGIN_BUILD_WORKER_TIMEOUT_MS || '10000', 10),\n    tempDirMaxAgeMs: parseInt(process.env.TEMP_DIR_MAX_AGE_MS || '14400000', 10),\n    dlqMaxAttempts: parseInt(process.env.PLUGIN_DLQ_MAX_ATTEMPTS || '3', 10),\n    dlqBackoffBaseMs: parseInt(process.env.PLUGIN_DLQ_BACKOFF_BASE_MS || '300000', 10),\n    dlqMaxSize: parseInt(process.env.PLUGIN_DLQ_MAX_SIZE || '20', 10),\n  };\n}\n\nexport function loadDatabaseConfig(): DatabaseConfig {\n  return {\n    postgres: {\n      host: process.env.DB_HOST || 'postgres',\n      port: parseInt(process.env.DB_PORT || '5432', 10),\n      database: process.env.DATABASE || 'pipeline_builder',\n      user: process.env.DB_USER || 'postgres',\n      password: process.env.DB_PASSWORD || '',\n    },\n    drizzle: {\n      maxPoolSize: parseInt(process.env.DRIZZLE_MAX_POOL_SIZE || '20', 10),\n      idleTimeoutMillis: parseInt(process.env.DRIZZLE_IDLE_TIMEOUT_MILLIS || '30000', 10),\n      connectionTimeoutMillis: parseInt(process.env.DRIZZLE_CONNECTION_TIMEOUT_MILLIS || '10000', 10),\n    },\n  };\n}\n\nexport function loadObservabilityConfig(): ObservabilityConfig {\n  return {\n    logLevel: process.env.LOG_LEVEL || 'info',\n    logFormat: process.env.LOG_FORMAT || 'json',\n    serviceName: process.env.SERVICE_NAME || 'api',\n    tracing: {\n      enabled: process.env.OTEL_TRACING_ENABLED === 'true',\n      endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318/v1/traces',\n    },\n  };\n}\n\nexport function loadComplianceConfig(): ComplianceConfig {\n  return {\n    scanSchedulerIntervalMs: parseInt(process.env.SCAN_SCHEDULER_INTERVAL_MS || '60000', 10),\n    systemOrgScansEnabled: process.env.SYSTEM_ORG_SCANS_ENABLED === 'true',\n    scanLockTtlMs: parseInt(process.env.SCAN_LOCK_TTL_MS || '300000', 10),\n    digestSchedulerIntervalMs: parseInt(process.env.DIGEST_SCHEDULER_INTERVAL_MS || '3600000', 10),\n    digestLockTtlMs: parseInt(process.env.DIGEST_LOCK_TTL_MS || '300000', 10),\n  };\n}\n\n/**\n * Load plugin build configuration. Builds run against a rootless `moby/buildkit`\n * sidecar — see `BUILDKIT_HOST`.\n *\n * Environment variables:\n * - `DOCKER_BUILD_TEMP_ROOT` — Temp directory for build contexts (default: `<cwd>/tmp`)\n * - `DOCKER_BUILD_TIMEOUT_MS` — Build timeout in milliseconds (default: `900000` / 15 min)\n * - `DOCKER_PUSH_TIMEOUT_MS` — Push timeout in milliseconds (default: `300000` / 5 min)\n * - `BUILDKIT_HOST` — buildctl `--addr` value for the buildkitd sidecar\n *   (default: `unix:///run/buildkit/buildkitd.sock`)\n */\nexport function loadDockerConfig(): BuildConfig {\n  return {\n    tempRoot: process.env.DOCKER_BUILD_TEMP_ROOT || path.join(process.cwd(), 'tmp'),\n    timeoutMs: parseInt(process.env.DOCKER_BUILD_TIMEOUT_MS || '900000', 10),\n    pushTimeoutMs: parseInt(process.env.DOCKER_PUSH_TIMEOUT_MS || '300000', 10),\n    buildkitAddr: process.env.BUILDKIT_HOST || 'unix:///run/buildkit/buildkitd.sock',\n  };\n}\n\n/**\n * Load AWS infrastructure configuration from environment variables.\n *\n * Environment variables:\n * - `LAMBDA_RUNTIME` — Lambda runtime (default: `'nodejs24.x'`; unknown values fall back to it)\n * - `LAMBDA_TIMEOUT` — Lambda timeout in seconds (default: `900`)\n * - `LAMBDA_MEMORY_SIZE` — Lambda memory in MB (default: `512`)\n * - `LAMBDA_ARCHITECTURE` — `'x86_64'` or ARM (default: ARM_64)\n * - `LOG_GROUP_NAME` — CloudWatch log group (default: `'/pipeline-builder/logs'`)\n * - `LOG_RETENTION` — Log retention in days (default: `7`)\n * - `LOG_REMOVAL_POLICY` — `'RETAIN'` or destroy (default: DESTROY)\n * - `CODEBUILD_COMPUTE_TYPE` — CodeBuild compute type (default: `'SMALL'`)\n *\n * @returns AWS infrastructure configuration\n */\nexport function loadAWSConfig(): AWSConfig {\n  return {\n    lambda: {\n      runtime: parseRuntime(process.env.LAMBDA_RUNTIME || 'nodejs24.x'),\n      timeout: Duration.seconds(parseInt(process.env.LAMBDA_TIMEOUT || '900', 10)),\n      memorySize: parseInt(process.env.LAMBDA_MEMORY_SIZE || '512', 10),\n      architecture: process.env.LAMBDA_ARCHITECTURE === 'x86_64'\n        ? Architecture.X86_64\n        : Architecture.ARM_64,\n      reservedConcurrentExecutions: process.env.LAMBDA_RESERVED_CONCURRENCY\n        ? parseInt(process.env.LAMBDA_RESERVED_CONCURRENCY, 10)\n        : undefined,\n    },\n\n    logging: {\n      groupName: process.env.LOG_GROUP_NAME || '/pipeline-builder/logs',\n      retention: parseRetention(process.env.LOG_RETENTION || '7'),\n      removalPolicy: process.env.LOG_REMOVAL_POLICY === 'RETAIN'\n        ? RemovalPolicy.RETAIN\n        : RemovalPolicy.DESTROY,\n    },\n\n    codeBuild: {\n      computeType: getComputeType(process.env.CODEBUILD_COMPUTE_TYPE || 'SMALL'),\n      defaultImage: process.env.CODEBUILD_DEFAULT_IMAGE || 'pipeline-bootstrap:1.0',\n    },\n  };\n}\n\n/**\n * Parse Lambda runtime string into a CDK Runtime enum value.\n *\n * @param runtime - Runtime string (e.g. `'nodejs24.x'`)\n * @returns CDK Runtime enum; falls back to NODEJS_24_X for unknown values\n */\nfunction parseRuntime(runtime: string): Runtime {\n  const runtimeMap: Record<string, Runtime> = {\n    'nodejs24.x': Runtime.NODEJS_24_X,\n  };\n  return runtimeMap[runtime] || Runtime.NODEJS_24_X;\n}\n\n/**\n * Parse log retention days string into a CDK RetentionDays enum value.\n * RetentionDays enum values are the numeric day counts themselves,\n * so we parse the string and check if it's a valid enum member.\n *\n * @param days - Retention period in days as a string (e.g. `'30'`)\n * @returns CDK RetentionDays enum; falls back to ONE_DAY for unknown values\n */\nconst VALID_RETENTION_DAYS = new Set(Object.values(RetentionDays).filter((v): v is number => typeof v === 'number'));\n\nfunction parseRetention(days: string): RetentionDays {\n  const parsed = parseInt(days, 10);\n  return VALID_RETENTION_DAYS.has(parsed) ? parsed as RetentionDays : RetentionDays.ONE_DAY;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infrastructure-config.js","sourceRoot":"","sources":["../../src/config/infrastructure-config.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport path from 'path';\nimport type { AWSConfig, BuildConfig, ComplianceConfig, DatabaseConfig, ObservabilityConfig, PluginBuildConfig, RedisConfig, RegistryConfig } from './config-types.js';\n\n/**\n * Load Docker registry configuration from environment variables.\n *\n * Environment variables:\n * - `IMAGE_REGISTRY_HOST` — Registry hostname (default: `'registry'`)\n * - `IMAGE_REGISTRY_PORT` — Registry port (default: `5000`)\n * - `IMAGE_REGISTRY_PULL_HOST` — Host an out-of-cluster client (CodeBuild)\n *   uses to pull plugin images. When unset, derived from `PLATFORM_BASE_URL`'s\n *   host (the public endpoint CodeBuild can resolve), then `IMAGE_REGISTRY_HOST`.\n * - `IMAGE_REGISTRY_PULL_PORT` — Port for the above. When unset, derived from\n *   `PLATFORM_BASE_URL`'s port, then `IMAGE_REGISTRY_PORT`.\n * - `DOCKER_NETWORK` — Docker network for build/push (default: `''`)\n * - `IMAGE_REGISTRY_HTTP` — Use plain HTTP instead of HTTPS (default: `true`,\n *   the in-cluster registry has no TLS).\n *\n * @returns Registry configuration\n */\nexport function loadRegistryConfig(): RegistryConfig {\n  const host = process.env.IMAGE_REGISTRY_HOST || 'registry';\n  const port = parseInt(process.env.IMAGE_REGISTRY_PORT || '5000', 10);\n  // When no explicit pull host is set, derive it from PLATFORM_BASE_URL — the\n  // public platform endpoint an out-of-cluster client (AWS CodeBuild) can\n  // resolve, unlike the in-cluster `registry` ClusterIP. Only falls back to the\n  // in-cluster host when PLATFORM_BASE_URL is unset/unparseable (e.g. local).\n  const platform = parsePlatformBaseUrl(process.env.PLATFORM_BASE_URL);\n  return {\n    host,\n    port,\n    pullHost: process.env.IMAGE_REGISTRY_PULL_HOST || platform?.host || host,\n    pullPort: process.env.IMAGE_REGISTRY_PULL_PORT\n      ? parseInt(process.env.IMAGE_REGISTRY_PULL_PORT, 10)\n      : (platform?.port ?? port),\n    network: process.env.DOCKER_NETWORK || '',\n    http: process.env.IMAGE_REGISTRY_HTTP !== 'false',\n  };\n}\n\n/** Extract host + port from PLATFORM_BASE_URL (e.g. `https://pipeline-builder.com`\n *  → `{ host: 'pipeline-builder.com', port: 443 }`). Returns null when the value\n *  is unset or not a valid URL. Exported so the CLI (pipeline-manager) derives\n *  the registry pull target with the SAME parsing, instead of duplicating it. */\nexport function parsePlatformBaseUrl(raw?: string): { host: string; port: number } | null {\n  if (!raw) return null;\n  try {\n    const u = new URL(raw);\n    // A scheme-less value like `host:8443` parses with a custom protocol and an\n    // EMPTY hostname — reject it so callers fall back rather than derive a\n    // host-less endpoint.\n    if (!u.hostname) return null;\n    const port = u.port ? parseInt(u.port, 10) : (u.protocol === 'https:' ? 443 : 80);\n    return { host: u.hostname, port };\n  } catch {\n    return null;\n  }\n}\n\nexport function loadRedisConfig(): RedisConfig {\n  return {\n    host: process.env.REDIS_HOST || 'localhost',\n    port: parseInt(process.env.REDIS_PORT || '6379', 10),\n  };\n}\n\n/**\n * Load plugin build queue configuration.\n *\n * Environment variables:\n * - `PLUGIN_BUILD_CONCURRENCY` — Max concurrent plugin builds (default: `1`)\n */\nexport function loadPluginBuildConfig(): PluginBuildConfig {\n  return {\n    concurrency: parseInt(process.env.PLUGIN_BUILD_CONCURRENCY || '1', 10),\n    maxAttempts: parseInt(process.env.PLUGIN_BUILD_MAX_ATTEMPTS || '2', 10),\n    backoffDelayMs: parseInt(process.env.PLUGIN_BUILD_BACKOFF_DELAY_MS || '5000', 10),\n    workerTimeoutMs: parseInt(process.env.PLUGIN_BUILD_WORKER_TIMEOUT_MS || '10000', 10),\n    tempDirMaxAgeMs: parseInt(process.env.TEMP_DIR_MAX_AGE_MS || '14400000', 10),\n    dlqMaxAttempts: parseInt(process.env.PLUGIN_DLQ_MAX_ATTEMPTS || '3', 10),\n    dlqBackoffBaseMs: parseInt(process.env.PLUGIN_DLQ_BACKOFF_BASE_MS || '300000', 10),\n    dlqMaxSize: parseInt(process.env.PLUGIN_DLQ_MAX_SIZE || '20', 10),\n  };\n}\n\nexport function loadDatabaseConfig(): DatabaseConfig {\n  return {\n    postgres: {\n      host: process.env.DB_HOST || 'postgres',\n      port: parseInt(process.env.DB_PORT || '5432', 10),\n      database: process.env.DATABASE || 'pipeline_builder',\n      user: process.env.DB_USER || 'postgres',\n      password: process.env.DB_PASSWORD || '',\n    },\n    drizzle: {\n      maxPoolSize: parseInt(process.env.DRIZZLE_MAX_POOL_SIZE || '20', 10),\n      idleTimeoutMillis: parseInt(process.env.DRIZZLE_IDLE_TIMEOUT_MILLIS || '30000', 10),\n      connectionTimeoutMillis: parseInt(process.env.DRIZZLE_CONNECTION_TIMEOUT_MILLIS || '10000', 10),\n    },\n  };\n}\n\nexport function loadObservabilityConfig(): ObservabilityConfig {\n  return {\n    logLevel: process.env.LOG_LEVEL || 'info',\n    logFormat: process.env.LOG_FORMAT || 'json',\n    serviceName: process.env.SERVICE_NAME || 'api',\n    tracing: {\n      enabled: process.env.OTEL_TRACING_ENABLED === 'true',\n      endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318/v1/traces',\n    },\n  };\n}\n\nexport function loadComplianceConfig(): ComplianceConfig {\n  return {\n    scanSchedulerIntervalMs: parseInt(process.env.SCAN_SCHEDULER_INTERVAL_MS || '60000', 10),\n    systemOrgScansEnabled: process.env.SYSTEM_ORG_SCANS_ENABLED === 'true',\n    scanLockTtlMs: parseInt(process.env.SCAN_LOCK_TTL_MS || '300000', 10),\n    digestSchedulerIntervalMs: parseInt(process.env.DIGEST_SCHEDULER_INTERVAL_MS || '3600000', 10),\n    digestLockTtlMs: parseInt(process.env.DIGEST_LOCK_TTL_MS || '300000', 10),\n  };\n}\n\n/**\n * Load plugin build configuration. Builds run against a rootless `moby/buildkit`\n * sidecar — see `BUILDKIT_HOST`.\n *\n * Environment variables:\n * - `DOCKER_BUILD_TEMP_ROOT` — Temp directory for build contexts (default: `<cwd>/tmp`)\n * - `DOCKER_BUILD_TIMEOUT_MS` — Build timeout in milliseconds (default: `900000` / 15 min)\n * - `DOCKER_PUSH_TIMEOUT_MS` — Push timeout in milliseconds (default: `300000` / 5 min)\n * - `BUILDKIT_HOST` — buildctl `--addr` value for the buildkitd sidecar\n *   (default: `unix:///run/buildkit/buildkitd.sock`)\n */\nexport function loadDockerConfig(): BuildConfig {\n  return {\n    tempRoot: process.env.DOCKER_BUILD_TEMP_ROOT || path.join(process.cwd(), 'tmp'),\n    timeoutMs: parseInt(process.env.DOCKER_BUILD_TIMEOUT_MS || '900000', 10),\n    pushTimeoutMs: parseInt(process.env.DOCKER_PUSH_TIMEOUT_MS || '300000', 10),\n    buildkitAddr: process.env.BUILDKIT_HOST || 'unix:///run/buildkit/buildkitd.sock',\n  };\n}\n\n/**\n * Load AWS infrastructure configuration from environment variables.\n *\n * Environment variables:\n * - `LAMBDA_RUNTIME` — Lambda runtime (default: `'nodejs24.x'`; unknown values fall back to it)\n * - `LAMBDA_TIMEOUT` — Lambda timeout in seconds (default: `900`)\n * - `LAMBDA_MEMORY_SIZE` — Lambda memory in MB (default: `512`)\n * - `LAMBDA_ARCHITECTURE` — `'x86_64'` or ARM (default: ARM_64)\n * - `LOG_GROUP_NAME` — CloudWatch log group (default: `'/pipeline-builder/logs'`)\n * - `LOG_RETENTION` — Log retention in days (default: `7`)\n * - `LOG_REMOVAL_POLICY` — `'RETAIN'` or destroy (default: DESTROY)\n * - `CODEBUILD_COMPUTE_TYPE` — CodeBuild compute type (default: `'SMALL'`)\n *\n * @returns AWS infrastructure configuration\n */\nexport function loadAWSConfig(): AWSConfig {\n  return {\n    lambda: {\n      runtime: process.env.LAMBDA_RUNTIME || 'nodejs24.x',\n      timeoutSeconds: parseInt(process.env.LAMBDA_TIMEOUT || '900', 10),\n      memorySize: parseInt(process.env.LAMBDA_MEMORY_SIZE || '512', 10),\n      architecture: process.env.LAMBDA_ARCHITECTURE === 'x86_64' ? 'x86_64' : 'arm64',\n      reservedConcurrentExecutions: process.env.LAMBDA_RESERVED_CONCURRENCY\n        ? parseInt(process.env.LAMBDA_RESERVED_CONCURRENCY, 10)\n        : undefined,\n    },\n\n    logging: {\n      groupName: process.env.LOG_GROUP_NAME || '/pipeline-builder/logs',\n      retentionDays: parseRetentionDays(process.env.LOG_RETENTION || '7'),\n      removalPolicy: process.env.LOG_REMOVAL_POLICY === 'RETAIN' ? 'retain' : 'destroy',\n    },\n\n    codeBuild: {\n      computeType: (process.env.CODEBUILD_COMPUTE_TYPE || 'SMALL').toUpperCase(),\n      defaultImage: process.env.CODEBUILD_DEFAULT_IMAGE || 'pipeline-bootstrap:1.0',\n    },\n  };\n}\n\n/**\n * Valid CloudWatch Logs retention periods, in days. Mirrors the day counts of\n * CDK's `RetentionDays` enum (whose members ARE the day counts), but written out\n * so this module stays free of `aws-cdk-lib`  see the note on {@link AWSConfig}.\n * `0` is CDK's `INFINITE` (never expire).\n */\nconst VALID_RETENTION_DAYS = new Set([\n  0, 1, 3, 5, 7, 14, 30, 60, 90, 120, 150, 180, 365, 400, 545, 731,\n  1096, 1827, 2192, 2557, 2922, 3288, 3653,\n]);\n\n/**\n * Parse a log-retention string into a valid CloudWatch retention day count.\n *\n * @param days - Retention period in days as a string (e.g. `'30'`)\n * @returns the day count; falls back to 1 day for unknown/invalid values\n */\nfunction parseRetentionDays(days: string): number {\n  const parsed = parseInt(days, 10);\n  return VALID_RETENTION_DAYS.has(parsed) ? parsed : 1;\n}\n"]}

package/lib/core/metadata-helpers.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Metadata and string helpers that are FREE of `aws-cdk-lib`.
+ *
+ * Split out of `pipeline-helpers.ts` (which builds CodeBuild steps and therefore
+ * pulls in the CDK) so the main `@pipeline-builder/pipeline-core` entry point can
+ * export them without putting `aws-cdk-lib` on every consumer's import graph.
+ * Anything here that needs a CDK type belongs in `pipeline-helpers.ts` instead.
+ */
+import { type MetaDataType } from './pipeline-types.js';
+/**
+ * Merge multiple metadata objects into one. Later sources override earlier ones.
+ */
+export declare function merge(...sources: Array<Partial<MetaDataType>>): MetaDataType;
+/**
+ * Extract non-namespaced metadata keys as environment variable strings.
+ * Keys starting with 'aws:cdk:' are reserved for CDK construct props
+ * (processed by metadata extraction functions) and are excluded here.
+ *
+ * All values are converted to strings for CodeBuild compatibility.
+ */
+export declare function extractMetadataEnv(metadata: MetaDataType): Record<string, string>;
+/** Resolve the effective failureBehavior: a scan/security-category plugin is pinned
+ *  to 'fail'; otherwise the authored value (default 'fail'). */
+export declare function resolveFailureBehavior(category?: string, authored?: 'fail' | 'warn' | 'ignore'): 'fail' | 'warn' | 'ignore';
+/**
+ * Replaces all characters that are not letters or numbers with the specified value
+ * @param input - The string to process
+ * @param replaceValue - The character(s) to replace non-alphanumeric characters with (default: '_')
+ * @returns The string with non-alphanumeric characters replaced
+ */
+export declare function replaceNonAlphanumeric(input: string, replaceValue?: string): string;