@pipeline-builder/pipeline-core 3.1.1

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,32 @@
+# @pipeline-builder/pipeline-core
+
+📖 **[View documentation](https://mwashburn160.github.io/pipeline-builder/)**
+
+AWS CDK construct library for [Pipeline Builder](https://mwashburn160.github.io/pipeline-builder/): the `Builder` construct that assembles plugin specs into a CodePipeline stack, the `PluginLookup` custom resource that resolves plugins at deploy time, pipeline/plugin domain types, and shared application configuration. Also re-exports `pipeline-data` so consumers only depend on one package.
+
+## Key Exports
+
+### CDK Constructs
+- `Builder` — Composable CodePipeline builder construct
+- `PluginLookup` — Custom resource + Lambda that resolves plugin specs at deploy time
+
+### Pipeline Types
+- `Pipeline`, `Plugin`, `PipelineFilter`, `PluginFilter`
+- `AccessModifier`, `ComputeType`, `PluginType`, `MetaDataType`
+
+### Configuration
+- `Config` — Application config loader
+- `CoreConstants` — Shared timeouts, cache keys, compression thresholds
+- `getConnection`, `db`, `schema` — Re-exported from `pipeline-data`
+
+### Helpers
+- `replaceNonAlphanumeric`, `extractMetadataEnv` — String utilities
+- `buildPipelineConditions`, `buildPluginConditions`, `validatePipelineFilter` — Filter builders
+
+## License
+
+Apache-2.0. See [LICENSE](./LICENSE).
+
+---
+
+**Keywords:** aws, codepipeline, codebuild, cicd, ci-cd, devops, cdk, aws-cdk, cloudformation, pipeline, pipeline-as-code, containerized, docker, kubernetes, plugins, typescript, self-service, multi-tenant, compliance, automation, infrastructure-as-code, iac, cli

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

@@ -0,0 +1,81 @@
+import type { Algorithm } from 'jsonwebtoken';
+import type { AppConfig } from './config-types';
+/**
+ * Core constants — configurable via environment variables with sensible defaults.
+ */
+export declare class CoreConstants {
+    static readonly NAME_PATTERN: RegExp;
+    static readonly ALLOWED_JWT_ALGORITHMS: Algorithm[];
+    static readonly HANDLER_TIMEOUT_MS: number;
+    /** Default platform URL fallback when PLATFORM_BASE_URL is not set. */
+    static readonly DEFAULT_PLATFORM_URL = "https://localhost:8443";
+    static readonly HANDLER_DEFAULT_BASE_URL: string;
+    static readonly HANDLER_MAX_RETRIES: number;
+    static readonly HANDLER_RETRY_DELAY_MS: number;
+    static readonly PLUGIN_IMAGE_PREFIX: string;
+    static readonly PLUGIN_BUILD_QUEUE_NAME: string;
+    static readonly PLUGIN_BUILD_MAX_ATTEMPTS: number;
+    static readonly PLUGIN_BUILD_BACKOFF_DELAY_MS: number;
+    static readonly PLUGIN_BUILD_COMPLETED_RETENTION_SECS: number;
+    static readonly PLUGIN_BUILD_FAILED_RETENTION_SECS: number;
+    static readonly PLUGIN_BUILD_WORKER_TIMEOUT_MS: number;
+    static readonly MAX_PAGE_LIMIT: number;
+    static readonly DEFAULT_PAGE_LIMIT: number;
+    static readonly MAX_PROMPT_LENGTH: number;
+    static readonly PLUGIN_MAX_UPLOAD_MB: number;
+    static readonly PIPELINE_NAME_MAX_LENGTH: number;
+    static readonly DEFAULT_PLUGIN_VERSION: string;
+    static readonly SSE_STREAM_TIMEOUT_MS: number;
+    static readonly GITHUB_API_BASE_URL: string;
+    static readonly BITBUCKET_API_BASE_URL: string;
+    static readonly MAX_BULK_ITEMS: number;
+    static readonly MAX_EVENTS_PER_BATCH: number;
+    static readonly DEFAULT_REPORT_RANGE_DAYS: number;
+    static readonly SECRETS_PATH_PREFIX: string;
+    /** Build a Secrets Manager path: {prefix}/{orgId}/{name} */
+    static secretPath(orgId: string, name: string): string;
+    static readonly DB_MAX_RETRIES: number;
+    static readonly DB_RETRY_DELAY_MS: number;
+    static readonly DB_TRANSACTION_TIMEOUT_MS: number;
+    static readonly DB_CLOSE_TIMEOUT_MS: number;
+    static readonly COMPRESSION_THRESHOLD_BYTES: number;
+    static readonly IDEMPOTENCY_TTL_MS: number;
+    static readonly IDEMPOTENCY_MAX_STORE_SIZE: number;
+    static readonly IDEMPOTENCY_CLEANUP_INTERVAL_MS: number;
+    static readonly CACHE_CLEANUP_INTERVAL_MS: number;
+    static readonly CACHE_TTL_ENTITY: number;
+    static readonly CACHE_TTL_MESSAGE: number;
+    static readonly CACHE_TTL_REPORT_INVENTORY: number;
+    static readonly CACHE_TTL_REPORT_TIMESERIES: number;
+    static readonly CACHE_TTL_COMPLIANCE_RULES: number;
+    static readonly CACHE_TTL_BILLING_PLANS: number;
+    static readonly SSE_BACKPRESSURE_THRESHOLD: number;
+    static readonly CACHE_CONTROL_LIST: string;
+    static readonly CACHE_CONTROL_DETAIL: string;
+}
+/**
+ * Configuration facade with lazy per-section loading.
+ *
+ * Each section is loaded and validated independently on first access,
+ * so requesting `Config.get('aws')` does not trigger loading of
+ * server, auth, or billing config (and their env var requirements).
+ *
+ * Usage: `Config.get('server')`, `Config.get('auth')`, etc.
+ */
+export declare class Config {
+    private static cache;
+    /**
+     * Get a specific configuration section (loaded lazily on first access).
+     */
+    static get<K extends keyof AppConfig>(section: K): AppConfig[K];
+    /**
+     * Validate auth configuration (JWT secrets, algorithms, expiration).
+     * Call this at server startup, not during CDK synthesis.
+     */
+    static validateAuth(): void;
+    /**
+     * Untyped config access — use when the published package types don't include a new section yet.
+     * Avoids the `(Config as unknown as ...).get(...)` cast pattern in consumers.
+     */
+    static getAny(section: string): unknown;
+}

package/lib/config/app-config.js

@@ -0,0 +1,151 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.CoreConstants = void 0;
+const billing_config_1 = require("./billing-config");
+const infrastructure_config_1 = require("./infrastructure-config");
+const server_config_1 = require("./server-config");
+/**
+ * Core constants — configurable via environment variables with sensible defaults.
+ */
+class CoreConstants {
+    static NAME_PATTERN = /^[a-z0-9-]+$/;
+    // Supported JWT algorithms
+    static ALLOWED_JWT_ALGORITHMS = ['HS256', 'RS256', 'ES256'];
+    // Custom Resource Handler configuration (must be less than Lambda timeout of 30s to allow response handling)
+    static HANDLER_TIMEOUT_MS = parseInt(process.env.HANDLER_TIMEOUT_MS || '25000', 10); // 25s
+    /** Default platform URL fallback when PLATFORM_BASE_URL is not set. */
+    static DEFAULT_PLATFORM_URL = 'https://localhost:8443';
+    static HANDLER_DEFAULT_BASE_URL = process.env.PLATFORM_BASE_URL || CoreConstants.DEFAULT_PLATFORM_URL;
+    static HANDLER_MAX_RETRIES = parseInt(process.env.HANDLER_MAX_RETRIES || '2', 10);
+    static HANDLER_RETRY_DELAY_MS = parseInt(process.env.HANDLER_RETRY_DELAY_MS || '1000', 10); // 1s
+    // Plugin image configuration
+    static PLUGIN_IMAGE_PREFIX = process.env.PLUGIN_IMAGE_PREFIX || 'p-';
+    // Plugin build queue configuration
+    static PLUGIN_BUILD_QUEUE_NAME = process.env.PLUGIN_BUILD_QUEUE_NAME || 'plugin-build';
+    static PLUGIN_BUILD_MAX_ATTEMPTS = parseInt(process.env.PLUGIN_BUILD_MAX_ATTEMPTS || '2', 10);
+    static PLUGIN_BUILD_BACKOFF_DELAY_MS = parseInt(process.env.PLUGIN_BUILD_BACKOFF_DELAY_MS || '5000', 10); // 5s
+    static PLUGIN_BUILD_COMPLETED_RETENTION_SECS = parseInt(process.env.PLUGIN_BUILD_COMPLETED_RETENTION_SECS || '3600', 10); // 1 hr
+    static PLUGIN_BUILD_FAILED_RETENTION_SECS = parseInt(process.env.PLUGIN_BUILD_FAILED_RETENTION_SECS || '86400', 10); // 24 hr
+    static PLUGIN_BUILD_WORKER_TIMEOUT_MS = parseInt(process.env.PLUGIN_BUILD_WORKER_TIMEOUT_MS || '10000', 10); // 10s
+    // Pagination and limits
+    static MAX_PAGE_LIMIT = parseInt(process.env.MAX_PAGE_LIMIT || '1000', 10);
+    static DEFAULT_PAGE_LIMIT = parseInt(process.env.DEFAULT_PAGE_LIMIT || '100', 10);
+    static MAX_PROMPT_LENGTH = parseInt(process.env.MAX_PROMPT_LENGTH || '5000', 10);
+    static PLUGIN_MAX_UPLOAD_MB = parseInt(process.env.PLUGIN_MAX_UPLOAD_MB || '4096', 10);
+    static PIPELINE_NAME_MAX_LENGTH = parseInt(process.env.PIPELINE_NAME_MAX_LENGTH || '100', 10);
+    static DEFAULT_PLUGIN_VERSION = process.env.DEFAULT_PLUGIN_VERSION || '1.0.0';
+    // SSE stream timeout for AI generation endpoints
+    static SSE_STREAM_TIMEOUT_MS = parseInt(process.env.SSE_STREAM_TIMEOUT_MS || '300000', 10); // 5 min
+    // Git provider API base URLs (configurable for enterprise instances)
+    static GITHUB_API_BASE_URL = process.env.GITHUB_API_BASE_URL || 'https://api.github.com';
+    static BITBUCKET_API_BASE_URL = process.env.BITBUCKET_API_BASE_URL || 'https://api.bitbucket.org/2.0';
+    // Bulk operations and event ingestion
+    static MAX_BULK_ITEMS = parseInt(process.env.MAX_BULK_ITEMS || '100', 10);
+    static MAX_EVENTS_PER_BATCH = parseInt(process.env.MAX_EVENTS_PER_BATCH || '100', 10);
+    static DEFAULT_REPORT_RANGE_DAYS = parseInt(process.env.DEFAULT_REPORT_RANGE_DAYS || '30', 10);
+    // Secrets Manager path prefix for org-scoped secrets
+    static SECRETS_PATH_PREFIX = process.env.SECRETS_PATH_PREFIX || 'pipeline-builder';
+    /** Build a Secrets Manager path: {prefix}/{orgId}/{name} */
+    static secretPath(orgId, name) {
+        return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/${name}`;
+    }
+    // Database connection
+    static DB_MAX_RETRIES = parseInt(process.env.DB_MAX_RETRIES || '3', 10);
+    static DB_RETRY_DELAY_MS = parseInt(process.env.DB_RETRY_DELAY_MS || '1000', 10); // 1s
+    static DB_TRANSACTION_TIMEOUT_MS = parseInt(process.env.DB_TRANSACTION_TIMEOUT_MS || '30000', 10); // 30s
+    static DB_CLOSE_TIMEOUT_MS = parseInt(process.env.DB_CLOSE_TIMEOUT_MS || '5000', 10); // 5s
+    // Response compression
+    static COMPRESSION_THRESHOLD_BYTES = parseInt(process.env.COMPRESSION_THRESHOLD_BYTES || '1024', 10);
+    // Idempotency
+    static IDEMPOTENCY_TTL_MS = parseInt(process.env.IDEMPOTENCY_TTL_MS || '300000', 10); // 5 min
+    static IDEMPOTENCY_MAX_STORE_SIZE = parseInt(process.env.IDEMPOTENCY_MAX_STORE_SIZE || '10000', 10);
+    static IDEMPOTENCY_CLEANUP_INTERVAL_MS = parseInt(process.env.IDEMPOTENCY_CLEANUP_INTERVAL_MS || '60000', 10); // 1 min
+    // Cache
+    static CACHE_CLEANUP_INTERVAL_MS = parseInt(process.env.CACHE_CLEANUP_INTERVAL_MS || '30000', 10); // 30s
+    // Server-side cache TTLs (seconds)
+    static CACHE_TTL_ENTITY = parseInt(process.env.CACHE_TTL_ENTITY || '60', 10); // plugin/pipeline findById
+    static CACHE_TTL_MESSAGE = parseInt(process.env.CACHE_TTL_MESSAGE || '300', 10); // announcements/conversations (5 min)
+    static CACHE_TTL_REPORT_INVENTORY = parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10); // plugin summary/distribution (5 min)
+    static CACHE_TTL_REPORT_TIMESERIES = parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10); // execution/build metrics (2 min)
+    static CACHE_TTL_COMPLIANCE_RULES = parseInt(process.env.CACHE_TTL_COMPLIANCE_RULES || '60', 10); // active compliance rules
+    static CACHE_TTL_BILLING_PLANS = parseInt(process.env.CACHE_TTL_BILLING_PLANS || '14400', 10); // billing plans (4 hours)
+    // SSE backpressure
+    static SSE_BACKPRESSURE_THRESHOLD = parseInt(process.env.SSE_BACKPRESSURE_THRESHOLD || '10', 10);
+    // HTTP Cache-Control headers
+    static CACHE_CONTROL_LIST = process.env.CACHE_CONTROL_LIST || 'private, max-age=30, stale-while-revalidate=60';
+    static CACHE_CONTROL_DETAIL = process.env.CACHE_CONTROL_DETAIL || 'private, max-age=60, stale-while-revalidate=120';
+}
+exports.CoreConstants = CoreConstants;
+/**
+ * Per-section loader map — each section is loaded lazily on first access.
+ * This avoids loading all config sections (and their required env vars)
+ * when only one section is needed (e.g. CDK synthesis only needs 'aws').
+ */
+const sectionLoaders = {
+    server: server_config_1.loadServerConfig,
+    auth: server_config_1.loadAuthConfig,
+    database: infrastructure_config_1.loadDatabaseConfig,
+    registry: infrastructure_config_1.loadRegistryConfig,
+    redis: infrastructure_config_1.loadRedisConfig,
+    pluginBuild: infrastructure_config_1.loadPluginBuildConfig,
+    dockerConfig: infrastructure_config_1.loadDockerConfig,
+    observability: infrastructure_config_1.loadObservabilityConfig,
+    compliance: infrastructure_config_1.loadComplianceConfig,
+    aws: infrastructure_config_1.loadAWSConfig,
+    rateLimit: server_config_1.loadRateLimitConfig,
+    billing: billing_config_1.loadBillingConfig,
+};
+/** Per-section validators — only run for sections that have validation logic. */
+const sectionValidators = {
+    server: server_config_1.validateServerConfig,
+};
+/**
+ * Configuration facade with lazy per-section loading.
+ *
+ * Each section is loaded and validated independently on first access,
+ * so requesting `Config.get('aws')` does not trigger loading of
+ * server, auth, or billing config (and their env var requirements).
+ *
+ * Usage: `Config.get('server')`, `Config.get('auth')`, etc.
+ */
+class Config {
+    static cache = new Map();
+    /**
+     * Get a specific configuration section (loaded lazily on first access).
+     */
+    static get(section) {
+        if (!this.cache.has(section)) {
+            const loader = sectionLoaders[section];
+            const value = loader();
+            const validator = sectionValidators[section];
+            if (validator)
+                validator(value);
+            this.cache.set(section, value);
+        }
+        return this.cache.get(section);
+    }
+    /**
+     * @internal Reset configuration (for testing only)
+     */
+    static _resetForTesting() {
+        this.cache.clear();
+    }
+    /**
+     * Validate auth configuration (JWT secrets, algorithms, expiration).
+     * Call this at server startup, not during CDK synthesis.
+     */
+    static validateAuth() {
+        (0, server_config_1.validateAuthConfig)(this.get('auth'));
+    }
+    /**
+     * Untyped config access — use when the published package types don't include a new section yet.
+     * Avoids the `(Config as unknown as ...).get(...)` cast pattern in consumers.
+     */
+    static getAny(section) {
+        return this.get(section);
+    }
+}
+exports.Config = Config;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-config.js","sourceRoot":"","sources":["../../src/config/app-config.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Algorithm } from 'jsonwebtoken';\nimport { loadBillingConfig } from './billing-config';\nimport type { AppConfig } from './config-types';\nimport {\n  loadRegistryConfig,\n  loadRedisConfig,\n  loadPluginBuildConfig,\n  loadDockerConfig,\n  loadDatabaseConfig,\n  loadObservabilityConfig,\n  loadComplianceConfig,\n  loadAWSConfig,\n} from './infrastructure-config';\nimport {\n  loadServerConfig,\n  loadAuthConfig,\n  loadRateLimitConfig,\n  validateServerConfig,\n  validateAuthConfig,\n} from './server-config';\n\n/**\n * Core constants — configurable via environment variables with sensible defaults.\n */\nexport class CoreConstants {\n  static readonly NAME_PATTERN = /^[a-z0-9-]+$/;\n\n  // Supported JWT algorithms\n  static readonly ALLOWED_JWT_ALGORITHMS: Algorithm[] = ['HS256', 'RS256', 'ES256'];\n\n  // Custom Resource Handler configuration (must be less than Lambda timeout of 30s to allow response handling)\n  static readonly HANDLER_TIMEOUT_MS = parseInt(process.env.HANDLER_TIMEOUT_MS || '25000', 10); // 25s\n  /** Default platform URL fallback when PLATFORM_BASE_URL is not set. */\n  static readonly DEFAULT_PLATFORM_URL = 'https://localhost:8443';\n\n  static readonly HANDLER_DEFAULT_BASE_URL = process.env.PLATFORM_BASE_URL || CoreConstants.DEFAULT_PLATFORM_URL;\n  static readonly HANDLER_MAX_RETRIES = parseInt(process.env.HANDLER_MAX_RETRIES || '2', 10);\n  static readonly HANDLER_RETRY_DELAY_MS = parseInt(process.env.HANDLER_RETRY_DELAY_MS || '1000', 10); // 1s\n\n  // Plugin image configuration\n  static readonly PLUGIN_IMAGE_PREFIX = process.env.PLUGIN_IMAGE_PREFIX || 'p-';\n\n  // Plugin build queue configuration\n  static readonly PLUGIN_BUILD_QUEUE_NAME = process.env.PLUGIN_BUILD_QUEUE_NAME || 'plugin-build';\n  static readonly PLUGIN_BUILD_MAX_ATTEMPTS = parseInt(process.env.PLUGIN_BUILD_MAX_ATTEMPTS || '2', 10);\n  static readonly PLUGIN_BUILD_BACKOFF_DELAY_MS = parseInt(process.env.PLUGIN_BUILD_BACKOFF_DELAY_MS || '5000', 10); // 5s\n  static readonly PLUGIN_BUILD_COMPLETED_RETENTION_SECS = parseInt(process.env.PLUGIN_BUILD_COMPLETED_RETENTION_SECS || '3600', 10); // 1 hr\n  static readonly PLUGIN_BUILD_FAILED_RETENTION_SECS = parseInt(process.env.PLUGIN_BUILD_FAILED_RETENTION_SECS || '86400', 10); // 24 hr\n  static readonly PLUGIN_BUILD_WORKER_TIMEOUT_MS = parseInt(process.env.PLUGIN_BUILD_WORKER_TIMEOUT_MS || '10000', 10); // 10s\n\n  // Pagination and limits\n  static readonly MAX_PAGE_LIMIT = parseInt(process.env.MAX_PAGE_LIMIT || '1000', 10);\n  static readonly DEFAULT_PAGE_LIMIT = parseInt(process.env.DEFAULT_PAGE_LIMIT || '100', 10);\n  static readonly MAX_PROMPT_LENGTH = parseInt(process.env.MAX_PROMPT_LENGTH || '5000', 10);\n  static readonly PLUGIN_MAX_UPLOAD_MB = parseInt(process.env.PLUGIN_MAX_UPLOAD_MB || '4096', 10);\n  static readonly PIPELINE_NAME_MAX_LENGTH = parseInt(process.env.PIPELINE_NAME_MAX_LENGTH || '100', 10);\n  static readonly DEFAULT_PLUGIN_VERSION = process.env.DEFAULT_PLUGIN_VERSION || '1.0.0';\n\n  // SSE stream timeout for AI generation endpoints\n  static readonly SSE_STREAM_TIMEOUT_MS = parseInt(process.env.SSE_STREAM_TIMEOUT_MS || '300000', 10); // 5 min\n\n  // Git provider API base URLs (configurable for enterprise instances)\n  static readonly GITHUB_API_BASE_URL = process.env.GITHUB_API_BASE_URL || 'https://api.github.com';\n  static readonly BITBUCKET_API_BASE_URL = process.env.BITBUCKET_API_BASE_URL || 'https://api.bitbucket.org/2.0';\n\n  // Bulk operations and event ingestion\n  static readonly MAX_BULK_ITEMS = parseInt(process.env.MAX_BULK_ITEMS || '100', 10);\n  static readonly MAX_EVENTS_PER_BATCH = parseInt(process.env.MAX_EVENTS_PER_BATCH || '100', 10);\n  static readonly DEFAULT_REPORT_RANGE_DAYS = parseInt(process.env.DEFAULT_REPORT_RANGE_DAYS || '30', 10);\n\n  // Secrets Manager path prefix for org-scoped secrets\n  static readonly SECRETS_PATH_PREFIX = process.env.SECRETS_PATH_PREFIX || 'pipeline-builder';\n\n  /** Build a Secrets Manager path: {prefix}/{orgId}/{name} */\n  static secretPath(orgId: string, name: string): string {\n    return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/${name}`;\n  }\n\n  // Database connection\n  static readonly DB_MAX_RETRIES = parseInt(process.env.DB_MAX_RETRIES || '3', 10);\n  static readonly DB_RETRY_DELAY_MS = parseInt(process.env.DB_RETRY_DELAY_MS || '1000', 10); // 1s\n  static readonly DB_TRANSACTION_TIMEOUT_MS = parseInt(process.env.DB_TRANSACTION_TIMEOUT_MS || '30000', 10); // 30s\n  static readonly DB_CLOSE_TIMEOUT_MS = parseInt(process.env.DB_CLOSE_TIMEOUT_MS || '5000', 10); // 5s\n\n  // Response compression\n  static readonly COMPRESSION_THRESHOLD_BYTES = parseInt(process.env.COMPRESSION_THRESHOLD_BYTES || '1024', 10);\n\n  // Idempotency\n  static readonly IDEMPOTENCY_TTL_MS = parseInt(process.env.IDEMPOTENCY_TTL_MS || '300000', 10); // 5 min\n  static readonly IDEMPOTENCY_MAX_STORE_SIZE = parseInt(process.env.IDEMPOTENCY_MAX_STORE_SIZE || '10000', 10);\n  static readonly IDEMPOTENCY_CLEANUP_INTERVAL_MS = parseInt(process.env.IDEMPOTENCY_CLEANUP_INTERVAL_MS || '60000', 10); // 1 min\n\n  // Cache\n  static readonly CACHE_CLEANUP_INTERVAL_MS = parseInt(process.env.CACHE_CLEANUP_INTERVAL_MS || '30000', 10); // 30s\n\n  // Server-side cache TTLs (seconds)\n  static readonly CACHE_TTL_ENTITY = parseInt(process.env.CACHE_TTL_ENTITY || '60', 10); // plugin/pipeline findById\n  static readonly CACHE_TTL_MESSAGE = parseInt(process.env.CACHE_TTL_MESSAGE || '300', 10); // announcements/conversations (5 min)\n  static readonly CACHE_TTL_REPORT_INVENTORY = parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10); // plugin summary/distribution (5 min)\n  static readonly CACHE_TTL_REPORT_TIMESERIES = parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10); // execution/build metrics (2 min)\n  static readonly CACHE_TTL_COMPLIANCE_RULES = parseInt(process.env.CACHE_TTL_COMPLIANCE_RULES || '60', 10); // active compliance rules\n  static readonly CACHE_TTL_BILLING_PLANS = parseInt(process.env.CACHE_TTL_BILLING_PLANS || '14400', 10); // billing plans (4 hours)\n\n  // SSE backpressure\n  static readonly SSE_BACKPRESSURE_THRESHOLD = parseInt(process.env.SSE_BACKPRESSURE_THRESHOLD || '10', 10);\n\n  // HTTP Cache-Control headers\n  static readonly CACHE_CONTROL_LIST = process.env.CACHE_CONTROL_LIST || 'private, max-age=30, stale-while-revalidate=60';\n  static readonly CACHE_CONTROL_DETAIL = process.env.CACHE_CONTROL_DETAIL || 'private, max-age=60, stale-while-revalidate=120';\n}\n\n/**\n * Per-section loader map — each section is loaded lazily on first access.\n * This avoids loading all config sections (and their required env vars)\n * when only one section is needed (e.g. CDK synthesis only needs 'aws').\n */\nconst sectionLoaders: { [K in keyof AppConfig]: () => AppConfig[K] } = {\n  server: loadServerConfig,\n  auth: loadAuthConfig,\n  database: loadDatabaseConfig,\n  registry: loadRegistryConfig,\n  redis: loadRedisConfig,\n  pluginBuild: loadPluginBuildConfig,\n  dockerConfig: loadDockerConfig,\n  observability: loadObservabilityConfig,\n  compliance: loadComplianceConfig,\n  aws: loadAWSConfig,\n  rateLimit: loadRateLimitConfig,\n  billing: loadBillingConfig,\n};\n\n/** Per-section validators — only run for sections that have validation logic. */\nconst sectionValidators: Partial<{ [K in keyof AppConfig]: (config: AppConfig[K]) => void }> = {\n  server: validateServerConfig,\n};\n\n/**\n * Configuration facade with lazy per-section loading.\n *\n * Each section is loaded and validated independently on first access,\n * so requesting `Config.get('aws')` does not trigger loading of\n * server, auth, or billing config (and their env var requirements).\n *\n * Usage: `Config.get('server')`, `Config.get('auth')`, etc.\n */\nexport class Config {\n  private static cache = new Map<keyof AppConfig, unknown>();\n\n  /**\n   * Get a specific configuration section (loaded lazily on first access).\n   */\n  static get<K extends keyof AppConfig>(section: K): AppConfig[K] {\n    if (!this.cache.has(section)) {\n      const loader = sectionLoaders[section];\n      const value = loader();\n      const validator = sectionValidators[section];\n      if (validator) (validator as (v: AppConfig[K]) => void)(value);\n      this.cache.set(section, value);\n    }\n    return this.cache.get(section) as AppConfig[K];\n  }\n\n  /**\n   * @internal Reset configuration (for testing only)\n   */\n  static _resetForTesting(): void {\n    this.cache.clear();\n  }\n\n  /**\n   * Validate auth configuration (JWT secrets, algorithms, expiration).\n   * Call this at server startup, not during CDK synthesis.\n   */\n  static validateAuth(): void {\n    validateAuthConfig(this.get('auth'));\n  }\n\n  /**\n   * Untyped config access — use when the published package types don't include a new section yet.\n   * Avoids the `(Config as unknown as ...).get(...)` cast pattern in consumers.\n   */\n  static getAny(section: string): unknown {\n    return this.get(section as keyof AppConfig);\n  }\n}\n"]}

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

@@ -0,0 +1,17 @@
+/**
+ * Load billing plan configuration from environment variables.
+ *
+ * Per-plan prices are the most likely to vary between environments:
+ *   BILLING_PLAN_{TIER}_MONTHLY / BILLING_PLAN_{TIER}_ANNUAL  (in cents)
+ *
+ * Optional overrides for descriptions and features:
+ *   BILLING_PLAN_{TIER}_DESCRIPTION   (plain string)
+ *   BILLING_PLAN_{TIER}_FEATURES      (JSON string array)
+ *
+ * All defaults match the original hardcoded seed data for backward compatibility.
+ */
+import type { BillingConfig } from './config-types';
+/**
+ * Load billing plan configuration from environment variables.
+ */
+export declare function loadBillingConfig(): BillingConfig;

package/lib/config/billing-config.js

@@ -0,0 +1,95 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBillingConfig = loadBillingConfig;
+// -- Default features (match original seed-plans.ts) -------------------------
+const DEFAULT_DEVELOPER_FEATURES = [
+    'Up to 100 plugins',
+    'Up to 10 pipelines',
+    'Unlimited API calls',
+    'Community support',
+];
+const DEFAULT_PRO_FEATURES = [
+    'Up to 1,000 plugins',
+    'Up to 100 pipelines',
+    'Unlimited API calls',
+    'Community support',
+    'Reporting dashboard',
+];
+const DEFAULT_UNLIMITED_FEATURES = [
+    'Unlimited plugins',
+    'Unlimited pipelines',
+    'Unlimited API calls',
+    'Priority support',
+    'Reporting dashboard',
+    'Custom integrations',
+];
+/**
+ * Parse a JSON array from an env var, falling back to default.
+ */
+function parseFeatures(envVar, fallback) {
+    if (!envVar)
+        return fallback;
+    try {
+        const parsed = JSON.parse(envVar);
+        return Array.isArray(parsed) ? parsed : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+/**
+ * Load billing plan configuration from environment variables.
+ */
+function loadBillingConfig() {
+    const plans = [
+        {
+            id: 'developer',
+            name: 'Developer',
+            description: process.env.BILLING_PLAN_DEVELOPER_DESCRIPTION
+                || 'Free starter tier for individual developers',
+            tier: 'developer',
+            prices: {
+                monthly: parseInt(process.env.BILLING_PLAN_DEVELOPER_MONTHLY || '0', 10),
+                annual: parseInt(process.env.BILLING_PLAN_DEVELOPER_ANNUAL || '0', 10),
+            },
+            features: parseFeatures(process.env.BILLING_PLAN_DEVELOPER_FEATURES, DEFAULT_DEVELOPER_FEATURES),
+            isActive: true,
+            isDefault: true,
+            sortOrder: 0,
+        },
+        {
+            id: 'pro',
+            name: 'Pro',
+            description: process.env.BILLING_PLAN_PRO_DESCRIPTION
+                || 'For teams and production workloads',
+            tier: 'pro',
+            prices: {
+                monthly: parseInt(process.env.BILLING_PLAN_PRO_MONTHLY || '799', 10),
+                annual: parseInt(process.env.BILLING_PLAN_PRO_ANNUAL || '7990', 10),
+            },
+            features: parseFeatures(process.env.BILLING_PLAN_PRO_FEATURES, DEFAULT_PRO_FEATURES),
+            isActive: true,
+            isDefault: false,
+            sortOrder: 1,
+        },
+        {
+            id: 'unlimited',
+            name: 'Unlimited',
+            description: process.env.BILLING_PLAN_UNLIMITED_DESCRIPTION
+                || 'No restrictions for enterprise teams',
+            tier: 'unlimited',
+            prices: {
+                monthly: parseInt(process.env.BILLING_PLAN_UNLIMITED_MONTHLY || '1199', 10),
+                annual: parseInt(process.env.BILLING_PLAN_UNLIMITED_ANNUAL || '11990', 10),
+            },
+            features: parseFeatures(process.env.BILLING_PLAN_UNLIMITED_FEATURES, DEFAULT_UNLIMITED_FEATURES),
+            isActive: true,
+            isDefault: false,
+            sortOrder: 2,
+        },
+    ];
+    return { plans };
+}
+//# sourceMappingURL=data:application/json;base64,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