@pipeline-builder/pipeline-core 0.0.1

package/lib/pipeline/plugin-lookup.js

@@ -0,0 +1,316 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { createLogger, SYSTEM_ORG_ID } from '@pipeline-builder/api-core';
+import { CustomResource, Token, Duration } from 'aws-cdk-lib';
+import { PolicyStatement, Effect } from 'aws-cdk-lib/aws-iam';
+import { Runtime, Architecture } from 'aws-cdk-lib/aws-lambda';
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { LogGroup, RetentionDays } from 'aws-cdk-lib/aws-logs';
+import { Provider } from 'aws-cdk-lib/custom-resources';
+import { Construct } from 'constructs';
+import { Config, CoreConstants } from '../config/app-config.js';
+import { UniqueId } from '../core/id-generator.js';
+const log = createLogger('plugin-lookup');
+// ESM-safe module directory (the package is `type: module`; `__dirname` is
+// not defined under ES modules).
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+/**
+ * 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 infra 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 class PluginLookup extends Construct {
+    _uniqueId;
+    _provider;
+    _platformUrl;
+    _runtime;
+    _timeout;
+    _memorySize;
+    _reservedConcurrentExecutions;
+    _orgId;
+    _resolvedPlugins;
+    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 ?? Runtime.NODEJS_24_X;
+        this._timeout = props.timeout ?? Duration.seconds(30);
+        this._memorySize = props.memorySize ?? Config.get('aws').lambda.memorySize;
+        this._reservedConcurrentExecutions = props.reservedConcurrentExecutions;
+        this._resolvedPlugins = props.resolvedPlugins;
+        const onEventHandler = this.createLambdaFunction();
+        // Log-group strategy:
+        //   Previous code created an `AWS::Logs::LogGroup` resource with an
+        //   EXPLICIT name (`/aws/lambda/plugin-lookup-N`). That breaks every
+        //   re-deploy after a rolled-back stack: AWS auto-creates the group on
+        //   first Lambda invocation, the rollback leaves it as an orphan, and
+        //   the next CDK run fails with "Resource ... already exists" because
+        //   the explicit name collides with the orphan.
+        //
+        //   Fix: use `LogGroup.fromLogGroupName()` to adopt-or-pass-through.
+        //   If the group exists, CDK references it without trying to recreate.
+        //   If it doesn't, AWS Lambda auto-creates it on first invocation.
+        //   Retention is then set via a separate retention-policy custom
+        //   resource which is idempotent (safe to apply to existing groups).
+        const logGroupName = `/aws/lambda/${this._uniqueId.generate('plugin:lookup').replace(/:/g, '-')}`;
+        const logGroup = LogGroup.fromLogGroupName(this, this._uniqueId.generate('log:group'), logGroupName);
+        this._provider = new 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);
+        // Pre-resolved by `pipeline-manager pipeline synth` from the platform API.
+        // Skip the custom resource entirely — we already know the plugin's
+        // name, version, commands, env, etc. at synth time, so the resulting CFN
+        // template can ship with the real CodeBuild image baked in.
+        const cacheKey = props.alias || props.name;
+        const preResolved = this._resolvedPlugins?.[cacheKey];
+        if (preResolved) {
+            log.debug(`Plugin "${props.name}" pre-resolved (alias=${cacheKey}) — skipping custom resource`);
+            return preResolved;
+        }
+        const custom = this.createCustomResource(props);
+        const encoded = custom.getAttString('ResultValue');
+        if (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 infra 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 = CoreConstants.secretPath(this._orgId, 'platform');
+        const fn = new NodejsFunction(this, this._uniqueId.generate('onevent:handler'), {
+            runtime: this._runtime,
+            timeout: this._timeout,
+            memorySize: this._memorySize,
+            architecture: Architecture.ARM_64,
+            entry: join(MODULE_DIR, '/../handlers/plugin-lookup-handler.js'),
+            depsLockFilePath: join(MODULE_DIR, '/../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: [
+                    // Provided by the Lambda Node.js runtime — never bundle.
+                    '@aws-sdk/*',
+                    // Synth-only libraries that must NEVER end up in a Lambda bundle.
+                    // The handler doesn't use them; this is a guard so a stray transitive
+                    // import (e.g. via a config module that pulls infrastructure-config →
+                    // aws-cdk-lib) can't drag the entire ~hundreds-of-MB CDK into the
+                    // bundle and OOM-kill esbuild during cold-start synth. If one of these
+                    // is ever genuinely reached at runtime the Lambda will fail loudly at
+                    // init (module not found) rather than silently OOM at synth — which is
+                    // the correct signal, since CDK has no business running in this Lambda.
+                    'aws-cdk-lib',
+                    'aws-cdk-lib/*',
+                    'constructs',
+                ],
+            },
+        });
+        // 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 PolicyStatement({
+            effect: 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 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_ORG_ID,
+            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: [],
+            dockerfile: null,
+            buildType: 'metadata_only',
+            ownerId: null,
+            ownerType: null,
+            lifecycle: 'production',
+            criticality: null,
+            labels: {},
+            links: [],
+            visibility: 'public',
+            isDefault: false,
+            isActive: true,
+            deletedAt: null,
+            deletedBy: null,
+            purgeAfter: null,
+        };
+    }
+    /**
+     * Fallback for a plugin whose lookup returned no record (not in the platform
+     * catalog for this org) and so could not be pre-resolved at synth.
+     *
+     * This step FAILS the build (exit 1) on purpose. The previous behaviour —
+     * `echo "…" && exit 0` — was a false positive: an unresolved security/quality
+     * step (dependency-check, semgrep, spotbugs, …) reported the stage green while
+     * running nothing, giving false assurance that scans/builds had passed. A
+     * plugin step that can't run its plugin must go red, consistent with
+     * `basePlugin().failureBehavior === 'fail'`. The message is actionable so the
+     * operator knows the catalog is empty/incomplete, not that the tool crashed.
+     */
+    fallback() {
+        return {
+            ...PluginLookup.basePlugin(),
+            commands: [
+                'echo "ERROR: plugin lookup returned no record — this plugin is not in the platform catalog for this org, so the step cannot run." >&2',
+                'echo "This step fails instead of passing as a no-op (an unresolved plugin reporting success would be a false-positive green)." >&2',
+                'echo "Fix: load the plugin into the platform (deploy/bin/load-plugins.sh), then re-run the pipeline." >&2',
+                'exit 1',
+            ],
+        };
+    }
+    /**
+     * Synth plugin with pipeline-manager commands. Cold-start bootstrap for
+     * the synth step when pre-resolution by `pipeline-manager pipeline synth/deploy`
+     * didn't populate `resolvedPlugins` for the synth plugin. Runs on the
+     * configured `CODEBUILD_DEFAULT_IMAGE` (default `pipeline-bootstrap:1.0`)
+     * and self-bootstraps the real synth via
+     * `pipeline-manager pipeline synth --id ${PIPELINE_ID}`.
+     *
+     * No `installCommands`: the default image already has `pipeline-manager`
+     * baked in (that's the whole point of `pipeline-bootstrap:1.0`). If the
+     * operator points CODEBUILD_DEFAULT_IMAGE at an image lacking it (e.g.
+     * vanilla aws/codebuild/standard:7.0), this step exits 127 — fix that
+     * by using an image with pipeline-manager rather than papering over it
+     * with a per-build `npm install -g`.
+     */
+    bootstrap() {
+        return {
+            ...PluginLookup.basePlugin(),
+            name: 'cdk-synth',
+            primaryOutputDirectory: 'cdk.out',
+            commands: [
+                'pipeline-manager pipeline synth --id ${PIPELINE_ID} --store-tokens --quiet --no-notices --no-verify-ssl',
+            ],
+        };
+    }
+}
+//# 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 { dirname, join } from 'path';\nimport { fileURLToPath } from 'url';\nimport { createLogger, SYSTEM_ORG_ID } from '@pipeline-builder/api-core';\nimport type { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';\nimport { CustomResource, Token, Duration } 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.js';\nimport { Config, CoreConstants } from '../config/app-config.js';\nimport { UniqueId } from '../core/id-generator.js';\n\nconst log = createLogger('plugin-lookup');\n\n// ESM-safe module directory (the package is `type: module`; `__dirname` is\n// not defined under ES modules).\nconst MODULE_DIR = dirname(fileURLToPath(import.meta.url));\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   * Plugins pre-resolved by `pipeline-manager pipeline synth` from the platform API.\n   * Keyed by `alias || name` (matches the construct's normalize() output).\n   * When a lookup hits this map, `plugin()` returns the resolved Plugin\n   * directly — no custom resource is created. This is what makes the\n   * name, version, commands, env, etc. available at synth time so the resulting\n   * CFN template ships with the real values baked in.\n   */\n  readonly resolvedPlugins?: Record<string, Plugin>;\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 infra 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  private readonly _resolvedPlugins?: Record<string, Plugin>;\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    this._resolvedPlugins = props.resolvedPlugins;\n\n    const onEventHandler = this.createLambdaFunction();\n\n    // Log-group strategy:\n    //   Previous code created an `AWS::Logs::LogGroup` resource with an\n    //   EXPLICIT name (`/aws/lambda/plugin-lookup-N`). That breaks every\n    //   re-deploy after a rolled-back stack: AWS auto-creates the group on\n    //   first Lambda invocation, the rollback leaves it as an orphan, and\n    //   the next CDK run fails with \"Resource ... already exists\" because\n    //   the explicit name collides with the orphan.\n    //\n    //   Fix: use `LogGroup.fromLogGroupName()` to adopt-or-pass-through.\n    //   If the group exists, CDK references it without trying to recreate.\n    //   If it doesn't, AWS Lambda auto-creates it on first invocation.\n    //   Retention is then set via a separate retention-policy custom\n    //   resource which is idempotent (safe to apply to existing groups).\n    const logGroupName = `/aws/lambda/${this._uniqueId.generate('plugin:lookup').replace(/:/g, '-')}`;\n    const logGroup = LogGroup.fromLogGroupName(\n      this,\n      this._uniqueId.generate('log:group'),\n      logGroupName,\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\n    // Pre-resolved by `pipeline-manager pipeline synth` from the platform API.\n    // Skip the custom resource entirely — we already know the plugin's\n    // name, version, commands, env, etc. at synth time, so the resulting CFN\n    // template can ship with the real CodeBuild image baked in.\n    const cacheKey = props.alias || props.name;\n    const preResolved = this._resolvedPlugins?.[cacheKey];\n    if (preResolved) {\n      log.debug(`Plugin \"${props.name}\" pre-resolved (alias=${cacheKey}) — skipping custom resource`);\n      return preResolved;\n    }\n\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 infra 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(MODULE_DIR, '/../handlers/plugin-lookup-handler.js'),\n      depsLockFilePath: join(MODULE_DIR, '/../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: [\n          // Provided by the Lambda Node.js runtime — never bundle.\n          '@aws-sdk/*',\n          // Synth-only libraries that must NEVER end up in a Lambda bundle.\n          // The handler doesn't use them; this is a guard so a stray transitive\n          // import (e.g. via a config module that pulls infrastructure-config →\n          // aws-cdk-lib) can't drag the entire ~hundreds-of-MB CDK into the\n          // bundle and OOM-kill esbuild during cold-start synth. If one of these\n          // is ever genuinely reached at runtime the Lambda will fail loudly at\n          // init (module not found) rather than silently OOM at synth — which is\n          // the correct signal, since CDK has no business running in this Lambda.\n          'aws-cdk-lib',\n          'aws-cdk-lib/*',\n          'constructs',\n        ],\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_ORG_ID,\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      dockerfile: null,\n      buildType: 'metadata_only',\n      ownerId: null,\n      ownerType: null,\n      lifecycle: 'production',\n      criticality: null,\n      labels: {},\n      links: [],\n      visibility: 'public',\n      isDefault: false,\n      isActive: true,\n      deletedAt: null,\n      deletedBy: null,\n      purgeAfter: null,\n    };\n  }\n\n  /**\n   * Fallback for a plugin whose lookup returned no record (not in the platform\n   * catalog for this org) and so could not be pre-resolved at synth.\n   *\n   * This step FAILS the build (exit 1) on purpose. The previous behaviour —\n   * `echo \"…\" && exit 0` — was a false positive: an unresolved security/quality\n   * step (dependency-check, semgrep, spotbugs, …) reported the stage green while\n   * running nothing, giving false assurance that scans/builds had passed. A\n   * plugin step that can't run its plugin must go red, consistent with\n   * `basePlugin().failureBehavior === 'fail'`. The message is actionable so the\n   * operator knows the catalog is empty/incomplete, not that the tool crashed.\n   */\n  private fallback(): Plugin {\n    return {\n      ...PluginLookup.basePlugin(),\n      commands: [\n        'echo \"ERROR: plugin lookup returned no record — this plugin is not in the platform catalog for this org, so the step cannot run.\" >&2',\n        'echo \"This step fails instead of passing as a no-op (an unresolved plugin reporting success would be a false-positive green).\" >&2',\n        'echo \"Fix: load the plugin into the platform (deploy/bin/load-plugins.sh), then re-run the pipeline.\" >&2',\n        'exit 1',\n      ],\n    };\n  }\n\n  /**\n   * Synth plugin with pipeline-manager commands. Cold-start bootstrap for\n   * the synth step when pre-resolution by `pipeline-manager pipeline synth/deploy`\n   * didn't populate `resolvedPlugins` for the synth plugin. Runs on the\n   * configured `CODEBUILD_DEFAULT_IMAGE` (default `pipeline-bootstrap:1.0`)\n   * and self-bootstraps the real synth via\n   * `pipeline-manager pipeline synth --id ${PIPELINE_ID}`.\n   *\n   * No `installCommands`: the default image already has `pipeline-manager`\n   * baked in (that's the whole point of `pipeline-bootstrap:1.0`). If the\n   * operator points CODEBUILD_DEFAULT_IMAGE at an image lacking it (e.g.\n   * vanilla aws/codebuild/standard:7.0), this step exits 127 — fix that\n   * by using an image with pipeline-manager rather than papering over it\n   * with a per-build `npm install -g`.\n   */\n  public bootstrap(): Plugin {\n    return {\n      ...PluginLookup.basePlugin(),\n      name: 'cdk-synth',\n      primaryOutputDirectory: 'cdk.out',\n      commands: [\n        'pipeline-manager pipeline synth --id ${PIPELINE_ID} --store-tokens --quiet --no-notices --no-verify-ssl',\n      ],\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,138 @@
+/**
+ * The `PluginSpec` domain type — the shape of a plugin's declared contract as
+ * stored in the database and exchanged over the API.
+ *
+ * Kept in its own module, apart from the synth-time authoring types in
+ * `step-types.ts`, because those reference CDK types (`Construct`,
+ * `IFileSetProducer`, CodeBuild's `ComputeType`) while this one is pure data.
+ * API services consume `PluginSpec`; only the CDK entry point consumes the rest.
+ */
+import type { ComputeType, PluginType } from '../core/pipeline-types.js';
+/**
+ * Plugin spec defining plugin behavior and requirements.
+ * This is typically loaded from a plugin spec file (plugin-spec.yaml).
+ */
+export interface PluginSpec {
+    /**
+     * Unique identifier for the plugin
+     * @example 'nodejs-build'
+     */
+    readonly name: string;
+    /**
+     * Human-readable description of what the plugin does
+     * @example 'Builds and tests Node.js applications'
+     */
+    readonly description?: string;
+    /**
+     * Keywords for plugin discovery and categorization
+     * @example ['nodejs', 'typescript', 'build', 'test']
+     */
+    readonly keywords?: string[];
+    /**
+     * Plugin category for AI-assisted selection and organization.
+     * One of: language, security, quality, testing, deploy, artifact,
+     *         infrastructure, monitoring, notification, ai
+     */
+    readonly category?: string;
+    /**
+     * Semantic version of the plugin
+     * @example '1.0.0'
+     */
+    readonly version?: string;
+    /**
+     * Type of pipeline step this plugin creates
+     * @default PluginType.CODE_BUILD_STEP
+     */
+    readonly pluginType?: PluginType;
+    /**
+     * CodeBuild compute resource size to use
+     * @default ComputeType.SMALL
+     */
+    readonly computeType?: ComputeType;
+    /**
+     * Maximum execution time in minutes.
+     * Used as fallback when the pipeline step doesn't set timeout.
+     * @default 60 (AWS CodeBuild default)
+     */
+    readonly timeout?: number;
+    /**
+     * What happens when this step fails.
+     * - 'fail': Stop the pipeline (default)
+     * - 'warn': Log a warning and continue
+     * - 'ignore': Silently continue
+     * @default 'fail'
+     */
+    readonly failureBehavior?: 'fail' | 'warn' | 'ignore';
+    /**
+     * Secret requirements for this plugin.
+     * Declares named secrets the plugin expects at build time.
+     */
+    readonly secrets?: Array<{
+        name: string;
+        required: boolean;
+        description?: string;
+    }>;
+    /**
+     * Directory containing the primary build output artifacts
+     * @example 'dist'
+     */
+    readonly primaryOutputDirectory?: string;
+    /**
+     * Additional metadata that can be accessed during plugin execution
+     * Keys should use the format 'aws:cdk:{namespace}:{key}' (all lowercase)
+     */
+    readonly metadata?: Record<string, string | number | boolean>;
+    /**
+     * Path to Dockerfile or Dockerfile content
+     * Used to build the container environment for this plugin
+     */
+    readonly dockerfile?: string;
+    /**
+     * Commands to run during the install phase
+     * Typically used for installing dependencies
+     * @example ['npm ci', 'npm run build']
+     */
+    readonly installCommands?: string[];
+    /**
+     * Commands to run during the build/execution phase
+     * These are the main commands that perform the plugin's work
+     * @example ['npm test', 'npm run deploy']
+     */
+    readonly commands?: string[];
+    /**
+     * Environment variables to set in the build environment
+     * @example { API_URL: 'https://api.example.com', LOG_LEVEL: 'info' }
+     */
+    readonly env?: Record<string, string>;
+    /**
+     * Docker build arguments passed via --build-arg at image build time.
+     * Used to parameterize Dockerfile ARG values when building the plugin image.
+     * @example { PYTHON_VERSION: '3.12', NODE_ENV: 'production' }
+     */
+    readonly buildArgs?: Record<string, string>;
+    /**
+     * Pipeline metadata keys the plugin references via `{{ pipeline.metadata.X }}`.
+     * Declared as a contract — pipelines using this plugin must supply all
+     * listed keys unless the template uses `| default: '...'`.
+     * @example ['env', 'namespace', 'clusterName']
+     */
+    readonly requiredMetadata?: string[];
+    /**
+     * Pipeline vars keys the plugin references via `{{ pipeline.vars.X }}`.
+     * @example ['branch', 'slackChannel']
+     */
+    readonly requiredVars?: string[];
+    /**
+     * Optional type declarations for the metadata keys listed in `requiredMetadata`.
+     * Used at upload time to verify that coercion filters (`| number`, `| bool`,
+     * `| json`) match the declared type — e.g. `{{ pipeline.metadata.count | number }}`
+     * requires `count: 'number'` here, otherwise the plugin is rejected.
+     * Keys not declared default to `'string'`.
+     * @example { count: 'number', enabled: 'bool' }
+     */
+    readonly metadataTypes?: Record<string, 'string' | 'number' | 'bool' | 'json'>;
+    /**
+     * Optional type declarations for vars keys (same semantics as `metadataTypes`).
+     */
+    readonly varsTypes?: Record<string, 'string' | 'number' | 'bool' | 'json'>;
+}

