@pipeline-builder/pipeline-core 3.1.1

package/lib/pipeline/pipeline-configuration.js

@@ -0,0 +1,196 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineConfiguration = void 0;
+const app_config_1 = require("../config/app-config");
+const pipeline_helpers_1 = require("../core/pipeline-helpers");
+const pipeline_types_1 = require("../core/pipeline-types");
+/**
+ * Validated and processed pipeline configuration (business logic layer).
+ * This class handles all non-CDK logic: validation, sanitization, and metadata merging.
+ * It can be tested independently without CDK dependencies.
+ *
+ * ## Metadata merge chain (last wins)
+ *
+ * 1. `BuilderProps.global` — base metadata inherited by all steps
+ * 2. `BuilderProps.defaults.metadata` — pipeline-level CodeBuild defaults metadata
+ * 3. `BuilderProps.synth.metadata` or `StageStepOptions.metadata` — per-step metadata
+ * 4. `plugin.metadata` — plugin's own metadata (merged in `createCodeBuildStep`)
+ * 5. `metadataForXxx()` — extracted CDK props spread last into construct calls
+ *
+ * Steps 1–3 are merged here into `this.metadata.merged`.
+ * Step 4 happens in `createCodeBuildStep` via `merge(metadata, plugin.metadata)`.
+ * Step 5 is spread last in the CDK constructor call, giving metadata full override authority.
+ */
+class PipelineConfiguration {
+    project;
+    organization;
+    pipelineName;
+    metadata;
+    source;
+    plugin;
+    network;
+    defaults;
+    synthCustomization;
+    stages;
+    constructor(props) {
+        this.validateProps(props);
+        // Sanitize project and organization names
+        this.project = (0, pipeline_helpers_1.replaceNonAlphanumeric)(props.project, '_').toLowerCase();
+        this.organization = (0, pipeline_helpers_1.replaceNonAlphanumeric)(props.organization, '_').toLowerCase();
+        // Calculate pipeline name
+        this.pipelineName = props.pipelineName ?? `${this.organization}-${this.project}-pipeline`;
+        // Metadata merging: global → defaults → synth-specific
+        const global = { ...(props.global ?? {}) };
+        const withDefaults = (0, pipeline_helpers_1.merge)(global, props.defaults?.metadata ?? {});
+        this.metadata = {
+            global,
+            synth: props.synth.metadata ?? {},
+            merged: (0, pipeline_helpers_1.merge)(withDefaults, props.synth.metadata ?? {}),
+        };
+        // Expose synth/builder properties directly
+        this.source = props.synth.source;
+        this.plugin = props.synth.plugin;
+        this.network = props.synth.network;
+        this.defaults = props.defaults;
+        this.synthCustomization = {
+            preInstallCommands: props.synth.preInstallCommands,
+            postInstallCommands: props.synth.postInstallCommands,
+            preCommands: props.synth.preCommands,
+            postCommands: props.synth.postCommands,
+            env: props.synth.env,
+        };
+        this.stages = props.stages;
+    }
+    /**
+     * Validates BuilderProps to ensure all required fields are present.
+     * Throws an error with detailed messages if validation fails.
+     */
+    validateProps(props) {
+        const errors = [];
+        if (!props.project) {
+            errors.push('BuilderProps.project is required');
+        }
+        if (!props.organization) {
+            errors.push('BuilderProps.organization is required');
+        }
+        if (!props.synth?.source) {
+            errors.push('BuilderProps.synth.source is required');
+        }
+        if (!props.synth?.plugin) {
+            errors.push('BuilderProps.synth.plugin is required');
+        }
+        else if (!props.synth.plugin.name?.trim()) {
+            errors.push('BuilderProps.synth.plugin.name must be a non-empty string');
+        }
+        // Validate repo format for GitHub and CodeStar sources (both use "owner/repo")
+        const sourceType = props.synth?.source?.type;
+        if (sourceType === 'github' || sourceType === 'codestar') {
+            const repo = props.synth?.source?.options?.repo;
+            if (repo && !repo.includes('/')) {
+                errors.push(`Invalid ${sourceType} repository format: "${repo}". Expected format: "owner/repo"`);
+            }
+        }
+        // Validate pipeline name length (AWS max 100 characters)
+        const MAX_PIPELINE_NAME_LENGTH = app_config_1.CoreConstants.PIPELINE_NAME_MAX_LENGTH;
+        const pipelineName = props.pipelineName
+            ?? `${(0, pipeline_helpers_1.replaceNonAlphanumeric)(props.organization ?? '', '_').toLowerCase()}-${(0, pipeline_helpers_1.replaceNonAlphanumeric)(props.project ?? '', '_').toLowerCase()}-pipeline`;
+        if (pipelineName.length > MAX_PIPELINE_NAME_LENGTH) {
+            errors.push(`Pipeline name "${pipelineName}" exceeds AWS maximum of ${MAX_PIPELINE_NAME_LENGTH} characters (${pipelineName.length})`);
+        }
+        // Validate stages
+        if (props.stages) {
+            const stageNames = new Set();
+            for (const stage of props.stages) {
+                if (!stage.stageName?.trim()) {
+                    errors.push('Each stage must have a non-empty stageName');
+                }
+                else if (stageNames.has(stage.stageName)) {
+                    errors.push(`Duplicate stage name: "${stage.stageName}"`);
+                }
+                else {
+                    stageNames.add(stage.stageName);
+                }
+                if (!stage.steps?.length) {
+                    errors.push(`Stage "${stage.stageName ?? '(unnamed)'}" must have at least one step`);
+                }
+            }
+        }
+        if (errors.length > 0) {
+            throw new Error('Pipeline configuration validation failed:\n' +
+                errors.map(e => `  - ${e}`).join('\n'));
+        }
+    }
+    /**
+     * Extracts S3 source options with defaults applied.
+     *
+     * @returns S3 options with `objectKey` defaulting to `'source.zip'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `s3`
+     */
+    getS3Options() {
+        const source = this.source;
+        if (source.type !== 's3') {
+            throw new Error('Source type is not S3');
+        }
+        return {
+            ...source.options,
+            objectKey: source.options.objectKey ?? 'source.zip',
+            trigger: source.options.trigger ?? pipeline_types_1.TriggerType.NONE,
+        };
+    }
+    /**
+     * Extracts GitHub source options with defaults applied.
+     *
+     * @returns GitHub options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `github`
+     */
+    getGitHubOptions() {
+        const source = this.source;
+        if (source.type !== 'github') {
+            throw new Error('Source type is not GitHub');
+        }
+        return {
+            ...source.options,
+            branch: source.options.branch ?? 'main',
+            trigger: source.options.trigger ?? pipeline_types_1.TriggerType.NONE,
+        };
+    }
+    /**
+     * Extracts CodeStar source options with defaults applied.
+     *
+     * @returns CodeStar options with `branch` defaulting to `'main'`, `trigger` defaulting to `NONE`, and `codeBuildCloneOutput` defaulting to `false`
+     * @throws {Error} If the configured source type is not `codestar`
+     */
+    getCodeStarOptions() {
+        const source = this.source;
+        if (source.type !== 'codestar') {
+            throw new Error('Source type is not CodeStar');
+        }
+        return {
+            ...source.options,
+            branch: source.options.branch ?? 'main',
+            trigger: source.options.trigger ?? pipeline_types_1.TriggerType.NONE,
+            codeBuildCloneOutput: source.options.codeBuildCloneOutput ?? false,
+        };
+    }
+    /**
+     * Extracts CodeCommit source options with defaults applied.
+     *
+     * @returns CodeCommit options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`
+     * @throws {Error} If the configured source type is not `codecommit`
+     */
+    getCodeCommitOptions() {
+        const source = this.source;
+        if (source.type !== 'codecommit') {
+            throw new Error('Source type is not CodeCommit');
+        }
+        return {
+            ...source.options,
+            branch: source.options.branch ?? 'main',
+            trigger: source.options.trigger ?? pipeline_types_1.TriggerType.NONE,
+        };
+    }
+}
+exports.PipelineConfiguration = PipelineConfiguration;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-configuration.js","sourceRoot":"","sources":["../../src/pipeline/pipeline-configuration.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { BuilderProps } from './pipeline-builder';\nimport type { CodeCommitOptions, CodeStarOptions, GitHubOptions, S3Options } from './source-types';\nimport type { PluginOptions, StageOptions, StepCustomization } from './step-types';\nimport { CoreConstants } from '../config/app-config';\nimport type { CodeBuildDefaults, NetworkConfig } from '../core/network-types';\nimport { merge, replaceNonAlphanumeric } from '../core/pipeline-helpers';\nimport type { MetaDataType, SourceType } from '../core/pipeline-types';\nimport { TriggerType } from '../core/pipeline-types';\n\n/**\n * Validated and processed pipeline configuration (business logic layer).\n * This class handles all non-CDK logic: validation, sanitization, and metadata merging.\n * It can be tested independently without CDK dependencies.\n *\n * ## Metadata merge chain (last wins)\n *\n * 1. `BuilderProps.global` — base metadata inherited by all steps\n * 2. `BuilderProps.defaults.metadata` — pipeline-level CodeBuild defaults metadata\n * 3. `BuilderProps.synth.metadata` or `StageStepOptions.metadata` — per-step metadata\n * 4. `plugin.metadata` — plugin's own metadata (merged in `createCodeBuildStep`)\n * 5. `metadataForXxx()` — extracted CDK props spread last into construct calls\n *\n * Steps 1–3 are merged here into `this.metadata.merged`.\n * Step 4 happens in `createCodeBuildStep` via `merge(metadata, plugin.metadata)`.\n * Step 5 is spread last in the CDK constructor call, giving metadata full override authority.\n */\nexport class PipelineConfiguration {\n  public readonly project: string;\n  public readonly organization: string;\n  public readonly pipelineName: string;\n  public readonly metadata: {\n    readonly global: MetaDataType;\n    readonly synth: MetaDataType;\n    readonly merged: MetaDataType;\n  };\n  public readonly source: SourceType;\n  public readonly plugin: PluginOptions;\n  public readonly network: NetworkConfig | undefined;\n  public readonly defaults: CodeBuildDefaults | undefined;\n  public readonly synthCustomization: StepCustomization;\n  public readonly stages: StageOptions[] | undefined;\n\n  constructor(props: BuilderProps) {\n    this.validateProps(props);\n\n    // Sanitize project and organization names\n    this.project = replaceNonAlphanumeric(props.project, '_').toLowerCase();\n    this.organization = replaceNonAlphanumeric(props.organization, '_').toLowerCase();\n\n    // Calculate pipeline name\n    this.pipelineName = props.pipelineName ?? `${this.organization}-${this.project}-pipeline`;\n\n    // Metadata merging: global → defaults → synth-specific\n    const global = { ...(props.global ?? {}) };\n    const withDefaults = merge(global, props.defaults?.metadata ?? {});\n    this.metadata = {\n      global,\n      synth: props.synth.metadata ?? {},\n      merged: merge(withDefaults, props.synth.metadata ?? {}),\n    };\n\n    // Expose synth/builder properties directly\n    this.source = props.synth.source;\n    this.plugin = props.synth.plugin;\n    this.network = props.synth.network;\n    this.defaults = props.defaults;\n    this.synthCustomization = {\n      preInstallCommands: props.synth.preInstallCommands,\n      postInstallCommands: props.synth.postInstallCommands,\n      preCommands: props.synth.preCommands,\n      postCommands: props.synth.postCommands,\n      env: props.synth.env,\n    };\n    this.stages = props.stages;\n  }\n\n  /**\n   * Validates BuilderProps to ensure all required fields are present.\n   * Throws an error with detailed messages if validation fails.\n   */\n  private validateProps(props: BuilderProps): void {\n    const errors: string[] = [];\n\n    if (!props.project) {\n      errors.push('BuilderProps.project is required');\n    }\n\n    if (!props.organization) {\n      errors.push('BuilderProps.organization is required');\n    }\n\n    if (!props.synth?.source) {\n      errors.push('BuilderProps.synth.source is required');\n    }\n\n    if (!props.synth?.plugin) {\n      errors.push('BuilderProps.synth.plugin is required');\n    } else if (!props.synth.plugin.name?.trim()) {\n      errors.push('BuilderProps.synth.plugin.name must be a non-empty string');\n    }\n\n    // Validate repo format for GitHub and CodeStar sources (both use \"owner/repo\")\n    const sourceType = props.synth?.source?.type;\n    if (sourceType === 'github' || sourceType === 'codestar') {\n      const repo = props.synth?.source?.options?.repo;\n      if (repo && !repo.includes('/')) {\n        errors.push(`Invalid ${sourceType} repository format: \"${repo}\". Expected format: \"owner/repo\"`);\n      }\n    }\n\n    // Validate pipeline name length (AWS max 100 characters)\n    const MAX_PIPELINE_NAME_LENGTH = CoreConstants.PIPELINE_NAME_MAX_LENGTH;\n    const pipelineName = props.pipelineName\n      ?? `${replaceNonAlphanumeric(props.organization ?? '', '_').toLowerCase()}-${replaceNonAlphanumeric(props.project ?? '', '_').toLowerCase()}-pipeline`;\n    if (pipelineName.length > MAX_PIPELINE_NAME_LENGTH) {\n      errors.push(`Pipeline name \"${pipelineName}\" exceeds AWS maximum of ${MAX_PIPELINE_NAME_LENGTH} characters (${pipelineName.length})`);\n    }\n\n    // Validate stages\n    if (props.stages) {\n      const stageNames = new Set<string>();\n      for (const stage of props.stages) {\n        if (!stage.stageName?.trim()) {\n          errors.push('Each stage must have a non-empty stageName');\n        } else if (stageNames.has(stage.stageName)) {\n          errors.push(`Duplicate stage name: \"${stage.stageName}\"`);\n        } else {\n          stageNames.add(stage.stageName);\n        }\n        if (!stage.steps?.length) {\n          errors.push(`Stage \"${stage.stageName ?? '(unnamed)'}\" must have at least one step`);\n        }\n      }\n    }\n\n    if (errors.length > 0) {\n      throw new Error(\n        'Pipeline configuration validation failed:\\n' +\n        errors.map(e => `  - ${e}`).join('\\n'),\n      );\n    }\n  }\n\n  /**\n   * Extracts S3 source options with defaults applied.\n   *\n   * @returns S3 options with `objectKey` defaulting to `'source.zip'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `s3`\n   */\n  getS3Options(): Required<Pick<S3Options, 'bucketName' | 'objectKey' | 'trigger'>> & Omit<S3Options, 'bucketName' | 'objectKey' | 'trigger'> {\n    const source = this.source;\n    if (source.type !== 's3') {\n      throw new Error('Source type is not S3');\n    }\n\n    return {\n      ...source.options,\n      objectKey: source.options.objectKey ?? 'source.zip',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n\n  /**\n   * Extracts GitHub source options with defaults applied.\n   *\n   * @returns GitHub options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `github`\n   */\n  getGitHubOptions(): Required<Pick<GitHubOptions, 'repo' | 'branch' | 'trigger'>> & Omit<GitHubOptions, 'repo' | 'branch' | 'trigger'> {\n    const source = this.source;\n    if (source.type !== 'github') {\n      throw new Error('Source type is not GitHub');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n\n  /**\n   * Extracts CodeStar source options with defaults applied.\n   *\n   * @returns CodeStar options with `branch` defaulting to `'main'`, `trigger` defaulting to `NONE`, and `codeBuildCloneOutput` defaulting to `false`\n   * @throws {Error} If the configured source type is not `codestar`\n   */\n  getCodeStarOptions(): Required<Pick<CodeStarOptions, 'repo' | 'branch' | 'trigger' | 'codeBuildCloneOutput' | 'connectionArn'>> {\n    const source = this.source;\n    if (source.type !== 'codestar') {\n      throw new Error('Source type is not CodeStar');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n      codeBuildCloneOutput: source.options.codeBuildCloneOutput ?? false,\n    };\n  }\n\n  /**\n   * Extracts CodeCommit source options with defaults applied.\n   *\n   * @returns CodeCommit options with `branch` defaulting to `'main'` and `trigger` defaulting to `NONE`\n   * @throws {Error} If the configured source type is not `codecommit`\n   */\n  getCodeCommitOptions(): Required<Pick<CodeCommitOptions, 'repositoryName' | 'branch' | 'trigger'>> {\n    const source = this.source;\n    if (source.type !== 'codecommit') {\n      throw new Error('Source type is not CodeCommit');\n    }\n\n    return {\n      ...source.options,\n      branch: source.options.branch ?? 'main',\n      trigger: source.options.trigger ?? TriggerType.NONE,\n    };\n  }\n}\n"]}

package/lib/pipeline/plugin-lookup.d.ts

@@ -0,0 +1,100 @@
+import { Plugin } from '@pipeline-builder/pipeline-data';
+import { Duration } from 'aws-cdk-lib';
+import { Runtime } from 'aws-cdk-lib/aws-lambda';
+import { RetentionDays } from 'aws-cdk-lib/aws-logs';
+import { Construct } from 'constructs';
+import type { PluginOptions } from './step-types';
+import { UniqueId } from '../core/id-generator';
+/**
+ * Configuration for PluginLookup construct
+ */
+export interface PluginLookupProps {
+    readonly organization: string;
+    readonly project: string;
+    readonly platformUrl: string;
+    readonly uniqueId: UniqueId;
+    /** Organization ID for resolving per-org secrets from Secrets Manager */
+    readonly orgId?: string;
+    readonly runtime?: Runtime;
+    /** Lambda timeout (default: 30s) */
+    readonly timeout?: Duration;
+    /** Lambda memory in MB (default: 512) */
+    readonly memorySize?: number;
+    /** Log retention (default: ONE_WEEK) */
+    readonly logRetention?: RetentionDays;
+    /** Reserved concurrent executions for the lookup Lambda (default: 30) */
+    readonly reservedConcurrentExecutions?: number;
+}
+/**
+ * CDK Construct responsible for looking up plugin configurations from an external platform
+ * using AWS CloudFormation Custom Resources backed by a Lambda function.
+ *
+ * This construct creates:
+ * - A Lambda function (plugin-lookup-handler) that fetches plugin configs
+ * - A CloudWatch Log Group for the Lambda
+ * - A Custom Resource Provider that invokes the Lambda
+ * - An IAM policy granting the Lambda access to the credentials secret
+ *
+ * ## Prerequisites
+ *
+ * Before deploying, store a JWT token in Secrets Manager:
+ * ```sh
+ * pipeline-manager store-token --days 30 --region <region>
+ * ```
+ *
+ * The Lambda resolves the secret by name at runtime:
+ * `{SECRETS_PATH_PREFIX}/{orgId}/platform`
+ *
+ * @see handlers/plugin-lookup-handler.ts for the Lambda implementation
+ */
+export declare class PluginLookup extends Construct {
+    private readonly _uniqueId;
+    private readonly _provider;
+    private readonly _platformUrl;
+    private readonly _runtime;
+    private readonly _timeout;
+    private readonly _memorySize;
+    private readonly _reservedConcurrentExecutions?;
+    private readonly _orgId?;
+    constructor(scope: Construct, id: string, props: PluginLookupProps);
+    /**
+     * Looks up and resolves plugin configuration using either a simple name or full PluginOptions object
+     * During synthesis, if the value is unresolved (token), returns fallback plugin
+     * During deployment, attempts to parse the actual value returned by the custom resource
+     * @param plugin - Plugin name (string) or complete PluginOptions configuration
+     * @returns Resolved Plugin object or fallback default configuration
+     */
+    plugin(plugin: string | PluginOptions): Plugin;
+    /**
+     * Creates the Lambda function that serves as the event handler for the custom resource provider.
+     *
+     * JWT token is stored in a pre-existing Secrets Manager secret at
+     * `{SECRETS_PATH_PREFIX}/{orgId}/platform`. The Lambda resolves the
+     * secret by name at runtime using `CoreConstants.SECRETS_PATH_PREFIX`.
+     *
+     * Create the secret before deploying with:
+     *   pipeline-manager store-token --days 30 --region <region>
+     */
+    private createLambdaFunction;
+    /**
+     * Build the default plugin filter.
+     * Access control (orgId scoping, public/private visibility) is handled by
+     * the platform's access control query builder based on the JWT's organizationId.
+     */
+    private defaultFilter;
+    private normalize;
+    /**
+     * Creates a CustomResource instance that triggers plugin lookup during deployment
+     */
+    private createCustomResource;
+    /** Base plugin shape with no-op defaults for fields CDK doesn't use. */
+    private static basePlugin;
+    /** Fallback for unresolved plugin lookup tokens during synthesis. */
+    private fallback;
+    /**
+     * Synth plugin with pipeline-manager commands.
+     * Used when RESOLVED_SYNTH_PLUGIN is not set (default/CLI) — CDK needs real
+     * commands at synthesis time, but the custom resource resolves at deploy time.
+     */
+    fallbackSynth(): Plugin;
+}

package/lib/pipeline/plugin-lookup.js

@@ -0,0 +1,247 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginLookup = void 0;
+const path_1 = require("path");
+const api_core_1 = require("@pipeline-builder/api-core");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_lambda_nodejs_1 = require("aws-cdk-lib/aws-lambda-nodejs");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const custom_resources_1 = require("aws-cdk-lib/custom-resources");
+const constructs_1 = require("constructs");
+const app_config_1 = require("../config/app-config");
+const log = (0, api_core_1.createLogger)('Lookup');
+/**
+ * CDK Construct responsible for looking up plugin configurations from an external platform
+ * using AWS CloudFormation Custom Resources backed by a Lambda function.
+ *
+ * This construct creates:
+ * - A Lambda function (plugin-lookup-handler) that fetches plugin configs
+ * - A CloudWatch Log Group for the Lambda
+ * - A Custom Resource Provider that invokes the Lambda
+ * - An IAM policy granting the Lambda access to the credentials secret
+ *
+ * ## Prerequisites
+ *
+ * Before deploying, store a JWT token in Secrets Manager:
+ * ```sh
+ * pipeline-manager store-token --days 30 --region <region>
+ * ```
+ *
+ * The Lambda resolves the secret by name at runtime:
+ * `{SECRETS_PATH_PREFIX}/{orgId}/platform`
+ *
+ * @see handlers/plugin-lookup-handler.ts for the Lambda implementation
+ */
+class PluginLookup extends constructs_1.Construct {
+    _uniqueId;
+    _provider;
+    _platformUrl;
+    _runtime;
+    _timeout;
+    _memorySize;
+    _reservedConcurrentExecutions;
+    _orgId;
+    constructor(scope, id, props) {
+        super(scope, id);
+        if (!props.organization || !props.project) {
+            throw new Error('Both organization and project are required.');
+        }
+        this._uniqueId = props.uniqueId;
+        this._platformUrl = props.platformUrl;
+        this._orgId = props.orgId;
+        this._runtime = props.runtime ?? aws_lambda_1.Runtime.NODEJS_24_X;
+        this._timeout = props.timeout ?? aws_cdk_lib_1.Duration.seconds(30);
+        this._memorySize = props.memorySize ?? app_config_1.Config.get('aws').lambda.memorySize;
+        this._reservedConcurrentExecutions = props.reservedConcurrentExecutions;
+        const onEventHandler = this.createLambdaFunction();
+        const logGroup = new aws_logs_1.LogGroup(this, this._uniqueId.generate('log:group'), {
+            logGroupName: `/aws/lambda/${this._uniqueId.generate('plugin:lookup').replace(/:/g, '-')}`,
+            retention: props.logRetention ?? aws_logs_1.RetentionDays.ONE_WEEK,
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+        });
+        this._provider = new custom_resources_1.Provider(this, this._uniqueId.generate('resource:provider'), {
+            onEventHandler,
+            logGroup,
+        });
+        log.debug(`PluginLookup initialized for ${props.organization}/${props.project}`);
+    }
+    /**
+     * Looks up and resolves plugin configuration using either a simple name or full PluginOptions object
+     * During synthesis, if the value is unresolved (token), returns fallback plugin
+     * During deployment, attempts to parse the actual value returned by the custom resource
+     * @param plugin - Plugin name (string) or complete PluginOptions configuration
+     * @returns Resolved Plugin object or fallback default configuration
+     */
+    plugin(plugin) {
+        const props = this.normalize(plugin);
+        const custom = this.createCustomResource(props);
+        const encoded = custom.getAttString('ResultValue');
+        if (aws_cdk_lib_1.Token.isUnresolved(encoded)) {
+            log.debug(`Plugin "${props.name}" value is unresolved (token) during synthesis — using fallback. The actual plugin will be resolved at deployment time.`);
+            return this.fallback();
+        }
+        try {
+            const decoded = Buffer.from(encoded, 'base64').toString('utf-8');
+            const data = JSON.parse(decoded);
+            if (!data || typeof data !== 'object' || !data.name || !Array.isArray(data.commands)) {
+                throw new Error('Invalid plugin response: missing required fields (name, commands)');
+            }
+            return data;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to parse plugin "${props.name}" data: ${errorMsg}`);
+        }
+    }
+    /**
+     * Creates the Lambda function that serves as the event handler for the custom resource provider.
+     *
+     * JWT token is stored in a pre-existing Secrets Manager secret at
+     * `{SECRETS_PATH_PREFIX}/{orgId}/platform`. The Lambda resolves the
+     * secret by name at runtime using `CoreConstants.SECRETS_PATH_PREFIX`.
+     *
+     * Create the secret before deploying with:
+     *   pipeline-manager store-token --days 30 --region <region>
+     */
+    createLambdaFunction() {
+        if (!this._orgId) {
+            throw new Error('orgId is required for PluginLookup — needed to resolve the per-org platform secret');
+        }
+        const secretName = app_config_1.CoreConstants.secretPath(this._orgId, 'platform');
+        const fn = new aws_lambda_nodejs_1.NodejsFunction(this, this._uniqueId.generate('onevent:handler'), {
+            runtime: this._runtime,
+            timeout: this._timeout,
+            memorySize: this._memorySize,
+            architecture: aws_lambda_1.Architecture.ARM_64,
+            entry: (0, path_1.join)(__dirname, '/../handlers/plugin-lookup-handler.js'),
+            depsLockFilePath: (0, path_1.join)(__dirname, '/../handlers/pnpm-lock.yaml'),
+            reservedConcurrentExecutions: this._reservedConcurrentExecutions,
+            environment: {
+                PLATFORM_SECRET_NAME: secretName,
+                // Allow self-signed certs when platform uses HTTPS without a CA-signed certificate
+                ...(process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0' && {
+                    NODE_TLS_REJECT_UNAUTHORIZED: '0',
+                }),
+            },
+            bundling: {
+                minify: true,
+                sourceMap: false,
+                target: 'es2022',
+                externalModules: ['@aws-sdk/*'],
+            },
+        });
+        // Grant the Lambda permission to read the per-org platform secret.
+        // The wildcard suffix handles the 6-char random ID that Secrets Manager appends.
+        fn.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: ['secretsmanager:GetSecretValue'],
+            resources: [`arn:aws:secretsmanager:*:*:secret:${secretName}-*`],
+        }));
+        return fn;
+    }
+    /**
+     * Build the default plugin filter.
+     * Access control (orgId scoping, public/private visibility) is handled by
+     * the platform's access control query builder based on the JWT's organizationId.
+     */
+    defaultFilter(name) {
+        return {
+            name,
+            isActive: true,
+            isDefault: true,
+        };
+    }
+    normalize(plugin) {
+        if (typeof plugin === 'string') {
+            return {
+                name: plugin,
+                filter: this.defaultFilter(plugin),
+                alias: `${plugin}-alias`,
+            };
+        }
+        return {
+            name: plugin.name,
+            alias: plugin.alias ?? `${plugin.name}-alias`,
+            filter: plugin.filter ?? this.defaultFilter(plugin.name),
+            metadata: plugin.metadata,
+        };
+    }
+    /**
+     * Creates a CustomResource instance that triggers plugin lookup during deployment
+     */
+    createCustomResource(props) {
+        const resourceId = this._uniqueId.generate(props.alias || props.name);
+        return new aws_cdk_lib_1.CustomResource(this, resourceId, {
+            serviceToken: this._provider.serviceToken,
+            resourceType: 'Custom::PluginLookup',
+            properties: {
+                baseURL: this._platformUrl,
+                pluginFilter: props.filter,
+            },
+        });
+    }
+    /** Base plugin shape with no-op defaults for fields CDK doesn't use. */
+    static basePlugin() {
+        const now = new Date();
+        return {
+            id: '00000000-0000-0000-0000-000000000000',
+            orgId: 'system',
+            createdBy: 'system',
+            createdAt: now,
+            updatedBy: 'system',
+            updatedAt: now,
+            name: 'fallback',
+            description: null,
+            keywords: [],
+            category: 'unknown',
+            version: '1.0.0',
+            metadata: {},
+            pluginType: 'CodeBuildStep',
+            computeType: 'SMALL',
+            timeout: null,
+            failureBehavior: 'fail',
+            secrets: [],
+            primaryOutputDirectory: 'cdk.out',
+            env: {},
+            buildArgs: {},
+            installCommands: [],
+            commands: [],
+            imageTag: '',
+            dockerfile: null,
+            buildType: 'metadata_only',
+            accessModifier: 'public',
+            isDefault: false,
+            isActive: true,
+            deletedAt: null,
+            deletedBy: null,
+        };
+    }
+    /** Fallback for unresolved plugin lookup tokens during synthesis. */
+    fallback() {
+        return {
+            ...PluginLookup.basePlugin(),
+            commands: ['echo "FALLBACK: Plugin lookup unresolved — will be resolved at deployment time"'],
+        };
+    }
+    /**
+     * Synth plugin with pipeline-manager commands.
+     * Used when RESOLVED_SYNTH_PLUGIN is not set (default/CLI) — CDK needs real
+     * commands at synthesis time, but the custom resource resolves at deploy time.
+     */
+    fallbackSynth() {
+        return {
+            ...PluginLookup.basePlugin(),
+            name: 'cdk-synth',
+            primaryOutputDirectory: 'cdk.out',
+            commands: [
+                'pipeline-manager synth --id ${PIPELINE_ID} --store-tokens --quiet --no-notices --no-verify-ssl',
+            ],
+        };
+    }
+}
+exports.PluginLookup = PluginLookup;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-lookup.js","sourceRoot":"","sources":["../../src/pipeline/plugin-lookup.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { join } from 'path';\nimport { createLogger } from '@pipeline-builder/api-core';\nimport { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';\nimport { CustomResource, Token, Duration, RemovalPolicy } from 'aws-cdk-lib';\nimport { PolicyStatement, Effect } from 'aws-cdk-lib/aws-iam';\nimport { Runtime, Architecture } from 'aws-cdk-lib/aws-lambda';\nimport { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';\nimport { LogGroup, RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { Provider } from 'aws-cdk-lib/custom-resources';\nimport { Construct } from 'constructs';\nimport type { PluginOptions } from './step-types';\nimport { Config, CoreConstants } from '../config/app-config';\nimport { UniqueId } from '../core/id-generator';\n\nconst log = createLogger('Lookup');\n\ninterface InputProps {\n  readonly baseURL: string;\n  readonly pluginFilter: PluginFilter;\n}\n\n/**\n * Configuration for PluginLookup construct\n */\nexport interface PluginLookupProps {\n  readonly organization: string;\n  readonly project: string;\n  readonly platformUrl: string;\n  readonly uniqueId: UniqueId;\n  /** Organization ID for resolving per-org secrets from Secrets Manager */\n  readonly orgId?: string;\n  readonly runtime?: Runtime;\n  /** Lambda timeout (default: 30s) */\n  readonly timeout?: Duration;\n  /** Lambda memory in MB (default: 512) */\n  readonly memorySize?: number;\n  /** Log retention (default: ONE_WEEK) */\n  readonly logRetention?: RetentionDays;\n  /** Reserved concurrent executions for the lookup Lambda (default: 30) */\n  readonly reservedConcurrentExecutions?: number;\n}\n\n/**\n * CDK Construct responsible for looking up plugin configurations from an external platform\n * using AWS CloudFormation Custom Resources backed by a Lambda function.\n *\n * This construct creates:\n * - A Lambda function (plugin-lookup-handler) that fetches plugin configs\n * - A CloudWatch Log Group for the Lambda\n * - A Custom Resource Provider that invokes the Lambda\n * - An IAM policy granting the Lambda access to the credentials secret\n *\n * ## Prerequisites\n *\n * Before deploying, store a JWT token in Secrets Manager:\n * ```sh\n * pipeline-manager store-token --days 30 --region <region>\n * ```\n *\n * The Lambda resolves the secret by name at runtime:\n * `{SECRETS_PATH_PREFIX}/{orgId}/platform`\n *\n * @see handlers/plugin-lookup-handler.ts for the Lambda implementation\n */\nexport class PluginLookup extends Construct {\n  private readonly _uniqueId: UniqueId;\n  private readonly _provider: Provider;\n  private readonly _platformUrl: string;\n  private readonly _runtime: Runtime;\n  private readonly _timeout: Duration;\n  private readonly _memorySize: number;\n  private readonly _reservedConcurrentExecutions?: number;\n  private readonly _orgId?: string;\n\n  constructor(scope: Construct, id: string, props: PluginLookupProps) {\n    super(scope, id);\n\n    if (!props.organization || !props.project) {\n      throw new Error('Both organization and project are required.');\n    }\n\n    this._uniqueId = props.uniqueId;\n    this._platformUrl = props.platformUrl;\n    this._orgId = props.orgId;\n    this._runtime = props.runtime ?? Runtime.NODEJS_24_X;\n    this._timeout = props.timeout ?? Duration.seconds(30);\n    this._memorySize = props.memorySize ?? Config.get('aws').lambda.memorySize;\n    this._reservedConcurrentExecutions = props.reservedConcurrentExecutions;\n\n    const onEventHandler = this.createLambdaFunction();\n\n    const logGroup = new LogGroup(this, this._uniqueId.generate('log:group'), {\n      logGroupName: `/aws/lambda/${this._uniqueId.generate('plugin:lookup').replace(/:/g, '-')}`,\n      retention: props.logRetention ?? RetentionDays.ONE_WEEK,\n      removalPolicy: RemovalPolicy.DESTROY,\n    });\n\n    this._provider = new Provider(this, this._uniqueId.generate('resource:provider'), {\n      onEventHandler,\n      logGroup,\n    });\n\n    log.debug(`PluginLookup initialized for ${props.organization}/${props.project}`);\n  }\n\n  /**\n   * Looks up and resolves plugin configuration using either a simple name or full PluginOptions object\n   * During synthesis, if the value is unresolved (token), returns fallback plugin\n   * During deployment, attempts to parse the actual value returned by the custom resource\n   * @param plugin - Plugin name (string) or complete PluginOptions configuration\n   * @returns Resolved Plugin object or fallback default configuration\n   */\n  public plugin(plugin: string | PluginOptions): Plugin {\n    const props = this.normalize(plugin);\n    const custom = this.createCustomResource(props);\n    const encoded = custom.getAttString('ResultValue');\n\n    if (Token.isUnresolved(encoded)) {\n      log.debug(`Plugin \"${props.name}\" value is unresolved (token) during synthesis — using fallback. The actual plugin will be resolved at deployment time.`);\n      return this.fallback();\n    }\n\n    try {\n      const decoded = Buffer.from(encoded, 'base64').toString('utf-8');\n      const data = JSON.parse(decoded);\n\n      if (!data || typeof data !== 'object' || !data.name || !Array.isArray(data.commands)) {\n        throw new Error('Invalid plugin response: missing required fields (name, commands)');\n      }\n\n      return data as Plugin;\n    } catch (error) {\n      const errorMsg = error instanceof Error ? error.message : 'Unknown error';\n      throw new Error(`Failed to parse plugin \"${props.name}\" data: ${errorMsg}`);\n    }\n  }\n\n  /**\n   * Creates the Lambda function that serves as the event handler for the custom resource provider.\n   *\n   * JWT token is stored in a pre-existing Secrets Manager secret at\n   * `{SECRETS_PATH_PREFIX}/{orgId}/platform`. The Lambda resolves the\n   * secret by name at runtime using `CoreConstants.SECRETS_PATH_PREFIX`.\n   *\n   * Create the secret before deploying with:\n   *   pipeline-manager store-token --days 30 --region <region>\n   */\n  private createLambdaFunction(): NodejsFunction {\n    if (!this._orgId) {\n      throw new Error('orgId is required for PluginLookup — needed to resolve the per-org platform secret');\n    }\n    const secretName = CoreConstants.secretPath(this._orgId, 'platform');\n\n    const fn = new NodejsFunction(this, this._uniqueId.generate('onevent:handler'), {\n      runtime: this._runtime,\n      timeout: this._timeout,\n      memorySize: this._memorySize,\n      architecture: Architecture.ARM_64,\n      entry: join(__dirname, '/../handlers/plugin-lookup-handler.js'),\n      depsLockFilePath: join(__dirname, '/../handlers/pnpm-lock.yaml'),\n      reservedConcurrentExecutions: this._reservedConcurrentExecutions,\n      environment: {\n        PLATFORM_SECRET_NAME: secretName,\n        // Allow self-signed certs when platform uses HTTPS without a CA-signed certificate\n        ...(process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0' && {\n          NODE_TLS_REJECT_UNAUTHORIZED: '0',\n        }),\n      },\n      bundling: {\n        minify: true,\n        sourceMap: false,\n        target: 'es2022',\n        externalModules: ['@aws-sdk/*'],\n      },\n    });\n\n    // Grant the Lambda permission to read the per-org platform secret.\n    // The wildcard suffix handles the 6-char random ID that Secrets Manager appends.\n    fn.addToRolePolicy(new PolicyStatement({\n      effect: Effect.ALLOW,\n      actions: ['secretsmanager:GetSecretValue'],\n      resources: [`arn:aws:secretsmanager:*:*:secret:${secretName}-*`],\n    }));\n\n    return fn;\n  }\n\n  /**\n   * Build the default plugin filter.\n   * Access control (orgId scoping, public/private visibility) is handled by\n   * the platform's access control query builder based on the JWT's organizationId.\n   */\n  private defaultFilter(name: string): PluginFilter {\n    return {\n      name,\n      isActive: true,\n      isDefault: true,\n    };\n  }\n\n  private normalize(plugin: string | PluginOptions): PluginOptions {\n    if (typeof plugin === 'string') {\n      return {\n        name: plugin,\n        filter: this.defaultFilter(plugin),\n        alias: `${plugin}-alias`,\n      };\n    }\n\n    return {\n      name: plugin.name,\n      alias: plugin.alias ?? `${plugin.name}-alias`,\n      filter: plugin.filter ?? this.defaultFilter(plugin.name),\n      metadata: plugin.metadata,\n    };\n  }\n\n  /**\n   * Creates a CustomResource instance that triggers plugin lookup during deployment\n   */\n  private createCustomResource(props: PluginOptions): CustomResource {\n    const resourceId = this._uniqueId.generate(props.alias || props.name);\n\n    return new CustomResource(this, resourceId, {\n      serviceToken: this._provider.serviceToken,\n      resourceType: 'Custom::PluginLookup',\n      properties: {\n        baseURL: this._platformUrl,\n        pluginFilter: props.filter,\n      } as InputProps,\n    });\n  }\n\n  /** Base plugin shape with no-op defaults for fields CDK doesn't use. */\n  private static basePlugin(): Plugin {\n    const now = new Date();\n    return {\n      id: '00000000-0000-0000-0000-000000000000',\n      orgId: 'system',\n      createdBy: 'system',\n      createdAt: now,\n      updatedBy: 'system',\n      updatedAt: now,\n      name: 'fallback',\n      description: null,\n      keywords: [],\n      category: 'unknown',\n      version: '1.0.0',\n      metadata: {},\n      pluginType: 'CodeBuildStep',\n      computeType: 'SMALL',\n      timeout: null,\n      failureBehavior: 'fail',\n      secrets: [],\n      primaryOutputDirectory: 'cdk.out',\n      env: {},\n      buildArgs: {},\n      installCommands: [],\n      commands: [],\n      imageTag: '',\n      dockerfile: null,\n      buildType: 'metadata_only',\n      accessModifier: 'public',\n      isDefault: false,\n      isActive: true,\n      deletedAt: null,\n      deletedBy: null,\n    };\n  }\n\n  /** Fallback for unresolved plugin lookup tokens during synthesis. */\n  private fallback(): Plugin {\n    return {\n      ...PluginLookup.basePlugin(),\n      commands: ['echo \"FALLBACK: Plugin lookup unresolved — will be resolved at deployment time\"'],\n    };\n  }\n\n  /**\n   * Synth plugin with pipeline-manager commands.\n   * Used when RESOLVED_SYNTH_PLUGIN is not set (default/CLI) — CDK needs real\n   * commands at synthesis time, but the custom resource resolves at deploy time.\n   */\n  public fallbackSynth(): Plugin {\n    return {\n      ...PluginLookup.basePlugin(),\n      name: 'cdk-synth',\n      primaryOutputDirectory: 'cdk.out',\n      commands: [\n        'pipeline-manager synth --id ${PIPELINE_ID} --store-tokens --quiet --no-notices --no-verify-ssl',\n      ],\n    };\n  }\n}\n"]}