@pipeline-builder/pipeline-core 3.1.1

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

@@ -0,0 +1,213 @@
+import type { QuotaTier } 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
+ */
+export interface AppConfig {
+    readonly server: ServerConfig;
+    readonly auth: AuthConfig;
+    readonly database: DatabaseConfig;
+    readonly registry: RegistryConfig;
+    readonly redis: RedisConfig;
+    readonly pluginBuild: PluginBuildConfig;
+    readonly dockerConfig: BuildConfig;
+    readonly observability: ObservabilityConfig;
+    readonly compliance: ComplianceConfig;
+    readonly aws: AWSConfig;
+    readonly rateLimit: RateLimitConfig;
+    readonly billing: BillingConfig;
+}
+/** Express server configuration. */
+export interface ServerConfig {
+    /** HTTP listen port (env: `PORT`). */
+    readonly port: number;
+    readonly cors: {
+        /** Whether to include credentials in CORS responses (env: `CORS_CREDENTIALS`). */
+        readonly credentials: boolean;
+        /** Allowed origin(s) — single string, array, or `'*'` (env: `CORS_ORIGIN`). */
+        readonly origin: string | string[];
+    };
+    /** Number of reverse proxy hops to trust (env: `TRUST_PROXY`). */
+    readonly trustProxy: number;
+    /** Frontend base URL, used as CORS fallback (env: `PLATFORM_BASE_URL`). */
+    readonly platformUrl: string;
+    readonly httpClient: {
+        /** Default HTTP request timeout in ms (env: `HTTP_CLIENT_TIMEOUT`). */
+        readonly timeout: number;
+        /** Maximum retry attempts for failed requests (env: `HTTP_CLIENT_MAX_RETRIES`). */
+        readonly maxRetries: number;
+        /** Base delay between retries in ms (env: `HTTP_CLIENT_RETRY_DELAY_MS`). */
+        readonly retryDelayMs: number;
+    };
+    readonly sse: {
+        /** Max SSE clients per request (env: `SSE_MAX_CLIENTS_PER_REQUEST`). */
+        readonly maxClientsPerRequest: number;
+        /** SSE client timeout in ms (env: `SSE_CLIENT_TIMEOUT_MS`). */
+        readonly clientTimeoutMs: number;
+        /** SSE cleanup interval in ms (env: `SSE_CLEANUP_INTERVAL_MS`). */
+        readonly cleanupIntervalMs: number;
+    };
+    readonly services: {
+        readonly pluginHost: string;
+        readonly pluginPort: number;
+        readonly pipelineHost: string;
+        readonly pipelinePort: number;
+        readonly messageHost: string;
+        readonly messagePort: number;
+        readonly complianceHost: string;
+        readonly compliancePort: number;
+        readonly billingHost: string;
+        readonly billingPort: number;
+        readonly billingTimeout: number;
+    };
+}
+/** JWT and refresh token authentication configuration. */
+export interface AuthConfig {
+    readonly jwt: {
+        /** Signing secret for access tokens (env: `JWT_SECRET`). */
+        readonly secret: string;
+        /** Token lifetime in seconds (env: `JWT_EXPIRES_IN`). */
+        readonly expiresIn: number;
+        /** Signing algorithm, e.g. `'HS256'` (env: `JWT_ALGORITHM`). */
+        readonly algorithm: Algorithm;
+        /** bcrypt salt rounds for password hashing (env: `JWT_SALT_ROUNDS`). */
+        readonly saltRounds: number;
+    };
+    readonly refreshToken: {
+        /** Signing secret for refresh tokens (env: `REFRESH_TOKEN_SECRET`). */
+        readonly secret: string;
+        /** Token lifetime in seconds (env: `REFRESH_TOKEN_EXPIRES_IN`). */
+        readonly expiresIn: number;
+    };
+}
+/** PostgreSQL and Drizzle ORM database configuration. */
+export interface DatabaseConfig {
+    readonly postgres: {
+        /** PostgreSQL host (env: `DB_HOST`). */
+        readonly host: string;
+        /** PostgreSQL port (env: `DB_PORT`). */
+        readonly port: number;
+        /** Database name (env: `DATABASE`). */
+        readonly database: string;
+        /** Database user (env: `DB_USER`). */
+        readonly user: string;
+        /** Database password (env: `DB_PASSWORD`). */
+        readonly password: string;
+    };
+    readonly drizzle: {
+        /** Maximum connection pool size (env: `DRIZZLE_MAX_POOL_SIZE`). */
+        readonly maxPoolSize: number;
+        /** Idle connection timeout in ms (env: `DRIZZLE_IDLE_TIMEOUT_MILLIS`). */
+        readonly idleTimeoutMillis: number;
+        /** New connection timeout in ms (env: `DRIZZLE_CONNECTION_TIMEOUT_MILLIS`). */
+        readonly connectionTimeoutMillis: number;
+    };
+}
+export interface RegistryConfig {
+    readonly host: string;
+    readonly port: number;
+    readonly user: string;
+    readonly token: string;
+    /** Docker network for build/push (empty string = default). */
+    readonly network: string;
+    /** Use plain HTTP instead of HTTPS (env: `DOCKER_REGISTRY_HTTP`). Defaults to true. */
+    readonly http: boolean;
+    /** Skip TLS certificate verification for self-signed certs (env: `DOCKER_REGISTRY_INSECURE`). Defaults to true. */
+    readonly insecure: boolean;
+}
+export interface RedisConfig {
+    readonly host: string;
+    readonly port: number;
+}
+export interface PluginBuildConfig {
+    readonly concurrency: number;
+    readonly maxAttempts: number;
+    readonly backoffDelayMs: number;
+    readonly workerTimeoutMs: number;
+    readonly tempDirMaxAgeMs: number;
+    readonly dlqMaxAttempts: number;
+    readonly dlqBackoffBaseMs: number;
+    readonly dlqMaxSize: number;
+}
+export interface BuildConfig {
+    /** Build strategy: 'podman' (default), 'docker', or 'kaniko'. */
+    readonly strategy: 'docker' | 'kaniko' | 'podman';
+    /** Root directory for build temp files. */
+    readonly tempRoot: string;
+    /** Build timeout in milliseconds. */
+    readonly timeoutMs: number;
+    /** Push timeout in milliseconds. */
+    readonly pushTimeoutMs: number;
+    /** Path to Kaniko executor binary (only used when strategy=kaniko). */
+    readonly kanikoExecutor: string;
+    /** Kaniko layer cache directory (only used when strategy=kaniko). */
+    readonly kanikoCacheDir: string;
+}
+export interface ObservabilityConfig {
+    readonly logLevel: string;
+    readonly logFormat: string;
+    readonly serviceName: string;
+    readonly tracing: {
+        readonly enabled: boolean;
+        readonly endpoint: string;
+    };
+}
+export interface ComplianceConfig {
+    readonly scanSchedulerIntervalMs: number;
+}
+export interface AWSConfig {
+    readonly lambda: {
+        readonly runtime: Runtime;
+        readonly timeout: Duration;
+        readonly memorySize: number;
+        readonly architecture: Architecture;
+        readonly reservedConcurrentExecutions?: number;
+    };
+    readonly logging: {
+        readonly groupName: string;
+        readonly retention: RetentionDays;
+        readonly removalPolicy: RemovalPolicy;
+    };
+    readonly codeBuild: {
+        readonly computeType: ComputeType;
+    };
+    /** When true, resolve synth plugin via custom resource Lambda at deploy time.
+     *  When false (default), use fallback synth commands (pipeline-manager synth). */
+    readonly resolvedSynthPlugin: boolean;
+}
+/** Express rate limiting configuration. */
+export interface RateLimitConfig {
+    /** Maximum requests per window (env: `LIMITER_MAX`). */
+    readonly max: number;
+    /** Rate limit window in milliseconds (env: `LIMITER_WINDOWMS`). */
+    readonly windowMs: number;
+    /** Include legacy `X-RateLimit-*` headers. */
+    readonly legacyHeaders: boolean;
+    /** Include standard `RateLimit-*` headers (RFC 6585). */
+    readonly standardHeaders: boolean;
+}
+/** Price configuration for a single billing plan (in cents). */
+export interface BillingPlanPrices {
+    readonly monthly: number;
+    readonly annual: number;
+}
+/** Full billing plan definition used for seeding and runtime configuration. */
+export interface BillingPlanConfig {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly tier: QuotaTier;
+    readonly prices: BillingPlanPrices;
+    readonly features: readonly string[];
+    readonly isActive: boolean;
+    readonly isDefault: boolean;
+    readonly sortOrder: number;
+}
+/** Billing plans configuration. */
+export interface BillingConfig {
+    readonly plans: readonly BillingPlanConfig[];
+}

package/lib/config/config-types.js

@@ -0,0 +1,5 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+//# 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 } 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 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: `JWT_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  readonly user: string;\n  readonly token: string;\n  /** Docker network for build/push (empty string = default). */\n  readonly network: string;\n  /** Use plain HTTP instead of HTTPS (env: `DOCKER_REGISTRY_HTTP`). Defaults to true. */\n  readonly http: boolean;\n  /** Skip TLS certificate verification for self-signed certs (env: `DOCKER_REGISTRY_INSECURE`). Defaults to true. */\n  readonly insecure: 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  /** Build strategy: 'podman' (default), 'docker', or 'kaniko'. */\n  readonly strategy: 'docker' | 'kaniko' | 'podman';\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  /** Path to Kaniko executor binary (only used when strategy=kaniko). */\n  readonly kanikoExecutor: string;\n  /** Kaniko layer cache directory (only used when strategy=kaniko). */\n  readonly kanikoCacheDir: 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}\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  /** When true, resolve synth plugin via custom resource Lambda at deploy time.\n   *  When false (default), use fallback synth commands (pipeline-manager synth). */\n  readonly resolvedSynthPlugin: boolean;\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/** Billing plans configuration. */\nexport interface BillingConfig {\n  readonly plans: readonly BillingPlanConfig[];\n}\n"]}

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