package/lib/pipeline/plugin-spec.js

@@ -0,0 +1,4 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLXNwZWMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcGlwZWxpbmUvcGx1Z2luLXNwZWMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIFRoZSBgUGx1Z2luU3BlY2AgZG9tYWluIHR5cGUg4oCUIHRoZSBzaGFwZSBvZiBhIHBsdWdpbidzIGRlY2xhcmVkIGNvbnRyYWN0IGFzXG4gKiBzdG9yZWQgaW4gdGhlIGRhdGFiYXNlIGFuZCBleGNoYW5nZWQgb3ZlciB0aGUgQVBJLlxuICpcbiAqIEtlcHQgaW4gaXRzIG93biBtb2R1bGUsIGFwYXJ0IGZyb20gdGhlIHN5bnRoLXRpbWUgYXV0aG9yaW5nIHR5cGVzIGluXG4gKiBgc3RlcC10eXBlcy50c2AsIGJlY2F1c2UgdGhvc2UgcmVmZXJlbmNlIENESyB0eXBlcyAoYENvbnN0cnVjdGAsXG4gKiBgSUZpbGVTZXRQcm9kdWNlcmAsIENvZGVCdWlsZCdzIGBDb21wdXRlVHlwZWApIHdoaWxlIHRoaXMgb25lIGlzIHB1cmUgZGF0YS5cbiAqIEFQSSBzZXJ2aWNlcyBjb25zdW1lIGBQbHVnaW5TcGVjYDsgb25seSB0aGUgQ0RLIGVudHJ5IHBvaW50IGNvbnN1bWVzIHRoZSByZXN0LlxuICovXG5cbmltcG9ydCB0eXBlIHsgQ29tcHV0ZVR5cGUsIFBsdWdpblR5cGUgfSBmcm9tICcuLi9jb3JlL3BpcGVsaW5lLXR5cGVzLmpzJztcblxuLyoqXG4gKiBQbHVnaW4gc3BlYyBkZWZpbmluZyBwbHVnaW4gYmVoYXZpb3IgYW5kIHJlcXVpcmVtZW50cy5cbiAqIFRoaXMgaXMgdHlwaWNhbGx5IGxvYWRlZCBmcm9tIGEgcGx1Z2luIHNwZWMgZmlsZSAocGx1Z2luLXNwZWMueWFtbCkuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUGx1Z2luU3BlYyB7XG4gIC8qKlxuICAgKiBVbmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIHBsdWdpblxuICAgKiBAZXhhbXBsZSAnbm9kZWpzLWJ1aWxkJ1xuICAgKi9cbiAgcmVhZG9ubHkgbmFtZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBIdW1hbi1yZWFkYWJsZSBkZXNjcmlwdGlvbiBvZiB3aGF0IHRoZSBwbHVnaW4gZG9lc1xuICAgKiBAZXhhbXBsZSAnQnVpbGRzIGFuZCB0ZXN0cyBOb2RlLmpzIGFwcGxpY2F0aW9ucydcbiAgICovXG4gIHJlYWRvbmx5IGRlc2NyaXB0aW9uPzogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBLZXl3b3JkcyBmb3IgcGx1Z2luIGRpc2NvdmVyeSBhbmQgY2F0ZWdvcml6YXRpb25cbiAgICogQGV4YW1wbGUgWydub2RlanMnLCAndHlwZXNjcmlwdCcsICdidWlsZCcsICd0ZXN0J11cbiAgICovXG4gIHJlYWRvbmx5IGtleXdvcmRzPzogc3RyaW5nW107XG5cbiAgLyoqXG4gICAqIFBsdWdpbiBjYXRlZ29yeSBmb3IgQUktYXNzaXN0ZWQgc2VsZWN0aW9uIGFuZCBvcmdhbml6YXRpb24uXG4gICAqIE9uZSBvZjogbGFuZ3VhZ2UsIHNlY3VyaXR5LCBxdWFsaXR5LCB0ZXN0aW5nLCBkZXBsb3ksIGFydGlmYWN0LFxuICAgKiAgICAgICAgIGluZnJhc3RydWN0dXJlLCBtb25pdG9yaW5nLCBub3RpZmljYXRpb24sIGFpXG4gICAqL1xuICByZWFkb25seSBjYXRlZ29yeT86IHN0cmluZztcblxuICAvKipcbiAgICogU2VtYW50aWMgdmVyc2lvbiBvZiB0aGUgcGx1Z2luXG4gICAqIEBleGFtcGxlICcxLjAuMCdcbiAgICovXG4gIHJlYWRvbmx5IHZlcnNpb24/OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFR5cGUgb2YgcGlwZWxpbmUgc3RlcCB0aGlzIHBsdWdpbiBjcmVhdGVzXG4gICAqIEBkZWZhdWx0IFBsdWdpblR5cGUuQ09ERV9CVUlMRF9TVEVQXG4gICAqL1xuICByZWFkb25seSBwbHVnaW5UeXBlPzogUGx1Z2luVHlwZTtcblxuICAvKipcbiAgICogQ29kZUJ1aWxkIGNvbXB1dGUgcmVzb3VyY2Ugc2l6ZSB0byB1c2VcbiAgICogQGRlZmF1bHQgQ29tcHV0ZVR5cGUuU01BTExcbiAgICovXG4gIHJlYWRvbmx5IGNvbXB1dGVUeXBlPzogQ29tcHV0ZVR5cGU7XG5cbiAgLyoqXG4gICAqIE1heGltdW0gZXhlY3V0aW9uIHRpbWUgaW4gbWludXRlcy5cbiAgICogVXNlZCBhcyBmYWxsYmFjayB3aGVuIHRoZSBwaXBlbGluZSBzdGVwIGRvZXNuJ3Qgc2V0IHRpbWVvdXQuXG4gICAqIEBkZWZhdWx0IDYwIChBV1MgQ29kZUJ1aWxkIGRlZmF1bHQpXG4gICAqL1xuICByZWFkb25seSB0aW1lb3V0PzogbnVtYmVyO1xuXG4gIC8qKlxuICAgKiBXaGF0IGhhcHBlbnMgd2hlbiB0aGlzIHN0ZXAgZmFpbHMuXG4gICAqIC0gJ2ZhaWwnOiBTdG9wIHRoZSBwaXBlbGluZSAoZGVmYXVsdClcbiAgICogLSAnd2Fybic6IExvZyBhIHdhcm5pbmcgYW5kIGNvbnRpbnVlXG4gICAqIC0gJ2lnbm9yZSc6IFNpbGVudGx5IGNvbnRpbnVlXG4gICAqIEBkZWZhdWx0ICdmYWlsJ1xuICAgKi9cbiAgcmVhZG9ubHkgZmFpbHVyZUJlaGF2aW9yPzogJ2ZhaWwnIHwgJ3dhcm4nIHwgJ2lnbm9yZSc7XG5cbiAgLyoqXG4gICAqIFNlY3JldCByZXF1aXJlbWVudHMgZm9yIHRoaXMgcGx1Z2luLlxuICAgKiBEZWNsYXJlcyBuYW1lZCBzZWNyZXRzIHRoZSBwbHVnaW4gZXhwZWN0cyBhdCBidWlsZCB0aW1lLlxuICAgKi9cbiAgcmVhZG9ubHkgc2VjcmV0cz86IEFycmF5PHsgbmFtZTogc3RyaW5nOyByZXF1aXJlZDogYm9vbGVhbjsgZGVzY3JpcHRpb24/OiBzdHJpbmcgfT47XG5cbiAgLyoqXG4gICAqIERpcmVjdG9yeSBjb250YWluaW5nIHRoZSBwcmltYXJ5IGJ1aWxkIG91dHB1dCBhcnRpZmFjdHNcbiAgICogQGV4YW1wbGUgJ2Rpc3QnXG4gICAqL1xuICByZWFkb25seSBwcmltYXJ5T3V0cHV0RGlyZWN0b3J5Pzogc3RyaW5nO1xuICAvKipcbiAgICogQWRkaXRpb25hbCBtZXRhZGF0YSB0aGF0IGNhbiBiZSBhY2Nlc3NlZCBkdXJpbmcgcGx1Z2luIGV4ZWN1dGlvblxuICAgKiBLZXlzIHNob3VsZCB1c2UgdGhlIGZvcm1hdCAnYXdzOmNkazp7bmFtZXNwYWNlfTp7a2V5fScgKGFsbCBsb3dlcmNhc2UpXG4gICAqL1xuICByZWFkb25seSBtZXRhZGF0YT86IFJlY29yZDxzdHJpbmcsIHN0cmluZyB8IG51bWJlciB8IGJvb2xlYW4+O1xuXG4gIC8qKlxuICAgKiBQYXRoIHRvIERvY2tlcmZpbGUgb3IgRG9ja2VyZmlsZSBjb250ZW50XG4gICAqIFVzZWQgdG8gYnVpbGQgdGhlIGNvbnRhaW5lciBlbnZpcm9ubWVudCBmb3IgdGhpcyBwbHVnaW5cbiAgICovXG4gIHJlYWRvbmx5IGRvY2tlcmZpbGU/OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIENvbW1hbmRzIHRvIHJ1biBkdXJpbmcgdGhlIGluc3RhbGwgcGhhc2VcbiAgICogVHlwaWNhbGx5IHVzZWQgZm9yIGluc3RhbGxpbmcgZGVwZW5kZW5jaWVzXG4gICAqIEBleGFtcGxlIFsnbnBtIGNpJywgJ25wbSBydW4gYnVpbGQnXVxuICAgKi9cbiAgcmVhZG9ubHkgaW5zdGFsbENvbW1hbmRzPzogc3RyaW5nW107XG5cbiAgLyoqXG4gICAqIENvbW1hbmRzIHRvIHJ1biBkdXJpbmcgdGhlIGJ1aWxkL2V4ZWN1dGlvbiBwaGFzZVxuICAgKiBUaGVzZSBhcmUgdGhlIG1haW4gY29tbWFuZHMgdGhhdCBwZXJmb3JtIHRoZSBwbHVnaW4ncyB3b3JrXG4gICAqIEBleGFtcGxlIFsnbnBtIHRlc3QnLCAnbnBtIHJ1biBkZXBsb3knXVxuICAgKi9cbiAgcmVhZG9ubHkgY29tbWFuZHM/OiBzdHJpbmdbXTtcblxuICAvKipcbiAgICogRW52aXJvbm1lbnQgdmFyaWFibGVzIHRvIHNldCBpbiB0aGUgYnVpbGQgZW52aXJvbm1lbnRcbiAgICogQGV4YW1wbGUgeyBBUElfVVJMOiAnaHR0cHM6Ly9hcGkuZXhhbXBsZS5jb20nLCBMT0dfTEVWRUw6ICdpbmZvJyB9XG4gICAqL1xuICByZWFkb25seSBlbnY/OiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+O1xuXG4gIC8qKlxuICAgKiBEb2NrZXIgYnVpbGQgYXJndW1lbnRzIHBhc3NlZCB2aWEgLS1idWlsZC1hcmcgYXQgaW1hZ2UgYnVpbGQgdGltZS5cbiAgICogVXNlZCB0byBwYXJhbWV0ZXJpemUgRG9ja2VyZmlsZSBBUkcgdmFsdWVzIHdoZW4gYnVpbGRpbmcgdGhlIHBsdWdpbiBpbWFnZS5cbiAgICogQGV4YW1wbGUgeyBQWVRIT05fVkVSU0lPTjogJzMuMTInLCBOT0RFX0VOVjogJ3Byb2R1Y3Rpb24nIH1cbiAgICovXG4gIHJlYWRvbmx5IGJ1aWxkQXJncz86IFJlY29yZDxzdHJpbmcsIHN0cmluZz47XG5cbiAgLyoqXG4gICAqIFBpcGVsaW5lIG1ldGFkYXRhIGtleXMgdGhlIHBsdWdpbiByZWZlcmVuY2VzIHZpYSBge3sgcGlwZWxpbmUubWV0YWRhdGEuWCB9fWAuXG4gICAqIERlY2xhcmVkIGFzIGEgY29udHJhY3Qg4oCUIHBpcGVsaW5lcyB1c2luZyB0aGlzIHBsdWdpbiBtdXN0IHN1cHBseSBhbGxcbiAgICogbGlzdGVkIGtleXMgdW5sZXNzIHRoZSB0ZW1wbGF0ZSB1c2VzIGB8IGRlZmF1bHQ6ICcuLi4nYC5cbiAgICogQGV4YW1wbGUgWydlbnYnLCAnbmFtZXNwYWNlJywgJ2NsdXN0ZXJOYW1lJ11cbiAgICovXG4gIHJlYWRvbmx5IHJlcXVpcmVkTWV0YWRhdGE/OiBzdHJpbmdbXTtcblxuICAvKipcbiAgICogUGlwZWxpbmUgdmFycyBrZXlzIHRoZSBwbHVnaW4gcmVmZXJlbmNlcyB2aWEgYHt7IHBpcGVsaW5lLnZhcnMuWCB9fWAuXG4gICAqIEBleGFtcGxlIFsnYnJhbmNoJywgJ3NsYWNrQ2hhbm5lbCddXG4gICAqL1xuICByZWFkb25seSByZXF1aXJlZFZhcnM/OiBzdHJpbmdbXTtcblxuICAvKipcbiAgICogT3B0aW9uYWwgdHlwZSBkZWNsYXJhdGlvbnMgZm9yIHRoZSBtZXRhZGF0YSBrZXlzIGxpc3RlZCBpbiBgcmVxdWlyZWRNZXRhZGF0YWAuXG4gICAqIFVzZWQgYXQgdXBsb2FkIHRpbWUgdG8gdmVyaWZ5IHRoYXQgY29lcmNpb24gZmlsdGVycyAoYHwgbnVtYmVyYCwgYHwgYm9vbGAsXG4gICAqIGB8IGpzb25gKSBtYXRjaCB0aGUgZGVjbGFyZWQgdHlwZSDigJQgZS5nLiBge3sgcGlwZWxpbmUubWV0YWRhdGEuY291bnQgfCBudW1iZXIgfX1gXG4gICAqIHJlcXVpcmVzIGBjb3VudDogJ251bWJlcidgIGhlcmUsIG90aGVyd2lzZSB0aGUgcGx1Z2luIGlzIHJlamVjdGVkLlxuICAgKiBLZXlzIG5vdCBkZWNsYXJlZCBkZWZhdWx0IHRvIGAnc3RyaW5nJ2AuXG4gICAqIEBleGFtcGxlIHsgY291bnQ6ICdudW1iZXInLCBlbmFibGVkOiAnYm9vbCcgfVxuICAgKi9cbiAgcmVhZG9ubHkgbWV0YWRhdGFUeXBlcz86IFJlY29yZDxzdHJpbmcsICdzdHJpbmcnIHwgJ251bWJlcicgfCAnYm9vbCcgfCAnanNvbic+O1xuXG4gIC8qKlxuICAgKiBPcHRpb25hbCB0eXBlIGRlY2xhcmF0aW9ucyBmb3IgdmFycyBrZXlzIChzYW1lIHNlbWFudGljcyBhcyBgbWV0YWRhdGFUeXBlc2ApLlxuICAgKi9cbiAgcmVhZG9ubHkgdmFyc1R5cGVzPzogUmVjb3JkPHN0cmluZywgJ3N0cmluZycgfCAnbnVtYmVyJyB8ICdib29sJyB8ICdqc29uJz47XG59XG4iXX0=

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

