@pipeline-builder/pipeline-core 4.4.2 → 4.4.4

package/lib/core/step-manifest.js

@@ -44,4 +44,4 @@ export function pluginImageRepository(plugin) {
 }
 /** A plugin image repository lookup may return: `public/<publisher>/<name>`, `org-<id>/<name>` or `system/<name>`. */
 export const PLUGIN_IMAGE_REPOSITORY_RE = /^(?:public\/[a-z0-9]+(?:-[a-z0-9]+)*|org-[a-z0-9][a-z0-9-]*|system)\/[a-z0-9][a-z0-9._-]*$/;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcC1tYW5pZmVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb3JlL3N0ZXAtbWFuaWZlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0Qzs7Ozs7Ozs7Ozs7R0FXRztBQUVILE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUUzRDs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsdUJBQXVCLENBQUM7QUFFMUQ7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLHNDQUFzQyxDQUFDO0FBNEI1RTs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxVQUFVLHFCQUFxQixDQUFDLE1BQXNCO0lBQzFELElBQUksTUFBTSxDQUFDLFNBQVMsS0FBSyxlQUFlO1FBQUUsT0FBTyxJQUFJLENBQUM7SUFDdEQsTUFBTSxTQUFTLEdBQUcsTUFBTSxDQUFDLEtBQUssS0FBSyxhQUFhLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsT0FBTyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDcEYsT0FBTyxHQUFHLFNBQVMsSUFBSSxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUM7QUFDdkMsQ0FBQztBQUVELHNIQUFzSDtBQUN0SCxNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBRyw0RkFBNEYsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIFN0ZXAgbWFuaWZlc3Q6IHdoaWNoIHBsdWdpbiBlYWNoIENvZGVQaXBlbGluZSBhY3Rpb25cbiAqIG9mIGEgZGVwbG95ZWQgcGlwZWxpbmUgcnVucy4gQ0RLLWZyZWUgaGFsZiDigJQgdGhlIHNoYXBlcyBhbmQgaGVscGVycyBzaGFyZWQgYnlcbiAqIHRoZSBzeW50aCAod2hpY2ggcmVjb3JkcyBpdCwgc2VlIGBwaXBlbGluZS9zdGVwLW1hbmlmZXN0LXJlY29yZGVyLnRzYCksIHRoZVxuICogQ0xJICh3aGljaCBzaGlwcyBpdCB3aXRoIHRoZSByZWdpc3RyeSByZWdpc3RyYXRpb24pIGFuZCB0aGUgcGlwZWxpbmUgc2VydmljZVxuICogKHdoaWNoIHZhbGlkYXRlcyBhbmQgc3RvcmVzIGl0IGluIGBwaXBlbGluZV9zdGVwX21hbmlmZXN0c2ApLlxuICpcbiAqIEV2ZW50IGluZ2VzdCBqb2lucyBgcGlwZWxpbmVfZXZlbnRzYCBvbiAocGlwZWxpbmVfaWQsIHN0YWdlX25hbWUsXG4gKiBhY3Rpb25fbmFtZSksIHNvIGBzdGFnZU5hbWVgL2BhY3Rpb25OYW1lYCBoZXJlIGFyZSByZWFkIG9mZiB0aGUgQlVJTFRcbiAqIENvZGVQaXBlbGluZSwgbmV2ZXIgcmVjb21wdXRlZCBmcm9tIG91ciBvd24gaWRzIOKAlCB0aGV5IGFyZSBleGFjdGx5IHRoZSBuYW1lc1xuICogQ29kZVBpcGVsaW5lIHN0YXRlLWNoYW5nZSBldmVudHMgcmVwb3J0LlxuICovXG5cbmltcG9ydCB7IFNZU1RFTV9PUkdfSUQgfSBmcm9tICdAcGlwZWxpbmUtYnVpbGRlci9hcGktY29yZSc7XG5cbi8qKlxuICogRmlsZSB0aGUgc3ludGggYXBwIHdyaXRlcyB0aGUgbWFuaWZlc3QgdG8sIGluc2lkZSB0aGUgY2xvdWQgYXNzZW1ibHlcbiAqIGRpcmVjdG9yeSAoYGNkayBkZXBsb3kgLS1vdXRwdXQ9PGRpcj5gKS4gVGhlIENMSSByZWFkcyBpdCBiYWNrIGFmdGVyIGFcbiAqIHN1Y2Nlc3NmdWwgZGVwbG95IGFuZCBmb3J3YXJkcyBpdCBvbiB0aGUgcmVnaXN0cnkgUE9TVC5cbiAqL1xuZXhwb3J0IGNvbnN0IFNURVBfTUFOSUZFU1RfRklMRSA9ICdwYi1zdGVwLW1hbmlmZXN0Lmpzb24nO1xuXG4vKipcbiAqIGBpZGAgb2YgZXZlcnkgc3ludGhlc2l6ZWQgcGxhY2Vob2xkZXIgcGx1Z2luIChQbHVnaW5Mb29rdXAgYGZhbGxiYWNrKClgIC9cbiAqIGBib290c3RyYXAoKWApIOKAlCBhIHJlY29yZCBzdGFuZGluZyBpbiBmb3IgYSBsb29rdXAgdGhhdCBjb3VsZCBub3QgcmVzb2x2ZSBhdFxuICogc3ludGguIE5ldmVyIGEgcmVhbCBgcGx1Z2luc2Agcm93LCBzbyB0aGUgc3RlcCBtYW5pZmVzdCBuZXZlciByZWNvcmRzIGl0LlxuICovXG5leHBvcnQgY29uc3QgUExBQ0VIT0xERVJfUExVR0lOX0lEID0gJzAwMDAwMDAwLTAwMDAtMDAwMC0wMDAwLTAwMDAwMDAwMDAwMCc7XG5cbi8qKlxuICogT25lIG1hbmlmZXN0IGVudHJ5IGFzIHRoZSBzeW50aCByZWNvcmRzIGl0LiBDYXJyaWVzIHRoZSByZXNvbHZlZCBwbHVnaW5cbiAqIHJlY29yZCdzIGlkIHNvIHRoZSBwaXBlbGluZSBzZXJ2aWNlIGNhbiByZS1yZXNvbHZlIHRoZSBhdXRob3JpdGF0aXZlXG4gKiBuYW1lL3ZlcnNpb24vZGlnZXN0L293bmVyIGl0c2VsZiDigJQgdGhlIENMSSdzIGNsYWltIGlzIG5ldmVyIHRydXN0ZWQgZm9yXG4gKiBhbnl0aGluZyB0aGF0IGZlZWRzIGNyb3NzLW9yZyBzdGF0cyAocHVibGlzaGVyLCB2ZXJpZmllZCB1c2UpLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFN0ZXBNYW5pZmVzdEVudHJ5IHtcbiAgLyoqIENvZGVQaXBlbGluZSBzdGFnZSBuYW1lLCBhcyB0aGUgYnVpbHQgcGlwZWxpbmUgbmFtZXMgaXQuICovXG4gIHJlYWRvbmx5IHN0YWdlTmFtZTogc3RyaW5nO1xuICAvKiogQ29kZVBpcGVsaW5lIGFjdGlvbiBuYW1lLCBhcyB0aGUgYnVpbHQgcGlwZWxpbmUgbmFtZXMgaXQuICovXG4gIHJlYWRvbmx5IGFjdGlvbk5hbWU6IHN0cmluZztcbiAgLyoqIGBwbHVnaW5zLmlkYCBvZiB0aGUgcmVzb2x2ZWQgcGx1Z2luIHJlY29yZC4gKi9cbiAgcmVhZG9ubHkgcGx1Z2luSWQ6IHN0cmluZztcbiAgcmVhZG9ubHkgcGx1Z2luTmFtZTogc3RyaW5nO1xuICByZWFkb25seSBwbHVnaW5WZXJzaW9uOiBzdHJpbmc7XG4gIC8qKiBTaWduZWQgaW1hZ2UgZGlnZXN0IHRoZSBzdGVwIGlzIHBpbm5lZCB0bzsgbnVsbCBmb3IgaW1hZ2UtbGVzcyBwbHVnaW5zLiAqL1xuICByZWFkb25seSBpbWFnZURpZ2VzdDogc3RyaW5nIHwgbnVsbDtcbn1cblxuLyoqIFRoZSBwbHVnaW4gZmllbGRzIHtAbGluayBwbHVnaW5JbWFnZVJlcG9zaXRvcnl9IHJlYWRzLiAqL1xuZXhwb3J0IGludGVyZmFjZSBQbHVnaW5JbWFnZVJlZiB7XG4gIHJlYWRvbmx5IG9yZ0lkOiBzdHJpbmc7XG4gIHJlYWRvbmx5IG5hbWU6IHN0cmluZztcbiAgcmVhZG9ubHkgYnVpbGRUeXBlPzogc3RyaW5nIHwgbnVsbDtcbn1cblxuLyoqXG4gKiBSZWdpc3RyeSByZXBvc2l0b3J5IGFuIG9yZy1vd25lZCBwbHVnaW4gUk9XJ3MgaW1hZ2UgbGl2ZXMgYXRcbiAqIChgPG5hbWVzcGFjZT4vPG5hbWU+YCwgbm8gaG9zdCwgbm8gZGlnZXN0KTogdGhlIHN5c3RlbSBvcmcncyB1bmRlclxuICogYHN5c3RlbS9gLCBhIHRlbmFudCdzIHVuZGVyIGBvcmctPG9yZ0lkPi9gLiBNdXN0IG1hdGNoIHRoZSBwdXNoIHNpZGVcbiAqIChhcGkvcGx1Z2luIGBwbHVnaW5VcmlgKS4gUmV0dXJucyBudWxsIGZvciBhIGBtZXRhZGF0YV9vbmx5YCBwbHVnaW4uXG4gKlxuICogT25seSBmb3Igcm93cyB0aGUgY2FsbGVyJ3Mgb3JnIHJlc29sdmVzIGFzIGl0cyBPV04gKG9yIGl0cyBwYXJlbnQncyk6IHRoZVxuICogcGx1Z2luIGxvb2t1cCBzdGFtcHMgaXQgYXMgdGhlIHJlY29yZCdzIGBpbWFnZVJlcG9zaXRvcnlgLiBBIGxpc3RlZCBwbHVnaW4nc1xuICogcmVwb3NpdG9yeSBpcyBpdHMgbGlzdGluZyB2ZXJzaW9uJ3MgYHB1YmxpYy88cHVibGlzaGVyPi88bmFtZT5gIGNvcHkg4oCUXG4gKiBzeW50aCBuZXZlciBkZXJpdmVzIGEgcmVwb3NpdG9yeSBpdHNlbGYuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBwbHVnaW5JbWFnZVJlcG9zaXRvcnkocGx1Z2luOiBQbHVnaW5JbWFnZVJlZik6IHN0cmluZyB8IG51bGwge1xuICBpZiAocGx1Z2luLmJ1aWxkVHlwZSA9PT0gJ21ldGFkYXRhX29ubHknKSByZXR1cm4gbnVsbDtcbiAgY29uc3QgbmFtZXNwYWNlID0gcGx1Z2luLm9yZ0lkID09PSBTWVNURU1fT1JHX0lEID8gJ3N5c3RlbScgOiBgb3JnLSR7cGx1Z2luLm9yZ0lkfWA7XG4gIHJldHVybiBgJHtuYW1lc3BhY2V9LyR7cGx1Z2luLm5hbWV9YDtcbn1cblxuLyoqIEEgcGx1Z2luIGltYWdlIHJlcG9zaXRvcnkgbG9va3VwIG1heSByZXR1cm46IGBwdWJsaWMvPHB1Ymxpc2hlcj4vPG5hbWU+YCwgYG9yZy08aWQ+LzxuYW1lPmAgb3IgYHN5c3RlbS88bmFtZT5gLiAqL1xuZXhwb3J0IGNvbnN0IFBMVUdJTl9JTUFHRV9SRVBPU0lUT1JZX1JFID0gL14oPzpwdWJsaWNcXC9bYS16MC05XSsoPzotW2EtejAtOV0rKSp8b3JnLVthLXowLTldW2EtejAtOS1dKnxzeXN0ZW0pXFwvW2EtejAtOV1bYS16MC05Ll8tXSokLztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/synth-failure.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The machine-readable reason a synth failed, as ONE log line.
