@pipeline-builder/pipeline-core 0.0.1

package/lib/handlers/plugin-lookup-handler.js

@@ -0,0 +1,292 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
+import axios, { AxiosError } from 'axios';
+// Import the dependency-free leaf, NOT `app-config.js`/`CoreConstants`: the latter
+// transitively pulls infrastructure-config → aws-cdk-lib, which esbuild then tries
+// to bundle into this Lambda (hundreds of MB → OOM/SIGKILL during cold-start synth).
+import { HANDLER_TIMEOUT_MS, HANDLER_MAX_RETRIES, HANDLER_RETRY_DELAY_MS, HANDLER_DEFAULT_BASE_URL, } from '../config/handler-constants.js';
+/**
+ * Structured logger for Lambda (outputs JSON to CloudWatch).
+ * Debug messages only emitted when LOG_LEVEL=debug.
+ */
+function logEntry(level, tag, message, data) {
+    const line = JSON.stringify({ level, tag, message, data, ts: new Date().toISOString() });
+    switch (level) {
+        case 'ERROR':
+            console.error(line);
+            break;
+        case 'DEBUG':
+            if (process.env.LOG_LEVEL === 'debug')
+                console.debug(line);
+            break;
+        default: console.log(line);
+    }
+}
+const lambdaLog = {
+    info: (tag, message, data) => logEntry('INFO', tag, message, data),
+    error: (tag, message, data) => logEntry('ERROR', tag, message, data),
+    debug: (tag, message, data) => logEntry('DEBUG', tag, message, data),
+};
+const RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);
+const RETRYABLE_CODES = new Set(['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT']);
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/** Platform secret name — injected as PLATFORM_SECRET_NAME env var by PluginLookup construct. */
+const PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME;
+if (!PLATFORM_SECRET_NAME) {
+    throw new Error('PLATFORM_SECRET_NAME environment variable is required');
+}
+/** Cached token to avoid repeated Secrets Manager calls within a single invocation. */
+let cachedToken = null;
+/** @internal Reset cached token (for testing only). */
+export function _resetCredentialsCache() { cachedToken = null; }
+/**
+ * Fetch JWT token from AWS Secrets Manager.
+ * Caches the result for the lifetime of the Lambda execution context.
+ *
+ * The secret name is set via PLATFORM_SECRET_NAME env var (e.g. `{prefix}/{orgId}/platform`)
+ * Create it with: `pipeline-manager infra store-token`
+ */
+async function getToken() {
+    if (cachedToken)
+        return cachedToken;
+    lambdaLog.info('AUTH', `Fetching token from Secrets Manager: ${PLATFORM_SECRET_NAME}`);
+    const client = new SecretsManagerClient({});
+    const response = await client.send(new GetSecretValueCommand({ SecretId: PLATFORM_SECRET_NAME }));
+    if (!response.SecretString) {
+        throw new Error(`Secret "${PLATFORM_SECRET_NAME}" is empty`);
+    }
+    const parsed = JSON.parse(response.SecretString);
+    // Schema is `{ username, password, ... }` — the `password` field is the
+    // platform JWT. Same secret is read by CodeBuild's `secretsManagerCredentials`
+    // for registry pulls (Basic auth: username:password = orgId:JWT). The
+    // pipeline-image-registry token endpoint validates the password as a JWT
+    // and issues a registry token scoped to the JWT's org.
+    if (!parsed.password) {
+        throw new Error(`Secret "${PLATFORM_SECRET_NAME}" missing password — run "pipeline-manager infra store-token" to generate`);
+    }
+    cachedToken = parsed.password;
+    lambdaLog.info('AUTH', 'Token retrieved from Secrets Manager');
+    return cachedToken;
+}
+/**
+ * Creates a pre-configured Axios instance for API requests.
+ *
+ * @param baseURL - Base URL of the target API
+ * @param token - JWT token for authorization
+ * @returns Configured Axios instance
+ */
+function create(baseURL, token) {
+    return axios.create({
+        baseURL,
+        timeout: HANDLER_TIMEOUT_MS,
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        },
+    });
+}
+/**
+ * Fetches plugin configuration from the external API with retry logic.
+ * Retries on transient failures (429, 502, 503, 504, network errors)
+ * with exponential backoff.
+ *
+ * @param api - Configured Axios instance
+ * @param pluginFilter - Filter criteria for the plugin lookup
+ * @returns The plugin data returned by the API
+ * @throws Error on persistent failure, timeout or invalid response
+ */
+async function fetch(api, pluginFilter) {
+    lambdaLog.debug('FETCH', 'Starting plugin fetch', { filter: pluginFilter });
+    let lastError;
+    for (let attempt = 0; attempt <= HANDLER_MAX_RETRIES; attempt++) {
+        if (attempt > 0) {
+            const delay = HANDLER_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+            lambdaLog.info('RETRY', `Attempt ${attempt + 1}/${HANDLER_MAX_RETRIES + 1} after ${delay}ms`);
+            await sleep(delay);
+        }
+        try {
+            const { data, status } = await api.post('/api/plugins/lookup', {
+                filter: pluginFilter,
+            });
+            if (!data) {
+                throw new Error('Empty response data from API');
+            }
+            lambdaLog.info('FETCH', 'Plugin fetched successfully', {
+                status,
+                plugin: data.name,
+                version: data.version,
+                id: data.id,
+            });
+            return data;
+        }
+        catch (error) {
+            if (error instanceof AxiosError) {
+                if (error.code === 'ECONNABORTED') {
+                    lambdaLog.error('FETCH', `Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);
+                    throw new Error(`Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);
+                }
+                const retryable = error.response
+                    ? RETRYABLE_STATUSES.has(error.response.status)
+                    : RETRYABLE_CODES.has(error.code ?? '');
+                const msg = error.response
+                    ? `API error ${error.response.status}: ${error.response.statusText}`
+                    : error.code || error.message;
+                if (retryable && attempt < HANDLER_MAX_RETRIES) {
+                    lambdaLog.info('RETRY', `Retryable error: ${msg}`, { attempt: attempt + 1 });
+                    lastError = new Error(`Failed to fetch plugin: ${msg}`);
+                    continue;
+                }
+                // Don't log the upstream body verbatim — it may carry a stack trace,
+                // a request payload echo, or other sensitive data we shouldn't echo
+                // into Lambda CloudWatch logs. Keep just the high-level shape.
+                const safeBody = error.response?.data && typeof error.response.data === 'object'
+                    ? { code: error.response.data.code, message: error.response.data.message }
+                    : undefined;
+                lambdaLog.error('FETCH', msg, { responseBody: safeBody });
+                throw new Error(`Failed to fetch plugin: ${msg}`);
+            }
+            throw error instanceof Error ? error : new Error('Unknown error during plugin fetch');
+        }
+    }
+    throw lastError ?? new Error('Failed to fetch plugin after retries');
+}
+/**
+ * Validates the plugin filter object
+ *
+ * @param pluginFilter - Filter to validate
+ * @returns true if valid
+ * @throws Error if invalid
+ */
+function validatePluginFilter(pluginFilter) {
+    if (!pluginFilter || typeof pluginFilter !== 'object') {
+        throw new Error('Missing or invalid pluginFilter');
+    }
+    const filter = pluginFilter;
+    if (!filter.name && !filter.id && !filter.version && !filter.orgId) {
+        throw new Error('PluginFilter must have at least one criterion (name, id, version, or orgId)');
+    }
+    return true;
+}
+/**
+ * Lambda handler for CloudFormation Custom Resource that performs plugin lookup.
+ *
+ * Authenticates using JWT token from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).
+ * Create the secret with: `pipeline-manager infra store-token`
+ *
+ * Request Types:
+ * - Create/Update: fetches and returns plugin configuration from API
+ * - Delete: no-op (always succeeds)
+ *
+ * Response:
+ * - Success: Returns base64-encoded plugin JSON in Data.ResultValue
+ * - Failure: Returns error message in Reason
+ *
+ * @param event - CloudFormation custom resource event
+ * @returns CloudFormation response
+ *
+ * @example
+ * Custom Resource Properties:
+ * ```json
+ * {
+ *   "baseURL": "https://api.example.com",
+ *   "pluginFilter": {
+ *     "name": "nodejs-build",
+ *     "version": "1.0.0",
+ *     "isActive": true
+ *   }
+ * }
+ * ```
+ */
+export const handler = async (event) => {
+    // NOTE: never log event.StackId here — the CloudFormation Stack ARN embeds the
+    // AWS account id (arn:aws:cloudformation:<region>:<ACCOUNT_ID>:stack/…), which
+    // must never be persisted to CloudWatch. requestId + logicalResourceId are
+    // sufficient for correlation. (StackId is still returned in the CFN response
+    // body below — that is the mandatory CFN protocol field and is not a log.)
+    lambdaLog.info('START', `${event.RequestType} request received`, {
+        logicalResourceId: event.LogicalResourceId,
+        requestId: event.RequestId,
+    });
+    const baseResponse = {
+        StackId: event.StackId,
+        RequestId: event.RequestId,
+        LogicalResourceId: event.LogicalResourceId,
+        PhysicalResourceId: event.LogicalResourceId,
+    };
+    try {
+        // Handle Delete - always succeed (no-op)
+        if (event.RequestType === 'Delete') {
+            lambdaLog.info('DELETE', 'No-op - returning SUCCESS');
+            return {
+                ...baseResponse,
+                Status: 'SUCCESS',
+                Reason: 'Delete completed (no-op)',
+            };
+        }
+        // Extract and validate properties
+        const pluginFilter = event.ResourceProperties.pluginFilter;
+        const baseURL = event.ResourceProperties.baseURL || HANDLER_DEFAULT_BASE_URL;
+        if (!baseURL.startsWith('https://') && !baseURL.startsWith('http://')) {
+            throw new Error(`Invalid baseURL: "${baseURL}" — must start with http:// or https://`);
+        }
+        lambdaLog.info('CONFIG', 'Configuration loaded', { baseURL, pluginFilter });
+        validatePluginFilter(pluginFilter);
+        // Get token from Secrets Manager and create API client
+        const token = await getToken();
+        const api = create(baseURL, token);
+        // Fetch plugin
+        lambdaLog.info('FETCH', 'Initiating plugin lookup...');
+        const plugin = await fetch(api, pluginFilter);
+        lambdaLog.info('FETCH', 'Plugin retrieved successfully', {
+            name: plugin.name,
+            version: plugin.version,
+            id: plugin.id,
+        });
+        // Strip large fields to stay within CloudFormation's 4096-byte Data limit.
+        // CDK constructs only need the fields used by createCodeBuildStep().
+        const slim = {
+            id: plugin.id,
+            name: plugin.name,
+            version: plugin.version,
+            pluginType: plugin.pluginType,
+            computeType: plugin.computeType,
+            commands: plugin.commands,
+            installCommands: plugin.installCommands,
+            env: plugin.env,
+            metadata: plugin.metadata,
+            primaryOutputDirectory: plugin.primaryOutputDirectory,
+            secrets: plugin.secrets,
+            failureBehavior: plugin.failureBehavior,
+            timeout: plugin.timeout,
+        };
+        const encoded = Buffer.from(JSON.stringify(slim), 'utf-8').toString('base64');
+        lambdaLog.debug('ENCODE', 'Encoded plugin data', { length: encoded.length });
+        return {
+            ...baseResponse,
+            Status: 'SUCCESS',
+            Reason: `Plugin '${plugin.name}' (v${plugin.version}) retrieved successfully`,
+            Data: {
+                ResultValue: encoded,
+            },
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : 'Unexpected error occurred';
+        lambdaLog.error('ERROR', 'Handler failed', {
+            reason,
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        return {
+            ...baseResponse,
+            Status: 'FAILED',
+            Reason: reason,
+        };
+    }
+    finally {
+        lambdaLog.info('END', 'Custom resource execution completed');
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-lookup-handler.js","sourceRoot":"","sources":["../../src/handlers/plugin-lookup-handler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';\nimport type { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';\nimport type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceResponse } from 'aws-lambda';\nimport axios, { type AxiosInstance, AxiosError } from 'axios';\n// Import the dependency-free leaf, NOT `app-config.js`/`CoreConstants`: the latter\n// transitively pulls infrastructure-config → aws-cdk-lib, which esbuild then tries\n// to bundle into this Lambda (hundreds of MB → OOM/SIGKILL during cold-start synth).\nimport {\n  HANDLER_TIMEOUT_MS,\n  HANDLER_MAX_RETRIES,\n  HANDLER_RETRY_DELAY_MS,\n  HANDLER_DEFAULT_BASE_URL,\n} from '../config/handler-constants.js';\n\n/**\n * Structured logger for Lambda (outputs JSON to CloudWatch).\n * Debug messages only emitted when LOG_LEVEL=debug.\n */\nfunction logEntry(level: string, tag: string, message: string, data?: unknown) {\n  const line = JSON.stringify({ level, tag, message, data, ts: new Date().toISOString() });\n  switch (level) {\n    case 'ERROR': console.error(line); break;\n    case 'DEBUG': if (process.env.LOG_LEVEL === 'debug') console.debug(line); break;\n    default: console.log(line);\n  }\n}\n\nconst lambdaLog = {\n  info: (tag: string, message: string, data?: unknown) => logEntry('INFO', tag, message, data),\n  error: (tag: string, message: string, data?: unknown) => logEntry('ERROR', tag, message, data),\n  debug: (tag: string, message: string, data?: unknown) => logEntry('DEBUG', tag, message, data),\n};\n\nconst RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);\nconst RETRYABLE_CODES = new Set(['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT']);\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/** Platform secret name — injected as PLATFORM_SECRET_NAME env var by PluginLookup construct. */\nconst PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME;\nif (!PLATFORM_SECRET_NAME) {\n  throw new Error('PLATFORM_SECRET_NAME environment variable is required');\n}\n\n/** Cached token to avoid repeated Secrets Manager calls within a single invocation. */\nlet cachedToken: string | null = null;\n\n/** @internal Reset cached token (for testing only). */\nexport function _resetCredentialsCache(): void { cachedToken = null; }\n\n/**\n * Fetch JWT token from AWS Secrets Manager.\n * Caches the result for the lifetime of the Lambda execution context.\n *\n * The secret name is set via PLATFORM_SECRET_NAME env var (e.g. `{prefix}/{orgId}/platform`)\n * Create it with: `pipeline-manager infra store-token`\n */\nasync function getToken(): Promise<string> {\n  if (cachedToken) return cachedToken;\n\n  lambdaLog.info('AUTH', `Fetching token from Secrets Manager: ${PLATFORM_SECRET_NAME}`);\n\n  const client = new SecretsManagerClient({});\n  const response = await client.send(new GetSecretValueCommand({ SecretId: PLATFORM_SECRET_NAME }));\n\n  if (!response.SecretString) {\n    throw new Error(`Secret \"${PLATFORM_SECRET_NAME}\" is empty`);\n  }\n\n  const parsed = JSON.parse(response.SecretString) as Record<string, string>;\n  // Schema is `{ username, password, ... }` — the `password` field is the\n  // platform JWT. Same secret is read by CodeBuild's `secretsManagerCredentials`\n  // for registry pulls (Basic auth: username:password = orgId:JWT). The\n  // pipeline-image-registry token endpoint validates the password as a JWT\n  // and issues a registry token scoped to the JWT's org.\n  if (!parsed.password) {\n    throw new Error(`Secret \"${PLATFORM_SECRET_NAME}\" missing password — run \"pipeline-manager infra store-token\" to generate`);\n  }\n\n  cachedToken = parsed.password;\n  lambdaLog.info('AUTH', 'Token retrieved from Secrets Manager');\n  return cachedToken;\n}\n\n/**\n * Creates a pre-configured Axios instance for API requests.\n *\n * @param baseURL - Base URL of the target API\n * @param token - JWT token for authorization\n * @returns Configured Axios instance\n */\nfunction create(baseURL: string, token: string): AxiosInstance {\n  return axios.create({\n    baseURL,\n    timeout: HANDLER_TIMEOUT_MS,\n    headers: {\n      'Content-Type': 'application/json',\n      'Authorization': `Bearer ${token}`,\n    },\n  });\n}\n\n/**\n * Fetches plugin configuration from the external API with retry logic.\n * Retries on transient failures (429, 502, 503, 504, network errors)\n * with exponential backoff.\n *\n * @param api - Configured Axios instance\n * @param pluginFilter - Filter criteria for the plugin lookup\n * @returns The plugin data returned by the API\n * @throws Error on persistent failure, timeout or invalid response\n */\nasync function fetch(api: AxiosInstance, pluginFilter: PluginFilter): Promise<Plugin> {\n  lambdaLog.debug('FETCH', 'Starting plugin fetch', { filter: pluginFilter });\n\n  let lastError: Error | undefined;\n\n  for (let attempt = 0; attempt <= HANDLER_MAX_RETRIES; attempt++) {\n    if (attempt > 0) {\n      const delay = HANDLER_RETRY_DELAY_MS * Math.pow(2, attempt - 1);\n      lambdaLog.info('RETRY', `Attempt ${attempt + 1}/${HANDLER_MAX_RETRIES + 1} after ${delay}ms`);\n      await sleep(delay);\n    }\n\n    try {\n      const { data, status } = await api.post<Plugin>('/api/plugins/lookup', {\n        filter: pluginFilter,\n      });\n\n      if (!data) {\n        throw new Error('Empty response data from API');\n      }\n\n      lambdaLog.info('FETCH', 'Plugin fetched successfully', {\n        status,\n        plugin: data.name,\n        version: data.version,\n        id: data.id,\n      });\n\n      return data;\n    } catch (error) {\n      if (error instanceof AxiosError) {\n        if (error.code === 'ECONNABORTED') {\n          lambdaLog.error('FETCH', `Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);\n          throw new Error(`Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);\n        }\n\n        const retryable = error.response\n          ? RETRYABLE_STATUSES.has(error.response.status)\n          : RETRYABLE_CODES.has(error.code ?? '');\n\n        const msg = error.response\n          ? `API error ${error.response.status}: ${error.response.statusText}`\n          : error.code || error.message;\n\n        if (retryable && attempt < HANDLER_MAX_RETRIES) {\n          lambdaLog.info('RETRY', `Retryable error: ${msg}`, { attempt: attempt + 1 });\n          lastError = new Error(`Failed to fetch plugin: ${msg}`);\n          continue;\n        }\n\n        // Don't log the upstream body verbatim — it may carry a stack trace,\n        // a request payload echo, or other sensitive data we shouldn't echo\n        // into Lambda CloudWatch logs. Keep just the high-level shape.\n        const safeBody = error.response?.data && typeof error.response.data === 'object'\n          ? { code: (error.response.data as { code?: string }).code, message: (error.response.data as { message?: string }).message }\n          : undefined;\n        lambdaLog.error('FETCH', msg, { responseBody: safeBody });\n        throw new Error(`Failed to fetch plugin: ${msg}`);\n      }\n\n      throw error instanceof Error ? error : new Error('Unknown error during plugin fetch');\n    }\n  }\n\n  throw lastError ?? new Error('Failed to fetch plugin after retries');\n}\n\n/**\n * Validates the plugin filter object\n *\n * @param pluginFilter - Filter to validate\n * @returns true if valid\n * @throws Error if invalid\n */\nfunction validatePluginFilter(pluginFilter: unknown): pluginFilter is PluginFilter {\n  if (!pluginFilter || typeof pluginFilter !== 'object') {\n    throw new Error('Missing or invalid pluginFilter');\n  }\n\n  const filter = pluginFilter as Record<string, unknown>;\n  if (!filter.name && !filter.id && !filter.version && !filter.orgId) {\n    throw new Error('PluginFilter must have at least one criterion (name, id, version, or orgId)');\n  }\n\n  return true;\n}\n\n/**\n * Lambda handler for CloudFormation Custom Resource that performs plugin lookup.\n *\n * Authenticates using JWT token from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).\n * Create the secret with: `pipeline-manager infra store-token`\n *\n * Request Types:\n * - Create/Update: fetches and returns plugin configuration from API\n * - Delete: no-op (always succeeds)\n *\n * Response:\n * - Success: Returns base64-encoded plugin JSON in Data.ResultValue\n * - Failure: Returns error message in Reason\n *\n * @param event - CloudFormation custom resource event\n * @returns CloudFormation response\n *\n * @example\n * Custom Resource Properties:\n * ```json\n * {\n *   \"baseURL\": \"https://api.example.com\",\n *   \"pluginFilter\": {\n *     \"name\": \"nodejs-build\",\n *     \"version\": \"1.0.0\",\n *     \"isActive\": true\n *   }\n * }\n * ```\n */\nexport const handler = async (\n  event: CloudFormationCustomResourceEvent,\n): Promise<CloudFormationCustomResourceResponse> => {\n  // NOTE: never log event.StackId here — the CloudFormation Stack ARN embeds the\n  // AWS account id (arn:aws:cloudformation:<region>:<ACCOUNT_ID>:stack/…), which\n  // must never be persisted to CloudWatch. requestId + logicalResourceId are\n  // sufficient for correlation. (StackId is still returned in the CFN response\n  // body below — that is the mandatory CFN protocol field and is not a log.)\n  lambdaLog.info('START', `${event.RequestType} request received`, {\n    logicalResourceId: event.LogicalResourceId,\n    requestId: event.RequestId,\n  });\n\n  const baseResponse: Partial<CloudFormationCustomResourceResponse> = {\n    StackId: event.StackId,\n    RequestId: event.RequestId,\n    LogicalResourceId: event.LogicalResourceId,\n    PhysicalResourceId: event.LogicalResourceId,\n  };\n\n  try {\n    // Handle Delete - always succeed (no-op)\n    if (event.RequestType === 'Delete') {\n      lambdaLog.info('DELETE', 'No-op - returning SUCCESS');\n      return {\n        ...baseResponse,\n        Status: 'SUCCESS',\n        Reason: 'Delete completed (no-op)',\n      } as CloudFormationCustomResourceResponse;\n    }\n\n    // Extract and validate properties\n    const pluginFilter = event.ResourceProperties.pluginFilter;\n    const baseURL = event.ResourceProperties.baseURL || HANDLER_DEFAULT_BASE_URL;\n\n    if (!baseURL.startsWith('https://') && !baseURL.startsWith('http://')) {\n      throw new Error(`Invalid baseURL: \"${baseURL}\" — must start with http:// or https://`);\n    }\n\n    lambdaLog.info('CONFIG', 'Configuration loaded', { baseURL, pluginFilter });\n\n    validatePluginFilter(pluginFilter);\n\n    // Get token from Secrets Manager and create API client\n    const token = await getToken();\n    const api = create(baseURL, token);\n\n    // Fetch plugin\n    lambdaLog.info('FETCH', 'Initiating plugin lookup...');\n    const plugin = await fetch(api, pluginFilter);\n    lambdaLog.info('FETCH', 'Plugin retrieved successfully', {\n      name: plugin.name,\n      version: plugin.version,\n      id: plugin.id,\n    });\n\n    // Strip large fields to stay within CloudFormation's 4096-byte Data limit.\n    // CDK constructs only need the fields used by createCodeBuildStep().\n    const slim = {\n      id: plugin.id,\n      name: plugin.name,\n      version: plugin.version,\n      pluginType: plugin.pluginType,\n      computeType: plugin.computeType,\n      commands: plugin.commands,\n      installCommands: plugin.installCommands,\n      env: plugin.env,\n      metadata: plugin.metadata,\n      primaryOutputDirectory: plugin.primaryOutputDirectory,\n      secrets: plugin.secrets,\n      failureBehavior: plugin.failureBehavior,\n      timeout: plugin.timeout,\n    };\n\n    const encoded = Buffer.from(JSON.stringify(slim), 'utf-8').toString('base64');\n    lambdaLog.debug('ENCODE', 'Encoded plugin data', { length: encoded.length });\n\n    return {\n      ...baseResponse,\n      Status: 'SUCCESS',\n      Reason: `Plugin '${plugin.name}' (v${plugin.version}) retrieved successfully`,\n      Data: {\n        ResultValue: encoded,\n      },\n    } as CloudFormationCustomResourceResponse;\n  } catch (error) {\n    const reason = error instanceof Error ? error.message : 'Unexpected error occurred';\n    lambdaLog.error('ERROR', 'Handler failed', {\n      reason,\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n\n    return {\n      ...baseResponse,\n      Status: 'FAILED',\n      Reason: reason,\n    } as CloudFormationCustomResourceResponse;\n  } finally {\n    lambdaLog.info('END', 'Custom resource execution completed');\n  }\n};\n"]}

package/lib/handlers/pnpm-lock.yaml

@@ -0,0 +1,12 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies: {}
+
+packages: {}

package/lib/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @module @pipeline-builder/pipeline-core
+ *
+ * Application configuration, pipeline domain types, and the template engine.
+ *
+ * This entry point is deliberately FREE of `aws-cdk-lib`. The CDK constructs live
+ * behind a separate subpath — `@pipeline-builder/pipeline-core/cdk` — because the
+ * API services consume this package for config and domain types only, and an
+ * `export *` of the constructs from here put the whole of `aws-cdk-lib` on the
+ * import graph of every service that read so much as a port number. Anything that
+ * imports `aws-cdk-lib`, at type level or value level, belongs in `cdk.ts`.
+ *
+ * **Config**
+ * - Config — application configuration singleton (environment-driven)
+ * - ConfigTypes — typed configuration interfaces
+ *
+ * **Types**
+ * - PipelineType, ComputeType, PluginType, Visibility — pipeline domain enums
+ * - RoleTypes, SecurityGroupTypes — infrastructure type definitions
+ * - PluginSpec — a plugin's declared contract
+ * - IdGenerator — deterministic ID generation
+ *
+ * **Helpers**
+ * - replaceNonAlphanumeric, extractMetadataEnv — string and metadata utilities
+ *
+ * **Re-exports from api-core**
+ * - ErrorCode, createLogger
+ *
+ * The Postgres/Drizzle data layer (db, schema, CrudService, query builders,
+ * filter/compliance types, etc.) is NOT re-exported here — import those
+ * directly from `@pipeline-builder/pipeline-data`.
+ */
+export * from './config/app-config.js';
+export * from './config/config-types.js';
+export * from './config/entitlements.js';
+export * from './config/service-client.js';
+export { parsePlatformBaseUrl } from './config/infrastructure-config.js';
+export * from './core/pipeline-types.js';
+export * from './core/role-types.js';
+export * from './core/security-group-types.js';
+export * from './core/id-generator.js';
+export { replaceNonAlphanumeric, extractMetadataEnv } from './core/metadata-helpers.js';
+export * from './pipeline/plugin-spec.js';
+export { ErrorCode, createLogger, } from '@pipeline-builder/api-core';
+export * from './template/index.js';

package/lib/index.js

@@ -0,0 +1,53 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * @module @pipeline-builder/pipeline-core
+ *
+ * Application configuration, pipeline domain types, and the template engine.
+ *
+ * This entry point is deliberately FREE of `aws-cdk-lib`. The CDK constructs live
+ * behind a separate subpath — `@pipeline-builder/pipeline-core/cdk` — because the
+ * API services consume this package for config and domain types only, and an
+ * `export *` of the constructs from here put the whole of `aws-cdk-lib` on the
+ * import graph of every service that read so much as a port number. Anything that
+ * imports `aws-cdk-lib`, at type level or value level, belongs in `cdk.ts`.
+ *
+ * **Config**
+ * - Config — application configuration singleton (environment-driven)
+ * - ConfigTypes — typed configuration interfaces
+ *
+ * **Types**
+ * - PipelineType, ComputeType, PluginType, Visibility — pipeline domain enums
+ * - RoleTypes, SecurityGroupTypes — infrastructure type definitions
+ * - PluginSpec — a plugin's declared contract
+ * - IdGenerator — deterministic ID generation
+ *
+ * **Helpers**
+ * - replaceNonAlphanumeric, extractMetadataEnv — string and metadata utilities
+ *
+ * **Re-exports from api-core**
+ * - ErrorCode, createLogger
+ *
+ * The Postgres/Drizzle data layer (db, schema, CrudService, query builders,
+ * filter/compliance types, etc.) is NOT re-exported here — import those
+ * directly from `@pipeline-builder/pipeline-data`.
+ */
+// Configuration
+export * from './config/app-config.js';
+export * from './config/config-types.js';
+export * from './config/entitlements.js';
+export * from './config/service-client.js';
+export { parsePlatformBaseUrl } from './config/infrastructure-config.js';
+// Core types (public surface)
+export * from './core/pipeline-types.js';
+export * from './core/role-types.js';
+export * from './core/security-group-types.js';
+export * from './core/id-generator.js';
+export { replaceNonAlphanumeric, extractMetadataEnv } from './core/metadata-helpers.js';
+// Plugin domain type (the synth-time authoring types live in the `/cdk` entry)
+export * from './pipeline/plugin-spec.js';
+// Re-export from api-core (only items consumed by external packages)
+export { ErrorCode, createLogger, } from '@pipeline-builder/api-core';
+// Template engine — synth-time scripting for pipeline config + plugin specs
+export * from './template/index.js';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/pipeline/pipeline-builder.d.ts

@@ -0,0 +1,123 @@
+import type { Plugin } from '@pipeline-builder/pipeline-data';
+import { CodePipeline } from 'aws-cdk-lib/pipelines';
+import { Construct } from 'constructs';
+import { PipelineConfiguration } from './pipeline-configuration.js';
+import type { StageOptions, SynthOptions } from './step-types.js';
+import type { RegistryConfig } from '../config/config-types.js';
+import type { CodeBuildDefaults } from '../core/network-types.js';
+import type { MetaDataType } from '../core/pipeline-types.js';
+import type { RoleConfig } from '../core/role-types.js';
+/**
+ * Configuration properties for the PipelineBuilder construct
+ */
+export interface BuilderProps {
+    /** Project identifier (will be sanitized to lowercase alphanumeric with underscores) */
+    readonly project: string;
+    /** Organization identifier (will be sanitized to lowercase alphanumeric with underscores) */
+    readonly organization: string;
+    /**
+     * Optional deploy environment (e.g. `production`, `staging`) for the
+     * single-environment case. When set (and no stage declares its own
+     * `environment`), pipeline-core derives the `pb.deploys` tag from it, marking
+     * the sole stage — or the LAST stage of a multi-stage pipeline (with a synth
+     * warning), or a literal `Deploy` stage when there are no stages to name — as
+     * the deploy for DORA metrics. For multi-environment pipelines, declare
+     * `environment` per stage instead (see `StageOptions.environment`).
+     */
+    readonly environment?: string;
+    /** Tenant identifier for resolving per-org secrets from AWS Secrets Manager */
+    readonly orgId?: string;
+    /** Pipeline database record ID — injected as PIPELINE_ID env var for autonomous synth */
+    readonly pipelineId?: string;
+    /** Optional custom pipeline name. Defaults to: {organization}-{project}-pipeline */
+    readonly pipelineName?: string;
+    /** Global metadata inherited by all pipeline steps */
+    readonly global?: MetaDataType;
+    /**
+     * Pipeline-level template variables, exposed to `{{ pipeline.vars.* }}` in
+     * pipeline configs and plugin specs (see `PluginSpec.requiredVars`). Declared
+     * here so the `pipeline.vars` template scope is type-checked end-to-end.
+     */
+    readonly vars?: Record<string, unknown>;
+    /**
+     * Pipeline-level CodeBuild defaults applied to all CodeBuild actions
+     * (synth, self-mutation, asset publishing) via `codeBuildDefaults`.
+     */
+    readonly defaults?: CodeBuildDefaults;
+    /**
+     * Optional IAM role for the CodePipeline.
+     * When provided, resolves to a CDK IRole and is passed to the CodePipeline construct.
+     * When omitted, CDK auto-creates a role with the correct codepipeline.amazonaws.com principal.
+     */
+    readonly role?: RoleConfig;
+    /** Synthesis configuration including source and plugin details */
+    readonly synth: SynthOptions;
+    /**
+     * Optional pipeline stages, each containing one or more CodeBuild steps.
+     * Stages are added as waves to the CodePipeline after the synth step.
+     */
+    readonly stages?: StageOptions[];
+    /** Optional cron/rate expression for scheduled pipeline execution. */
+    readonly schedule?: string;
+    /** Custom tags applied to all pipeline resources. */
+    readonly tags?: Record<string, string>;
+    /**
+     * Plugins pre-resolved by `pipeline-manager pipeline synth` from the platform API,
+     * keyed by `alias || name`. When present, `PluginLookup.plugin()` returns
+     * the matching entry directly and skips the custom resource — so the
+     * synthesized CFN template ships with the real CodeBuild image baked in.
+     * Populated by the CLI before invoking the boilerplate app; CDK consumers
+     * who construct PipelineBuilder directly normally leave this unset.
+     */
+    readonly resolvedPlugins?: Record<string, Plugin>;
+    /**
+     * Platform-sourced registry overrides, applied over the env-loaded `registry`
+     * config at synth start. pipeline-manager populates this from the platform URL
+     * it deploys against so the CodeBuild image URIs use a pull host AWS CodeBuild
+     * can resolve (instead of the in-cluster `registry:5000` default). CDK
+     * consumers constructing PipelineBuilder directly normally leave this unset.
+     */
+    readonly registry?: Partial<RegistryConfig>;
+}
+/**
+ * CDK construct that creates and configures a CodePipeline for continuous deployment.
+ *
+ * Features:
+ * - Multi-source support (S3, GitHub, CodeStar)
+ * - Plugin-based build steps
+ * - Metadata-driven configuration
+ * - Automatic tagging
+ * - Automatic sanitization of project and organization names
+ *
+ * @example
+ * ```typescript
+ * new PipelineBuilder(this, 'MyPipeline', {
+ *   project: 'my-app',
+ *   organization: 'my-org',
+ *   synth: {
+ *     source: {
+ *       type: 'github',
+ *       options: { repo: 'owner/repo', branch: 'main' }
+ *     },
+ *     plugin: { name: 'synth' }
+ *   }
+ * });
+ * ```
+ */
+export declare class PipelineBuilder extends Construct {
+    readonly pipeline: CodePipeline;
+    readonly config: PipelineConfiguration;
+    constructor(scope: Construct, id: string, props: BuilderProps);
+    /**
+     * Build a custom artifact bucket when `encryption.kmsKeyArn` and/or
+     * `operations.artifactRetentionDays` are set. Returns undefined otherwise so
+     * CDK auto-creates the default artifact bucket (unchanged behavior).
+     */
+    private buildArtifactBucket;
+    /**
+     * Resolves CodeBuildDefaults into the shape expected by CDK's codeBuildDefaults.
+     * Combines network config, security groups, and pipeline-level environment variables
+     * (PIPELINE_ID, EXECUTION_ID, PLATFORM_BASE_URL) available to all CodeBuild actions.
+     */
+    private resolveDefaults;
+}