@@ -0,0 +1,62 @@
+import { CodePipelineSource } from 'aws-cdk-lib/pipelines';
+import { Construct } from 'constructs';
+import type { PipelineConfiguration } from './pipeline-configuration.js';
+import { UniqueId } from '../core/id-generator.js';
+/**
+ * Creates the appropriate CodePipelineSource based on the pipeline configuration.
+ *
+ * Supports S3, GitHub, CodeStar connection, and CodeCommit sources.
+ *
+ * **Note on SCHEDULE triggers:** Scheduled pipelines require an EventBridge rule
+ * that starts the pipeline on a cron schedule. The source trigger is set to NONE
+ * (no polling/webhook). The EventBridge rule must be created separately as a
+ * pipeline-level construct, not at the source level. The `schedule` field on
+ * source options captures the cron expression for API/frontend use. The actual
+ * EventBridge rule creation is implemented in `PipelineBuilder` (the
+ * `ScheduleRule` `events.Rule` targeting the pipeline), not at the source level.
+ *
+ * @example
+ * ```typescript
+ * const sourceBuilder = new SourceBuilder(this, config);
+ * const source = sourceBuilder.create(uniqueId);
+ * ```
+ */
+export declare class SourceBuilder {
+    private readonly scope;
+    private readonly config;
+    constructor(scope: Construct, config: PipelineConfiguration);
+    /**
+     * Creates the appropriate CodePipelineSource based on source type
+     */
+    create(id: UniqueId): CodePipelineSource;
+    /**
+     * Creates an S3 source for the pipeline
+     */
+    private createS3Source;
+    /**
+     * Creates a GitHub source for the pipeline
+     */
+    private createGitHubSource;
+    /**
+     * Resolve the GitHub authentication token into a {@link SecretValue} without
+     * leaking the token value into the synthesized template.
+     *
+     * - `undefined` token → no authentication (CDK default).
+     * - A `SecretValue` → passed through (already a reference, never plaintext).
+     * - A Secrets Manager ARN or `secretsmanager:<name>` string → resolved via
+     *   `SecretValue.secretsManager`, so only the reference lands in the template.
+     * - A genuine raw plaintext token → rejected by default (it would be baked as
+     *   plaintext into CloudFormation/CDK context). Only when
+     *   `allowPlainTextToken` is explicitly set is it embedded via
+     *   `SecretValue.unsafePlainText`, and a loud warning is emitted.
+     */
+    private resolveGitHubAuthentication;
+    /**
+     * Creates a CodeStar connection source for the pipeline
+     */
+    private createCodeStarSource;
+    /**
+     * Creates a CodeCommit source for the pipeline
+     */
+    private createCodeCommitSource;
+}