+ *
+ * A CodePipeline action failure event only carries CodeBuild's generic
+ * summary ("Error while executing command: pipeline-manager pipeline synth …
+ * exit status 1") — never the build's output — so the reason a plugin was
+ * refused (not installed, denied by policy, signature failure) was readable only
+ * by opening the build log. `pipeline-manager pipeline synth` prints this line
+ * when it fails inside CodeBuild; the events Lambda finds it in the failed
+ * build's CloudWatch log stream and attaches it to the execution event.
+ *
+ * Dependency-free so the events Lambda can bundle it.
+ */
+/** Prefix of the line; the JSON payload follows after one space. */
+export declare const SYNTH_FAILURE_MARKER = "PB_SYNTH_FAILURE";
+/** One plugin the synth refused. */
+export interface SynthFailurePlugin {
+    readonly plugin: string;
+    readonly code: string;
+    readonly message: string;
+}
+/** The structured synth failure. */
+export interface SynthFailure {
+    /** One code for the whole failure: the refusal code when all agree, else `PLUGINS_REFUSED` / `SYNTH_FAILED`. */
+    readonly code: string;
+    readonly message: string;
+    readonly plugins: readonly SynthFailurePlugin[];
+}
+/** Build the failure from the refusals (empty for a failure that is not a plugin refusal). */
+export declare function synthFailure(message: string, plugins?: readonly SynthFailurePlugin[]): SynthFailure;
+/** The single log line for a failure. Newlines never appear inside it (JSON-escaped). */
+export declare function formatSynthFailure(failure: SynthFailure): string;
+/**
+ * Parse a log line (or a CloudWatch event message, which may carry a
+ * timestamp prefix) back into the failure. Returns null for any line that is
+ * not a well-formed failure line.
+ */
+export declare function parseSynthFailure(line: string): SynthFailure | null;

package/lib/core/synth-failure.js

@@ -0,0 +1,63 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The machine-readable reason a synth failed, as ONE log line.
+ *
+ * A CodePipeline action failure event only carries CodeBuild's generic
+ * summary ("Error while executing command: pipeline-manager pipeline synth …
+ * exit status 1") — never the build's output — so the reason a plugin was
+ * refused (not installed, denied by policy, signature failure) was readable only
+ * by opening the build log. `pipeline-manager pipeline synth` prints this line
+ * when it fails inside CodeBuild; the events Lambda finds it in the failed
+ * build's CloudWatch log stream and attaches it to the execution event.
+ *
+ * Dependency-free so the events Lambda can bundle it.
+ */
+/** Prefix of the line; the JSON payload follows after one space. */
+export const SYNTH_FAILURE_MARKER = 'PB_SYNTH_FAILURE';
+/** Caps keep the payload well inside the reporting ingest's 8 KB `detail` bound. */
+const MAX_MESSAGE = 1000;
+const MAX_PLUGINS = 10;
+const MAX_PLUGIN_MESSAGE = 300;
+const clip = (s, max) => (s.length > max ? `${s.slice(0, max - 1)}…` : s);
+/** Build the failure from the refusals (empty for a failure that is not a plugin refusal). */
+export function synthFailure(message, plugins = []) {
+    const codes = [...new Set(plugins.map((p) => p.code))];
+    const code = plugins.length === 0 ? 'SYNTH_FAILED' : codes.length === 1 ? codes[0] : 'PLUGINS_REFUSED';
+    return {
+        code,
+        message: clip(message, MAX_MESSAGE),
+        plugins: plugins.slice(0, MAX_PLUGINS).map((p) => ({
+            plugin: clip(p.plugin, 100),
+            code: clip(p.code, 100),
+            message: clip(p.message, MAX_PLUGIN_MESSAGE),
+        })),
+    };
+}
+/** The single log line for a failure. Newlines never appear inside it (JSON-escaped). */
+export function formatSynthFailure(failure) {
+    return `${SYNTH_FAILURE_MARKER} ${JSON.stringify(failure)}`;
+}
+/**
+ * Parse a log line (or a CloudWatch event message, which may carry a
+ * timestamp prefix) back into the failure. Returns null for any line that is
+ * not a well-formed failure line.
+ */
+export function parseSynthFailure(line) {
+    const at = line.indexOf(`${SYNTH_FAILURE_MARKER} {`);
+    if (at === -1)
+        return null;
+    try {
+        const parsed = JSON.parse(line.slice(at + SYNTH_FAILURE_MARKER.length + 1).trim());
+        if (typeof parsed.code !== 'string' || typeof parsed.message !== 'string')
+            return null;
+        const plugins = Array.isArray(parsed.plugins)
+            ? parsed.plugins.filter((p) => !!p && typeof p.plugin === 'string' && typeof p.code === 'string' && typeof p.message === 'string')
+            : [];
+        return { ...synthFailure(parsed.message, plugins), code: clip(parsed.code, 100) };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/handlers/plugin-lookup-handler.d.ts

@@ -1,4 +1,20 @@
-import type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceResponse } from 'aws-lambda';
+import type { PluginFilter } from '@pipeline-builder/pipeline-data';
+import type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceResponse, Context } from 'aws-lambda';
+/**
+ * A plain 429's `Retry-After` (delta-seconds) in ms, clipped to
+ * {@link HANDLER_RETRY_AFTER_MAX_MS}; `undefined` when absent or unparseable (an
+ * HTTP-date is not worth parsing for a wait this short — the backoff applies).
+ */
+export declare function retryAfterMs(headers: unknown): number | undefined;
+/** Truncate to `max` UTF-8 bytes on a character boundary, marking the cut. */
+export declare function truncateReason(reason: string, max?: number): string;
+/**
+ * The refusal as the plugin service wrote it — `code`, `message` and a compact
+ * rendering of `details` (the blocking CVEs, the policy that refused it…) —
+ * so the CloudFormation failure says WHY, not just "API error 409: Conflict".
+ * Only those three fields are read: the body is never echoed verbatim.
+ */
+export declare function describeRefusal(status: number, statusText: string, body: unknown, filter?: PluginFilter): string;
 /**
  * Lambda handler for CloudFormation Custom Resource that performs plugin lookup.
  *
@@ -14,6 +30,7 @@ import type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceRes
  * - Failure: Returns error message in Reason
  *
  * @param event - CloudFormation custom resource event
+ * @param context - Lambda context; its awsRequestId rides the lookup as `X-Request-Id`
  * @returns CloudFormation response
  *
  * @example
@@ -29,4 +46,4 @@ import type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceRes
  * }
  * ```
  */
-export declare const handler: (event: CloudFormationCustomResourceEvent) => Promise<CloudFormationCustomResourceResponse>;
+export declare const handler: (event: CloudFormationCustomResourceEvent, context?: Pick<Context, 'awsRequestId'>) => Promise<CloudFormationCustomResourceResponse>;

package/lib/handlers/plugin-lookup-handler.js

@@ -1,12 +1,16 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { Agent } from 'https';
 import axios, { AxiosError } from 'axios';
 // Import the dependency-free leaf, NOT `app-config.js`/`CoreConstants`: the latter
 // transitively pulls infrastructure-config → aws-cdk-lib, which esbuild then tries
 // to bundle into this Lambda (hundreds of MB → OOM/SIGKILL during cold-start synth).
-import { HANDLER_TIMEOUT_MS, HANDLER_MAX_RETRIES, HANDLER_RETRY_DELAY_MS, HANDLER_DEFAULT_BASE_URL, } from '../config/handler-constants.js';
-import { unwrapLookup } from '../core/plugin-lookup-envelope.js';
 import { createPlatformCredential, isCredentialRefusal } from './platform-credential.js';
+import { HANDLER_TIMEOUT_MS, HANDLER_MAX_RETRIES, HANDLER_RETRY_DELAY_MS, HANDLER_RETRY_AFTER_MAX_MS, HANDLER_DEFAULT_BASE_URL, } from '../config/handler-constants.js';
+import { correlationHeaders } from '../core/audit-correlation.js';
+import { platformCaList } from '../core/platform-tls.js';
+import { exactPinNotFoundMessage, lookupNotFoundState, unwrapLookup } from '../core/plugin-lookup-envelope.js';
+import { describeQuotaExceeded } from '../core/quota-exceeded.js';
 /**
  * Structured logger for Lambda (outputs JSON to CloudWatch).
  * Debug messages only emitted when LOG_LEVEL=debug.
@@ -38,6 +42,18 @@ const RETRYABLE_CODES = new Set(['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT']);
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+/**
+ * A plain 429's `Retry-After` (delta-seconds) in ms, clipped to
+ * {@link HANDLER_RETRY_AFTER_MAX_MS}; `undefined` when absent or unparseable (an
+ * HTTP-date is not worth parsing for a wait this short — the backoff applies).
+ */
+export function retryAfterMs(headers) {
+    const raw = headers?.['retry-after'];
+    const seconds = typeof raw === 'string' || typeof raw === 'number' ? Number(raw) : NaN;
+    if (!Number.isFinite(seconds) || seconds < 0)
+        return undefined;
+    return Math.min(seconds * 1000, HANDLER_RETRY_AFTER_MAX_MS);
+}
 /** Platform secret name — injected as PLATFORM_SECRET_NAME env var by PluginLookup construct. */
 const PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME;
 if (!PLATFORM_SECRET_NAME) {
@@ -55,20 +71,69 @@ export function _resetCredentialsCache() { credential.reset(); }
 /** The API refused the credential (401/403) — the caller may refresh it and retry once. */
 class CredentialRefusedError extends Error {
 }
+/**
+ * CloudFormation caps a custom resource's `Reason` (the response body as a
+ * whole must stay under 4096 bytes, and the reason is what the console and
+ * `cdk deploy` print). Leave headroom for the other response fields.
+ */
+const MAX_REASON_BYTES = 3500;
+/** Truncate to `max` UTF-8 bytes on a character boundary, marking the cut. */
+export function truncateReason(reason, max = MAX_REASON_BYTES) {
+    if (Buffer.byteLength(reason, 'utf8') <= max)
+        return reason;
+    const marker = ' …[truncated]';
+    let out = reason.slice(0, max);
+    while (Buffer.byteLength(out + marker, 'utf8') > max)
+        out = out.slice(0, -1);
+    return out + marker;
+}
+/**
+ * The refusal as the plugin service wrote it — `code`, `message` and a compact
+ * rendering of `details` (the blocking CVEs, the policy that refused it…) —
+ * so the CloudFormation failure says WHY, not just "API error 409: Conflict".
+ * Only those three fields are read: the body is never echoed verbatim.
+ */
+export function describeRefusal(status, statusText, body, filter) {
+    const data = body && typeof body === 'object' ? body : {};
+    const code = typeof data.code === 'string' ? data.code : undefined;
+    const pin = typeof filter?.version === 'string' && /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/.test(filter.version) ? filter.version : undefined;
+    // An exact pin that does not resolve: phrase it from details.state, as the CLI does.
+    if (status === 404 && pin && typeof filter?.name === 'string') {
+        return `${code ?? 'NOT_FOUND'}: ${exactPinNotFoundMessage(filter.name, pin, lookupNotFoundState(body))}`;
+    }
+    const message = typeof data.message === 'string' && data.message.length > 0 ? data.message : `API error ${status}: ${statusText}`;
+    let details = '';
+    if (data.details !== undefined && data.details !== null) {
+        try {
+            details = ` — details: ${JSON.stringify(data.details)}`;
+        }
+        catch {
+            details = '';
+        }
+    }
+    return `${code ? `${code}: ` : ''}${message}${details}`;
+}
 /**
  * Creates a pre-configured Axios instance for API requests.
  *
  * @param baseURL - Base URL of the target API
  * @param key - service-account key sent as the Bearer credential
+ * @param requestId - this Lambda invocation's awsRequestId, sent as `X-Request-Id`
+ *   so the plugin service's audit row joins back to this invocation's log
  * @returns Configured Axios instance
  */
-function create(baseURL, key) {
+function create(baseURL, key, requestId) {
+    // A private-CA platform is VERIFIED against PLATFORM_CA_BUNDLE (set by the
+    // PluginLookup construct when the synth had one); otherwise Node's default store.
+    const ca = platformCaList();
     return axios.create({
         baseURL,
         timeout: HANDLER_TIMEOUT_MS,
+        ...(ca && { httpsAgent: new Agent({ ca }) }),
         headers: {
             'Content-Type': 'application/json',
             'Authorization': `Bearer ${key}`,
+            ...correlationHeaders({ requestId }),
         },
     });
 }
@@ -78,31 +143,41 @@ function create(baseURL, key) {
  * with exponential backoff.
  *
  * @param api - Configured Axios instance
+ * @param baseURL - The platform URL `api` targets (prefixes a quota refusal's upgrade path)
  * @param pluginFilter - Filter criteria for the plugin lookup
  * @returns The plugin data returned by the API
  * @throws Error on persistent failure, timeout or invalid response
  */
-async function fetch(api, pluginFilter) {
+async function fetch(api, baseURL, pluginFilter, stepKey) {
     lambdaLog.debug('FETCH', 'Starting plugin fetch', { filter: pluginFilter });
     let lastError;
+    // A plain 429's Retry-After, honoured on the next attempt when longer than the backoff.
+    let serverDelay;
     for (let attempt = 0; attempt <= HANDLER_MAX_RETRIES; attempt++) {
         if (attempt > 0) {
-            const delay = HANDLER_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+            const delay = Math.max(HANDLER_RETRY_DELAY_MS * Math.pow(2, attempt - 1), serverDelay ?? 0);
+            serverDelay = undefined;
             lambdaLog.info('RETRY', `Attempt ${attempt + 1}/${HANDLER_MAX_RETRIES + 1} after ${delay}ms`);
             await sleep(delay);
         }
         try {
+            // Contract C1: with a known pipeline + step, the plugin service records
+            // the warnings it returns against them (not only this Lambda's log).
+            const pipelineId = process.env.PIPELINE_ID;
             const { data: body, status } = await api.post('/api/plugins/lookup', {
                 filter: pluginFilter,
+                ...(pipelineId && stepKey ? { context: { pipelineId, stepKeys: [stepKey] } } : {}),
             });
             const { plugin: data, warnings } = unwrapLookup(body);
             if (!data) {
                 throw new Error('Empty response data from API');
             }
-            // Lifecycle warnings (deprecated / yanked-but-pinned) — surfaced in the
-            // deploy log; the lookup still succeeds.
-            for (const message of warnings)
-                lambdaLog.warn('LIFECYCLE', message, { plugin: data.name, version: data.version });
+            // Graded warnings (lifecycle, vulnerability, compliance) — surfaced in the
+            // deploy log; the lookup still succeeds. Vulnerability state never fails a
+            // deploy: it is reported (and, with context, recorded server-side).
+            for (const w of warnings) {
+                lambdaLog.warn('PLUGIN_WARNING', `[${w.severity.toUpperCase()}] ${w.message}`, { plugin: data.name, version: data.version, code: w.code, severity: w.severity });
+            }
             lambdaLog.info('FETCH', 'Plugin fetched successfully', {
                 status,
                 plugin: data.name,
@@ -117,11 +192,24 @@ async function fetch(api, pluginFilter) {
                     lambdaLog.error('FETCH', `Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);
                     throw new Error(`Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);
                 }
+                // A QUOTA refusal is not transient: the counter only empties when the
+                // period resets, so retrying just spends two more lookups' worth of
+                // waiting and reports the same thing. Fail fast with the quota, the
+                // numbers, the reset date and where to raise it, as the CFN Reason.
+                const quotaMessage = error.response?.status === 429
+                    ? describeQuotaExceeded(error.response.data, baseURL)
+                    : undefined;
+                if (quotaMessage) {
+                    lambdaLog.error('FETCH', quotaMessage);
+                    throw new Error(`Failed to fetch plugin: ${quotaMessage}`);
+                }
                 const retryable = error.response
                     ? RETRYABLE_STATUSES.has(error.response.status)
                     : RETRYABLE_CODES.has(error.code ?? '');
+                if (error.response?.status === 429)
+                    serverDelay = retryAfterMs(error.response.headers);
                 const msg = error.response
-                    ? `API error ${error.response.status}: ${error.response.statusText}`
+                    ? describeRefusal(error.response.status, error.response.statusText, error.response.data, pluginFilter)
                     : error.code || error.message;
                 if (isCredentialRefusal(error.response?.status)) {
                     lambdaLog.warn('AUTH', `Credential refused: ${msg}`);
@@ -151,16 +239,16 @@ async function fetch(api, pluginFilter) {
  * likely rotated underneath this warm container (token-renew stores the new key
  * and revokes the old one), so drop the cache, re-read the secret and retry once.
  */
-async function lookupWithCredentialRefresh(baseURL, pluginFilter) {
+async function lookupWithCredentialRefresh(baseURL, pluginFilter, stepKey, requestId) {
     try {
-        return await fetch(create(baseURL, await credential.getKey()), pluginFilter);
+        return await fetch(create(baseURL, await credential.getKey(), requestId), baseURL, pluginFilter, stepKey);
     }
     catch (err) {
         if (!(err instanceof CredentialRefusedError))
             throw err;
         credential.invalidate();
         lambdaLog.info('AUTH', 'Re-reading the service-account key from Secrets Manager and retrying once');
-        return fetch(create(baseURL, await credential.getKey()), pluginFilter);
+        return fetch(create(baseURL, await credential.getKey(), requestId), baseURL, pluginFilter, stepKey);
     }
 }
 /**
@@ -195,6 +283,7 @@ function validatePluginFilter(pluginFilter) {
  * - Failure: Returns error message in Reason
  *
  * @param event - CloudFormation custom resource event
+ * @param context - Lambda context; its awsRequestId rides the lookup as `X-Request-Id`
  * @returns CloudFormation response
  *
  * @example
@@ -210,7 +299,7 @@ function validatePluginFilter(pluginFilter) {
  * }
  * ```
  */
-export const handler = async (event) => {
+export const handler = async (event, context) => {
     // NOTE: never log event.StackId here — the CloudFormation Stack ARN embeds the
     // AWS account id (arn:aws:cloudformation:<region>:<ACCOUNT_ID>:stack/…), which
     // must never be persisted to CloudWatch. requestId + logicalResourceId are
@@ -245,7 +334,8 @@ export const handler = async (event) => {
         lambdaLog.info('CONFIG', 'Configuration loaded', { baseURL, pluginFilter });
         validatePluginFilter(pluginFilter);
         lambdaLog.info('FETCH', 'Initiating plugin lookup...');
-        const plugin = await lookupWithCredentialRefresh(baseURL, pluginFilter);
+        const stepKey = typeof event.ResourceProperties.stepKey === 'string' ? event.ResourceProperties.stepKey : undefined;
+        const plugin = await lookupWithCredentialRefresh(baseURL, pluginFilter, stepKey, context?.awsRequestId);
         lambdaLog.info('FETCH', 'Plugin retrieved successfully', {
             name: plugin.name,
             version: plugin.version,
@@ -288,11 +378,11 @@ export const handler = async (event) => {
         return {
             ...baseResponse,
             Status: 'FAILED',
-            Reason: reason,
+            Reason: truncateReason(reason),
         };
     }
     finally {
         lambdaLog.info('END', 'Custom resource execution completed');
     }
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-lookup-handler.js","sourceRoot":"","sources":["../../src/handlers/plugin-lookup-handler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';\nimport type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceResponse } from 'aws-lambda';\nimport axios, { type AxiosInstance, AxiosError } from 'axios';\n// Import the dependency-free leaf, NOT `app-config.js`/`CoreConstants`: the latter\n// transitively pulls infrastructure-config → aws-cdk-lib, which esbuild then tries\n// to bundle into this Lambda (hundreds of MB → OOM/SIGKILL during cold-start synth).\nimport {\n  HANDLER_TIMEOUT_MS,\n  HANDLER_MAX_RETRIES,\n  HANDLER_RETRY_DELAY_MS,\n  HANDLER_DEFAULT_BASE_URL,\n} from '../config/handler-constants.js';\nimport { unwrapLookup } from '../core/plugin-lookup-envelope.js';\nimport { createPlatformCredential, isCredentialRefusal } from './platform-credential.js';\n\n/**\n * Structured logger for Lambda (outputs JSON to CloudWatch).\n * Debug messages only emitted when LOG_LEVEL=debug.\n */\nfunction logEntry(level: string, tag: string, message: string, data?: unknown) {\n  const line = JSON.stringify({ level, tag, message, data, ts: new Date().toISOString() });\n  switch (level) {\n    case 'ERROR': console.error(line); break;\n    case 'WARN': console.warn(line); break;\n    case 'DEBUG': if (process.env.LOG_LEVEL === 'debug') console.debug(line); break;\n    default: console.log(line);\n  }\n}\n\nconst lambdaLog = {\n  info: (tag: string, message: string, data?: unknown) => logEntry('INFO', tag, message, data),\n  error: (tag: string, message: string, data?: unknown) => logEntry('ERROR', tag, message, data),\n  warn: (tag: string, message: string, data?: unknown) => logEntry('WARN', tag, message, data),\n  debug: (tag: string, message: string, data?: unknown) => logEntry('DEBUG', tag, message, data),\n};\n\nconst RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);\nconst RETRYABLE_CODES = new Set(['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT']);\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/** Platform secret name — injected as PLATFORM_SECRET_NAME env var by PluginLookup construct. */\nconst PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME;\nif (!PLATFORM_SECRET_NAME) {\n  throw new Error('PLATFORM_SECRET_NAME environment variable is required');\n}\n\n/**\n * The service-account key (`pb_sa_…`) from Secrets Manager, cached for the warm\n * container. The plugin API trades it for a short-lived JWT itself, so the key\n * goes out as the Bearer credential. Create the secret with\n * `pipeline-manager infra store-token`.\n */\nconst credential = createPlatformCredential({ secretName: PLATFORM_SECRET_NAME });\n\n/** @internal Reset cached credential (for testing only). */\nexport function _resetCredentialsCache(): void { credential.reset(); }\n\n/** The API refused the credential (401/403) — the caller may refresh it and retry once. */\nclass CredentialRefusedError extends Error {}\n\n/**\n * Creates a pre-configured Axios instance for API requests.\n *\n * @param baseURL - Base URL of the target API\n * @param key - service-account key sent as the Bearer credential\n * @returns Configured Axios instance\n */\nfunction create(baseURL: string, key: string): AxiosInstance {\n  return axios.create({\n    baseURL,\n    timeout: HANDLER_TIMEOUT_MS,\n    headers: {\n      'Content-Type': 'application/json',\n      'Authorization': `Bearer ${key}`,\n    },\n  });\n}\n\n/**\n * Fetches plugin configuration from the external API with retry logic.\n * Retries on transient failures (429, 502, 503, 504, network errors)\n * with exponential backoff.\n *\n * @param api - Configured Axios instance\n * @param pluginFilter - Filter criteria for the plugin lookup\n * @returns The plugin data returned by the API\n * @throws Error on persistent failure, timeout or invalid response\n */\nasync function fetch(api: AxiosInstance, pluginFilter: PluginFilter): Promise<Plugin> {\n  lambdaLog.debug('FETCH', 'Starting plugin fetch', { filter: pluginFilter });\n\n  let lastError: Error | undefined;\n\n  for (let attempt = 0; attempt <= HANDLER_MAX_RETRIES; attempt++) {\n    if (attempt > 0) {\n      const delay = HANDLER_RETRY_DELAY_MS * Math.pow(2, attempt - 1);\n      lambdaLog.info('RETRY', `Attempt ${attempt + 1}/${HANDLER_MAX_RETRIES + 1} after ${delay}ms`);\n      await sleep(delay);\n    }\n\n    try {\n      const { data: body, status } = await api.post<unknown>('/api/plugins/lookup', {\n        filter: pluginFilter,\n      });\n\n      const { plugin: data, warnings } = unwrapLookup(body);\n      if (!data) {\n        throw new Error('Empty response data from API');\n      }\n      // Lifecycle warnings (deprecated / yanked-but-pinned) — surfaced in the\n      // deploy log; the lookup still succeeds.\n      for (const message of warnings) lambdaLog.warn('LIFECYCLE', message, { plugin: data.name, version: data.version });\n\n      lambdaLog.info('FETCH', 'Plugin fetched successfully', {\n        status,\n        plugin: data.name,\n        version: data.version,\n        id: data.id,\n      });\n\n      return data;\n    } catch (error) {\n      if (error instanceof AxiosError) {\n        if (error.code === 'ECONNABORTED') {\n          lambdaLog.error('FETCH', `Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);\n          throw new Error(`Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);\n        }\n\n        const retryable = error.response\n          ? RETRYABLE_STATUSES.has(error.response.status)\n          : RETRYABLE_CODES.has(error.code ?? '');\n\n        const msg = error.response\n          ? `API error ${error.response.status}: ${error.response.statusText}`\n          : error.code || error.message;\n\n        if (isCredentialRefusal(error.response?.status)) {\n          lambdaLog.warn('AUTH', `Credential refused: ${msg}`);\n          throw new CredentialRefusedError(`Failed to fetch plugin: ${msg}`);\n        }\n\n        if (retryable && attempt < HANDLER_MAX_RETRIES) {\n          lambdaLog.info('RETRY', `Retryable error: ${msg}`, { attempt: attempt + 1 });\n          lastError = new Error(`Failed to fetch plugin: ${msg}`);\n          continue;\n        }\n\n        // Don't log the upstream body verbatim — it may carry a stack trace,\n        // a request payload echo, or other sensitive data we shouldn't echo\n        // into Lambda CloudWatch logs. Keep just the high-level shape.\n        const safeBody = error.response?.data && typeof error.response.data === 'object'\n          ? { code: (error.response.data as { code?: string }).code, message: (error.response.data as { message?: string }).message }\n          : undefined;\n        lambdaLog.error('FETCH', msg, { responseBody: safeBody });\n        throw new Error(`Failed to fetch plugin: ${msg}`);\n      }\n\n      throw error instanceof Error ? error : new Error('Unknown error during plugin fetch');\n    }\n  }\n\n  throw lastError ?? new Error('Failed to fetch plugin after retries');\n}\n\n/**\n * Look the plugin up with the cached credential. On a 401/403 the key was most\n * likely rotated underneath this warm container (token-renew stores the new key\n * and revokes the old one), so drop the cache, re-read the secret and retry once.\n */\nasync function lookupWithCredentialRefresh(baseURL: string, pluginFilter: PluginFilter): Promise<Plugin> {\n  try {\n    return await fetch(create(baseURL, await credential.getKey()), pluginFilter);\n  } catch (err) {\n    if (!(err instanceof CredentialRefusedError)) throw err;\n    credential.invalidate();\n    lambdaLog.info('AUTH', 'Re-reading the service-account key from Secrets Manager and retrying once');\n    return fetch(create(baseURL, await credential.getKey()), pluginFilter);\n  }\n}\n\n/**\n * Validates the plugin filter object\n *\n * @param pluginFilter - Filter to validate\n * @returns true if valid\n * @throws Error if invalid\n */\nfunction validatePluginFilter(pluginFilter: unknown): pluginFilter is PluginFilter {\n  if (!pluginFilter || typeof pluginFilter !== 'object') {\n    throw new Error('Missing or invalid pluginFilter');\n  }\n\n  const filter = pluginFilter as Record<string, unknown>;\n  if (!filter.name && !filter.id && !filter.version && !filter.orgId) {\n    throw new Error('PluginFilter must have at least one criterion (name, id, version, or orgId)');\n  }\n\n  return true;\n}\n\n/**\n * Lambda handler for CloudFormation Custom Resource that performs plugin lookup.\n *\n * Authenticates with the service-account key from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).\n * Create the secret with: `pipeline-manager infra store-token`\n *\n * Request Types:\n * - Create/Update: fetches and returns plugin configuration from API\n * - Delete: no-op (always succeeds)\n *\n * Response:\n * - Success: Returns base64-encoded plugin JSON in Data.ResultValue\n * - Failure: Returns error message in Reason\n *\n * @param event - CloudFormation custom resource event\n * @returns CloudFormation response\n *\n * @example\n * Custom Resource Properties:\n * ```json\n * {\n *   \"baseURL\": \"https://api.example.com\",\n *   \"pluginFilter\": {\n *     \"name\": \"nodejs-build\",\n *     \"version\": \"1.0.0\",\n *     \"isActive\": true\n *   }\n * }\n * ```\n */\nexport const handler = async (\n  event: CloudFormationCustomResourceEvent,\n): Promise<CloudFormationCustomResourceResponse> => {\n  // NOTE: never log event.StackId here — the CloudFormation Stack ARN embeds the\n  // AWS account id (arn:aws:cloudformation:<region>:<ACCOUNT_ID>:stack/…), which\n  // must never be persisted to CloudWatch. requestId + logicalResourceId are\n  // sufficient for correlation. (StackId is still returned in the CFN response\n  // body below — that is the mandatory CFN protocol field and is not a log.)\n  lambdaLog.info('START', `${event.RequestType} request received`, {\n    logicalResourceId: event.LogicalResourceId,\n    requestId: event.RequestId,\n  });\n\n  const baseResponse: Partial<CloudFormationCustomResourceResponse> = {\n    StackId: event.StackId,\n    RequestId: event.RequestId,\n    LogicalResourceId: event.LogicalResourceId,\n    PhysicalResourceId: event.LogicalResourceId,\n  };\n\n  try {\n    // Handle Delete - always succeed (no-op)\n    if (event.RequestType === 'Delete') {\n      lambdaLog.info('DELETE', 'No-op - returning SUCCESS');\n      return {\n        ...baseResponse,\n        Status: 'SUCCESS',\n        Reason: 'Delete completed (no-op)',\n      } as CloudFormationCustomResourceResponse;\n    }\n\n    // Extract and validate properties\n    const pluginFilter = event.ResourceProperties.pluginFilter;\n    const baseURL = event.ResourceProperties.baseURL || HANDLER_DEFAULT_BASE_URL;\n\n    if (!baseURL.startsWith('https://') && !baseURL.startsWith('http://')) {\n      throw new Error(`Invalid baseURL: \"${baseURL}\" — must start with http:// or https://`);\n    }\n\n    lambdaLog.info('CONFIG', 'Configuration loaded', { baseURL, pluginFilter });\n\n    validatePluginFilter(pluginFilter);\n\n    lambdaLog.info('FETCH', 'Initiating plugin lookup...');\n    const plugin = await lookupWithCredentialRefresh(baseURL, pluginFilter);\n    lambdaLog.info('FETCH', 'Plugin retrieved successfully', {\n      name: plugin.name,\n      version: plugin.version,\n      id: plugin.id,\n    });\n\n    // Strip large fields to stay within CloudFormation's 4096-byte Data limit.\n    // CDK constructs only need the fields used by createCodeBuildStep().\n    const slim = {\n      id: plugin.id,\n      name: plugin.name,\n      version: plugin.version,\n      pluginType: plugin.pluginType,\n      computeType: plugin.computeType,\n      commands: plugin.commands,\n      installCommands: plugin.installCommands,\n      env: plugin.env,\n      metadata: plugin.metadata,\n      primaryOutputDirectory: plugin.primaryOutputDirectory,\n      secrets: plugin.secrets,\n      failureBehavior: plugin.failureBehavior,\n      timeout: plugin.timeout,\n    };\n\n    const encoded = Buffer.from(JSON.stringify(slim), 'utf-8').toString('base64');\n    lambdaLog.debug('ENCODE', 'Encoded plugin data', { length: encoded.length });\n\n    return {\n      ...baseResponse,\n      Status: 'SUCCESS',\n      Reason: `Plugin '${plugin.name}' (v${plugin.version}) retrieved successfully`,\n      Data: {\n        ResultValue: encoded,\n      },\n    } as CloudFormationCustomResourceResponse;\n  } catch (error) {\n    const reason = error instanceof Error ? error.message : 'Unexpected error occurred';\n    lambdaLog.error('ERROR', 'Handler failed', {\n      reason,\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n\n    return {\n      ...baseResponse,\n      Status: 'FAILED',\n      Reason: reason,\n    } as CloudFormationCustomResourceResponse;\n  } finally {\n    lambdaLog.info('END', 'Custom resource execution completed');\n  }\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-lookup-handler.js","sourceRoot":"","sources":["../../src/handlers/plugin-lookup-handler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Agent } from 'https';\nimport type { PluginFilter, Plugin } from '@pipeline-builder/pipeline-data';\nimport type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceResponse, Context } from 'aws-lambda';\nimport axios, { type AxiosInstance, AxiosError } from 'axios';\n// Import the dependency-free leaf, NOT `app-config.js`/`CoreConstants`: the latter\n// transitively pulls infrastructure-config → aws-cdk-lib, which esbuild then tries\n// to bundle into this Lambda (hundreds of MB → OOM/SIGKILL during cold-start synth).\nimport { createPlatformCredential, isCredentialRefusal } from './platform-credential.js';\nimport {\n  HANDLER_TIMEOUT_MS,\n  HANDLER_MAX_RETRIES,\n  HANDLER_RETRY_DELAY_MS,\n  HANDLER_RETRY_AFTER_MAX_MS,\n  HANDLER_DEFAULT_BASE_URL,\n} from '../config/handler-constants.js';\nimport { correlationHeaders } from '../core/audit-correlation.js';\nimport { platformCaList } from '../core/platform-tls.js';\nimport { exactPinNotFoundMessage, lookupNotFoundState, unwrapLookup } from '../core/plugin-lookup-envelope.js';\nimport { describeQuotaExceeded } from '../core/quota-exceeded.js';\n\n/**\n * Structured logger for Lambda (outputs JSON to CloudWatch).\n * Debug messages only emitted when LOG_LEVEL=debug.\n */\nfunction logEntry(level: string, tag: string, message: string, data?: unknown) {\n  const line = JSON.stringify({ level, tag, message, data, ts: new Date().toISOString() });\n  switch (level) {\n    case 'ERROR': console.error(line); break;\n    case 'WARN': console.warn(line); break;\n    case 'DEBUG': if (process.env.LOG_LEVEL === 'debug') console.debug(line); break;\n    default: console.log(line);\n  }\n}\n\nconst lambdaLog = {\n  info: (tag: string, message: string, data?: unknown) => logEntry('INFO', tag, message, data),\n  error: (tag: string, message: string, data?: unknown) => logEntry('ERROR', tag, message, data),\n  warn: (tag: string, message: string, data?: unknown) => logEntry('WARN', tag, message, data),\n  debug: (tag: string, message: string, data?: unknown) => logEntry('DEBUG', tag, message, data),\n};\n\nconst RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);\nconst RETRYABLE_CODES = new Set(['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT']);\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/**\n * A plain 429's `Retry-After` (delta-seconds) in ms, clipped to\n * {@link HANDLER_RETRY_AFTER_MAX_MS}; `undefined` when absent or unparseable (an\n * HTTP-date is not worth parsing for a wait this short — the backoff applies).\n */\nexport function retryAfterMs(headers: unknown): number | undefined {\n  const raw = (headers as Record<string, unknown> | undefined)?.['retry-after'];\n  const seconds = typeof raw === 'string' || typeof raw === 'number' ? Number(raw) : NaN;\n  if (!Number.isFinite(seconds) || seconds < 0) return undefined;\n  return Math.min(seconds * 1000, HANDLER_RETRY_AFTER_MAX_MS);\n}\n\n/** Platform secret name — injected as PLATFORM_SECRET_NAME env var by PluginLookup construct. */\nconst PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME;\nif (!PLATFORM_SECRET_NAME) {\n  throw new Error('PLATFORM_SECRET_NAME environment variable is required');\n}\n\n/**\n * The service-account key (`pb_sa_…`) from Secrets Manager, cached for the warm\n * container. The plugin API trades it for a short-lived JWT itself, so the key\n * goes out as the Bearer credential. Create the secret with\n * `pipeline-manager infra store-token`.\n */\nconst credential = createPlatformCredential({ secretName: PLATFORM_SECRET_NAME });\n\n/** @internal Reset cached credential (for testing only). */\nexport function _resetCredentialsCache(): void { credential.reset(); }\n\n/** The API refused the credential (401/403) — the caller may refresh it and retry once. */\nclass CredentialRefusedError extends Error {}\n\n/**\n * CloudFormation caps a custom resource's `Reason` (the response body as a\n * whole must stay under 4096 bytes, and the reason is what the console and\n * `cdk deploy` print). Leave headroom for the other response fields.\n */\nconst MAX_REASON_BYTES = 3500;\n\n/** Truncate to `max` UTF-8 bytes on a character boundary, marking the cut. */\nexport function truncateReason(reason: string, max = MAX_REASON_BYTES): string {\n  if (Buffer.byteLength(reason, 'utf8') <= max) return reason;\n  const marker = ' …[truncated]';\n  let out = reason.slice(0, max);\n  while (Buffer.byteLength(out + marker, 'utf8') > max) out = out.slice(0, -1);\n  return out + marker;\n}\n\n/**\n * The refusal as the plugin service wrote it — `code`, `message` and a compact\n * rendering of `details` (the blocking CVEs, the policy that refused it…) —\n * so the CloudFormation failure says WHY, not just \"API error 409: Conflict\".\n * Only those three fields are read: the body is never echoed verbatim.\n */\nexport function describeRefusal(status: number, statusText: string, body: unknown, filter?: PluginFilter): string {\n  const data = body && typeof body === 'object' ? body as { code?: unknown; message?: unknown; details?: unknown } : {};\n  const code = typeof data.code === 'string' ? data.code : undefined;\n  const pin = typeof filter?.version === 'string' && /^\\d+\\.\\d+\\.\\d+(-[0-9A-Za-z.-]+)?$/.test(filter.version) ? filter.version : undefined;\n  // An exact pin that does not resolve: phrase it from details.state, as the CLI does.\n  if (status === 404 && pin && typeof filter?.name === 'string') {\n    return `${code ?? 'NOT_FOUND'}: ${exactPinNotFoundMessage(filter.name, pin, lookupNotFoundState(body))}`;\n  }\n  const message = typeof data.message === 'string' && data.message.length > 0 ? data.message : `API error ${status}: ${statusText}`;\n  let details = '';\n  if (data.details !== undefined && data.details !== null) {\n    try {\n      details = ` — details: ${JSON.stringify(data.details)}`;\n    } catch {\n      details = '';\n    }\n  }\n  return `${code ? `${code}: ` : ''}${message}${details}`;\n}\n\n/**\n * Creates a pre-configured Axios instance for API requests.\n *\n * @param baseURL - Base URL of the target API\n * @param key - service-account key sent as the Bearer credential\n * @param requestId - this Lambda invocation's awsRequestId, sent as `X-Request-Id`\n *   so the plugin service's audit row joins back to this invocation's log\n * @returns Configured Axios instance\n */\nfunction create(baseURL: string, key: string, requestId?: string): AxiosInstance {\n  // A private-CA platform is VERIFIED against PLATFORM_CA_BUNDLE (set by the\n  // PluginLookup construct when the synth had one); otherwise Node's default store.\n  const ca = platformCaList();\n  return axios.create({\n    baseURL,\n    timeout: HANDLER_TIMEOUT_MS,\n    ...(ca && { httpsAgent: new Agent({ ca }) }),\n    headers: {\n      'Content-Type': 'application/json',\n      'Authorization': `Bearer ${key}`,\n      ...correlationHeaders({ requestId }),\n    },\n  });\n}\n\n/**\n * Fetches plugin configuration from the external API with retry logic.\n * Retries on transient failures (429, 502, 503, 504, network errors)\n * with exponential backoff.\n *\n * @param api - Configured Axios instance\n * @param baseURL - The platform URL `api` targets (prefixes a quota refusal's upgrade path)\n * @param pluginFilter - Filter criteria for the plugin lookup\n * @returns The plugin data returned by the API\n * @throws Error on persistent failure, timeout or invalid response\n */\nasync function fetch(api: AxiosInstance, baseURL: string, pluginFilter: PluginFilter, stepKey?: string): Promise<Plugin> {\n  lambdaLog.debug('FETCH', 'Starting plugin fetch', { filter: pluginFilter });\n\n  let lastError: Error | undefined;\n  // A plain 429's Retry-After, honoured on the next attempt when longer than the backoff.\n  let serverDelay: number | undefined;\n\n  for (let attempt = 0; attempt <= HANDLER_MAX_RETRIES; attempt++) {\n    if (attempt > 0) {\n      const delay = Math.max(HANDLER_RETRY_DELAY_MS * Math.pow(2, attempt - 1), serverDelay ?? 0);\n      serverDelay = undefined;\n      lambdaLog.info('RETRY', `Attempt ${attempt + 1}/${HANDLER_MAX_RETRIES + 1} after ${delay}ms`);\n      await sleep(delay);\n    }\n\n    try {\n      // Contract C1: with a known pipeline + step, the plugin service records\n      // the warnings it returns against them (not only this Lambda's log).\n      const pipelineId = process.env.PIPELINE_ID;\n      const { data: body, status } = await api.post<unknown>('/api/plugins/lookup', {\n        filter: pluginFilter,\n        ...(pipelineId && stepKey ? { context: { pipelineId, stepKeys: [stepKey] } } : {}),\n      });\n\n      const { plugin: data, warnings } = unwrapLookup(body);\n      if (!data) {\n        throw new Error('Empty response data from API');\n      }\n      // Graded warnings (lifecycle, vulnerability, compliance) — surfaced in the\n      // deploy log; the lookup still succeeds. Vulnerability state never fails a\n      // deploy: it is reported (and, with context, recorded server-side).\n      for (const w of warnings) {\n        lambdaLog.warn('PLUGIN_WARNING', `[${w.severity.toUpperCase()}] ${w.message}`, { plugin: data.name, version: data.version, code: w.code, severity: w.severity });\n      }\n\n      lambdaLog.info('FETCH', 'Plugin fetched successfully', {\n        status,\n        plugin: data.name,\n        version: data.version,\n        id: data.id,\n      });\n\n      return data;\n    } catch (error) {\n      if (error instanceof AxiosError) {\n        if (error.code === 'ECONNABORTED') {\n          lambdaLog.error('FETCH', `Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);\n          throw new Error(`Plugin lookup timed out after ${HANDLER_TIMEOUT_MS}ms`);\n        }\n\n        // A QUOTA refusal is not transient: the counter only empties when the\n        // period resets, so retrying just spends two more lookups' worth of\n        // waiting and reports the same thing. Fail fast with the quota, the\n        // numbers, the reset date and where to raise it, as the CFN Reason.\n        const quotaMessage = error.response?.status === 429\n          ? describeQuotaExceeded(error.response.data, baseURL)\n          : undefined;\n        if (quotaMessage) {\n          lambdaLog.error('FETCH', quotaMessage);\n          throw new Error(`Failed to fetch plugin: ${quotaMessage}`);\n        }\n\n        const retryable = error.response\n          ? RETRYABLE_STATUSES.has(error.response.status)\n          : RETRYABLE_CODES.has(error.code ?? '');\n        if (error.response?.status === 429) serverDelay = retryAfterMs(error.response.headers);\n\n        const msg = error.response\n          ? describeRefusal(error.response.status, error.response.statusText, error.response.data, pluginFilter)\n          : error.code || error.message;\n\n        if (isCredentialRefusal(error.response?.status)) {\n          lambdaLog.warn('AUTH', `Credential refused: ${msg}`);\n          throw new CredentialRefusedError(`Failed to fetch plugin: ${msg}`);\n        }\n\n        if (retryable && attempt < HANDLER_MAX_RETRIES) {\n          lambdaLog.info('RETRY', `Retryable error: ${msg}`, { attempt: attempt + 1 });\n          lastError = new Error(`Failed to fetch plugin: ${msg}`);\n          continue;\n        }\n\n        // Don't log the upstream body verbatim — it may carry a stack trace,\n        // a request payload echo, or other sensitive data we shouldn't echo\n        // into Lambda CloudWatch logs. Keep just the high-level shape.\n        const safeBody = error.response?.data && typeof error.response.data === 'object'\n          ? { code: (error.response.data as { code?: string }).code, message: (error.response.data as { message?: string }).message }\n          : undefined;\n        lambdaLog.error('FETCH', msg, { responseBody: safeBody });\n        throw new Error(`Failed to fetch plugin: ${msg}`);\n      }\n\n      throw error instanceof Error ? error : new Error('Unknown error during plugin fetch');\n    }\n  }\n\n  throw lastError ?? new Error('Failed to fetch plugin after retries');\n}\n\n/**\n * Look the plugin up with the cached credential. On a 401/403 the key was most\n * likely rotated underneath this warm container (token-renew stores the new key\n * and revokes the old one), so drop the cache, re-read the secret and retry once.\n */\nasync function lookupWithCredentialRefresh(baseURL: string, pluginFilter: PluginFilter, stepKey?: string, requestId?: string): Promise<Plugin> {\n  try {\n    return await fetch(create(baseURL, await credential.getKey(), requestId), baseURL, pluginFilter, stepKey);\n  } catch (err) {\n    if (!(err instanceof CredentialRefusedError)) throw err;\n    credential.invalidate();\n    lambdaLog.info('AUTH', 'Re-reading the service-account key from Secrets Manager and retrying once');\n    return fetch(create(baseURL, await credential.getKey(), requestId), baseURL, pluginFilter, stepKey);\n  }\n}\n\n/**\n * Validates the plugin filter object\n *\n * @param pluginFilter - Filter to validate\n * @returns true if valid\n * @throws Error if invalid\n */\nfunction validatePluginFilter(pluginFilter: unknown): pluginFilter is PluginFilter {\n  if (!pluginFilter || typeof pluginFilter !== 'object') {\n    throw new Error('Missing or invalid pluginFilter');\n  }\n\n  const filter = pluginFilter as Record<string, unknown>;\n  if (!filter.name && !filter.id && !filter.version && !filter.orgId) {\n    throw new Error('PluginFilter must have at least one criterion (name, id, version, or orgId)');\n  }\n\n  return true;\n}\n\n/**\n * Lambda handler for CloudFormation Custom Resource that performs plugin lookup.\n *\n * Authenticates with the service-account key from AWS Secrets Manager (PLATFORM_SECRET_NAME env var).\n * Create the secret with: `pipeline-manager infra store-token`\n *\n * Request Types:\n * - Create/Update: fetches and returns plugin configuration from API\n * - Delete: no-op (always succeeds)\n *\n * Response:\n * - Success: Returns base64-encoded plugin JSON in Data.ResultValue\n * - Failure: Returns error message in Reason\n *\n * @param event - CloudFormation custom resource event\n * @param context - Lambda context; its awsRequestId rides the lookup as `X-Request-Id`\n * @returns CloudFormation response\n *\n * @example\n * Custom Resource Properties:\n * ```json\n * {\n *   \"baseURL\": \"https://api.example.com\",\n *   \"pluginFilter\": {\n *     \"name\": \"nodejs-build\",\n *     \"version\": \"1.0.0\",\n *     \"isActive\": true\n *   }\n * }\n * ```\n */\nexport const handler = async (\n  event: CloudFormationCustomResourceEvent,\n  context?: Pick<Context, 'awsRequestId'>,\n): Promise<CloudFormationCustomResourceResponse> => {\n  // NOTE: never log event.StackId here — the CloudFormation Stack ARN embeds the\n  // AWS account id (arn:aws:cloudformation:<region>:<ACCOUNT_ID>:stack/…), which\n  // must never be persisted to CloudWatch. requestId + logicalResourceId are\n  // sufficient for correlation. (StackId is still returned in the CFN response\n  // body below — that is the mandatory CFN protocol field and is not a log.)\n  lambdaLog.info('START', `${event.RequestType} request received`, {\n    logicalResourceId: event.LogicalResourceId,\n    requestId: event.RequestId,\n  });\n\n  const baseResponse: Partial<CloudFormationCustomResourceResponse> = {\n    StackId: event.StackId,\n    RequestId: event.RequestId,\n    LogicalResourceId: event.LogicalResourceId,\n    PhysicalResourceId: event.LogicalResourceId,\n  };\n\n  try {\n    // Handle Delete - always succeed (no-op)\n    if (event.RequestType === 'Delete') {\n      lambdaLog.info('DELETE', 'No-op - returning SUCCESS');\n      return {\n        ...baseResponse,\n        Status: 'SUCCESS',\n        Reason: 'Delete completed (no-op)',\n      } as CloudFormationCustomResourceResponse;\n    }\n\n    // Extract and validate properties\n    const pluginFilter = event.ResourceProperties.pluginFilter;\n    const baseURL = event.ResourceProperties.baseURL || HANDLER_DEFAULT_BASE_URL;\n\n    if (!baseURL.startsWith('https://') && !baseURL.startsWith('http://')) {\n      throw new Error(`Invalid baseURL: \"${baseURL}\" — must start with http:// or https://`);\n    }\n\n    lambdaLog.info('CONFIG', 'Configuration loaded', { baseURL, pluginFilter });\n\n    validatePluginFilter(pluginFilter);\n\n    lambdaLog.info('FETCH', 'Initiating plugin lookup...');\n    const stepKey = typeof event.ResourceProperties.stepKey === 'string' ? event.ResourceProperties.stepKey : undefined;\n    const plugin = await lookupWithCredentialRefresh(baseURL, pluginFilter, stepKey, context?.awsRequestId);\n    lambdaLog.info('FETCH', 'Plugin retrieved successfully', {\n      name: plugin.name,\n      version: plugin.version,\n      id: plugin.id,\n    });\n\n    // Strip large fields to stay within CloudFormation's 4096-byte Data limit.\n    // CDK constructs only need the fields used by createCodeBuildStep().\n    const slim = {\n      id: plugin.id,\n      name: plugin.name,\n      version: plugin.version,\n      pluginType: plugin.pluginType,\n      computeType: plugin.computeType,\n      commands: plugin.commands,\n      installCommands: plugin.installCommands,\n      env: plugin.env,\n      metadata: plugin.metadata,\n      primaryOutputDirectory: plugin.primaryOutputDirectory,\n      secrets: plugin.secrets,\n      failureBehavior: plugin.failureBehavior,\n      timeout: plugin.timeout,\n    };\n\n    const encoded = Buffer.from(JSON.stringify(slim), 'utf-8').toString('base64');\n    lambdaLog.debug('ENCODE', 'Encoded plugin data', { length: encoded.length });\n\n    return {\n      ...baseResponse,\n      Status: 'SUCCESS',\n      Reason: `Plugin '${plugin.name}' (v${plugin.version}) retrieved successfully`,\n      Data: {\n        ResultValue: encoded,\n      },\n    } as CloudFormationCustomResourceResponse;\n  } catch (error) {\n    const reason = error instanceof Error ? error.message : 'Unexpected error occurred';\n    lambdaLog.error('ERROR', 'Handler failed', {\n      reason,\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n\n    return {\n      ...baseResponse,\n      Status: 'FAILED',\n      Reason: truncateReason(reason),\n    } as CloudFormationCustomResourceResponse;\n  } finally {\n    lambdaLog.info('END', 'Custom resource execution completed');\n  }\n};\n"]}

package/lib/index.d.ts

@@ -37,8 +37,15 @@ export * from './core/role-types.js';
 export * from './core/security-group-types.js';
 export { replaceNonAlphanumeric, extractMetadataEnv, resolveFailureBehavior, wrapCommandsForFailureBehavior, STEP_BOOTSTRAP_CMD } from './core/metadata-helpers.js';
 export * from './core/step-manifest.js';
-export { type ContractValueType, type PluginContract, type ContractScope, type ContractIssue, type ContractScopeProps, pipelineScopeMetadata, pipelineContractScope, contractScopeFromTemplateScope, isContractValueOfType, checkPluginContract, type PluginStepRef, collectPluginSteps, pluginLookupFilter, pluginArtifactAlias, type PluginRefIdentity, sanitizePublisher, } from './core/plugin-contract.js';
-export { unwrapLookup } from './core/plugin-lookup-envelope.js';
+export { type ContractValueType, type PluginContract, type ContractScope, type ContractIssue, type ContractScopeProps, pipelineScopeMetadata, pipelineContractScope, contractScopeFromTemplateScope, isContractValueOfType, checkPluginContract, type PluginStepRef, collectPluginSteps, pluginLookupFilter, pluginArtifactAlias, pluginStepLabel, type PluginRefIdentity, sanitizePublisher, } from './core/plugin-contract.js';
+export { unwrapLookup, summarizeLookupWarnings, LOOKUP_WARNING_SEVERITIES, type LookupWarning, type LookupWarningSeverity, lookupNotFoundState, exactPinNotFoundMessage, type LookupNotFoundState, } from './core/plugin-lookup-envelope.js';
+export * from './core/synth-failure.js';
+export * from './core/runtime-check.js';
+export * from './core/platform-tls.js';
+export * from './core/audit-correlation.js';
+export * from './core/quota-exceeded.js';
+export * from './core/security-reports.js';
+export * from './core/pipeline-registration.js';
 export * from './pipeline/deploy-attribution.js';
 export * from './pipeline/structure-preview.js';
 export * from './pipeline/plugin-spec.js';