@pipeline-builder/pipeline-core 0.0.1

package/lib/core/metadata-helpers.js

@@ -0,0 +1,55 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Metadata and string helpers that are FREE of `aws-cdk-lib`.
+ *
+ * Split out of `pipeline-helpers.ts` (which builds CodeBuild steps and therefore
+ * pulls in the CDK) so the main `@pipeline-builder/pipeline-core` entry point can
+ * export them without putting `aws-cdk-lib` on every consumer's import graph.
+ * Anything here that needs a CDK type belongs in `pipeline-helpers.ts` instead.
+ */
+import { CDK_METADATA_PREFIX } from './pipeline-types.js';
+/**
+ * Merge multiple metadata objects into one. Later sources override earlier ones.
+ */
+export function merge(...sources) {
+    return Object.assign({}, ...sources);
+}
+/**
+ * Extract non-namespaced metadata keys as environment variable strings.
+ * Keys starting with 'aws:cdk:' are reserved for CDK construct props
+ * (processed by metadata extraction functions) and are excluded here.
+ *
+ * All values are converted to strings for CodeBuild compatibility.
+ */
+export function extractMetadataEnv(metadata) {
+    const env = {};
+    for (const [key, value] of Object.entries(metadata)) {
+        if (!key.startsWith(CDK_METADATA_PREFIX)) {
+            env[key] = String(value);
+        }
+    }
+    return env;
+}
+/** Plugin categories whose failure must NEVER be masked. A scan/security step that
+ *  exits non-zero has to fail the pipeline (repo rule: a failed scan is red, never a
+ *  false-green `|| true`), so such a plugin's failureBehavior is forced to 'fail'
+ *  regardless of what the plugin or step authored. */
+const FAIL_FAST_CATEGORIES = /scan|security|sast|dast|vuln|secret/i;
+/** Resolve the effective failureBehavior: a scan/security-category plugin is pinned
+ *  to 'fail'; otherwise the authored value (default 'fail'). */
+export function resolveFailureBehavior(category, authored) {
+    if (category && FAIL_FAST_CATEGORIES.test(category))
+        return 'fail';
+    return authored ?? 'fail';
+}
+/**
+ * Replaces all characters that are not letters or numbers with the specified value
+ * @param input - The string to process
+ * @param replaceValue - The character(s) to replace non-alphanumeric characters with (default: '_')
+ * @returns The string with non-alphanumeric characters replaced
+ */
+export function replaceNonAlphanumeric(input, replaceValue = '_') {
+    return input.replace(/[^a-zA-Z0-9]/g, replaceValue);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/network-types.d.ts

@@ -0,0 +1,200 @@
+import type { SecretValue } from 'aws-cdk-lib';
+import type { MetaDataType } from './pipeline-types.js';
+import type { SecurityGroupConfig } from './security-group-types.js';
+/**
+ * Network configuration using explicit subnet IDs
+ *
+ * Use when you know the exact subnet IDs where CodeBuild should run.
+ * Subnets are selected directly by ID; VPC is looked up from the provided vpcId.
+ *
+ * @example
+ * ```typescript
+ * const network: SubnetIdsNetwork = {
+ *   type: 'subnetIds',
+ *   options: {
+ *     vpcId: 'vpc-0a1b2c3d4e5f6a7b8',
+ *     subnetIds: ['subnet-0a1b2c3d', 'subnet-4e5f6a7b'],
+ *     securityGroupIds: ['sg-12345678']
+ *   }
+ * };
+ * ```
+ */
+export interface SubnetIdsNetwork {
+    readonly type: 'subnetIds';
+    readonly options: SubnetIdsNetworkOptions;
+}
+/**
+ * Network configuration using VPC lookup by ID
+ *
+ * Looks up an existing VPC by its ID and resolves subnets via subnetSelection filters.
+ *
+ * @example
+ * ```typescript
+ * const network: VpcIdNetwork = {
+ *   type: 'vpcId',
+ *   options: {
+ *     vpcId: 'vpc-0a1b2c3d4e5f6a7b8',
+ *     subnetType: 'PRIVATE_WITH_EGRESS',
+ *     securityGroupIds: ['sg-12345678']
+ *   }
+ * };
+ * ```
+ */
+export interface VpcIdNetwork {
+    readonly type: 'vpcId';
+    readonly options: VpcIdNetworkOptions;
+}
+/**
+ * Network configuration using VPC lookup by tags
+ *
+ * Looks up an existing VPC by tag filters and resolves subnets via subnetSelection filters.
+ *
+ * @example
+ * ```typescript
+ * const network: VpcLookupNetwork = {
+ *   type: 'vpcLookup',
+ *   options: {
+ *     tags: { 'aws:cloudformation:stack-name': 'NetworkStack' },
+ *     subnetType: 'PRIVATE_WITH_EGRESS',
+ *     availabilityZones: ['us-east-1a', 'us-east-1b']
+ *   }
+ * };
+ * ```
+ */
+export interface VpcLookupNetwork {
+    readonly type: 'vpcLookup';
+    readonly options: VpcLookupNetworkOptions;
+}
+/**
+ * Common subnet selection filters shared by VPC-based network options
+ */
+interface SubnetSelectionOptions {
+    /**
+     * Subnet type filter for subnet selection
+     * Maps to CDK SubnetType values
+     * @default 'PRIVATE_WITH_EGRESS'
+     */
+    readonly subnetType?: SubnetTypeName;
+    /**
+     * Filter subnets to specific availability zones
+     * @example ['us-east-1a', 'us-east-1b']
+     */
+    readonly availabilityZones?: string[];
+    /**
+     * Filter subnets by CDK subnet group name
+     * Matches the groupName assigned during VPC creation
+     */
+    readonly subnetGroupName?: string;
+    /**
+     * Security group IDs to attach to CodeBuild projects
+     * @example ['sg-12345678']
+     */
+    readonly securityGroupIds?: string[];
+}
+/**
+ * Configuration options for explicit subnet ID network
+ */
+export interface SubnetIdsNetworkOptions {
+    /**
+     * VPC ID that contains the subnets.
+     * Required because CDK CodeBuildStep needs a vpc reference.
+     * Can be a plain string or a SecretValue (e.g. from Secrets Manager).
+     * @example 'vpc-0a1b2c3d4e5f6a7b8'
+     */
+    readonly vpcId: SecretValue | string;
+    /**
+     * Explicit list of subnet IDs where CodeBuild projects will run
+     * @example ['subnet-0a1b2c3d', 'subnet-4e5f6a7b']
+     */
+    readonly subnetIds: string[];
+    /**
+     * Security group IDs to attach to CodeBuild projects
+     * @example ['sg-12345678']
+     */
+    readonly securityGroupIds?: string[];
+}
+/**
+ * Configuration options for VPC lookup by ID
+ */
+export interface VpcIdNetworkOptions extends SubnetSelectionOptions {
+    /**
+     * VPC ID to look up
+     * Can be a plain string or a SecretValue (e.g. from Secrets Manager).
+     * @example 'vpc-0a1b2c3d4e5f6a7b8'
+     */
+    readonly vpcId: SecretValue | string;
+}
+/**
+ * Configuration options for VPC lookup by tags
+ */
+export interface VpcLookupNetworkOptions extends SubnetSelectionOptions {
+    /**
+     * Tag key-value pairs to identify the VPC
+     * All tags must match for lookup to succeed
+     * @example { Environment: 'production', Team: 'platform' }
+     */
+    readonly tags: Record<string, string>;
+    /**
+     * Optional VPC name (value of the 'Name' tag) for additional filtering
+     */
+    readonly vpcName?: string;
+    /**
+     * Optional AWS region override for cross-region VPC lookup
+     * @example 'us-west-2'
+     */
+    readonly region?: string;
+}
+/**
+ * Subnet type names corresponding to CDK SubnetType enum values
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.SubnetType.html
+ */
+export type SubnetTypeName = 'PRIVATE_WITH_EGRESS' | 'PRIVATE_WITH_NAT' | 'PRIVATE_ISOLATED' | 'PUBLIC';
+/**
+ * Union type of all supported network configurations.
+ *
+ * Used at two independent levels:
+ * - Pipeline-level (`defaults.network`) — applies to all CodeBuild actions
+ * - Step-level (`synth.network`, `CodeBuildStepOptions.network`) — applies to an individual build step
+ *
+ * Each variant resolves to vpc, subnetSelection, and optional securityGroups:
+ * - SubnetIdsNetwork: VPC looked up by ID, subnets selected explicitly by ID
+ * - VpcIdNetwork: VPC looked up by ID, subnets resolved via subnetSelection filters
+ * - VpcLookupNetwork: VPC looked up by tags, subnets resolved via subnetSelection filters
+ */
+export type NetworkConfig = SubnetIdsNetwork | VpcIdNetwork | VpcLookupNetwork;
+/**
+ * Pipeline-level CodeBuild defaults applied to every CodeBuild action
+ * (synth, self-mutation, asset publishing) via `codeBuildDefaults`.
+ *
+ * @example
+ * ```typescript
+ * const defaults: CodeBuildDefaults = {
+ *   network: {
+ *     type: 'vpcId',
+ *     options: { vpcId: 'vpc-abc123', subnetType: 'PRIVATE_WITH_EGRESS' }
+ *   },
+ *   metadata: {
+ *     [MetadataKeys.PRIVILEGED]: true,
+ *   },
+ * };
+ * ```
+ */
+export interface CodeBuildDefaults {
+    /**
+     * Network configuration for all CodeBuild actions.
+     * Resolves to vpc, subnetSelection, and optional securityGroups.
+     */
+    readonly network?: NetworkConfig;
+    /**
+     * Standalone security groups for all CodeBuild actions.
+     * Merged with any security groups resolved from network config.
+     */
+    readonly securityGroups?: SecurityGroupConfig;
+    /**
+     * Metadata applied to all CodeBuild actions.
+     * Merged with step-level metadata; step-level keys take precedence.
+     */
+    readonly metadata?: MetaDataType;
+}
+export {};

package/lib/core/network-types.js

@@ -0,0 +1,4 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-types.js","sourceRoot":"","sources":["../../src/core/network-types.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { SecretValue } from 'aws-cdk-lib';\nimport type { MetaDataType } from './pipeline-types.js';\nimport type { SecurityGroupConfig } from './security-group-types.js';\n\n/**\n * Network configuration using explicit subnet IDs\n *\n * Use when you know the exact subnet IDs where CodeBuild should run.\n * Subnets are selected directly by ID; VPC is looked up from the provided vpcId.\n *\n * @example\n * ```typescript\n * const network: SubnetIdsNetwork = {\n *   type: 'subnetIds',\n *   options: {\n *     vpcId: 'vpc-0a1b2c3d4e5f6a7b8',\n *     subnetIds: ['subnet-0a1b2c3d', 'subnet-4e5f6a7b'],\n *     securityGroupIds: ['sg-12345678']\n *   }\n * };\n * ```\n */\nexport interface SubnetIdsNetwork {\n  readonly type: 'subnetIds';\n  readonly options: SubnetIdsNetworkOptions;\n}\n\n/**\n * Network configuration using VPC lookup by ID\n *\n * Looks up an existing VPC by its ID and resolves subnets via subnetSelection filters.\n *\n * @example\n * ```typescript\n * const network: VpcIdNetwork = {\n *   type: 'vpcId',\n *   options: {\n *     vpcId: 'vpc-0a1b2c3d4e5f6a7b8',\n *     subnetType: 'PRIVATE_WITH_EGRESS',\n *     securityGroupIds: ['sg-12345678']\n *   }\n * };\n * ```\n */\nexport interface VpcIdNetwork {\n  readonly type: 'vpcId';\n  readonly options: VpcIdNetworkOptions;\n}\n\n/**\n * Network configuration using VPC lookup by tags\n *\n * Looks up an existing VPC by tag filters and resolves subnets via subnetSelection filters.\n *\n * @example\n * ```typescript\n * const network: VpcLookupNetwork = {\n *   type: 'vpcLookup',\n *   options: {\n *     tags: { 'aws:cloudformation:stack-name': 'NetworkStack' },\n *     subnetType: 'PRIVATE_WITH_EGRESS',\n *     availabilityZones: ['us-east-1a', 'us-east-1b']\n *   }\n * };\n * ```\n */\nexport interface VpcLookupNetwork {\n  readonly type: 'vpcLookup';\n  readonly options: VpcLookupNetworkOptions;\n}\n\n/**\n * Common subnet selection filters shared by VPC-based network options\n */\ninterface SubnetSelectionOptions {\n  /**\n   * Subnet type filter for subnet selection\n   * Maps to CDK SubnetType values\n   * @default 'PRIVATE_WITH_EGRESS'\n   */\n  readonly subnetType?: SubnetTypeName;\n\n  /**\n   * Filter subnets to specific availability zones\n   * @example ['us-east-1a', 'us-east-1b']\n   */\n  readonly availabilityZones?: string[];\n\n  /**\n   * Filter subnets by CDK subnet group name\n   * Matches the groupName assigned during VPC creation\n   */\n  readonly subnetGroupName?: string;\n\n  /**\n   * Security group IDs to attach to CodeBuild projects\n   * @example ['sg-12345678']\n   */\n  readonly securityGroupIds?: string[];\n}\n\n/**\n * Configuration options for explicit subnet ID network\n */\nexport interface SubnetIdsNetworkOptions {\n  /**\n   * VPC ID that contains the subnets.\n   * Required because CDK CodeBuildStep needs a vpc reference.\n   * Can be a plain string or a SecretValue (e.g. from Secrets Manager).\n   * @example 'vpc-0a1b2c3d4e5f6a7b8'\n   */\n  readonly vpcId: SecretValue | string;\n\n  /**\n   * Explicit list of subnet IDs where CodeBuild projects will run\n   * @example ['subnet-0a1b2c3d', 'subnet-4e5f6a7b']\n   */\n  readonly subnetIds: string[];\n\n  /**\n   * Security group IDs to attach to CodeBuild projects\n   * @example ['sg-12345678']\n   */\n  readonly securityGroupIds?: string[];\n}\n\n/**\n * Configuration options for VPC lookup by ID\n */\nexport interface VpcIdNetworkOptions extends SubnetSelectionOptions {\n  /**\n   * VPC ID to look up\n   * Can be a plain string or a SecretValue (e.g. from Secrets Manager).\n   * @example 'vpc-0a1b2c3d4e5f6a7b8'\n   */\n  readonly vpcId: SecretValue | string;\n}\n\n/**\n * Configuration options for VPC lookup by tags\n */\nexport interface VpcLookupNetworkOptions extends SubnetSelectionOptions {\n  /**\n   * Tag key-value pairs to identify the VPC\n   * All tags must match for lookup to succeed\n   * @example { Environment: 'production', Team: 'platform' }\n   */\n  readonly tags: Record<string, string>;\n\n  /**\n   * Optional VPC name (value of the 'Name' tag) for additional filtering\n   */\n  readonly vpcName?: string;\n\n  /**\n   * Optional AWS region override for cross-region VPC lookup\n   * @example 'us-west-2'\n   */\n  readonly region?: string;\n}\n\n/**\n * Subnet type names corresponding to CDK SubnetType enum values\n *\n * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.SubnetType.html\n */\nexport type SubnetTypeName =\n  | 'PRIVATE_WITH_EGRESS'\n  | 'PRIVATE_WITH_NAT'\n  | 'PRIVATE_ISOLATED'\n  | 'PUBLIC';\n\n/**\n * Union type of all supported network configurations.\n *\n * Used at two independent levels:\n * - Pipeline-level (`defaults.network`) — applies to all CodeBuild actions\n * - Step-level (`synth.network`, `CodeBuildStepOptions.network`) — applies to an individual build step\n *\n * Each variant resolves to vpc, subnetSelection, and optional securityGroups:\n * - SubnetIdsNetwork: VPC looked up by ID, subnets selected explicitly by ID\n * - VpcIdNetwork: VPC looked up by ID, subnets resolved via subnetSelection filters\n * - VpcLookupNetwork: VPC looked up by tags, subnets resolved via subnetSelection filters\n */\nexport type NetworkConfig = SubnetIdsNetwork | VpcIdNetwork | VpcLookupNetwork;\n\n/**\n * Pipeline-level CodeBuild defaults applied to every CodeBuild action\n * (synth, self-mutation, asset publishing) via `codeBuildDefaults`.\n *\n * @example\n * ```typescript\n * const defaults: CodeBuildDefaults = {\n *   network: {\n *     type: 'vpcId',\n *     options: { vpcId: 'vpc-abc123', subnetType: 'PRIVATE_WITH_EGRESS' }\n *   },\n *   metadata: {\n *     [MetadataKeys.PRIVILEGED]: true,\n *   },\n * };\n * ```\n */\nexport interface CodeBuildDefaults {\n  /**\n   * Network configuration for all CodeBuild actions.\n   * Resolves to vpc, subnetSelection, and optional securityGroups.\n   */\n  readonly network?: NetworkConfig;\n\n  /**\n   * Standalone security groups for all CodeBuild actions.\n   * Merged with any security groups resolved from network config.\n   */\n  readonly securityGroups?: SecurityGroupConfig;\n\n  /**\n   * Metadata applied to all CodeBuild actions.\n   * Merged with step-level metadata; step-level keys take precedence.\n   */\n  readonly metadata?: MetaDataType;\n}\n"]}

package/lib/core/network.d.ts

@@ -0,0 +1,33 @@
+import { type ISecurityGroup, type IVpc, type SubnetSelection } from 'aws-cdk-lib/aws-ec2';
+import { Construct } from 'constructs';
+import { UniqueId } from './id-generator.js';
+import type { NetworkConfig } from './network-types.js';
+/** Resolved CDK network props ready to spread into CodeBuildStep or codeBuildDefaults */
+export interface ResolvedNetwork {
+    vpc: IVpc;
+    subnetSelection: SubnetSelection;
+    securityGroups?: ISecurityGroup[];
+}
+/**
+ * Build a NetworkConfig from environment, for deployments that want EVERY
+ * synthesized pipeline's CodeBuild to run inside a VPC (the EC2 "internal" /
+ * inside-AWS-only mode) without per-pipeline network config. Returns undefined
+ * when the env isn't set — public/default deployments run CodeBuild in the
+ * AWS-managed network as before.
+ *
+ * Env (set on the pipeline service in internal mode):
+ *   PIPELINE_VPC_ID              VPC the CodeBuild projects join (required)
+ *   PIPELINE_SUBNET_IDS          comma-separated private subnet IDs (required)
+ *   PIPELINE_SECURITY_GROUP_IDS  comma-separated SG IDs (optional)
+ */
+export declare function networkConfigFromEnv(): NetworkConfig | undefined;
+/**
+ * Resolve a NetworkConfig into CDK props for CodeBuildStep or codeBuildDefaults.
+ * Uses discriminated union narrowing to delegate to the appropriate CDK lookups.
+ *
+ * @param scope - CDK construct scope
+ * @param id - UniqueId instance for generating unique construct IDs
+ * @param network - Network configuration to resolve
+ * @returns Resolved network props ready to spread into CDK constructs
+ */
+export declare function resolveNetwork(scope: Construct, id: UniqueId, network: NetworkConfig): ResolvedNetwork;

package/lib/core/network.js

@@ -0,0 +1,112 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { SecurityGroup, Subnet, SubnetType, Vpc } from 'aws-cdk-lib/aws-ec2';
+import { Construct } from 'constructs';
+import { UniqueId } from './id-generator.js';
+import { unwrapSecret } from './pipeline-helpers.js';
+/**
+ * Mapping from string subnet type names to CDK SubnetType enum values
+ */
+const SUBNET_TYPE_MAP = {
+    PRIVATE_WITH_EGRESS: SubnetType.PRIVATE_WITH_EGRESS,
+    PRIVATE_WITH_NAT: SubnetType.PRIVATE_WITH_NAT,
+    PRIVATE_ISOLATED: SubnetType.PRIVATE_ISOLATED,
+    PUBLIC: SubnetType.PUBLIC,
+};
+const DEFAULT_SUBNET_TYPE = 'PRIVATE_WITH_EGRESS';
+/**
+ * Build a NetworkConfig from environment, for deployments that want EVERY
+ * synthesized pipeline's CodeBuild to run inside a VPC (the EC2 "internal" /
+ * inside-AWS-only mode) without per-pipeline network config. Returns undefined
+ * when the env isn't set — public/default deployments run CodeBuild in the
+ * AWS-managed network as before.
+ *
+ * Env (set on the pipeline service in internal mode):
+ *   PIPELINE_VPC_ID              VPC the CodeBuild projects join (required)
+ *   PIPELINE_SUBNET_IDS          comma-separated private subnet IDs (required)
+ *   PIPELINE_SECURITY_GROUP_IDS  comma-separated SG IDs (optional)
+ */
+export function networkConfigFromEnv() {
+    const vpcId = (process.env.PIPELINE_VPC_ID || '').trim();
+    const subnetIds = (process.env.PIPELINE_SUBNET_IDS || '')
+        .split(',').map((s) => s.trim()).filter(Boolean);
+    if (!vpcId || subnetIds.length === 0)
+        return undefined;
+    const securityGroupIds = (process.env.PIPELINE_SECURITY_GROUP_IDS || '')
+        .split(',').map((s) => s.trim()).filter(Boolean);
+    return {
+        type: 'subnetIds',
+        options: {
+            vpcId,
+            subnetIds,
+            ...(securityGroupIds.length > 0 && { securityGroupIds }),
+        },
+    };
+}
+/**
+ * Resolve a NetworkConfig into CDK props for CodeBuildStep or codeBuildDefaults.
+ * Uses discriminated union narrowing to delegate to the appropriate CDK lookups.
+ *
+ * @param scope - CDK construct scope
+ * @param id - UniqueId instance for generating unique construct IDs
+ * @param network - Network configuration to resolve
+ * @returns Resolved network props ready to spread into CDK constructs
+ */
+export function resolveNetwork(scope, id, network) {
+    switch (network.type) {
+        case 'subnetIds': {
+            const vpc = Vpc.fromLookup(scope, id.generate('network:vpc'), {
+                vpcId: unwrapSecret(network.options.vpcId),
+            });
+            const subnets = network.options.subnetIds.map((subnetId) => Subnet.fromSubnetId(scope, id.generate('network:subnet'), subnetId));
+            return withSecurityGroups({ vpc, subnetSelection: { subnets } }, scope, id, network.options.securityGroupIds);
+        }
+        case 'vpcId': {
+            const vpc = Vpc.fromLookup(scope, id.generate('network:vpc'), {
+                vpcId: unwrapSecret(network.options.vpcId),
+            });
+            return withSecurityGroups({ vpc, subnetSelection: resolveSubnetSelection(network.options) }, scope, id, network.options.securityGroupIds);
+        }
+        case 'vpcLookup': {
+            const vpc = Vpc.fromLookup(scope, id.generate('network:vpc'), {
+                tags: network.options.tags,
+                ...(network.options.vpcName && { vpcName: network.options.vpcName }),
+                ...(network.options.region && { region: network.options.region }),
+            });
+            return withSecurityGroups({ vpc, subnetSelection: resolveSubnetSelection(network.options) }, scope, id, network.options.securityGroupIds);
+        }
+        default: {
+            const _exhaustive = network;
+            throw new Error(`Unknown network config type: ${_exhaustive.type}`);
+        }
+    }
+}
+/**
+ * Attach resolved security groups to a network result when present.
+ */
+function withSecurityGroups(result, scope, id, securityGroupIds) {
+    const securityGroups = resolveSecurityGroups(scope, id, securityGroupIds);
+    return securityGroups ? { ...result, securityGroups } : result;
+}
+/**
+ * Build a SubnetSelection from options that carry subnetType, availabilityZones,
+ * and subnetGroupName. Shared by vpcId and vpcLookup branches.
+ */
+function resolveSubnetSelection(options) {
+    return {
+        subnetType: SUBNET_TYPE_MAP[options.subnetType ?? DEFAULT_SUBNET_TYPE],
+        ...(options.availabilityZones && { availabilityZones: options.availabilityZones }),
+        ...(options.subnetGroupName && { subnetGroupName: options.subnetGroupName }),
+    };
+}
+/**
+ * Resolve security group IDs into CDK security group references.
+ * Returns undefined when no IDs are provided.
+ */
+function resolveSecurityGroups(scope, id, securityGroupIds) {
+    if (!securityGroupIds?.length) {
+        return undefined;
+    }
+    return securityGroupIds.map((sgId) => SecurityGroup.fromSecurityGroupId(scope, id.generate('network:sg'), sgId));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network.js","sourceRoot":"","sources":["../../src/core/network.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { type ISecurityGroup, type IVpc, SecurityGroup, Subnet, type SubnetSelection, SubnetType, Vpc } from 'aws-cdk-lib/aws-ec2';\nimport { Construct } from 'constructs';\nimport { UniqueId } from './id-generator.js';\nimport type {\n  NetworkConfig,\n  SubnetTypeName,\n} from './network-types.js';\nimport { unwrapSecret } from './pipeline-helpers.js';\n\n/**\n * Mapping from string subnet type names to CDK SubnetType enum values\n */\nconst SUBNET_TYPE_MAP: Record<SubnetTypeName, SubnetType> = {\n  PRIVATE_WITH_EGRESS: SubnetType.PRIVATE_WITH_EGRESS,\n  PRIVATE_WITH_NAT: SubnetType.PRIVATE_WITH_NAT,\n  PRIVATE_ISOLATED: SubnetType.PRIVATE_ISOLATED,\n  PUBLIC: SubnetType.PUBLIC,\n};\n\nconst DEFAULT_SUBNET_TYPE: SubnetTypeName = 'PRIVATE_WITH_EGRESS';\n\n/** Resolved CDK network props ready to spread into CodeBuildStep or codeBuildDefaults */\nexport interface ResolvedNetwork {\n  vpc: IVpc;\n  subnetSelection: SubnetSelection;\n  securityGroups?: ISecurityGroup[];\n}\n\n/**\n * Build a NetworkConfig from environment, for deployments that want EVERY\n * synthesized pipeline's CodeBuild to run inside a VPC (the EC2 \"internal\" /\n * inside-AWS-only mode) without per-pipeline network config. Returns undefined\n * when the env isn't set — public/default deployments run CodeBuild in the\n * AWS-managed network as before.\n *\n * Env (set on the pipeline service in internal mode):\n *   PIPELINE_VPC_ID              VPC the CodeBuild projects join (required)\n *   PIPELINE_SUBNET_IDS          comma-separated private subnet IDs (required)\n *   PIPELINE_SECURITY_GROUP_IDS  comma-separated SG IDs (optional)\n */\nexport function networkConfigFromEnv(): NetworkConfig | undefined {\n  const vpcId = (process.env.PIPELINE_VPC_ID || '').trim();\n  const subnetIds = (process.env.PIPELINE_SUBNET_IDS || '')\n    .split(',').map((s) => s.trim()).filter(Boolean);\n  if (!vpcId || subnetIds.length === 0) return undefined;\n\n  const securityGroupIds = (process.env.PIPELINE_SECURITY_GROUP_IDS || '')\n    .split(',').map((s) => s.trim()).filter(Boolean);\n\n  return {\n    type: 'subnetIds',\n    options: {\n      vpcId,\n      subnetIds,\n      ...(securityGroupIds.length > 0 && { securityGroupIds }),\n    },\n  };\n}\n\n/**\n * Resolve a NetworkConfig into CDK props for CodeBuildStep or codeBuildDefaults.\n * Uses discriminated union narrowing to delegate to the appropriate CDK lookups.\n *\n * @param scope - CDK construct scope\n * @param id - UniqueId instance for generating unique construct IDs\n * @param network - Network configuration to resolve\n * @returns Resolved network props ready to spread into CDK constructs\n */\nexport function resolveNetwork(\n  scope: Construct,\n  id: UniqueId,\n  network: NetworkConfig,\n): ResolvedNetwork {\n  switch (network.type) {\n    case 'subnetIds': {\n      const vpc = Vpc.fromLookup(scope, id.generate('network:vpc'), {\n        vpcId: unwrapSecret(network.options.vpcId),\n      });\n\n      const subnets = network.options.subnetIds.map(\n        (subnetId) => Subnet.fromSubnetId(scope, id.generate('network:subnet'), subnetId),\n      );\n\n      return withSecurityGroups(\n        { vpc, subnetSelection: { subnets } },\n        scope,\n        id,\n        network.options.securityGroupIds,\n      );\n    }\n    case 'vpcId': {\n      const vpc = Vpc.fromLookup(scope, id.generate('network:vpc'), {\n        vpcId: unwrapSecret(network.options.vpcId),\n      });\n\n      return withSecurityGroups(\n        { vpc, subnetSelection: resolveSubnetSelection(network.options) },\n        scope,\n        id,\n        network.options.securityGroupIds,\n      );\n    }\n    case 'vpcLookup': {\n      const vpc = Vpc.fromLookup(scope, id.generate('network:vpc'), {\n        tags: network.options.tags,\n        ...(network.options.vpcName && { vpcName: network.options.vpcName }),\n        ...(network.options.region && { region: network.options.region }),\n      });\n\n      return withSecurityGroups(\n        { vpc, subnetSelection: resolveSubnetSelection(network.options) },\n        scope,\n        id,\n        network.options.securityGroupIds,\n      );\n    }\n    default: {\n      const _exhaustive: never = network;\n      throw new Error(`Unknown network config type: ${(_exhaustive as NetworkConfig).type}`);\n    }\n  }\n}\n\n/**\n * Attach resolved security groups to a network result when present.\n */\nfunction withSecurityGroups(\n  result: Omit<ResolvedNetwork, 'securityGroups'>,\n  scope: Construct,\n  id: UniqueId,\n  securityGroupIds?: string[],\n): ResolvedNetwork {\n  const securityGroups = resolveSecurityGroups(scope, id, securityGroupIds);\n  return securityGroups ? { ...result, securityGroups } : result;\n}\n\n/**\n * Build a SubnetSelection from options that carry subnetType, availabilityZones,\n * and subnetGroupName. Shared by vpcId and vpcLookup branches.\n */\nfunction resolveSubnetSelection(\n  options: { subnetType?: SubnetTypeName; availabilityZones?: string[]; subnetGroupName?: string },\n): SubnetSelection {\n  return {\n    subnetType: SUBNET_TYPE_MAP[options.subnetType ?? DEFAULT_SUBNET_TYPE],\n    ...(options.availabilityZones && { availabilityZones: options.availabilityZones }),\n    ...(options.subnetGroupName && { subnetGroupName: options.subnetGroupName }),\n  };\n}\n\n/**\n * Resolve security group IDs into CDK security group references.\n * Returns undefined when no IDs are provided.\n */\nfunction resolveSecurityGroups(\n  scope: Construct,\n  id: UniqueId,\n  securityGroupIds?: string[],\n): ISecurityGroup[] | undefined {\n  if (!securityGroupIds?.length) {\n    return undefined;\n  }\n  return securityGroupIds.map(\n    (sgId) => SecurityGroup.fromSecurityGroupId(scope, id.generate('network:sg'), sgId),\n  );\n}\n"]}

package/lib/core/pipeline-helpers.d.ts

@@ -0,0 +1,61 @@
+import type { Plugin } from '@pipeline-builder/pipeline-data';
+import { SecretValue } from 'aws-cdk-lib';
+import { ComputeType as CDKComputeType, type IBuildImage } from 'aws-cdk-lib/aws-codebuild';
+import { CodeBuildStep, ManualApprovalStep, ShellStep } from 'aws-cdk-lib/pipelines';
+import type { Construct } from 'constructs';
+import type { CodeBuildStepOptions } from '../pipeline/step-types.js';
+/**
+ * Resolve the CodeBuild image to use for a plugin.
+ *
+ * Strategy:
+ *   1. If the plugin sets `aws:cdk:codebuild:buildenvironment:buildImage`
+ *      explicitly in metadata, the metadata-builder passthrough handles it
+ *      (via `metadataForBuildEnvironment`). This function returns
+ *      `undefined` and the metadata wins.
+ *   2. Otherwise, if the plugin has a `name`+`version` AND the registry
+ *      config is populated, build a `LinuxBuildImage.fromDockerRegistry()`
+ *      image pointing at `<registry-host>:<port>/<ns>/<name>:<version>`
+ *      where `<ns>` is `system` or `org-<orgId>`. CodeBuild authenticates by
+ *      sending the per-org platform Secret as Basic auth to
+ *      `pipeline-image-registry`'s `/token` endpoint; the JWT in `password`
+ *      resolves to a registry token scoped to the org.
+ *   3. If `metadata_only`, return `undefined` so CodeBuild uses its default
+ *      (`standard:7.0`).
+ *
+ * `scope` and `orgId` are required: the per-org platform Secret is named
+ * `pipeline-builder/<orgId>/platform`, and `Secret.fromSecretNameV2()`
+ * needs a Construct to anchor the imported secret to.
+ */
+export declare function resolvePluginImage(scope: Construct | undefined, plugin: Plugin, orgId?: string): IBuildImage | undefined;
+export declare function resolveDefaultBuildImage(scope?: Construct, orgId?: string): IBuildImage;
+/**
+ * Create a CodeBuild step or Shell step based on plugin configuration.
+ *
+ * Metadata merge order (last wins):
+ *   1. Plugin metadata (from plugin.metadata in database) — the plugin
+ *      author's baked-in defaults
+ *   2. Step-level metadata (from options.metadata) — the pipeline author's
+ *      per-step overrides, which are more specific and must win
+ *
+ * Environment merge order (last wins):
+ *   1. Plugin env vars (from plugin.env)
+ *   2. Custom env vars (from options.env)
+ *   3. WORKDIR from merged metadata
+ *
+ * CDK prop spread order (last wins):
+ *   programmatic defaults (input, commands, env, network) → metadata overrides
+ *
+ * This means metadata keys like `aws:cdk:pipelines:codebuildstep:commands`
+ * will override the plugin-derived commands when explicitly set.
+ */
+export declare function createCodeBuildStep(options: CodeBuildStepOptions): ShellStep | CodeBuildStep | ManualApprovalStep;
+/**
+ * Convert string or ComputeType enum to CDK ComputeType
+ */
+export declare function getComputeType(input?: string | CDKComputeType): CDKComputeType;
+/**
+ * Unwrap a SecretValue | string into a plain string.
+ * When a SecretValue is provided (e.g. from Secrets Manager), calls unsafeUnwrap()
+ * to extract the underlying value.
+ */
+export declare function unwrapSecret(value: SecretValue | string): string;