@pipeline-builder/pipeline-manager 4.1.15 → 4.1.16

package/dist/utils/plugin-resolver.js

@@ -1,15 +1,16 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { ErrorCode, errorMessage } from '@pipeline-builder/api-core';
+import { pluginArtifactAlias, pluginLookupFilter, unwrapLookup } from '@pipeline-builder/pipeline-core';
 import { ApiClient } from './api-client.js';
 import { printWarning } from './output-utils.js';
 /**
- * Cache key matching `PluginLookup.normalize()`: explicit alias when set,
- * otherwise `${name}-alias`. Must stay in sync with the consumers in
- * pipeline-core/plugin-lookup.ts and pipeline-builder.ts that read this map.
+ * Cache key matching `PluginLookup.normalize()`: the explicit alias when set,
+ * otherwise `[<publisher>-]<name>-alias` — pipeline-core's
+ * `pluginArtifactAlias`, the one rule every consumer of this map uses.
  */
 function cacheKey(ref) {
-    return ref.alias || `${ref.name}-alias`;
+    return pluginArtifactAlias(ref);
 }
 /**
  * Walk the pipeline props tree to collect every plugin reference. Plugins
@@ -29,7 +30,8 @@ function collectPluginRefs(props) {
         const key = cacheKey(r);
         // The name the lookup will TARGET — an explicit `filter.name` wins (see
         // below), so two refs that resolve to the same plugin are not a collision.
-        const target = r.filter?.name ?? r.name;
+        const name = r.filter?.name ?? r.name;
+        const target = r.publisher ? `${r.publisher}/${name}` : name;
         const holder = seen.get(key);
         if (holder !== undefined) {
             // One alias can only ever mean one plugin. Deduplicating on the alias
@@ -56,10 +58,24 @@ function collectPluginRefs(props) {
     }
     return refs;
 }
-/** The plugin service's 409 `IMAGE_VERIFICATION_FAILED` answer from `/plugins/lookup`. */
-function isImageVerificationFailure(err) {
+/**
+ * Lookup refusals that must STOP the synth rather than fall back to
+ * deploy-time resolution: an image whose signature doesn't verify, and a
+ * listing the org can't use (not installed, blocked by its policy, yanked or
+ * suspended). Falling back would quietly turn
+ * each into an unresolved step that fails at run time instead of now.
+ */
+const FATAL_LOOKUP_CODES = [
+    ErrorCode.IMAGE_VERIFICATION_FAILED,
+    ErrorCode.PLUGIN_NOT_INSTALLED,
+    ErrorCode.PLUGIN_BLOCKED_BY_POLICY,
+    ErrorCode.PLUGIN_UNAVAILABLE,
+];
+/** The error code of a plugin service answer, when it is one of {@link FATAL_LOOKUP_CODES}. */
+function fatalLookupCode(err) {
     const data = err?.response?.data;
-    return !!data && typeof data === 'object' && data.code === ErrorCode.IMAGE_VERIFICATION_FAILED;
+    const code = data && typeof data === 'object' ? data.code : undefined;
+    return typeof code === 'string' && FATAL_LOOKUP_CODES.includes(code) ? code : null;
 }
 /**
  * Pre-resolve plugins by calling the same `POST /api/plugins/lookup` endpoint
@@ -83,6 +99,7 @@ export async function resolvePluginsForProps(client, props) {
     const resolved = {};
     await Promise.all(refs.map(async (ref) => {
         const key = cacheKey(ref);
+        const label = ref.publisher ? `${ref.publisher}/${ref.name}` : ref.name;
         // The plugin NAME lives on the ref (a sibling of `filter`), NOT inside the
         // filter object — but the lookup matches on the filter. A filter without
         // `name` (e.g. `{version, visibility, isActive, isDefault}`) matches ANY
@@ -90,38 +107,35 @@ export async function resolvePluginsForProps(client, props) {
         // (seen: `dockerfile-multi-provider`). That made the synth and every step
         // resolve to the WRONG plugin. So when the filter omits `name`, fall back to
         // the ref's plugin name; an explicit filter `name` still takes precedence.
-        const filter = { name: ref.name, ...(ref.filter ?? { isActive: true, isDefault: true }) };
+        // Shared with the pipeline service's contract check (same filter, same plugin).
+        const filter = pluginLookupFilter(ref);
         try {
             const res = await client.post('/api/plugins/lookup', { filter });
-            // Unwrap the plugin record from whatever envelope the response middleware
-            // applied. The platform's standard success envelope is
-            // `{ success, statusCode, data: { plugin: Plugin } }` (note the DOUBLE
-            // nesting: data.plugin), but tolerate `{ data: Plugin }`, `{ plugin }`,
-            // and a bare Plugin too. Only stopping at `res.data` (which is
-            // `{ plugin: ... }`) made `.name` undefined → every lookup fell back to
-            // deploy-time resolution even though the catalog had the plugin.
-            const data = res.data;
-            const plugin = data?.plugin // { data: { plugin } }
-                ?? res.plugin // { plugin }
-                ?? data // { data: Plugin }
-                ?? res; // bare Plugin
-            if (plugin && typeof plugin === 'object' && plugin.name) {
+            const { plugin, warnings } = unwrapLookup(res);
+            for (const warning of warnings) {
+                printWarning(`Plugin "${label}": ${warning}`);
+            }
+            if (plugin) {
                 resolved[key] = plugin;
             }
             else {
-                printWarning(`Plugin "${ref.name}" lookup returned no record — falling back to deploy-time resolution`);
+                printWarning(`Plugin "${label}" lookup returned no record — falling back to deploy-time resolution`);
             }
         }
         catch (err) {
-            // A plugin whose image signature doesn't verify is NOT an outage to ride
-            // out: falling back would quietly turn it into an unresolved step. Stop.
-            if (isImageVerificationFailure(err)) {
-                throw new Error(`Plugin "${ref.name}" image failed signature verification: ${errorMessage(err)}`);
+            // A plugin whose image signature doesn't verify, or a listing the org
+            // can't use, is NOT an outage to ride out: falling back would quietly
+            // turn it into an unresolved step. Stop.
+            const fatal = fatalLookupCode(err);
+            if (fatal === ErrorCode.IMAGE_VERIFICATION_FAILED) {
+                throw new Error(`Plugin "${label}" image failed signature verification: ${errorMessage(err)}`);
             }
+            if (fatal)
+                throw new Error(`Plugin "${label}" can't be used (${fatal}): ${errorMessage(err)}`);
             const msg = errorMessage(err);
-            printWarning(`Plugin "${ref.name}" pre-resolution failed (${msg}) — falling back to deploy-time resolution`);
+            printWarning(`Plugin "${label}" pre-resolution failed (${msg}) — falling back to deploy-time resolution`);
         }
     }));
     return resolved;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-resolver.js","sourceRoot":"","sources":["../../src/utils/plugin-resolver.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ErrorCode, errorMessage } from '@pipeline-builder/api-core';\nimport { ApiClient } from './api-client.js';\nimport { printWarning } from './output-utils.js';\n\n/** Minimal plugin reference shape — matches PluginOptions from pipeline-core. */\ninterface PluginRef {\n  name: string;\n  alias?: string;\n  filter?: Record<string, unknown>;\n}\n\n/**\n * Cache key matching `PluginLookup.normalize()`: explicit alias when set,\n * otherwise `${name}-alias`. Must stay in sync with the consumers in\n * pipeline-core/plugin-lookup.ts and pipeline-builder.ts that read this map.\n */\nfunction cacheKey(ref: PluginRef): string {\n  return ref.alias || `${ref.name}-alias`;\n}\n\n/**\n * Walk the pipeline props tree to collect every plugin reference. Plugins\n * appear at `synth.plugin` and at `stages[].steps[].plugin`. Entries are\n * de-duplicated by `cacheKey()` — the same key `PluginLookup.plugin()` uses,\n * so the resolved-plugins map lookups match downstream.\n */\nfunction collectPluginRefs(props: Record<string, unknown>): PluginRef[] {\n  const refs: PluginRef[] = [];\n  const seen = new Map<string, string>();\n\n  const push = (raw: unknown): void => {\n    if (!raw || typeof raw !== 'object') return;\n    const r = raw as PluginRef;\n    if (!r.name) return;\n    const key = cacheKey(r);\n    // The name the lookup will TARGET — an explicit `filter.name` wins (see\n    // below), so two refs that resolve to the same plugin are not a collision.\n    const target = (r.filter?.name as string | undefined) ?? r.name;\n    const holder = seen.get(key);\n    if (holder !== undefined) {\n      // One alias can only ever mean one plugin. Deduplicating on the alias\n      // alone kept the FIRST plugin and silently dropped the second, so a step\n      // declaring `{ name: 'maven-build', alias: 'build' }` after another\n      // declaring `{ name: 'nodejs-build', alias: 'build' }` ran nodejs-build's\n      // image and commands — no error, just the wrong build.\n      if (holder !== target) {\n        throw new Error(\n          `Plugin alias \"${key}\" is used for two different plugins (\"${holder}\" and \"${target}\"). `\n          + 'Give each plugin its own alias.',\n        );\n      }\n      return;\n    }\n    seen.set(key, target);\n    refs.push(r);\n  };\n\n  const synth = props.synth as { plugin?: unknown } | undefined;\n  push(synth?.plugin);\n\n  const stages = props.stages as Array<{ steps?: Array<{ plugin?: unknown }> }> | undefined;\n  for (const stage of stages ?? []) {\n    for (const step of stage.steps ?? []) {\n      push(step.plugin);\n    }\n  }\n\n  return refs;\n}\n\n/** The plugin service's 409 `IMAGE_VERIFICATION_FAILED` answer from `/plugins/lookup`. */\nfunction isImageVerificationFailure(err: unknown): boolean {\n  const data = (err as { response?: { data?: unknown } } | undefined)?.response?.data;\n  return !!data && typeof data === 'object' && (data as { code?: unknown }).code === ErrorCode.IMAGE_VERIFICATION_FAILED;\n}\n\n/**\n * Pre-resolve plugins by calling the same `POST /api/plugins/lookup` endpoint\n * the deploy-time custom resource Lambda uses. Returning the full Plugin\n * record at synth time is what allows the resulting CFN template to ship\n * with real CodeBuild image URIs (`<host>/<ns>/<name>:<version>`) rather than\n * the `aws/codebuild/standard:7.0` fallback that the synth-time token path\n * forces.\n *\n * Failures are non-fatal: a missing plugin or unreachable API logs a warning\n * and falls through to the deploy-time custom resource path so partial\n * platform outages don't block synth/deploy. The exception is an image that\n * fails signature verification — that aborts the synth.\n *\n * Keyed by `alias || name` to match `PluginLookup.plugin()`.\n */\nexport async function resolvePluginsForProps(\n  client: ApiClient,\n  props: Record<string, unknown>,\n): Promise<Record<string, unknown>> {\n  const refs = collectPluginRefs(props);\n  if (refs.length === 0) return {};\n\n  const resolved: Record<string, unknown> = {};\n\n  await Promise.all(refs.map(async (ref) => {\n    const key = cacheKey(ref);\n    // The plugin NAME lives on the ref (a sibling of `filter`), NOT inside the\n    // filter object — but the lookup matches on the filter. A filter without\n    // `name` (e.g. `{version, visibility, isActive, isDefault}`) matches ANY\n    // plugin with those attributes, and the endpoint returns an arbitrary one\n    // (seen: `dockerfile-multi-provider`). That made the synth and every step\n    // resolve to the WRONG plugin. So when the filter omits `name`, fall back to\n    // the ref's plugin name; an explicit filter `name` still takes precedence.\n    const filter = { name: ref.name, ...(ref.filter ?? { isActive: true, isDefault: true }) };\n    try {\n      const res = await client.post<unknown>('/api/plugins/lookup', { filter });\n      // Unwrap the plugin record from whatever envelope the response middleware\n      // applied. The platform's standard success envelope is\n      // `{ success, statusCode, data: { plugin: Plugin } }` (note the DOUBLE\n      // nesting: data.plugin), but tolerate `{ data: Plugin }`, `{ plugin }`,\n      // and a bare Plugin too. Only stopping at `res.data` (which is\n      // `{ plugin: ... }`) made `.name` undefined → every lookup fell back to\n      // deploy-time resolution even though the catalog had the plugin.\n      const data = (res as { data?: unknown }).data;\n      const plugin =\n        (data as { plugin?: unknown } | undefined)?.plugin // { data: { plugin } }\n        ?? (res as { plugin?: unknown }).plugin // { plugin }\n        ?? data // { data: Plugin }\n        ?? res; // bare Plugin\n      if (plugin && typeof plugin === 'object' && (plugin as { name?: string }).name) {\n        resolved[key] = plugin;\n      } else {\n        printWarning(`Plugin \"${ref.name}\" lookup returned no record — falling back to deploy-time resolution`);\n      }\n    } catch (err) {\n      // A plugin whose image signature doesn't verify is NOT an outage to ride\n      // out: falling back would quietly turn it into an unresolved step. Stop.\n      if (isImageVerificationFailure(err)) {\n        throw new Error(`Plugin \"${ref.name}\" image failed signature verification: ${errorMessage(err)}`);\n      }\n      const msg = errorMessage(err);\n      printWarning(`Plugin \"${ref.name}\" pre-resolution failed (${msg}) — falling back to deploy-time resolution`);\n    }\n  }));\n\n  return resolved;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-resolver.js","sourceRoot":"","sources":["../../src/utils/plugin-resolver.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ErrorCode, errorMessage } from '@pipeline-builder/api-core';\nimport { pluginArtifactAlias, pluginLookupFilter, unwrapLookup } from '@pipeline-builder/pipeline-core';\nimport { ApiClient } from './api-client.js';\nimport { printWarning } from './output-utils.js';\n\n/** Minimal plugin reference shape — matches PluginOptions from pipeline-core. */\ninterface PluginRef {\n  name: string;\n  /** Publisher handle of an installed listing. */\n  publisher?: string;\n  alias?: string;\n  filter?: Record<string, unknown>;\n}\n\n/**\n * Cache key matching `PluginLookup.normalize()`: the explicit alias when set,\n * otherwise `[<publisher>-]<name>-alias` — pipeline-core's\n * `pluginArtifactAlias`, the one rule every consumer of this map uses.\n */\nfunction cacheKey(ref: PluginRef): string {\n  return pluginArtifactAlias(ref);\n}\n\n/**\n * Walk the pipeline props tree to collect every plugin reference. Plugins\n * appear at `synth.plugin` and at `stages[].steps[].plugin`. Entries are\n * de-duplicated by `cacheKey()` — the same key `PluginLookup.plugin()` uses,\n * so the resolved-plugins map lookups match downstream.\n */\nfunction collectPluginRefs(props: Record<string, unknown>): PluginRef[] {\n  const refs: PluginRef[] = [];\n  const seen = new Map<string, string>();\n\n  const push = (raw: unknown): void => {\n    if (!raw || typeof raw !== 'object') return;\n    const r = raw as PluginRef;\n    if (!r.name) return;\n    const key = cacheKey(r);\n    // The name the lookup will TARGET — an explicit `filter.name` wins (see\n    // below), so two refs that resolve to the same plugin are not a collision.\n    const name = (r.filter?.name as string | undefined) ?? r.name;\n    const target = r.publisher ? `${r.publisher}/${name}` : name;\n    const holder = seen.get(key);\n    if (holder !== undefined) {\n      // One alias can only ever mean one plugin. Deduplicating on the alias\n      // alone kept the FIRST plugin and silently dropped the second, so a step\n      // declaring `{ name: 'maven-build', alias: 'build' }` after another\n      // declaring `{ name: 'nodejs-build', alias: 'build' }` ran nodejs-build's\n      // image and commands — no error, just the wrong build.\n      if (holder !== target) {\n        throw new Error(\n          `Plugin alias \"${key}\" is used for two different plugins (\"${holder}\" and \"${target}\"). `\n          + 'Give each plugin its own alias.',\n        );\n      }\n      return;\n    }\n    seen.set(key, target);\n    refs.push(r);\n  };\n\n  const synth = props.synth as { plugin?: unknown } | undefined;\n  push(synth?.plugin);\n\n  const stages = props.stages as Array<{ steps?: Array<{ plugin?: unknown }> }> | undefined;\n  for (const stage of stages ?? []) {\n    for (const step of stage.steps ?? []) {\n      push(step.plugin);\n    }\n  }\n\n  return refs;\n}\n\n/**\n * Lookup refusals that must STOP the synth rather than fall back to\n * deploy-time resolution: an image whose signature doesn't verify, and a\n * listing the org can't use (not installed, blocked by its policy, yanked or\n * suspended). Falling back would quietly turn\n * each into an unresolved step that fails at run time instead of now.\n */\nconst FATAL_LOOKUP_CODES: readonly string[] = [\n  ErrorCode.IMAGE_VERIFICATION_FAILED,\n  ErrorCode.PLUGIN_NOT_INSTALLED,\n  ErrorCode.PLUGIN_BLOCKED_BY_POLICY,\n  ErrorCode.PLUGIN_UNAVAILABLE,\n];\n\n/** The error code of a plugin service answer, when it is one of {@link FATAL_LOOKUP_CODES}. */\nfunction fatalLookupCode(err: unknown): string | null {\n  const data = (err as { response?: { data?: unknown } } | undefined)?.response?.data;\n  const code = data && typeof data === 'object' ? (data as { code?: unknown }).code : undefined;\n  return typeof code === 'string' && FATAL_LOOKUP_CODES.includes(code) ? code : null;\n}\n\n/**\n * Pre-resolve plugins by calling the same `POST /api/plugins/lookup` endpoint\n * the deploy-time custom resource Lambda uses. Returning the full Plugin\n * record at synth time is what allows the resulting CFN template to ship\n * with real CodeBuild image URIs (`<host>/<ns>/<name>:<version>`) rather than\n * the `aws/codebuild/standard:7.0` fallback that the synth-time token path\n * forces.\n *\n * Failures are non-fatal: a missing plugin or unreachable API logs a warning\n * and falls through to the deploy-time custom resource path so partial\n * platform outages don't block synth/deploy. The exception is an image that\n * fails signature verification — that aborts the synth.\n *\n * Keyed by `alias || name` to match `PluginLookup.plugin()`.\n */\nexport async function resolvePluginsForProps(\n  client: ApiClient,\n  props: Record<string, unknown>,\n): Promise<Record<string, unknown>> {\n  const refs = collectPluginRefs(props);\n  if (refs.length === 0) return {};\n\n  const resolved: Record<string, unknown> = {};\n\n  await Promise.all(refs.map(async (ref) => {\n    const key = cacheKey(ref);\n    const label = ref.publisher ? `${ref.publisher}/${ref.name}` : ref.name;\n    // The plugin NAME lives on the ref (a sibling of `filter`), NOT inside the\n    // filter object — but the lookup matches on the filter. A filter without\n    // `name` (e.g. `{version, visibility, isActive, isDefault}`) matches ANY\n    // plugin with those attributes, and the endpoint returns an arbitrary one\n    // (seen: `dockerfile-multi-provider`). That made the synth and every step\n    // resolve to the WRONG plugin. So when the filter omits `name`, fall back to\n    // the ref's plugin name; an explicit filter `name` still takes precedence.\n    // Shared with the pipeline service's contract check (same filter, same plugin).\n    const filter = pluginLookupFilter(ref);\n    try {\n      const res = await client.post<unknown>('/api/plugins/lookup', { filter });\n      const { plugin, warnings } = unwrapLookup(res);\n      for (const warning of warnings) {\n        printWarning(`Plugin \"${label}\": ${warning}`);\n      }\n      if (plugin) {\n        resolved[key] = plugin;\n      } else {\n        printWarning(`Plugin \"${label}\" lookup returned no record — falling back to deploy-time resolution`);\n      }\n    } catch (err) {\n      // A plugin whose image signature doesn't verify, or a listing the org\n      // can't use, is NOT an outage to ride out: falling back would quietly\n      // turn it into an unresolved step. Stop.\n      const fatal = fatalLookupCode(err);\n      if (fatal === ErrorCode.IMAGE_VERIFICATION_FAILED) {\n        throw new Error(`Plugin \"${label}\" image failed signature verification: ${errorMessage(err)}`);\n      }\n      if (fatal) throw new Error(`Plugin \"${label}\" can't be used (${fatal}): ${errorMessage(err)}`);\n      const msg = errorMessage(err);\n      printWarning(`Plugin \"${label}\" pre-resolution failed (${msg}) — falling back to deploy-time resolution`);\n    }\n  }));\n\n  return resolved;\n}\n"]}

package/dist/utils/plugin-scan.d.ts

@@ -0,0 +1,22 @@
+import { type Exec } from './plugin-docker.js';
+export declare const SEVERITIES: readonly ['Critical', 'High', 'Medium', 'Low', 'Negligible', 'Unknown'];
+export type SeverityCounts = Record<typeof SEVERITIES[number], number>;
+export type ScanPreview = {
+    status: 'scanned';
+    counts: SeverityCounts;
+    critical: string[];
+} | {
+    status: 'unavailable';
+    reason: string;
+} | {
+    status: 'failed';
+    reason: string;
+};
+/** Count grype JSON matches by severity; list the critical ones (`CVE in package@version`). */
+export declare function summarizeGrype(json: string): {
+    counts: SeverityCounts;
+    critical: string[];
+};
+/** SBOM (syft) + scan (grype) of a local image. Never throws. */
+export declare function scanPreview(exec: Exec, image: string): ScanPreview;
+//# sourceMappingURL=plugin-scan.d.ts.map

package/dist/utils/plugin-scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-scan.d.ts","sourceRoot":"","sources":["../../src/utils/plugin-scan.ts"],"names":[],"mappings":"AAaA,OAAO,EAAW,KAAK,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAExD,eAAO,MAAM,UAAU,YAAI,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,SAAS,CAAU,CAAC;AAClG,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;AAEvE,MAAM,MAAM,WAAW,GACnB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GACjE;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC,+FAA+F;AAC/F,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAU3F;AAED,iEAAiE;AACjE,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,CAkBlE"}

package/dist/utils/plugin-scan.js

@@ -0,0 +1,52 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The local SCAN PREVIEW before `plugin publish`: syft builds an SBOM of the
+ * plugin image, grype scans that SBOM — the same pair the platform runs over
+ * the signed SBOM after upload. A critical finding fails the publish gate
+ * there, so it fails here first.
+ */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { hasTool } from './plugin-docker.js';
+export const SEVERITIES = ['Critical', 'High', 'Medium', 'Low', 'Negligible', 'Unknown'];
+/** Count grype JSON matches by severity; list the critical ones (`CVE in package@version`). */
+export function summarizeGrype(json) {
+    const counts = Object.fromEntries(SEVERITIES.map(s => [s, 0]));
+    const critical = [];
+    const doc = JSON.parse(json);
+    for (const m of doc.matches ?? []) {
+        const sev = SEVERITIES.includes(m.vulnerability?.severity ?? '') ? m.vulnerability.severity : 'Unknown';
+        counts[sev] += 1;
+        if (sev === 'Critical')
+            critical.push(`${m.vulnerability?.id ?? '?'} in ${m.artifact?.name ?? '?'}@${m.artifact?.version ?? '?'}`);
+    }
+    return { counts, critical };
+}
+/** SBOM (syft) + scan (grype) of a local image. Never throws. */
+export function scanPreview(exec, image) {
+    const missing = ['syft', 'grype'].filter(t => !hasTool(exec, t, ['version']));
+    if (missing.length)
+        return { status: 'unavailable', reason: `${missing.join(' and ')} not installed` };
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pipeline-manager-scan-'));
+    try {
+        const sbom = path.join(dir, 'sbom.spdx.json');
+        const s = exec('syft', ['scan', `docker:${image}`, '-o', `spdx-json=${sbom}`, '-q']);
+        if (s.error || s.status !== 0)
+            return { status: 'failed', reason: `syft could not build the SBOM: ${(s.stderr || s.error?.message || '').trim()}` };
+        const g = exec('grype', [`sbom:${sbom}`, '-o', 'json', '-q']);
+        if (g.error || g.status !== 0)
+            return { status: 'failed', reason: `grype could not scan the SBOM: ${(g.stderr || g.error?.message || '').trim()}` };
+        try {
+            return { status: 'scanned', ...summarizeGrype(g.stdout) };
+        }
+        catch {
+            return { status: 'failed', reason: 'grype output was not JSON' };
+        }
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/plugin-zip.d.ts

@@ -0,0 +1,15 @@
+export interface ZipEntry {
+    /** Forward-slash path relative to the zip root. */
+    name: string;
+    data: Buffer;
+}
+/**
+ * The files a plugin zip carries, sorted. `image.tar` rides along only for a
+ * `prebuilt` plugin (the server builds `build_image` plugins itself).
+ */
+export declare function collectPluginFiles(dir: string, opts: {
+    includeImageTar: boolean;
+}): ZipEntry[];
+/** Write `entries` as a ZIP archive. */
+export declare function writeZip(entries: ZipEntry[]): Buffer;
+//# sourceMappingURL=plugin-zip.d.ts.map

package/dist/utils/plugin-zip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-zip.d.ts","sourceRoot":"","sources":["../../src/utils/plugin-zip.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,QAAQ;IACvB,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE;IAAE,eAAe,EAAE,OAAO,CAAA;CAAE,GAAG,QAAQ,EAAE,CAiB9F;AAMD,wCAAwC;AACxC,wBAAgB,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM,CAqDpD"}

package/dist/utils/plugin-zip.js

@@ -0,0 +1,96 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Package a local plugin directory as the zip the upload API takes (the
+ * directory IS the zip root). A small, dependency-free ZIP writer: DEFLATE
+ * entries, regular files only — symlinks and anything outside the directory
+ * are refused, which the server would refuse anyway.
+ */
+import fs from 'fs';
+import path from 'path';
+import zlib from 'zlib';
+/** Never packaged: build outputs and VCS/editor state. */
+const EXCLUDED = new Set(['.git', '.DS_Store', 'node_modules', 'plugin.zip']);
+/**
+ * The files a plugin zip carries, sorted. `image.tar` rides along only for a
+ * `prebuilt` plugin (the server builds `build_image` plugins itself).
+ */
+export function collectPluginFiles(dir, opts) {
+    const root = path.resolve(dir);
+    const entries = [];
+    const walk = (abs) => {
+        for (const name of fs.readdirSync(abs).sort()) {
+            if (EXCLUDED.has(name))
+                continue;
+            const full = path.join(abs, name);
+            const rel = path.relative(root, full).split(path.sep).join('/');
+            if (rel === 'image.tar' && !opts.includeImageTar)
+                continue;
+            const st = fs.lstatSync(full);
+            if (st.isSymbolicLink())
+                throw new Error(`Refusing to package a symlink: ${rel}`);
+            if (st.isDirectory())
+                walk(full);
+            else if (st.isFile())
+                entries.push({ name: rel, data: fs.readFileSync(full) });
+        }
+    };
+    walk(root);
+    return entries;
+}
+/** DOS date/time for the zip headers (fixed, so a package is reproducible). */
+const DOS_TIME = 0;
+const DOS_DATE = 33; // 1980-01-01: (0 years << 9) | (month 1 << 5) | day 1
+/** Write `entries` as a ZIP archive. */
+export function writeZip(entries) {
+    const locals = [];
+    const centrals = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const name = Buffer.from(entry.name, 'utf-8');
+        const compressed = zlib.deflateRawSync(entry.data);
+        const crc = zlib.crc32(entry.data);
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4); // version needed
+        local.writeUInt16LE(0x0800, 6); // UTF-8 names
+        local.writeUInt16LE(8, 8); // deflate
+        local.writeUInt16LE(DOS_TIME, 10);
+        local.writeUInt16LE(DOS_DATE, 12);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(compressed.length, 18);
+        local.writeUInt32LE(entry.data.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        local.writeUInt16LE(0, 28);
+        locals.push(local, name, compressed);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(0x02014b50, 0);
+        central.writeUInt16LE(0x0314, 4); // made by: Unix (3), spec 2.0 (20)
+        central.writeUInt16LE(20, 6);
+        central.writeUInt16LE(0x0800, 8);
+        central.writeUInt16LE(8, 10);
+        central.writeUInt16LE(DOS_TIME, 12);
+        central.writeUInt16LE(DOS_DATE, 14);
+        central.writeUInt32LE(crc, 16);
+        central.writeUInt32LE(compressed.length, 20);
+        central.writeUInt32LE(entry.data.length, 24);
+        central.writeUInt16LE(name.length, 28);
+        central.writeUInt16LE(0, 30); // extra
+        central.writeUInt16LE(0, 32); // comment
+        central.writeUInt16LE(0, 34); // disk
+        central.writeUInt16LE(0, 36); // internal attrs
+        central.writeUInt32LE(0o100644 * 0x10000, 38); // external attrs: regular file, -rw-r--r--
+        central.writeUInt32LE(offset, 42);
+        centrals.push(central, name);
+        offset += local.length + name.length + compressed.length;
+    }
+    const centralSize = centrals.reduce((n, b) => n + b.length, 0);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(entries.length, 8);
+    end.writeUInt16LE(entries.length, 10);
+    end.writeUInt32LE(centralSize, 12);
+    end.writeUInt32LE(offset, 16);
+    return Buffer.concat([...locals, ...centrals, end]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-zip.js","sourceRoot":"","sources":["../../src/utils/plugin-zip.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Package a local plugin directory as the zip the upload API takes (the\n * directory IS the zip root). A small, dependency-free ZIP writer: DEFLATE\n * entries, regular files only — symlinks and anything outside the directory\n * are refused, which the server would refuse anyway.\n */\n\nimport fs from 'fs';\nimport path from 'path';\nimport zlib from 'zlib';\n\n/** Never packaged: build outputs and VCS/editor state. */\nconst EXCLUDED = new Set(['.git', '.DS_Store', 'node_modules', 'plugin.zip']);\n\nexport interface ZipEntry {\n  /** Forward-slash path relative to the zip root. */\n  name: string;\n  data: Buffer;\n}\n\n/**\n * The files a plugin zip carries, sorted. `image.tar` rides along only for a\n * `prebuilt` plugin (the server builds `build_image` plugins itself).\n */\nexport function collectPluginFiles(dir: string, opts: { includeImageTar: boolean }): ZipEntry[] {\n  const root = path.resolve(dir);\n  const entries: ZipEntry[] = [];\n  const walk = (abs: string): void => {\n    for (const name of fs.readdirSync(abs).sort()) {\n      if (EXCLUDED.has(name)) continue;\n      const full = path.join(abs, name);\n      const rel = path.relative(root, full).split(path.sep).join('/');\n      if (rel === 'image.tar' && !opts.includeImageTar) continue;\n      const st = fs.lstatSync(full);\n      if (st.isSymbolicLink()) throw new Error(`Refusing to package a symlink: ${rel}`);\n      if (st.isDirectory()) walk(full);\n      else if (st.isFile()) entries.push({ name: rel, data: fs.readFileSync(full) });\n    }\n  };\n  walk(root);\n  return entries;\n}\n\n/** DOS date/time for the zip headers (fixed, so a package is reproducible). */\nconst DOS_TIME = 0;\nconst DOS_DATE = 33; // 1980-01-01: (0 years << 9) | (month 1 << 5) | day 1\n\n/** Write `entries` as a ZIP archive. */\nexport function writeZip(entries: ZipEntry[]): Buffer {\n  const locals: Buffer[] = [];\n  const centrals: Buffer[] = [];\n  let offset = 0;\n  for (const entry of entries) {\n    const name = Buffer.from(entry.name, 'utf-8');\n    const compressed = zlib.deflateRawSync(entry.data);\n    const crc = zlib.crc32(entry.data);\n\n    const local = Buffer.alloc(30);\n    local.writeUInt32LE(0x04034b50, 0);\n    local.writeUInt16LE(20, 4); // version needed\n    local.writeUInt16LE(0x0800, 6); // UTF-8 names\n    local.writeUInt16LE(8, 8); // deflate\n    local.writeUInt16LE(DOS_TIME, 10);\n    local.writeUInt16LE(DOS_DATE, 12);\n    local.writeUInt32LE(crc, 14);\n    local.writeUInt32LE(compressed.length, 18);\n    local.writeUInt32LE(entry.data.length, 22);\n    local.writeUInt16LE(name.length, 26);\n    local.writeUInt16LE(0, 28);\n    locals.push(local, name, compressed);\n\n    const central = Buffer.alloc(46);\n    central.writeUInt32LE(0x02014b50, 0);\n    central.writeUInt16LE(0x0314, 4); // made by: Unix (3), spec 2.0 (20)\n    central.writeUInt16LE(20, 6);\n    central.writeUInt16LE(0x0800, 8);\n    central.writeUInt16LE(8, 10);\n    central.writeUInt16LE(DOS_TIME, 12);\n    central.writeUInt16LE(DOS_DATE, 14);\n    central.writeUInt32LE(crc, 16);\n    central.writeUInt32LE(compressed.length, 20);\n    central.writeUInt32LE(entry.data.length, 24);\n    central.writeUInt16LE(name.length, 28);\n    central.writeUInt16LE(0, 30); // extra\n    central.writeUInt16LE(0, 32); // comment\n    central.writeUInt16LE(0, 34); // disk\n    central.writeUInt16LE(0, 36); // internal attrs\n    central.writeUInt32LE(0o100644 * 0x10000, 38); // external attrs: regular file, -rw-r--r--\n    central.writeUInt32LE(offset, 42);\n    centrals.push(central, name);\n\n    offset += local.length + name.length + compressed.length;\n  }\n  const centralSize = centrals.reduce((n, b) => n + b.length, 0);\n  const end = Buffer.alloc(22);\n  end.writeUInt32LE(0x06054b50, 0);\n  end.writeUInt16LE(entries.length, 8);\n  end.writeUInt16LE(entries.length, 10);\n  end.writeUInt32LE(centralSize, 12);\n  end.writeUInt32LE(offset, 16);\n  return Buffer.concat([...locals, ...centrals, end]);\n}\n"]}

package/dist/utils/registry.d.ts

@@ -1,3 +1,4 @@
+import { type StepManifestEntry } from '@pipeline-builder/pipeline-core';
 /**
  * Helpers for registering a deployed pipeline ARN with the platform.
  *
@@ -54,6 +55,13 @@ export interface RegistryPayload {
     project: string;
     organization: string;
     stackName: string;
+    /**
+     * Which plugin each CodePipeline action runs, as the synth recorded it.
+     * Present only on a registration that follows a deploy; the platform then
+     * replaces the pipeline's step manifest with it. Absent (a manual `pipeline
+     * register`) leaves the stored manifest untouched.
+     */
+    steps?: StepManifestEntry[];
 }
 /** Pipeline fields needed to construct a RegistryPayload. */
 export interface PipelineForRegistry {
@@ -70,6 +78,13 @@ export interface PipelineForRegistry {
  * pipelineId + display metadata.
  */
 export declare function buildRegistryPayload(pipeline: PipelineForRegistry, regionOverride?: string): Promise<RegistryPayload>;
+/**
+ * Read the step manifest the synth app wrote into the cloud assembly
+ * (`<output>/pb-step-manifest.json`). Returns undefined when there is none or
+ * it is unreadable — registration then proceeds without it and the platform
+ * keeps the previous manifest, so a telemetry gap never blocks a deploy.
+ */
+export declare function readStepManifest(outputDir: string): Promise<StepManifestEntry[] | undefined>;
 /**
  * Persist a registration intent for later retry.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/utils/registry.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;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,CAgB1B;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":"AAMA,OAAO,EAA4C,KAAK,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAKnH;;;;;;;;;;;;;;;;;;;;;;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;IAClB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,iBAAiB,EAAE,CAAC;CAC7B;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,CAgB1B;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,EAAE,GAAG,SAAS,CAAC,CAOlG;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,7 +3,7 @@
 import { promises as fs } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
-import { parsePlatformBaseUrl } from '@pipeline-builder/pipeline-core';
+import { parsePlatformBaseUrl, STEP_MANIFEST_FILE } from '@pipeline-builder/pipeline-core';
 import { resolveAwsRegion } from './aws-env.js';
 import { printInfo } from './output-utils.js';
 import { defaultPipelineName } from '../config/cli.constants.js';
@@ -85,6 +85,21 @@ export async function buildRegistryPayload(pipeline, regionOverride) {
         stackName,
     };
 }
+/**
+ * Read the step manifest the synth app wrote into the cloud assembly
+ * (`<output>/pb-step-manifest.json`). Returns undefined when there is none or
+ * it is unreadable — registration then proceeds without it and the platform
+ * keeps the previous manifest, so a telemetry gap never blocks a deploy.
+ */
+export async function readStepManifest(outputDir) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(join(outputDir, STEP_MANIFEST_FILE), 'utf8'));
+        return Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Persist a registration intent for later retry.
  *
@@ -137,4 +152,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';\nimport { parsePlatformBaseUrl } from '@pipeline-builder/pipeline-core';\nimport { resolveAwsRegion } from './aws-env.js';\nimport { printInfo } from './output-utils.js';\nimport { defaultPipelineName } from '../config/cli.constants.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 pipeline register` drains them.\n *\n *   2. User explicitly invokes `pipeline-manager pipeline 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 * `pb.pipeline-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 = resolveAwsRegion(regionOverride);\n\n  const pipelineName = pipeline.pipelineName\n    || defaultPipelineName(pipeline.organization, pipeline.project);\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, STEP_MANIFEST_FILE, type StepManifestEntry } from '@pipeline-builder/pipeline-core';\nimport { resolveAwsRegion } from './aws-env.js';\nimport { printInfo } from './output-utils.js';\nimport { defaultPipelineName } from '../config/cli.constants.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 pipeline register` drains them.\n *\n *   2. User explicitly invokes `pipeline-manager pipeline 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   * Which plugin each CodePipeline action runs, as the synth recorded it.\n   * Present only on a registration that follows a deploy; the platform then\n   * replaces the pipeline's step manifest with it. Absent (a manual `pipeline\n   * register`) leaves the stored manifest untouched.\n   */\n  steps?: StepManifestEntry[];\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 * `pb.pipeline-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 = resolveAwsRegion(regionOverride);\n\n  const pipelineName = pipeline.pipelineName\n    || defaultPipelineName(pipeline.organization, pipeline.project);\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 * Read the step manifest the synth app wrote into the cloud assembly\n * (`<output>/pb-step-manifest.json`). Returns undefined when there is none or\n * it is unreadable — registration then proceeds without it and the platform\n * keeps the previous manifest, so a telemetry gap never blocks a deploy.\n */\nexport async function readStepManifest(outputDir: string): Promise<StepManifestEntry[] | undefined> {\n  try {\n    const parsed: unknown = JSON.parse(await fs.readFile(join(outputDir, STEP_MANIFEST_FILE), 'utf8'));\n    return Array.isArray(parsed) ? parsed as StepManifestEntry[] : undefined;\n  } catch {\n    return undefined;\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/dist/utils/service-account.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-account.d.ts","sourceRoot":"","sources":["../../src/utils/service-account.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMjD,yCAAyC;AACzC,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,MAAM,EAAE,SAAS,CAAC;IAClB,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC;IACxB,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,gBAAgB,EAAE,MAAM,CAAC;IACzB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAiDD,iDAAiD;AACjD,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAO9E;AA0DD,qFAAqF;AACrF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAKf;AAyCD;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,CAAC,CAanG"}
+{"version":3,"file":"service-account.d.ts","sourceRoot":"","sources":["../../src/utils/service-account.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMjD,yCAAyC;AACzC,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,MAAM,EAAE,SAAS,CAAC;IAClB,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC;IACxB,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,gBAAgB,EAAE,MAAM,CAAC;IACzB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAiDD,iDAAiD;AACjD,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAO9E;AA0DD,qFAAqF;AACrF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAKf;AAyCD;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,CAAC,CAanG"}