@@ -0,0 +1,55 @@
+import type { AWSConfig, BuildConfig, ComplianceConfig, DatabaseConfig, ObservabilityConfig, PluginBuildConfig, RedisConfig, RegistryConfig } from './config-types';
+/**
+ * Load Docker registry configuration from environment variables.
+ *
+ * Environment variables:
+ * - `IMAGE_REGISTRY_HOST` — Registry hostname (default: `'registry'`)
+ * - `IMAGE_REGISTRY_PORT` — Registry port (default: `5000`)
+ * - `IMAGE_REGISTRY_USER` — Registry username (default: `'admin'`)
+ * - `IMAGE_REGISTRY_TOKEN` — Registry auth token (default: `'password'`)
+ * - `DOCKER_NETWORK` — Docker network for build/push (default: `''`)
+ * - `DOCKER_REGISTRY_HTTP` — Use plain HTTP (default: `true`). Set `false` for HTTPS.
+ * - `DOCKER_REGISTRY_INSECURE` — Skip TLS verification (default: `true`). Set `false` for production.
+ *
+ * @returns Registry configuration
+ */
+export declare function loadRegistryConfig(): RegistryConfig;
+export declare function loadRedisConfig(): RedisConfig;
+/**
+ * Load plugin build queue configuration.
+ *
+ * Environment variables:
+ * - `PLUGIN_BUILD_CONCURRENCY` — Max concurrent plugin builds (default: `1`)
+ */
+export declare function loadPluginBuildConfig(): PluginBuildConfig;
+export declare function loadDatabaseConfig(): DatabaseConfig;
+export declare function loadObservabilityConfig(): ObservabilityConfig;
+export declare function loadComplianceConfig(): ComplianceConfig;
+/**
+ * Load Docker/Podman/Kaniko build configuration.
+ *
+ * Environment variables:
+ * - `DOCKER_BUILD_STRATEGY` — Build strategy: `podman`, `docker`, or `kaniko` (default: `podman`)
+ * - `DOCKER_BUILD_TEMP_ROOT` — Temp directory for build contexts (default: `<cwd>/tmp`)
+ * - `DOCKER_BUILD_TIMEOUT_MS` — Build timeout in milliseconds (default: `900000` / 15 min)
+ * - `DOCKER_PUSH_TIMEOUT_MS` — Push timeout in milliseconds (default: `300000` / 5 min)
+ * - `KANIKO_EXECUTOR_PATH` — Path to Kaniko executor binary (default: `/kaniko/executor`)
+ * - `KANIKO_CACHE_DIR` — Kaniko layer cache directory (default: `/kaniko/cache`)
+ */
+export declare function loadDockerConfig(): BuildConfig;
+/**
+ * Load AWS infrastructure configuration from environment variables.
+ *
+ * Environment variables:
+ * - `LAMBDA_RUNTIME` — Lambda runtime (default: `'nodejs24.x'`; supports nodejs22.x, nodejs24.x)
+ * - `LAMBDA_TIMEOUT` — Lambda timeout in seconds (default: `900`)
+ * - `LAMBDA_MEMORY_SIZE` — Lambda memory in MB (default: `128`)
+ * - `LAMBDA_ARCHITECTURE` — `'x86_64'` or ARM (default: ARM_64)
+ * - `LOG_GROUP_NAME` — CloudWatch log group (default: `'/pipeline-builder/logs'`)
+ * - `LOG_RETENTION` — Log retention in days (default: `7`)
+ * - `LOG_REMOVAL_POLICY` — `'RETAIN'` or destroy (default: DESTROY)
+ * - `CODEBUILD_COMPUTE_TYPE` — CodeBuild compute type (default: `'SMALL'`)
+ *
+ * @returns AWS infrastructure configuration
+ */
+export declare function loadAWSConfig(): AWSConfig;

package/lib/config/infrastructure-config.js

@@ -0,0 +1,200 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRegistryConfig = loadRegistryConfig;
+exports.loadRedisConfig = loadRedisConfig;
+exports.loadPluginBuildConfig = loadPluginBuildConfig;
+exports.loadDatabaseConfig = loadDatabaseConfig;
+exports.loadObservabilityConfig = loadObservabilityConfig;
+exports.loadComplianceConfig = loadComplianceConfig;
+exports.loadDockerConfig = loadDockerConfig;
+exports.loadAWSConfig = loadAWSConfig;
+const path_1 = __importDefault(require("path"));
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const pipeline_helpers_1 = require("../core/pipeline-helpers");
+function requireInProduction(envVar, devDefault) {
+    const value = process.env[envVar];
+    if (value)
+        return value;
+    if (process.env.NODE_ENV === 'production') {
+        throw new Error(`${envVar} is required in production`);
+    }
+    return devDefault;
+}
+/**
+ * Load Docker registry configuration from environment variables.
+ *
+ * Environment variables:
+ * - `IMAGE_REGISTRY_HOST` — Registry hostname (default: `'registry'`)
+ * - `IMAGE_REGISTRY_PORT` — Registry port (default: `5000`)
+ * - `IMAGE_REGISTRY_USER` — Registry username (default: `'admin'`)
+ * - `IMAGE_REGISTRY_TOKEN` — Registry auth token (default: `'password'`)
+ * - `DOCKER_NETWORK` — Docker network for build/push (default: `''`)
+ * - `DOCKER_REGISTRY_HTTP` — Use plain HTTP (default: `true`). Set `false` for HTTPS.
+ * - `DOCKER_REGISTRY_INSECURE` — Skip TLS verification (default: `true`). Set `false` for production.
+ *
+ * @returns Registry configuration
+ */
+function loadRegistryConfig() {
+    return {
+        host: process.env.IMAGE_REGISTRY_HOST || 'registry',
+        port: parseInt(process.env.IMAGE_REGISTRY_PORT || '5000', 10),
+        user: requireInProduction('IMAGE_REGISTRY_USER', 'admin'),
+        token: requireInProduction('IMAGE_REGISTRY_TOKEN', 'password'),
+        network: process.env.DOCKER_NETWORK || '',
+        http: process.env.DOCKER_REGISTRY_HTTP !== 'false',
+        insecure: process.env.DOCKER_REGISTRY_INSECURE !== 'false',
+    };
+}
+function loadRedisConfig() {
+    return {
+        host: process.env.REDIS_HOST || 'localhost',
+        port: parseInt(process.env.REDIS_PORT || '6379', 10),
+    };
+}
+/**
+ * Load plugin build queue configuration.
+ *
+ * Environment variables:
+ * - `PLUGIN_BUILD_CONCURRENCY` — Max concurrent plugin builds (default: `1`)
+ */
+function loadPluginBuildConfig() {
+    return {
+        concurrency: parseInt(process.env.PLUGIN_BUILD_CONCURRENCY || '1', 10),
+        maxAttempts: parseInt(process.env.PLUGIN_BUILD_MAX_ATTEMPTS || '2', 10),
+        backoffDelayMs: parseInt(process.env.PLUGIN_BUILD_BACKOFF_DELAY_MS || '5000', 10),
+        workerTimeoutMs: parseInt(process.env.PLUGIN_BUILD_WORKER_TIMEOUT_MS || '10000', 10),
+        tempDirMaxAgeMs: parseInt(process.env.TEMP_DIR_MAX_AGE_MS || '14400000', 10),
+        dlqMaxAttempts: parseInt(process.env.PLUGIN_DLQ_MAX_ATTEMPTS || '3', 10),
+        dlqBackoffBaseMs: parseInt(process.env.PLUGIN_DLQ_BACKOFF_BASE_MS || '300000', 10),
+        dlqMaxSize: parseInt(process.env.PLUGIN_DLQ_MAX_SIZE || '20', 10),
+    };
+}
+function loadDatabaseConfig() {
+    return {
+        postgres: {
+            host: process.env.DB_HOST || 'postgres',
+            port: parseInt(process.env.DB_PORT || '5432', 10),
+            database: process.env.DATABASE || 'pipeline_builder',
+            user: process.env.DB_USER || 'postgres',
+            password: process.env.DB_PASSWORD || '',
+        },
+        drizzle: {
+            maxPoolSize: parseInt(process.env.DRIZZLE_MAX_POOL_SIZE || '20', 10),
+            idleTimeoutMillis: parseInt(process.env.DRIZZLE_IDLE_TIMEOUT_MILLIS || '30000', 10),
+            connectionTimeoutMillis: parseInt(process.env.DRIZZLE_CONNECTION_TIMEOUT_MILLIS || '10000', 10),
+        },
+    };
+}
+function loadObservabilityConfig() {
+    return {
+        logLevel: process.env.LOG_LEVEL || 'info',
+        logFormat: process.env.LOG_FORMAT || 'json',
+        serviceName: process.env.SERVICE_NAME || 'api',
+        tracing: {
+            enabled: process.env.OTEL_TRACING_ENABLED === 'true',
+            endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318/v1/traces',
+        },
+    };
+}
+function loadComplianceConfig() {
+    return {
+        scanSchedulerIntervalMs: parseInt(process.env.SCAN_SCHEDULER_INTERVAL_MS || '60000', 10),
+    };
+}
+/**
+ * Load Docker/Podman/Kaniko build configuration.
+ *
+ * Environment variables:
+ * - `DOCKER_BUILD_STRATEGY` — Build strategy: `podman`, `docker`, or `kaniko` (default: `podman`)
+ * - `DOCKER_BUILD_TEMP_ROOT` — Temp directory for build contexts (default: `<cwd>/tmp`)
+ * - `DOCKER_BUILD_TIMEOUT_MS` — Build timeout in milliseconds (default: `900000` / 15 min)
+ * - `DOCKER_PUSH_TIMEOUT_MS` — Push timeout in milliseconds (default: `300000` / 5 min)
+ * - `KANIKO_EXECUTOR_PATH` — Path to Kaniko executor binary (default: `/kaniko/executor`)
+ * - `KANIKO_CACHE_DIR` — Kaniko layer cache directory (default: `/kaniko/cache`)
+ */
+function loadDockerConfig() {
+    const validStrategies = new Set(['docker', 'kaniko', 'podman']);
+    const strategyEnv = (process.env.DOCKER_BUILD_STRATEGY || '').toLowerCase();
+    return {
+        strategy: validStrategies.has(strategyEnv) ? strategyEnv : 'docker',
+        tempRoot: process.env.DOCKER_BUILD_TEMP_ROOT || path_1.default.join(process.cwd(), 'tmp'),
+        timeoutMs: parseInt(process.env.DOCKER_BUILD_TIMEOUT_MS || '900000', 10),
+        pushTimeoutMs: parseInt(process.env.DOCKER_PUSH_TIMEOUT_MS || '300000', 10),
+        kanikoExecutor: process.env.KANIKO_EXECUTOR_PATH || '/kaniko/executor',
+        kanikoCacheDir: process.env.KANIKO_CACHE_DIR || '/kaniko/cache',
+    };
+}
+/**
+ * Load AWS infrastructure configuration from environment variables.
+ *
+ * Environment variables:
+ * - `LAMBDA_RUNTIME` — Lambda runtime (default: `'nodejs24.x'`; supports nodejs22.x, nodejs24.x)
+ * - `LAMBDA_TIMEOUT` — Lambda timeout in seconds (default: `900`)
+ * - `LAMBDA_MEMORY_SIZE` — Lambda memory in MB (default: `128`)
+ * - `LAMBDA_ARCHITECTURE` — `'x86_64'` or ARM (default: ARM_64)
+ * - `LOG_GROUP_NAME` — CloudWatch log group (default: `'/pipeline-builder/logs'`)
+ * - `LOG_RETENTION` — Log retention in days (default: `7`)
+ * - `LOG_REMOVAL_POLICY` — `'RETAIN'` or destroy (default: DESTROY)
+ * - `CODEBUILD_COMPUTE_TYPE` — CodeBuild compute type (default: `'SMALL'`)
+ *
+ * @returns AWS infrastructure configuration
+ */
+function loadAWSConfig() {
+    return {
+        lambda: {
+            runtime: parseRuntime(process.env.LAMBDA_RUNTIME || 'nodejs24.x'),
+            timeout: aws_cdk_lib_1.Duration.seconds(parseInt(process.env.LAMBDA_TIMEOUT || '900', 10)),
+            memorySize: parseInt(process.env.LAMBDA_MEMORY_SIZE || '512', 10),
+            architecture: process.env.LAMBDA_ARCHITECTURE === 'x86_64'
+                ? aws_lambda_1.Architecture.X86_64
+                : aws_lambda_1.Architecture.ARM_64,
+            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'
+                ? aws_cdk_lib_1.RemovalPolicy.RETAIN
+                : aws_cdk_lib_1.RemovalPolicy.DESTROY,
+        },
+        codeBuild: {
+            computeType: (0, pipeline_helpers_1.getComputeType)(process.env.CODEBUILD_COMPUTE_TYPE || 'SMALL'),
+        },
+        resolvedSynthPlugin: process.env.RESOLVED_SYNTH_PLUGIN === 'true',
+    };
+}
+/**
+ * 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
+ */
+function parseRuntime(runtime) {
+    const runtimeMap = {
+        'nodejs24.x': aws_lambda_1.Runtime.NODEJS_24_X,
+    };
+    return runtimeMap[runtime] || aws_lambda_1.Runtime.NODEJS_24_X;
+}
+/**
+ * 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.
+ *
+ * @param days - Retention period in days as a string (e.g. `'30'`)
+ * @returns CDK RetentionDays enum; falls back to ONE_DAY for unknown values
+ */
+const VALID_RETENTION_DAYS = new Set(Object.values(aws_logs_1.RetentionDays).filter((v) => typeof v === 'number'));
+function parseRetention(days) {
+    const parsed = parseInt(days, 10);
+    return VALID_RETENTION_DAYS.has(parsed) ? parsed : aws_logs_1.RetentionDays.ONE_DAY;
+}
+//# 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 { 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';\nimport { getComputeType } from '../core/pipeline-helpers';\n\nfunction requireInProduction(envVar: string, devDefault: string): string {\n  const value = process.env[envVar];\n  if (value) return value;\n  if (process.env.NODE_ENV === 'production') {\n    throw new Error(`${envVar} is required in production`);\n  }\n  return devDefault;\n}\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_USER` — Registry username (default: `'admin'`)\n * - `IMAGE_REGISTRY_TOKEN` — Registry auth token (default: `'password'`)\n * - `DOCKER_NETWORK` — Docker network for build/push (default: `''`)\n * - `DOCKER_REGISTRY_HTTP` — Use plain HTTP (default: `true`). Set `false` for HTTPS.\n * - `DOCKER_REGISTRY_INSECURE` — Skip TLS verification (default: `true`). Set `false` for production.\n *\n * @returns Registry configuration\n */\nexport function loadRegistryConfig(): RegistryConfig {\n  return {\n    host: process.env.IMAGE_REGISTRY_HOST || 'registry',\n    port: parseInt(process.env.IMAGE_REGISTRY_PORT || '5000', 10),\n    user: requireInProduction('IMAGE_REGISTRY_USER', 'admin'),\n    token: requireInProduction('IMAGE_REGISTRY_TOKEN', 'password'),\n    network: process.env.DOCKER_NETWORK || '',\n    http: process.env.DOCKER_REGISTRY_HTTP !== 'false',\n    insecure: process.env.DOCKER_REGISTRY_INSECURE !== 'false',\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  };\n}\n\n/**\n * Load Docker/Podman/Kaniko build configuration.\n *\n * Environment variables:\n * - `DOCKER_BUILD_STRATEGY` — Build strategy: `podman`, `docker`, or `kaniko` (default: `podman`)\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 * - `KANIKO_EXECUTOR_PATH` — Path to Kaniko executor binary (default: `/kaniko/executor`)\n * - `KANIKO_CACHE_DIR` — Kaniko layer cache directory (default: `/kaniko/cache`)\n */\nexport function loadDockerConfig(): BuildConfig {\n  const validStrategies = new Set(['docker', 'kaniko', 'podman']);\n  const strategyEnv = (process.env.DOCKER_BUILD_STRATEGY || '').toLowerCase();\n  return {\n    strategy: validStrategies.has(strategyEnv) ? strategyEnv as BuildConfig['strategy'] : 'docker',\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    kanikoExecutor: process.env.KANIKO_EXECUTOR_PATH || '/kaniko/executor',\n    kanikoCacheDir: process.env.KANIKO_CACHE_DIR || '/kaniko/cache',\n  };\n}\n\n/**\n * Load AWS infrastructure configuration from environment variables.\n *\n * Environment variables:\n * - `LAMBDA_RUNTIME` — Lambda runtime (default: `'nodejs24.x'`; supports nodejs22.x, nodejs24.x)\n * - `LAMBDA_TIMEOUT` — Lambda timeout in seconds (default: `900`)\n * - `LAMBDA_MEMORY_SIZE` — Lambda memory in MB (default: `128`)\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    },\n\n    resolvedSynthPlugin: process.env.RESOLVED_SYNTH_PLUGIN === 'true',\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"]}

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

@@ -0,0 +1,53 @@
+import type { ServerConfig, AuthConfig, RateLimitConfig } from './config-types';
+/**
+ * Load server configuration from environment variables.
+ *
+ * Environment variables:
+ * - `PORT` — HTTP listen port (default: `3000`)
+ * - `CORS_ORIGIN` — Comma-separated allowed origins (default: `PLATFORM_BASE_URL`)
+ * - `CORS_CREDENTIALS` — Allow credentials; set to `'false'` to disable (default: `true`)
+ * - `TRUST_PROXY` — Express trust proxy hops (default: `1`)
+ * - `PLATFORM_BASE_URL` — Frontend URL used as CORS fallback (default: `'https://localhost:8443'`)
+ *
+ * @returns Server configuration with port, CORS, trust proxy, and platform URL
+ */
+export declare function loadServerConfig(): ServerConfig;
+/**
+ * Load authentication configuration from environment variables.
+ *
+ * Environment variables:
+ * - `JWT_SECRET` — **Required.** Secret key for signing JWTs
+ * - `REFRESH_TOKEN_SECRET` — **Required.** Secret key for signing refresh tokens
+ * - `JWT_EXPIRES_IN` — JWT lifetime in seconds (default: `7200` = 2 hours)
+ * - `JWT_ALGORITHM` — JWT signing algorithm (default: `'HS256'`)
+ * - `JWT_SALT_ROUNDS` — bcrypt salt rounds for password hashing (default: `12`)
+ * - `REFRESH_TOKEN_EXPIRES_IN` — Refresh token lifetime in seconds (default: `2592000` = 30 days)
+ *
+ * @returns Authentication configuration with safe defaults (empty strings when env vars are unset).
+ * Call {@link validateAuthConfig} at server startup to enforce required secrets.
+ */
+export declare function loadAuthConfig(): AuthConfig;
+/**
+ * Load rate limiting configuration from environment variables.
+ *
+ * Environment variables:
+ * - `LIMITER_MAX` — Max requests per window (default: `100`)
+ * - `LIMITER_WINDOWMS` — Rate limit window in ms (default: `900000` = 15 minutes)
+ *
+ * @returns Rate limit configuration
+ */
+export declare function loadRateLimitConfig(): RateLimitConfig;
+/**
+ * Validate server configuration and log warnings for insecure settings.
+ *
+ * @param config - Server configuration to validate
+ */
+export declare function validateServerConfig(config: ServerConfig): void;
+/**
+ * Validate authentication configuration (JWT secrets, algorithms, expiration).
+ * Call this at server startup, not during CDK synthesis.
+ *
+ * @param config - Auth configuration to validate
+ * @throws {Error} If secrets are insecure, too short (<32 chars), or use disallowed algorithms
+ */
+export declare function validateAuthConfig(config: AuthConfig): void;