@pipeline-builder/pipeline-manager 3.4.117 → 3.4.119

package/dist/commands/synth.js

@@ -10,6 +10,7 @@ import { createAuthenticatedClientAsync, printCommandHeader, printSslWarning } f
 import { ERROR_CODES, handleError } from '../utils/error-handler.js';
 import { extractSingleResponse, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';
 import { resolvePluginsForProps } from '../utils/plugin-resolver.js';
+import { bakePlatformRegistry } from '../utils/registry.js';
 // ESM has no __dirname; derive it from this module's URL.
 const __dirname = dirname(fileURLToPath(import.meta.url));
 /**
@@ -40,13 +41,17 @@ async function fetchPipelineConfig(pipelineId, options) {
         propsWithIds.resolvedPlugins = resolvedPlugins;
         printInfo('Pre-resolved plugins', { count: Object.keys(resolvedPlugins).length });
     }
+    // Bake the registry pull target from the platform URL we synth against (the
+    // host serving the registry /v2/ data path) so CodeBuild image URIs use a host
+    // AWS CodeBuild can resolve, not the in-cluster `registry:5000` default. No-op
+    // when IMAGE_REGISTRY_PULL_HOST is set (explicit env wins).
+    bakePlatformRegistry(propsWithIds, config.api.baseUrl);
     process.env.PIPELINE_PROPS = Buffer.from(JSON.stringify(propsWithIds)).toString('base64');
     // Propagate the resolved platform base URL into the boilerplate synth (which
-    // inherits process.env). loadRegistryConfig() derives the registry PULL host
-    // from PLATFORM_BASE_URL / IMAGE_REGISTRY_PULL_HOST; it only reads the env, so
-    // without this a URL configured via ~/.pipeline-manager/config.yml is invisible
-    // to the synth and it bakes the in-cluster `registry:5000` into CodeBuild (which
-    // can't resolve it from the VPC). IMAGE_REGISTRY_PULL_HOST still wins if set.
+    // inherits process.env). The synth uses it for serverConfig.platformUrl (the
+    // PluginLookup Lambda endpoint) and as the loadRegistryConfig pull-host
+    // fallback. Without this, a URL configured via ~/.pipeline-manager/config.yml
+    // is invisible to the synth subprocess (it reads only the env).
     if (config.api.baseUrl) {
         process.env.PLATFORM_BASE_URL = config.api.baseUrl;
     }
@@ -197,4 +202,4 @@ async function showResolvedPipeline(pipelineId, options) {
     }
     console.log(JSON.stringify(decoded, null, 2));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"synth.js","sourceRoot":"","sources":["../../src/commands/synth.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC3G,OAAO,EAAE,8BAA8B,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAChH,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACjJ,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAErE,0DAA0D;AAC1D,MAAM,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE1D;;;GAGG;AACH,KAAK,UAAU,mBAAmB,CAChC,UAAkB,EAClB,OAA0F;IAE1F,MAAM,MAAM,GAAG,MAAM,8BAA8B,CAAC,OAAO,CAAC,CAAC;IAC7D,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;IAElC,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,GAAG,CAC/B,GAAG,MAAM,CAAC,GAAG,CAAC,WAAW,IAAI,UAAU,EAAE,CAC1C,CAAC;IAEF,MAAM,QAAQ,GAAG,qBAAqB,CAAW,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAEhF,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC;QACrB,UAAU,CAAC,uBAAuB,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;QACxD,MAAM,IAAI,KAAK,CAAC,6CAA6C,UAAU,EAAE,CAAC,CAAC;IAC7E,CAAC;IAED,MAAM,YAAY,GAA4B;QAC5C,GAAG,QAAQ,CAAC,KAAgC;QAC5C,UAAU,EAAE,QAAQ,CAAC,EAAE,IAAI,UAAU;KACtC,CAAC;IACF,IAAI,QAAQ,CAAC,KAAK;QAAE,YAAY,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC;IAExD,wEAAwE;IACxE,yEAAyE;IACzE,yEAAyE;IACzE,iCAAiC;IACjC,MAAM,eAAe,GAAG,MAAM,sBAAsB,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3E,IAAI,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5C,YAAY,CAAC,eAAe,GAAG,eAAe,CAAC;QAC/C,SAAS,CAAC,sBAAsB,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IACpF,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAE1F,6EAA6E;IAC7E,6EAA6E;IAC7E,+EAA+E;IAC/E,gFAAgF;IAChF,iFAAiF;IACjF,8EAA8E;IAC9E,IAAI,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACvB,OAAO,CAAC,GAAG,CAAC,iBAAiB,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC;IACrD,CAAC;IAED,YAAY,CAAC,+BAA+B,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,KAAK,CAAC,OAAgB;IACpC,OAAO;SACJ,OAAO,CAAC,OAAO,CAAC;SAChB,WAAW,CAAC,gDAAgD,CAAC;SAC7D,MAAM,CAAC,eAAe,EAAE,0CAA0C,CAAC;SACnE,MAAM,CAAC,gBAAgB,EAAE,2FAA2F,EAAE,KAAK,CAAC;SAC5H,MAAM,CAAC,gBAAgB,EAAE,sBAAsB,EAAE,SAAS,CAAC;SAC3D,MAAM,CAAC,qBAAqB,EAAE,aAAa,CAAC;SAC5C,MAAM,CAAC,mBAAmB,EAAE,iCAAiC,CAAC;SAC9D,MAAM,CAAC,SAAS,EAAE,qBAAqB,EAAE,KAAK,CAAC;SAC/C,MAAM,CAAC,cAAc,EAAE,sBAAsB,CAAC;SAC9C,MAAM,CAAC,WAAW,EAAE,yBAAyB,EAAE,KAAK,CAAC;SACrD,MAAM,CAAC,QAAQ,EAAE,uBAAuB,EAAE,KAAK,CAAC;SAChD,MAAM,CAAC,cAAc,EAAE,qCAAqC,CAAC;SAC7D,MAAM,CAAC,iBAAiB,EAAE,sCAAsC,CAAC;SACjE,MAAM,CAAC,iBAAiB,EAAE,qGAAqG,EAAE,KAAK,CAAC;SACvI,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QACxB,MAAM,WAAW,GAAG,kBAAkB,CAAC,eAAe,CAAC,CAAC;QAExD,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,OAAO,CAAC,EAAE,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC;YAEzD,8CAA8C;YAC9C,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;gBACzB,MAAM,oBAAoB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBAChD,OAAO;YACT,CAAC;YAED,QAAQ,CAAC,OAAO,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;YACjG,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAEnC,4EAA4E;YAC5E,IAAI,OAAO,CAAC,SAAS,KAAK,KAAK,EAAE,CAAC;gBAChC,OAAO,CAAC,GAAG,CAAC,4BAA4B,GAAG,GAAG,CAAC;YACjD,CAAC;YAED,8EAA8E;YAC9E,IAAI,UAAU,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;gBAC9C,SAAS,CAAC,iCAAiC,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;gBACjE,MAAM,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;YACjD,CAAC;iBAAM,IAAI,CAAC,UAAU,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;gBACtD,YAAY,CAAC,sCAAsC,CAAC,CAAC;gBACrD,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;YACxF,CAAC;YAED,kBAAkB,EAAE,CAAC;YACrB,YAAY,CAAC,sBAAsB,CAAC,CAAC;YAErC,0BAA0B;YAC1B,IAAI,OAAO,CAAC,MAAM;gBAAE,eAAe,CAAC,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YAC9D,IAAI,OAAO,CAAC,OAAO;gBAAE,eAAe,CAAC,OAAO,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;YAEjE,MAAM,eAAe,GAAG,sBAAsB,CAAC,SAAS,CAAC,CAAC;YAC1D,MAAM,KAAK,GAAG;gBACZ,WAAW;gBACX,eAAe,eAAe,GAAG;gBACjC,YAAY,OAAO,CAAC,MAAM,EAAE;aAC7B,CAAC;YAEF,IAAI,OAAO,CAAC,OAAO;gBAAE,KAAK,CAAC,IAAI,CAAC,aAAa,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;YAChE,IAAI,OAAO,CAAC,KAAK;gBAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACzC,IAAI,OAAO,CAAC,OAAO,KAAK,KAAK;gBAAE,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAC1D,IAAI,OAAO,CAAC,OAAO;gBAAE,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAE7C,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAEhC,SAAS,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;YACvF,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAEhB,MAAM,MAAM,GAAG,sBAAsB,CAAC,OAAO,EAAE;gBAC7C,UAAU,EAAE,CAAC,OAAO,CAAC,KAAK;aAC3B,CAAC,CAAC;YAEH,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAChB,YAAY,CAAC,oBAAoB,CAAC,CAAC;YAEnC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;oBACjB,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC;wBACzB,OAAO,EAAE,IAAI;wBACb,WAAW;wBACX,QAAQ,EAAE,MAAM,CAAC,QAAQ;wBACzB,MAAM,EAAE,OAAO,CAAC,MAAM;qBACvB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;gBACf,CAAC;qBAAM,CAAC;oBACN,aAAa,CAAC;wBACZ,cAAc,EAAE,WAAW;wBAC3B,UAAU,EAAE,GAAG,MAAM,CAAC,QAAQ,IAAI;wBAClC,QAAQ,EAAE,OAAO,CAAC,MAAM;wBACxB,QAAQ,EAAE,WAAW;qBACtB,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;QAEH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,WAAW,CAAC,KAAK,EAAE,WAAW,CAAC,WAAW,EAAE;gBAC1C,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,KAAK;gBAC3B,IAAI,EAAE,IAAI;gBACV,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,EAAE;aACnE,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,oBAAoB,CACjC,UAA8B,EAC9B,OAA0F;IAE1F,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IACD,MAAM,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC/C,sEAAsE;IACtE,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;IAC3C,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IACxE,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;IAE7E,uEAAuE;IACvE,MAAM,EAAE,sBAAsB,EAAE,GAAG,MAAM,MAAM,CAAC,iCAAiC,CAAC,CAAC;IACnF,MAAM,KAAK,GAAG,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC;IAC7E,MAAM,aAAa,GAAG,CAAC,CAAS,EAAE,EAAE,CAClC,CAAC,KAAK,aAAa,IAAI,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC5E,MAAM,YAAY,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAChE,MAAM,MAAM,GAAG,sBAAsB,CAAC,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IAE/F,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACzB,OAAO,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC;QACpC,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAC9B,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,GAAG,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;QACtD,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;AAChD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { dirname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { Command } from 'commander';\nimport { assertShellSafe } from '../config/cli.constants.js';\nimport type { Pipeline } from '../types/pipeline.js';\nimport { auditLog } from '../utils/audit-log.js';\nimport { ensureCdkAvailable, executeCdkShellCommand, resolveBoilerplatePath } from '../utils/cdk-utils.js';\nimport { createAuthenticatedClientAsync, printCommandHeader, printSslWarning } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { extractSingleResponse, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { resolvePluginsForProps } from '../utils/plugin-resolver.js';\n\n// ESM has no __dirname; derive it from this module's URL.\nconst __dirname = dirname(fileURLToPath(import.meta.url));\n\n/**\n * Fetch pipeline config and set PIPELINE_PROPS env var for the boilerplate app.\n * Uses createAuthenticatedClientAsync which supports all three auth methods.\n */\nasync function fetchPipelineConfig(\n  pipelineId: string,\n  options: { storeTokens?: boolean; verifySsl?: boolean; region?: string; profile?: string },\n): Promise<void> {\n  const client = await createAuthenticatedClientAsync(options);\n  const config = client.getConfig();\n\n  const response = await client.get<Record<string, unknown>>(\n    `${config.api.pipelineUrl}/${pipelineId}`,\n  );\n\n  const pipeline = extractSingleResponse<Pipeline>(response, 'pipeline', 'props');\n\n  if (!pipeline?.props) {\n    printError('Pipeline has no props', { id: pipelineId });\n    throw new Error(`Failed to retrieve pipeline props for ID: ${pipelineId}`);\n  }\n\n  const propsWithIds: Record<string, unknown> = {\n    ...pipeline.props as Record<string, unknown>,\n    pipelineId: pipeline.id || pipelineId,\n  };\n  if (pipeline.orgId) propsWithIds.orgId = pipeline.orgId;\n\n  // Pre-resolve plugins from the platform API so the synthesized template\n  // ships with real CodeBuild image URIs baked in. Without this, CDK falls\n  // back to standard:7.0 because the deploy-time custom resource attribute\n  // is unresolvable at synth time.\n  const resolvedPlugins = await resolvePluginsForProps(client, propsWithIds);\n  if (Object.keys(resolvedPlugins).length > 0) {\n    propsWithIds.resolvedPlugins = resolvedPlugins;\n    printInfo('Pre-resolved plugins', { count: Object.keys(resolvedPlugins).length });\n  }\n\n  process.env.PIPELINE_PROPS = Buffer.from(JSON.stringify(propsWithIds)).toString('base64');\n\n  // Propagate the resolved platform base URL into the boilerplate synth (which\n  // inherits process.env). loadRegistryConfig() derives the registry PULL host\n  // from PLATFORM_BASE_URL / IMAGE_REGISTRY_PULL_HOST; it only reads the env, so\n  // without this a URL configured via ~/.pipeline-manager/config.yml is invisible\n  // to the synth and it bakes the in-cluster `registry:5000` into CodeBuild (which\n  // can't resolve it from the VPC). IMAGE_REGISTRY_PULL_HOST still wins if set.\n  if (config.api.baseUrl) {\n    process.env.PLATFORM_BASE_URL = config.api.baseUrl;\n  }\n\n  printSuccess('Pipeline configuration loaded');\n}\n\n/**\n * Registers the `synth` command with the CLI program.\n *\n * Runs CDK synthesis using the boilerplate app. Pipeline config is resolved from:\n * 1. --id flag or PIPELINE_ID env var → fetches config from platform API\n * 2. PIPELINE_PROPS env var (pre-encoded, from deploy command)\n *\n * Authentication methods (in priority order):\n * - PLATFORM_TOKEN env var\n * - --store-tokens → fetch from AWS Secrets Manager\n *\n * @example\n * ```bash\n * pipeline-manager synth --id <pipeline-id> --no-verify-ssl\n * pipeline-manager synth --id <pipeline-id> --store-tokens\n * pipeline-manager synth --quiet --no-notices          # CodePipeline (uses env vars)\n * ```\n */\nexport function synth(program: Command): void {\n  program\n    .command('synth')\n    .description('Run CDK synthesis using pipeline configuration')\n    .option('-i, --id <id>', 'Pipeline ID (or set PIPELINE_ID env var)')\n    .option('--store-tokens', 'Authenticate using token from AWS Secrets Manager (requires PLATFORM_SECRET_NAME env var)', false)\n    .option('--output <dir>', 'CDK output directory', 'cdk.out')\n    .option('--profile <profile>', 'AWS profile')\n    .option('--region <region>', 'AWS region (for --store-tokens)')\n    .option('--quiet', 'Suppress CDK output', false)\n    .option('--no-notices', 'Suppress CDK notices')\n    .option('--verbose', 'Show verbose CDK output', false)\n    .option('--json', 'Output result as JSON', false)\n    .option('--verify-ssl', 'Enable SSL certificate verification')\n    .option('--no-verify-ssl', 'Disable SSL certificate verification')\n    .option('--show-resolved', 'Print the resolved pipeline config (with {{ ... }} templates expanded) and exit without running CDK', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('CDK Synthesis');\n\n      try {\n        const pipelineId = options.id || process.env.PIPELINE_ID;\n\n        // --show-resolved: preview templates and exit\n        if (options.showResolved) {\n          await showResolvedPipeline(pipelineId, options);\n          return;\n        }\n\n        auditLog('synth', { executionId, pipelineId, output: options.output, profile: options.profile });\n        printSslWarning(options.verifySsl);\n\n        // Propagate to process.env so CDK constructs (Lambda, CodeBuild) inherit it\n        if (options.verifySsl === false) {\n          process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';\n        }\n\n        // Fetch pipeline config if ID is available and PIPELINE_PROPS not already set\n        if (pipelineId && !process.env.PIPELINE_PROPS) {\n          printInfo('Fetching pipeline configuration', { id: pipelineId });\n          await fetchPipelineConfig(pipelineId, options);\n        } else if (!pipelineId && !process.env.PIPELINE_PROPS) {\n          printWarning('No pipeline ID or PIPELINE_PROPS set');\n          throw new Error('Pipeline ID is required. Use --id <id> or set PIPELINE_ID env var.');\n        }\n\n        ensureCdkAvailable();\n        printSuccess('AWS CDK is available');\n\n        // Build cdk synth command\n        if (options.output) assertShellSafe(options.output, 'output');\n        if (options.profile) assertShellSafe(options.profile, 'profile');\n\n        const boilerplatePath = resolveBoilerplatePath(__dirname);\n        const parts = [\n          'cdk synth',\n          `--app=\"node ${boilerplatePath}\"`,\n          `--output=${options.output}`,\n        ];\n\n        if (options.profile) parts.push(`--profile=${options.profile}`);\n        if (options.quiet) parts.push('--quiet');\n        if (options.notices === false) parts.push('--no-notices');\n        if (options.verbose) parts.push('--verbose');\n\n        const command = parts.join(' ');\n\n        printInfo('Executing', { command: (command.split('--app')[0] ?? '').trim() + ' ...' });\n        console.log('');\n\n        const result = executeCdkShellCommand(command, {\n          showOutput: !options.quiet,\n        });\n\n        console.log('');\n        printSection('Synthesis Complete');\n\n        if (result.success) {\n          if (options.json) {\n            console.log(JSON.stringify({\n              success: true,\n              executionId,\n              duration: result.duration,\n              output: options.output,\n            }, null, 2));\n          } else {\n            printKeyValue({\n              'Execution ID': executionId,\n              'Duration': `${result.duration}ms`,\n              'Output': options.output,\n              'Status': '✓ Success',\n            });\n          }\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'synth', executionId, pipelineId: options.id },\n        });\n      }\n    });\n}\n\n/**\n * Fetch the pipeline by ID, apply pass-1 self-referencing template\n * resolution, and print it to stdout. Used by `synth --show-resolved`\n * and `deploy --show-resolved` to preview substitution before running CDK.\n */\nasync function showResolvedPipeline(\n  pipelineId: string | undefined,\n  options: { profile?: string; region?: string; storeTokens?: boolean; verifySsl?: boolean },\n): Promise<void> {\n  if (!pipelineId) {\n    throw new Error('--show-resolved requires --id or PIPELINE_ID env var');\n  }\n  await fetchPipelineConfig(pipelineId, options);\n  // fetchPipelineConfig writes PIPELINE_PROPS base64-encoded on success\n  const encoded = process.env.PIPELINE_PROPS;\n  if (!encoded) throw new Error('Failed to fetch pipeline configuration');\n  const decoded = JSON.parse(Buffer.from(encoded, 'base64').toString('utf-8'));\n\n  // Lazy import to avoid pulling pipeline-core into every CLI invocation\n  const { resolveSelfReferencing } = await import('@pipeline-builder/pipeline-core');\n  const scope = { metadata: decoded.metadata ?? {}, vars: decoded.vars ?? {} };\n  const isTemplatable = (f: string) =>\n    f === 'projectName' || f.startsWith('metadata.') || f.startsWith('vars.');\n  const fieldToScope = (f: string) => isTemplatable(f) ? f : null;\n  const result = resolveSelfReferencing(decoded, scope, isTemplatable, fieldToScope, 'pipeline');\n\n  if (result.errors.length) {\n    console.error('Resolution errors:');\n    for (const e of result.errors) {\n      console.error(`  [${e.field ?? '?'}] ${e.message}`);\n    }\n    process.exit(1);\n  }\n  console.log(JSON.stringify(decoded, null, 2));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"synth.js","sourceRoot":"","sources":["../../src/commands/synth.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC3G,OAAO,EAAE,8BAA8B,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAChH,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACjJ,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D,0DAA0D;AAC1D,MAAM,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE1D;;;GAGG;AACH,KAAK,UAAU,mBAAmB,CAChC,UAAkB,EAClB,OAA0F;IAE1F,MAAM,MAAM,GAAG,MAAM,8BAA8B,CAAC,OAAO,CAAC,CAAC;IAC7D,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;IAElC,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,GAAG,CAC/B,GAAG,MAAM,CAAC,GAAG,CAAC,WAAW,IAAI,UAAU,EAAE,CAC1C,CAAC;IAEF,MAAM,QAAQ,GAAG,qBAAqB,CAAW,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAEhF,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC;QACrB,UAAU,CAAC,uBAAuB,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;QACxD,MAAM,IAAI,KAAK,CAAC,6CAA6C,UAAU,EAAE,CAAC,CAAC;IAC7E,CAAC;IAED,MAAM,YAAY,GAA4B;QAC5C,GAAG,QAAQ,CAAC,KAAgC;QAC5C,UAAU,EAAE,QAAQ,CAAC,EAAE,IAAI,UAAU;KACtC,CAAC;IACF,IAAI,QAAQ,CAAC,KAAK;QAAE,YAAY,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC;IAExD,wEAAwE;IACxE,yEAAyE;IACzE,yEAAyE;IACzE,iCAAiC;IACjC,MAAM,eAAe,GAAG,MAAM,sBAAsB,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3E,IAAI,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5C,YAAY,CAAC,eAAe,GAAG,eAAe,CAAC;QAC/C,SAAS,CAAC,sBAAsB,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IACpF,CAAC;IAED,4EAA4E;IAC5E,+EAA+E;IAC/E,+EAA+E;IAC/E,4DAA4D;IAC5D,oBAAoB,CAAC,YAAY,EAAE,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAEvD,OAAO,CAAC,GAAG,CAAC,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAE1F,6EAA6E;IAC7E,6EAA6E;IAC7E,wEAAwE;IACxE,8EAA8E;IAC9E,gEAAgE;IAChE,IAAI,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACvB,OAAO,CAAC,GAAG,CAAC,iBAAiB,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC;IACrD,CAAC;IAED,YAAY,CAAC,+BAA+B,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,KAAK,CAAC,OAAgB;IACpC,OAAO;SACJ,OAAO,CAAC,OAAO,CAAC;SAChB,WAAW,CAAC,gDAAgD,CAAC;SAC7D,MAAM,CAAC,eAAe,EAAE,0CAA0C,CAAC;SACnE,MAAM,CAAC,gBAAgB,EAAE,2FAA2F,EAAE,KAAK,CAAC;SAC5H,MAAM,CAAC,gBAAgB,EAAE,sBAAsB,EAAE,SAAS,CAAC;SAC3D,MAAM,CAAC,qBAAqB,EAAE,aAAa,CAAC;SAC5C,MAAM,CAAC,mBAAmB,EAAE,iCAAiC,CAAC;SAC9D,MAAM,CAAC,SAAS,EAAE,qBAAqB,EAAE,KAAK,CAAC;SAC/C,MAAM,CAAC,cAAc,EAAE,sBAAsB,CAAC;SAC9C,MAAM,CAAC,WAAW,EAAE,yBAAyB,EAAE,KAAK,CAAC;SACrD,MAAM,CAAC,QAAQ,EAAE,uBAAuB,EAAE,KAAK,CAAC;SAChD,MAAM,CAAC,cAAc,EAAE,qCAAqC,CAAC;SAC7D,MAAM,CAAC,iBAAiB,EAAE,sCAAsC,CAAC;SACjE,MAAM,CAAC,iBAAiB,EAAE,qGAAqG,EAAE,KAAK,CAAC;SACvI,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QACxB,MAAM,WAAW,GAAG,kBAAkB,CAAC,eAAe,CAAC,CAAC;QAExD,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,OAAO,CAAC,EAAE,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC;YAEzD,8CAA8C;YAC9C,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;gBACzB,MAAM,oBAAoB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBAChD,OAAO;YACT,CAAC;YAED,QAAQ,CAAC,OAAO,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;YACjG,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAEnC,4EAA4E;YAC5E,IAAI,OAAO,CAAC,SAAS,KAAK,KAAK,EAAE,CAAC;gBAChC,OAAO,CAAC,GAAG,CAAC,4BAA4B,GAAG,GAAG,CAAC;YACjD,CAAC;YAED,8EAA8E;YAC9E,IAAI,UAAU,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;gBAC9C,SAAS,CAAC,iCAAiC,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;gBACjE,MAAM,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;YACjD,CAAC;iBAAM,IAAI,CAAC,UAAU,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;gBACtD,YAAY,CAAC,sCAAsC,CAAC,CAAC;gBACrD,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;YACxF,CAAC;YAED,kBAAkB,EAAE,CAAC;YACrB,YAAY,CAAC,sBAAsB,CAAC,CAAC;YAErC,0BAA0B;YAC1B,IAAI,OAAO,CAAC,MAAM;gBAAE,eAAe,CAAC,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YAC9D,IAAI,OAAO,CAAC,OAAO;gBAAE,eAAe,CAAC,OAAO,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;YAEjE,MAAM,eAAe,GAAG,sBAAsB,CAAC,SAAS,CAAC,CAAC;YAC1D,MAAM,KAAK,GAAG;gBACZ,WAAW;gBACX,eAAe,eAAe,GAAG;gBACjC,YAAY,OAAO,CAAC,MAAM,EAAE;aAC7B,CAAC;YAEF,IAAI,OAAO,CAAC,OAAO;gBAAE,KAAK,CAAC,IAAI,CAAC,aAAa,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;YAChE,IAAI,OAAO,CAAC,KAAK;gBAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACzC,IAAI,OAAO,CAAC,OAAO,KAAK,KAAK;gBAAE,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAC1D,IAAI,OAAO,CAAC,OAAO;gBAAE,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAE7C,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAEhC,SAAS,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;YACvF,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAEhB,MAAM,MAAM,GAAG,sBAAsB,CAAC,OAAO,EAAE;gBAC7C,UAAU,EAAE,CAAC,OAAO,CAAC,KAAK;aAC3B,CAAC,CAAC;YAEH,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAChB,YAAY,CAAC,oBAAoB,CAAC,CAAC;YAEnC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;oBACjB,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC;wBACzB,OAAO,EAAE,IAAI;wBACb,WAAW;wBACX,QAAQ,EAAE,MAAM,CAAC,QAAQ;wBACzB,MAAM,EAAE,OAAO,CAAC,MAAM;qBACvB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;gBACf,CAAC;qBAAM,CAAC;oBACN,aAAa,CAAC;wBACZ,cAAc,EAAE,WAAW;wBAC3B,UAAU,EAAE,GAAG,MAAM,CAAC,QAAQ,IAAI;wBAClC,QAAQ,EAAE,OAAO,CAAC,MAAM;wBACxB,QAAQ,EAAE,WAAW;qBACtB,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;QAEH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,WAAW,CAAC,KAAK,EAAE,WAAW,CAAC,WAAW,EAAE;gBAC1C,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,KAAK;gBAC3B,IAAI,EAAE,IAAI;gBACV,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,EAAE;aACnE,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,oBAAoB,CACjC,UAA8B,EAC9B,OAA0F;IAE1F,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IACD,MAAM,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC/C,sEAAsE;IACtE,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;IAC3C,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IACxE,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;IAE7E,uEAAuE;IACvE,MAAM,EAAE,sBAAsB,EAAE,GAAG,MAAM,MAAM,CAAC,iCAAiC,CAAC,CAAC;IACnF,MAAM,KAAK,GAAG,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC;IAC7E,MAAM,aAAa,GAAG,CAAC,CAAS,EAAE,EAAE,CAClC,CAAC,KAAK,aAAa,IAAI,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC5E,MAAM,YAAY,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAChE,MAAM,MAAM,GAAG,sBAAsB,CAAC,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IAE/F,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACzB,OAAO,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC;QACpC,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAC9B,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,GAAG,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;QACtD,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;AAChD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { dirname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { Command } from 'commander';\nimport { assertShellSafe } from '../config/cli.constants.js';\nimport type { Pipeline } from '../types/pipeline.js';\nimport { auditLog } from '../utils/audit-log.js';\nimport { ensureCdkAvailable, executeCdkShellCommand, resolveBoilerplatePath } from '../utils/cdk-utils.js';\nimport { createAuthenticatedClientAsync, printCommandHeader, printSslWarning } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { extractSingleResponse, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { resolvePluginsForProps } from '../utils/plugin-resolver.js';\nimport { bakePlatformRegistry } from '../utils/registry.js';\n\n// ESM has no __dirname; derive it from this module's URL.\nconst __dirname = dirname(fileURLToPath(import.meta.url));\n\n/**\n * Fetch pipeline config and set PIPELINE_PROPS env var for the boilerplate app.\n * Uses createAuthenticatedClientAsync which supports all three auth methods.\n */\nasync function fetchPipelineConfig(\n  pipelineId: string,\n  options: { storeTokens?: boolean; verifySsl?: boolean; region?: string; profile?: string },\n): Promise<void> {\n  const client = await createAuthenticatedClientAsync(options);\n  const config = client.getConfig();\n\n  const response = await client.get<Record<string, unknown>>(\n    `${config.api.pipelineUrl}/${pipelineId}`,\n  );\n\n  const pipeline = extractSingleResponse<Pipeline>(response, 'pipeline', 'props');\n\n  if (!pipeline?.props) {\n    printError('Pipeline has no props', { id: pipelineId });\n    throw new Error(`Failed to retrieve pipeline props for ID: ${pipelineId}`);\n  }\n\n  const propsWithIds: Record<string, unknown> = {\n    ...pipeline.props as Record<string, unknown>,\n    pipelineId: pipeline.id || pipelineId,\n  };\n  if (pipeline.orgId) propsWithIds.orgId = pipeline.orgId;\n\n  // Pre-resolve plugins from the platform API so the synthesized template\n  // ships with real CodeBuild image URIs baked in. Without this, CDK falls\n  // back to standard:7.0 because the deploy-time custom resource attribute\n  // is unresolvable at synth time.\n  const resolvedPlugins = await resolvePluginsForProps(client, propsWithIds);\n  if (Object.keys(resolvedPlugins).length > 0) {\n    propsWithIds.resolvedPlugins = resolvedPlugins;\n    printInfo('Pre-resolved plugins', { count: Object.keys(resolvedPlugins).length });\n  }\n\n  // Bake the registry pull target from the platform URL we synth against (the\n  // host serving the registry /v2/ data path) so CodeBuild image URIs use a host\n  // AWS CodeBuild can resolve, not the in-cluster `registry:5000` default. No-op\n  // when IMAGE_REGISTRY_PULL_HOST is set (explicit env wins).\n  bakePlatformRegistry(propsWithIds, config.api.baseUrl);\n\n  process.env.PIPELINE_PROPS = Buffer.from(JSON.stringify(propsWithIds)).toString('base64');\n\n  // Propagate the resolved platform base URL into the boilerplate synth (which\n  // inherits process.env). The synth uses it for serverConfig.platformUrl (the\n  // PluginLookup Lambda endpoint) and as the loadRegistryConfig pull-host\n  // fallback. Without this, a URL configured via ~/.pipeline-manager/config.yml\n  // is invisible to the synth subprocess (it reads only the env).\n  if (config.api.baseUrl) {\n    process.env.PLATFORM_BASE_URL = config.api.baseUrl;\n  }\n\n  printSuccess('Pipeline configuration loaded');\n}\n\n/**\n * Registers the `synth` command with the CLI program.\n *\n * Runs CDK synthesis using the boilerplate app. Pipeline config is resolved from:\n * 1. --id flag or PIPELINE_ID env var → fetches config from platform API\n * 2. PIPELINE_PROPS env var (pre-encoded, from deploy command)\n *\n * Authentication methods (in priority order):\n * - PLATFORM_TOKEN env var\n * - --store-tokens → fetch from AWS Secrets Manager\n *\n * @example\n * ```bash\n * pipeline-manager synth --id <pipeline-id> --no-verify-ssl\n * pipeline-manager synth --id <pipeline-id> --store-tokens\n * pipeline-manager synth --quiet --no-notices          # CodePipeline (uses env vars)\n * ```\n */\nexport function synth(program: Command): void {\n  program\n    .command('synth')\n    .description('Run CDK synthesis using pipeline configuration')\n    .option('-i, --id <id>', 'Pipeline ID (or set PIPELINE_ID env var)')\n    .option('--store-tokens', 'Authenticate using token from AWS Secrets Manager (requires PLATFORM_SECRET_NAME env var)', false)\n    .option('--output <dir>', 'CDK output directory', 'cdk.out')\n    .option('--profile <profile>', 'AWS profile')\n    .option('--region <region>', 'AWS region (for --store-tokens)')\n    .option('--quiet', 'Suppress CDK output', false)\n    .option('--no-notices', 'Suppress CDK notices')\n    .option('--verbose', 'Show verbose CDK output', false)\n    .option('--json', 'Output result as JSON', false)\n    .option('--verify-ssl', 'Enable SSL certificate verification')\n    .option('--no-verify-ssl', 'Disable SSL certificate verification')\n    .option('--show-resolved', 'Print the resolved pipeline config (with {{ ... }} templates expanded) and exit without running CDK', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('CDK Synthesis');\n\n      try {\n        const pipelineId = options.id || process.env.PIPELINE_ID;\n\n        // --show-resolved: preview templates and exit\n        if (options.showResolved) {\n          await showResolvedPipeline(pipelineId, options);\n          return;\n        }\n\n        auditLog('synth', { executionId, pipelineId, output: options.output, profile: options.profile });\n        printSslWarning(options.verifySsl);\n\n        // Propagate to process.env so CDK constructs (Lambda, CodeBuild) inherit it\n        if (options.verifySsl === false) {\n          process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';\n        }\n\n        // Fetch pipeline config if ID is available and PIPELINE_PROPS not already set\n        if (pipelineId && !process.env.PIPELINE_PROPS) {\n          printInfo('Fetching pipeline configuration', { id: pipelineId });\n          await fetchPipelineConfig(pipelineId, options);\n        } else if (!pipelineId && !process.env.PIPELINE_PROPS) {\n          printWarning('No pipeline ID or PIPELINE_PROPS set');\n          throw new Error('Pipeline ID is required. Use --id <id> or set PIPELINE_ID env var.');\n        }\n\n        ensureCdkAvailable();\n        printSuccess('AWS CDK is available');\n\n        // Build cdk synth command\n        if (options.output) assertShellSafe(options.output, 'output');\n        if (options.profile) assertShellSafe(options.profile, 'profile');\n\n        const boilerplatePath = resolveBoilerplatePath(__dirname);\n        const parts = [\n          'cdk synth',\n          `--app=\"node ${boilerplatePath}\"`,\n          `--output=${options.output}`,\n        ];\n\n        if (options.profile) parts.push(`--profile=${options.profile}`);\n        if (options.quiet) parts.push('--quiet');\n        if (options.notices === false) parts.push('--no-notices');\n        if (options.verbose) parts.push('--verbose');\n\n        const command = parts.join(' ');\n\n        printInfo('Executing', { command: (command.split('--app')[0] ?? '').trim() + ' ...' });\n        console.log('');\n\n        const result = executeCdkShellCommand(command, {\n          showOutput: !options.quiet,\n        });\n\n        console.log('');\n        printSection('Synthesis Complete');\n\n        if (result.success) {\n          if (options.json) {\n            console.log(JSON.stringify({\n              success: true,\n              executionId,\n              duration: result.duration,\n              output: options.output,\n            }, null, 2));\n          } else {\n            printKeyValue({\n              'Execution ID': executionId,\n              'Duration': `${result.duration}ms`,\n              'Output': options.output,\n              'Status': '✓ Success',\n            });\n          }\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'synth', executionId, pipelineId: options.id },\n        });\n      }\n    });\n}\n\n/**\n * Fetch the pipeline by ID, apply pass-1 self-referencing template\n * resolution, and print it to stdout. Used by `synth --show-resolved`\n * and `deploy --show-resolved` to preview substitution before running CDK.\n */\nasync function showResolvedPipeline(\n  pipelineId: string | undefined,\n  options: { profile?: string; region?: string; storeTokens?: boolean; verifySsl?: boolean },\n): Promise<void> {\n  if (!pipelineId) {\n    throw new Error('--show-resolved requires --id or PIPELINE_ID env var');\n  }\n  await fetchPipelineConfig(pipelineId, options);\n  // fetchPipelineConfig writes PIPELINE_PROPS base64-encoded on success\n  const encoded = process.env.PIPELINE_PROPS;\n  if (!encoded) throw new Error('Failed to fetch pipeline configuration');\n  const decoded = JSON.parse(Buffer.from(encoded, 'base64').toString('utf-8'));\n\n  // Lazy import to avoid pulling pipeline-core into every CLI invocation\n  const { resolveSelfReferencing } = await import('@pipeline-builder/pipeline-core');\n  const scope = { metadata: decoded.metadata ?? {}, vars: decoded.vars ?? {} };\n  const isTemplatable = (f: string) =>\n    f === 'projectName' || f.startsWith('metadata.') || f.startsWith('vars.');\n  const fieldToScope = (f: string) => isTemplatable(f) ? f : null;\n  const result = resolveSelfReferencing(decoded, scope, isTemplatable, fieldToScope, 'pipeline');\n\n  if (result.errors.length) {\n    console.error('Resolution errors:');\n    for (const e of result.errors) {\n      console.error(`  [${e.field ?? '?'}] ${e.message}`);\n    }\n    process.exit(1);\n  }\n  console.log(JSON.stringify(decoded, null, 2));\n}\n"]}

package/dist/utils/registry.d.ts

@@ -21,6 +21,30 @@
  * Auth is supplied by whichever command drains the intent (deploy or register),
  * so a stale intent file is never an authentication risk.
  */
+/**
+ * Platform-sourced registry pull target for the CDK synth, derived from the
+ * platform base URL the CLI deploys against (the same host that serves the
+ * registry `/v2/` data path via nginx). Reuses pipeline-core's
+ * `parsePlatformBaseUrl` so host/port parsing stays identical on both sides.
+ * Returns `undefined` for an unparseable/absent URL. (Only the pull host/port
+ * are returned — `registry.http` describes the in-cluster push hop, which the
+ * synth never reads, so deriving it from the public URL would be misleading.)
+ */
+export declare function registryOverrideFromBaseUrl(baseUrl: string | undefined): {
+    pullHost: string;
+    pullPort: number;
+} | undefined;
+/**
+ * Bake the platform-derived registry pull target into the synth props
+ * (`BuilderProps.registry`) so the CodeBuild image URIs use a host AWS CodeBuild
+ * can resolve — not the in-cluster `registry:5000` default. Shared by the
+ * `deploy` and `synth` commands.
+ *
+ * An explicit `IMAGE_REGISTRY_PULL_HOST` in the synth env takes precedence, so
+ * this is a no-op when it is set (the synth's `loadRegistryConfig` already
+ * honors it). Also a no-op for an unparseable/absent base URL.
+ */
+export declare function bakePlatformRegistry(props: Record<string, unknown>, baseUrl: string | undefined): void;
 /** Shape of the body POSTed to /api/pipelines/registry. */
 export interface RegistryPayload {
     pipelineId: string;

package/dist/utils/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/utils/registry.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,2DAA2D;AAC3D,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,6DAA6D;AAC7D,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAKD;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,mBAAmB,EAC7B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,eAAe,CAAC,CAmB1B;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAKlF;AAED,wDAAwD;AACxD,wBAAsB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ1E;AAED,oFAAoF;AACpF,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAqBrE"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/utils/registry.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAGpD;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAMtG;AAED,2DAA2D;AAC3D,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,6DAA6D;AAC7D,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAKD;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,mBAAmB,EAC7B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,eAAe,CAAC,CAmB1B;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAKlF;AAED,wDAAwD;AACxD,wBAAsB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ1E;AAED,oFAAoF;AACpF,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAqBrE"}

package/dist/utils/registry.js

@@ -3,6 +3,63 @@
 import { promises as fs } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import { parsePlatformBaseUrl } from '@pipeline-builder/pipeline-core';
+import { printInfo } from './output-utils.js';
+/**
+ * Helpers for registering a deployed pipeline ARN with the platform.
+ *
+ * The registry table maps deployed CodePipeline ARNs back to pipeline records
+ * and orgs. It's how the dashboard's "Deployed pipelines" panel and the event
+ * reporting Lambda resolve incoming events to a pipeline definition.
+ *
+ * Two failure modes are handled here:
+ *
+ *   1. Platform unreachable at deploy time. The CDK stack lands in AWS but the
+ *      registry POST fails. Without retry the deploy command would have to
+ *      re-run cdk-deploy (slow, sometimes blocked by stack state) just to
+ *      record the ARN. Instead, we write a pending intent to a local file;
+ *      `pipeline-manager register` drains them.
+ *
+ *   2. User explicitly invokes `pipeline-manager register --id <pipelineId>`
+ *      after a successful deploy that didn't register. Same path: rebuilds
+ *      the ARN from STS, POSTs to the platform.
+ *
+ * Pending intents store ONLY the registration payload — never tokens or URLs.
+ * Auth is supplied by whichever command drains the intent (deploy or register),
+ * so a stale intent file is never an authentication risk.
+ */
+/**
+ * Platform-sourced registry pull target for the CDK synth, derived from the
+ * platform base URL the CLI deploys against (the same host that serves the
+ * registry `/v2/` data path via nginx). Reuses pipeline-core's
+ * `parsePlatformBaseUrl` so host/port parsing stays identical on both sides.
+ * Returns `undefined` for an unparseable/absent URL. (Only the pull host/port
+ * are returned — `registry.http` describes the in-cluster push hop, which the
+ * synth never reads, so deriving it from the public URL would be misleading.)
+ */
+export function registryOverrideFromBaseUrl(baseUrl) {
+    const parsed = parsePlatformBaseUrl(baseUrl);
+    return parsed ? { pullHost: parsed.host, pullPort: parsed.port } : undefined;
+}
+/**
+ * Bake the platform-derived registry pull target into the synth props
+ * (`BuilderProps.registry`) so the CodeBuild image URIs use a host AWS CodeBuild
+ * can resolve — not the in-cluster `registry:5000` default. Shared by the
+ * `deploy` and `synth` commands.
+ *
+ * An explicit `IMAGE_REGISTRY_PULL_HOST` in the synth env takes precedence, so
+ * this is a no-op when it is set (the synth's `loadRegistryConfig` already
+ * honors it). Also a no-op for an unparseable/absent base URL.
+ */
+export function bakePlatformRegistry(props, baseUrl) {
+    if (process.env.IMAGE_REGISTRY_PULL_HOST)
+        return; // explicit env wins
+    const override = registryOverrideFromBaseUrl(baseUrl);
+    if (!override)
+        return;
+    props.registry = override;
+    printInfo('Registry pull target', { host: override.pullHost, port: override.pullPort });
+}
 /** Where pending registration intents are persisted between CLI invocations. */
 const PENDING_INTENTS_DIR = join(homedir(), '.pipeline-manager', 'pending-registrations');
 /**
@@ -81,4 +138,4 @@ export async function readPendingIntents() {
     }
     return intents;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/utils/registry.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { promises as fs } from 'fs';\nimport { homedir } from 'os';\nimport { join } from 'path';\n\n/**\n * Helpers for registering a deployed pipeline ARN with the platform.\n *\n * The registry table maps deployed CodePipeline ARNs back to pipeline records\n * and orgs. It's how the dashboard's \"Deployed pipelines\" panel and the event\n * reporting Lambda resolve incoming events to a pipeline definition.\n *\n * Two failure modes are handled here:\n *\n *   1. Platform unreachable at deploy time. The CDK stack lands in AWS but the\n *      registry POST fails. Without retry the deploy command would have to\n *      re-run cdk-deploy (slow, sometimes blocked by stack state) just to\n *      record the ARN. Instead, we write a pending intent to a local file;\n *      `pipeline-manager register` drains them.\n *\n *   2. User explicitly invokes `pipeline-manager register --id <pipelineId>`\n *      after a successful deploy that didn't register. Same path: rebuilds\n *      the ARN from STS, POSTs to the platform.\n *\n * Pending intents store ONLY the registration payload — never tokens or URLs.\n * Auth is supplied by whichever command drains the intent (deploy or register),\n * so a stale intent file is never an authentication risk.\n */\n\n/** Shape of the body POSTed to /api/pipelines/registry. */\nexport interface RegistryPayload {\n  pipelineId: string;\n  orgId: string;\n  pipelineName: string;\n  region: string;\n  project: string;\n  organization: string;\n  stackName: string;\n}\n\n/** Pipeline fields needed to construct a RegistryPayload. */\nexport interface PipelineForRegistry {\n  id: string;\n  orgId: string;\n  pipelineName?: string;\n  project: string;\n  organization: string;\n}\n\n/** Where pending registration intents are persisted between CLI invocations. */\nconst PENDING_INTENTS_DIR = join(homedir(), '.pipeline-manager', 'pending-registrations');\n\n/**\n * Build a RegistryPayload from the platform's pipeline metadata. No AWS calls\n * and no ARN/account: the events Lambda attributes events via the pipeline's\n * `PIPELINE_EVENT_ID` tag (= pipelineId), so the registry only needs the stable\n * pipelineId + display metadata.\n */\nexport async function buildRegistryPayload(\n  pipeline: PipelineForRegistry,\n  regionOverride?: string,\n): Promise<RegistryPayload> {\n  const region = regionOverride\n    || process.env.AWS_REGION\n    || process.env.CDK_DEFAULT_REGION\n    || 'us-east-1';\n\n  const pipelineName = pipeline.pipelineName\n    || `${pipeline.organization}-${pipeline.project}-pipeline`.toLowerCase();\n  const stackName = `${pipeline.project}-${pipeline.organization}`.toLowerCase();\n\n  return {\n    pipelineId: pipeline.id,\n    orgId: pipeline.orgId,\n    pipelineName,\n    region,\n    project: pipeline.project,\n    organization: pipeline.organization,\n    stackName,\n  };\n}\n\n/**\n * Persist a registration intent for later retry.\n *\n * Intent files are keyed by pipelineId so re-running deploy on the same\n * pipeline overwrites rather than accumulates. We deliberately store the\n * payload plain (not the full pipeline doc, not auth) so a stale file is\n * safe to leave around indefinitely.\n */\nexport async function writePendingIntent(payload: RegistryPayload): Promise<string> {\n  await fs.mkdir(PENDING_INTENTS_DIR, { recursive: true });\n  const path = join(PENDING_INTENTS_DIR, `${payload.pipelineId}.json`);\n  await fs.writeFile(path, JSON.stringify(payload, null, 2), 'utf8');\n  return path;\n}\n\n/** Remove a pending intent after a successful drain. */\nexport async function clearPendingIntent(pipelineId: string): Promise<void> {\n  const path = join(PENDING_INTENTS_DIR, `${pipelineId}.json`);\n  try {\n    await fs.unlink(path);\n  } catch (err) {\n    // ENOENT is fine — already cleared. Anything else is a real problem.\n    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;\n  }\n}\n\n/** Read all pending intents currently on disk. Empty array if dir doesn't exist. */\nexport async function readPendingIntents(): Promise<RegistryPayload[]> {\n  let entries: string[];\n  try {\n    entries = await fs.readdir(PENDING_INTENTS_DIR);\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return [];\n    throw err;\n  }\n\n  const intents: RegistryPayload[] = [];\n  for (const file of entries) {\n    if (!file.endsWith('.json')) continue;\n    try {\n      const text = await fs.readFile(join(PENDING_INTENTS_DIR, file), 'utf8');\n      intents.push(JSON.parse(text) as RegistryPayload);\n    } catch {\n      // Skip unreadable / malformed files — they'll need manual cleanup but\n      // shouldn't block valid intents from draining.\n    }\n  }\n  return intents;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/utils/registry.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { promises as fs } from 'fs';\nimport { homedir } from 'os';\nimport { join } from 'path';\nimport { parsePlatformBaseUrl } from '@pipeline-builder/pipeline-core';\nimport { printInfo } from './output-utils.js';\n\n/**\n * Helpers for registering a deployed pipeline ARN with the platform.\n *\n * The registry table maps deployed CodePipeline ARNs back to pipeline records\n * and orgs. It's how the dashboard's \"Deployed pipelines\" panel and the event\n * reporting Lambda resolve incoming events to a pipeline definition.\n *\n * Two failure modes are handled here:\n *\n *   1. Platform unreachable at deploy time. The CDK stack lands in AWS but the\n *      registry POST fails. Without retry the deploy command would have to\n *      re-run cdk-deploy (slow, sometimes blocked by stack state) just to\n *      record the ARN. Instead, we write a pending intent to a local file;\n *      `pipeline-manager register` drains them.\n *\n *   2. User explicitly invokes `pipeline-manager register --id <pipelineId>`\n *      after a successful deploy that didn't register. Same path: rebuilds\n *      the ARN from STS, POSTs to the platform.\n *\n * Pending intents store ONLY the registration payload — never tokens or URLs.\n * Auth is supplied by whichever command drains the intent (deploy or register),\n * so a stale intent file is never an authentication risk.\n */\n\n/**\n * Platform-sourced registry pull target for the CDK synth, derived from the\n * platform base URL the CLI deploys against (the same host that serves the\n * registry `/v2/` data path via nginx). Reuses pipeline-core's\n * `parsePlatformBaseUrl` so host/port parsing stays identical on both sides.\n * Returns `undefined` for an unparseable/absent URL. (Only the pull host/port\n * are returned — `registry.http` describes the in-cluster push hop, which the\n * synth never reads, so deriving it from the public URL would be misleading.)\n */\nexport function registryOverrideFromBaseUrl(\n  baseUrl: string | undefined,\n): { pullHost: string; pullPort: number } | undefined {\n  const parsed = parsePlatformBaseUrl(baseUrl);\n  return parsed ? { pullHost: parsed.host, pullPort: parsed.port } : undefined;\n}\n\n/**\n * Bake the platform-derived registry pull target into the synth props\n * (`BuilderProps.registry`) so the CodeBuild image URIs use a host AWS CodeBuild\n * can resolve — not the in-cluster `registry:5000` default. Shared by the\n * `deploy` and `synth` commands.\n *\n * An explicit `IMAGE_REGISTRY_PULL_HOST` in the synth env takes precedence, so\n * this is a no-op when it is set (the synth's `loadRegistryConfig` already\n * honors it). Also a no-op for an unparseable/absent base URL.\n */\nexport function bakePlatformRegistry(props: Record<string, unknown>, baseUrl: string | undefined): void {\n  if (process.env.IMAGE_REGISTRY_PULL_HOST) return; // explicit env wins\n  const override = registryOverrideFromBaseUrl(baseUrl);\n  if (!override) return;\n  props.registry = override;\n  printInfo('Registry pull target', { host: override.pullHost, port: override.pullPort });\n}\n\n/** Shape of the body POSTed to /api/pipelines/registry. */\nexport interface RegistryPayload {\n  pipelineId: string;\n  orgId: string;\n  pipelineName: string;\n  region: string;\n  project: string;\n  organization: string;\n  stackName: string;\n}\n\n/** Pipeline fields needed to construct a RegistryPayload. */\nexport interface PipelineForRegistry {\n  id: string;\n  orgId: string;\n  pipelineName?: string;\n  project: string;\n  organization: string;\n}\n\n/** Where pending registration intents are persisted between CLI invocations. */\nconst PENDING_INTENTS_DIR = join(homedir(), '.pipeline-manager', 'pending-registrations');\n\n/**\n * Build a RegistryPayload from the platform's pipeline metadata. No AWS calls\n * and no ARN/account: the events Lambda attributes events via the pipeline's\n * `PIPELINE_EVENT_ID` tag (= pipelineId), so the registry only needs the stable\n * pipelineId + display metadata.\n */\nexport async function buildRegistryPayload(\n  pipeline: PipelineForRegistry,\n  regionOverride?: string,\n): Promise<RegistryPayload> {\n  const region = regionOverride\n    || process.env.AWS_REGION\n    || process.env.CDK_DEFAULT_REGION\n    || 'us-east-1';\n\n  const pipelineName = pipeline.pipelineName\n    || `${pipeline.organization}-${pipeline.project}-pipeline`.toLowerCase();\n  const stackName = `${pipeline.project}-${pipeline.organization}`.toLowerCase();\n\n  return {\n    pipelineId: pipeline.id,\n    orgId: pipeline.orgId,\n    pipelineName,\n    region,\n    project: pipeline.project,\n    organization: pipeline.organization,\n    stackName,\n  };\n}\n\n/**\n * Persist a registration intent for later retry.\n *\n * Intent files are keyed by pipelineId so re-running deploy on the same\n * pipeline overwrites rather than accumulates. We deliberately store the\n * payload plain (not the full pipeline doc, not auth) so a stale file is\n * safe to leave around indefinitely.\n */\nexport async function writePendingIntent(payload: RegistryPayload): Promise<string> {\n  await fs.mkdir(PENDING_INTENTS_DIR, { recursive: true });\n  const path = join(PENDING_INTENTS_DIR, `${payload.pipelineId}.json`);\n  await fs.writeFile(path, JSON.stringify(payload, null, 2), 'utf8');\n  return path;\n}\n\n/** Remove a pending intent after a successful drain. */\nexport async function clearPendingIntent(pipelineId: string): Promise<void> {\n  const path = join(PENDING_INTENTS_DIR, `${pipelineId}.json`);\n  try {\n    await fs.unlink(path);\n  } catch (err) {\n    // ENOENT is fine — already cleared. Anything else is a real problem.\n    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;\n  }\n}\n\n/** Read all pending intents currently on disk. Empty array if dir doesn't exist. */\nexport async function readPendingIntents(): Promise<RegistryPayload[]> {\n  let entries: string[];\n  try {\n    entries = await fs.readdir(PENDING_INTENTS_DIR);\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return [];\n    throw err;\n  }\n\n  const intents: RegistryPayload[] = [];\n  for (const file of entries) {\n    if (!file.endsWith('.json')) continue;\n    try {\n      const text = await fs.readFile(join(PENDING_INTENTS_DIR, file), 'utf8');\n      intents.push(JSON.parse(text) as RegistryPayload);\n    } catch {\n      // Skip unreadable / malformed files — they'll need manual cleanup but\n      // shouldn't block valid intents from draining.\n    }\n  }\n  return intents;\n}\n"]}

package/package.json

@@ -41,8 +41,8 @@
     "typescript": "6.0.3",
     "yaml": "2.9.0",
     "zod": "4.4.3",
-    "@pipeline-builder/ai-core": "3.4.79",
-    "@pipeline-builder/pipeline-core": "3.4.89"
+    "@pipeline-builder/pipeline-core": "3.4.90",
+    "@pipeline-builder/ai-core": "3.4.79"
   },
   "keywords": [
     "ci-cd",
@@ -97,7 +97,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.117",
+  "version": "3.4.119",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },