@pipeline-builder/pipeline-manager 4.4.6 → 4.4.8

package/dist/commands/verify-plugins.d.ts

@@ -0,0 +1,45 @@
+import { type RuntimeCheckResult, type RuntimeCheckStep } from '@pipeline-builder/pipeline-core';
+import { Command } from 'commander';
+import type { ApiClient } from '../utils/api-client.js';
+interface VerifyOptions {
+    pipelineId: string;
+    stepsFile?: string;
+    manifest?: string;
+    storeTokens?: boolean;
+    verifySsl?: boolean;
+    region?: string;
+    profile?: string;
+    json?: boolean;
+    strict?: boolean;
+}
+/**
+ * The steps to ask about, from (first match): `--steps-file` (JSON
+ * `[{ stepKey, imageDigest }]`), `--manifest` (a synth's `pb-step-manifest.json`
+ * — rows carrying a stepKey and a digest), or the `PB_VERIFY_STEPS` env var the
+ * synthesized verify step carries. No source, or an empty list, is an error: a
+ * check that asked about nothing must not pass.
+ */
+export declare function loadVerifySteps(options: Pick<VerifyOptions, 'stepsFile' | 'manifest'>, env?: NodeJS.ProcessEnv): RuntimeCheckStep[];
+/** `POST /api/plugins/runtime-check` (contract C2), envelope unwrapped. */
+export declare function runtimeCheck(client: ApiClient, pipelineId: string, steps: readonly RuntimeCheckStep[]): Promise<RuntimeCheckResult>;
+/**
+ * Registers `plugin verify`: ask the platform what it now knows about the
+ * plugin images a pipeline runs — a CVE flagged, a KEV listing or an
+ * org-policy change since the synth that pinned them — and print the graded
+ * verdict. Vulnerability state is REPORTED, never enforced: the command exits
+ * 0 whatever the verdict (the platform also notifies on a pipeline running a
+ * vulnerable plugin). If the check itself cannot run (platform unreachable,
+ * unreadable answer) it warns and exits 0, or exits non-zero with `--strict`.
+ *
+ * The synthesized pipeline runs this as a report-only step in each stage when
+ * the `aws:cdk:operations:runtimevulncheck` metadata flag is on.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager plugin verify --pipeline-id <id> --manifest cdk.out/pb-step-manifest.json
+ * pipeline-manager plugin verify --pipeline-id "$PIPELINE_ID" --store-tokens   # in CodeBuild (PB_VERIFY_STEPS)
+ * ```
+ */
+export declare function verifyPlugins(program: Command): void;
+export {};
+//# sourceMappingURL=verify-plugins.d.ts.map

package/dist/commands/verify-plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-plugins.d.ts","sourceRoot":"","sources":["../../src/commands/verify-plugins.ts"],"names":[],"mappings":"AAKA,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EAEtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAWxD,UAAU,aAAa;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,WAAW,GAAG,UAAU,CAAC,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,gBAAgB,EAAE,CAiBhJ;AAED,2EAA2E;AAC3E,wBAAsB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAOzI;AAUD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAsDpD"}

package/dist/commands/verify-plugins.js

@@ -0,0 +1,134 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { readFileSync } from 'node:fs';
+import { errorMessage } from '@pipeline-builder/api-core';
+import { parseRuntimeCheckSteps, RUNTIME_CHECK_STEPS_ENV, RUNTIME_CHECK_VERDICTS, } from '@pipeline-builder/pipeline-core';
+import { Command } from 'commander';
+import pico from 'picocolors';
+import { createAuthenticatedClientAsync, printCommandHeader, printSslWarning, withProfileOption, withRegionOption, withSslOptions, } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';
+import { printInfo, printSection, printSuccess, printWarning } from '../utils/output-utils.js';
+import { setPipelineId } from '../utils/request-context.js';
+import { unwrapEnvelope } from '../utils/response-utils.js';
+const { bold, cyan, red, yellow } = pico;
+/**
+ * The steps to ask about, from (first match): `--steps-file` (JSON
+ * `[{ stepKey, imageDigest }]`), `--manifest` (a synth's `pb-step-manifest.json`
+ * — rows carrying a stepKey and a digest), or the `PB_VERIFY_STEPS` env var the
+ * synthesized verify step carries. No source, or an empty list, is an error: a
+ * check that asked about nothing must not pass.
+ */
+export function loadVerifySteps(options, env = process.env) {
+    let steps;
+    if (options.stepsFile) {
+        steps = parseRuntimeCheckSteps(readFileSync(options.stepsFile, 'utf8'));
+    }
+    else if (options.manifest) {
+        const rows = JSON.parse(readFileSync(options.manifest, 'utf8'));
+        if (!Array.isArray(rows))
+            throw new ValidationError('--manifest must be a step manifest (a JSON array)', 'manifest');
+        steps = parseRuntimeCheckSteps(JSON.stringify(rows
+            .filter((r) => r.stepKey && r.imageDigest)
+            .map((r) => ({ stepKey: r.stepKey, imageDigest: r.imageDigest }))));
+    }
+    else if (env[RUNTIME_CHECK_STEPS_ENV]) {
+        steps = parseRuntimeCheckSteps(env[RUNTIME_CHECK_STEPS_ENV]);
+    }
+    else {
+        throw new ValidationError(`No steps to verify: pass --steps-file or --manifest, or set ${RUNTIME_CHECK_STEPS_ENV}`, 'steps');
+    }
+    if (steps.length === 0)
+        throw new ValidationError('No image-backed steps to verify', 'steps');
+    return steps;
+}
+/** `POST /api/plugins/runtime-check` (contract C2), envelope unwrapped. */
+export async function runtimeCheck(client, pipelineId, steps) {
+    const response = await client.post(`${client.getConfig().api.pluginUrl}/runtime-check`, { pipelineId, steps });
+    const body = unwrapEnvelope(response);
+    if (!body.verdict || !RUNTIME_CHECK_VERDICTS.includes(body.verdict)) {
+        throw new Error('runtime-check returned no readable verdict');
+    }
+    return { verdict: body.verdict, steps: Array.isArray(body.steps) ? body.steps : [] };
+}
+const VERDICT_STYLE = {
+    ok: (t) => t,
+    info: cyan,
+    warning: yellow,
+    error: red,
+    critical: (t) => bold(red(t)),
+};
+/**
+ * Registers `plugin verify`: ask the platform what it now knows about the
+ * plugin images a pipeline runs — a CVE flagged, a KEV listing or an
+ * org-policy change since the synth that pinned them — and print the graded
+ * verdict. Vulnerability state is REPORTED, never enforced: the command exits
+ * 0 whatever the verdict (the platform also notifies on a pipeline running a
+ * vulnerable plugin). If the check itself cannot run (platform unreachable,
+ * unreadable answer) it warns and exits 0, or exits non-zero with `--strict`.
+ *
+ * The synthesized pipeline runs this as a report-only step in each stage when
+ * the `aws:cdk:operations:runtimevulncheck` metadata flag is on.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager plugin verify --pipeline-id <id> --manifest cdk.out/pb-step-manifest.json
+ * pipeline-manager plugin verify --pipeline-id "$PIPELINE_ID" --store-tokens   # in CodeBuild (PB_VERIFY_STEPS)
+ * ```
+ */
+export function verifyPlugins(program) {
+    withSslOptions(withRegionOption(withProfileOption(program
+        .command('verify')
+        .description('Report, at run time, the current vulnerability state of a pipeline\'s pinned plugin images (never fails on it)')
+        .requiredOption('-p, --pipeline-id <id>', 'Pipeline ID')
+        .option('--steps-file <file>', 'JSON [{ stepKey, imageDigest }] to check')
+        .option('--manifest <file>', 'A synth\'s pb-step-manifest.json to check')
+        .option('--store-tokens', 'Authenticate using the key in AWS Secrets Manager (PLATFORM_SECRET_NAME)', false)
+        .option('--strict', 'Exit non-zero when the check itself cannot run (never for vulnerability state)', false)
+        .option('--json', 'Print the verdict as JSON', false))))
+        .action(async (options) => {
+        const executionId = printCommandHeader('Plugin Run-time Check', undefined, { quiet: options.json });
+        try {
+            printSslWarning(options.verifySsl);
+            // Bad input is the caller's bug, not an outage: always an error.
+            const steps = loadVerifySteps(options);
+            printInfo('Checking plugin images', { pipelineId: options.pipelineId, steps: steps.length });
+            setPipelineId(options.pipelineId);
+            let result;
+            try {
+                const client = await createAuthenticatedClientAsync(options);
+                result = await runtimeCheck(client, options.pipelineId, steps);
+            }
+            catch (error) {
+                if (options.strict)
+                    throw error;
+                printWarning('Run-time plugin check could not run — continuing (pass --strict to fail instead)', { error: errorMessage(error) });
+                return;
+            }
+            if (options.json)
+                console.log(JSON.stringify(result, null, 2));
+            printSection(`Verdict: ${VERDICT_STYLE[result.verdict](result.verdict.toUpperCase())}`);
+            for (const step of result.steps) {
+                if (step.verdict === 'ok')
+                    continue;
+                for (const reason of step.reasons) {
+                    const sev = reason.severity ?? step.verdict;
+                    const tag = (VERDICT_STYLE[sev] ?? yellow)(`[${sev.toUpperCase()}]`);
+                    console.log(`  ${tag} ${step.stepKey} (${step.imageDigest.slice(0, 19)}…) ${reason.code}: ${reason.message}`);
+                }
+            }
+            const flagged = result.steps.filter((s) => s.verdict !== 'ok').length;
+            if (result.verdict === 'ok')
+                printSuccess('Run-time plugin check: no findings');
+            else
+                printWarning(`Run-time plugin check: ${flagged} step(s) with findings (worst: ${result.verdict}) — reported, not enforced`);
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'plugin-verify', executionId, pipelineId: options.pipelineId },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"verify-plugins.js","sourceRoot":"","sources":["../../src/commands/verify-plugins.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { readFileSync } from 'node:fs';\nimport { errorMessage } from '@pipeline-builder/api-core';\nimport {\n  parseRuntimeCheckSteps,\n  RUNTIME_CHECK_STEPS_ENV,\n  RUNTIME_CHECK_VERDICTS,\n  type RuntimeCheckResult,\n  type RuntimeCheckStep,\n  type StepManifestEntry,\n} from '@pipeline-builder/pipeline-core';\nimport { Command } from 'commander';\nimport pico from 'picocolors';\nimport type { ApiClient } from '../utils/api-client.js';\nimport {\n  createAuthenticatedClientAsync, printCommandHeader, printSslWarning, withProfileOption, withRegionOption, withSslOptions,\n} from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';\nimport { printInfo, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { setPipelineId } from '../utils/request-context.js';\nimport { unwrapEnvelope } from '../utils/response-utils.js';\n\nconst { bold, cyan, red, yellow } = pico;\n\ninterface VerifyOptions {\n  pipelineId: string;\n  stepsFile?: string;\n  manifest?: string;\n  storeTokens?: boolean;\n  verifySsl?: boolean;\n  region?: string;\n  profile?: string;\n  json?: boolean;\n  strict?: boolean;\n}\n\n/**\n * The steps to ask about, from (first match): `--steps-file` (JSON\n * `[{ stepKey, imageDigest }]`), `--manifest` (a synth's `pb-step-manifest.json`\n * — rows carrying a stepKey and a digest), or the `PB_VERIFY_STEPS` env var the\n * synthesized verify step carries. No source, or an empty list, is an error: a\n * check that asked about nothing must not pass.\n */\nexport function loadVerifySteps(options: Pick<VerifyOptions, 'stepsFile' | 'manifest'>, env: NodeJS.ProcessEnv = process.env): RuntimeCheckStep[] {\n  let steps: RuntimeCheckStep[];\n  if (options.stepsFile) {\n    steps = parseRuntimeCheckSteps(readFileSync(options.stepsFile, 'utf8'));\n  } else if (options.manifest) {\n    const rows = JSON.parse(readFileSync(options.manifest, 'utf8')) as StepManifestEntry[];\n    if (!Array.isArray(rows)) throw new ValidationError('--manifest must be a step manifest (a JSON array)', 'manifest');\n    steps = parseRuntimeCheckSteps(JSON.stringify(rows\n      .filter((r) => r.stepKey && r.imageDigest)\n      .map((r) => ({ stepKey: r.stepKey, imageDigest: r.imageDigest }))));\n  } else if (env[RUNTIME_CHECK_STEPS_ENV]) {\n    steps = parseRuntimeCheckSteps(env[RUNTIME_CHECK_STEPS_ENV]!);\n  } else {\n    throw new ValidationError(`No steps to verify: pass --steps-file or --manifest, or set ${RUNTIME_CHECK_STEPS_ENV}`, 'steps');\n  }\n  if (steps.length === 0) throw new ValidationError('No image-backed steps to verify', 'steps');\n  return steps;\n}\n\n/** `POST /api/plugins/runtime-check` (contract C2), envelope unwrapped. */\nexport async function runtimeCheck(client: ApiClient, pipelineId: string, steps: readonly RuntimeCheckStep[]): Promise<RuntimeCheckResult> {\n  const response = await client.post<unknown>(`${client.getConfig().api.pluginUrl}/runtime-check`, { pipelineId, steps });\n  const body = unwrapEnvelope(response) as Partial<RuntimeCheckResult>;\n  if (!body.verdict || !RUNTIME_CHECK_VERDICTS.includes(body.verdict)) {\n    throw new Error('runtime-check returned no readable verdict');\n  }\n  return { verdict: body.verdict, steps: Array.isArray(body.steps) ? body.steps : [] };\n}\n\nconst VERDICT_STYLE: Record<string, (s: string) => string> = {\n  ok: (t) => t,\n  info: cyan,\n  warning: yellow,\n  error: red,\n  critical: (t) => bold(red(t)),\n};\n\n/**\n * Registers `plugin verify`: ask the platform what it now knows about the\n * plugin images a pipeline runs — a CVE flagged, a KEV listing or an\n * org-policy change since the synth that pinned them — and print the graded\n * verdict. Vulnerability state is REPORTED, never enforced: the command exits\n * 0 whatever the verdict (the platform also notifies on a pipeline running a\n * vulnerable plugin). If the check itself cannot run (platform unreachable,\n * unreadable answer) it warns and exits 0, or exits non-zero with `--strict`.\n *\n * The synthesized pipeline runs this as a report-only step in each stage when\n * the `aws:cdk:operations:runtimevulncheck` metadata flag is on.\n *\n * @example\n * ```bash\n * pipeline-manager plugin verify --pipeline-id <id> --manifest cdk.out/pb-step-manifest.json\n * pipeline-manager plugin verify --pipeline-id \"$PIPELINE_ID\" --store-tokens   # in CodeBuild (PB_VERIFY_STEPS)\n * ```\n */\nexport function verifyPlugins(program: Command): void {\n  withSslOptions(\n    withRegionOption(\n      withProfileOption(program\n        .command('verify')\n        .description('Report, at run time, the current vulnerability state of a pipeline\\'s pinned plugin images (never fails on it)')\n        .requiredOption('-p, --pipeline-id <id>', 'Pipeline ID')\n        .option('--steps-file <file>', 'JSON [{ stepKey, imageDigest }] to check')\n        .option('--manifest <file>', 'A synth\\'s pb-step-manifest.json to check')\n        .option('--store-tokens', 'Authenticate using the key in AWS Secrets Manager (PLATFORM_SECRET_NAME)', false)\n        .option('--strict', 'Exit non-zero when the check itself cannot run (never for vulnerability state)', false)\n        .option('--json', 'Print the verdict as JSON', false)),\n    ),\n  )\n    .action(async (options: VerifyOptions) => {\n      const executionId = printCommandHeader('Plugin Run-time Check', undefined, { quiet: options.json });\n      try {\n        printSslWarning(options.verifySsl);\n        // Bad input is the caller's bug, not an outage: always an error.\n        const steps = loadVerifySteps(options);\n        printInfo('Checking plugin images', { pipelineId: options.pipelineId, steps: steps.length });\n        setPipelineId(options.pipelineId);\n\n        let result: RuntimeCheckResult;\n        try {\n          const client = await createAuthenticatedClientAsync(options);\n          result = await runtimeCheck(client, options.pipelineId, steps);\n        } catch (error) {\n          if (options.strict) throw error;\n          printWarning('Run-time plugin check could not run — continuing (pass --strict to fail instead)', { error: errorMessage(error) });\n          return;\n        }\n\n        if (options.json) console.log(JSON.stringify(result, null, 2));\n        printSection(`Verdict: ${VERDICT_STYLE[result.verdict]!(result.verdict.toUpperCase())}`);\n        for (const step of result.steps) {\n          if (step.verdict === 'ok') continue;\n          for (const reason of step.reasons) {\n            const sev = reason.severity ?? step.verdict;\n            const tag = (VERDICT_STYLE[sev] ?? yellow)(`[${sev.toUpperCase()}]`);\n            console.log(`  ${tag} ${step.stepKey} (${step.imageDigest.slice(0, 19)}…) ${reason.code}: ${reason.message}`);\n          }\n        }\n        const flagged = result.steps.filter((s) => s.verdict !== 'ok').length;\n        if (result.verdict === 'ok') printSuccess('Run-time plugin check: no findings');\n        else printWarning(`Run-time plugin check: ${flagged} step(s) with findings (worst: ${result.verdict}) — reported, not enforced`);\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'plugin-verify', executionId, pipelineId: options.pipelineId },\n        });\n      }\n    });\n}\n"]}

package/dist/lambda/token-renew-handler.d.ts

@@ -1,2 +1,4 @@
-export declare const handler: () => Promise<void>;
+export declare const handler: (_event?: unknown, context?: {
+    awsRequestId?: string;
+}) => Promise<void>;
 //# sourceMappingURL=token-renew-handler.d.ts.map

package/dist/lambda/token-renew-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token-renew-handler.d.ts","sourceRoot":"","sources":["../../src/lambda/token-renew-handler.ts"],"names":[],"mappings":"AA8GA,eAAO,MAAM,OAAO,QAAa,OAAO,CAAC,IAAI,CAwE5C,CAAC"}
+{"version":3,"file":"token-renew-handler.d.ts","sourceRoot":"","sources":["../../src/lambda/token-renew-handler.ts"],"names":[],"mappings":"AAoHA,eAAO,MAAM,OAAO,YAAmB,OAAO,YAAY;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,KAAG,OAAO,CAAC,IAAI,CAyEjG,CAAC"}

package/dist/lambda/token-renew-handler.js

@@ -1,6 +1,31 @@
 // src/lambda/token-renew-handler.ts
 import { SecretsManagerClient as SecretsManagerClient2, PutSecretValueCommand } from "@aws-sdk/client-secrets-manager";
 
+// ../pipeline-core/lib/core/audit-correlation.js
+var REQUEST_ID_HEADER = "X-Request-Id";
+var PIPELINE_EXECUTION_ID_HEADER = "X-Pipeline-Execution-Id";
+var CODEBUILD_BUILD_ID_HEADER = "X-CodeBuild-Build-Id";
+var MAX_CORRELATION_VALUE = 128;
+function sanitizeCorrelationValue(value) {
+  if (typeof value !== "string")
+    return void 0;
+  const clean = value.replace(/[^\x21-\x7e]/g, "").slice(0, MAX_CORRELATION_VALUE);
+  return clean.length > 0 ? clean : void 0;
+}
+function correlationHeaders(ids) {
+  const headers = {};
+  const requestId = sanitizeCorrelationValue(ids.requestId);
+  const executionId = sanitizeCorrelationValue(ids.pipelineExecutionId);
+  const buildId = sanitizeCorrelationValue(ids.codeBuildBuildId);
+  if (requestId)
+    headers[REQUEST_ID_HEADER] = requestId;
+  if (executionId)
+    headers[PIPELINE_EXECUTION_ID_HEADER] = executionId;
+  if (buildId)
+    headers[CODEBUILD_BUILD_ID_HEADER] = buildId;
+  return headers;
+}
+
 // ../pipeline-core/lib/handlers/platform-credential.js
 import { GetSecretValueCommand, SecretsManagerClient } from "@aws-sdk/client-secrets-manager";
 var ACCESS_KEY_PREFIXES = ["pb_sa_", "pb_pat_"];
@@ -29,13 +54,13 @@ function log(level, msg, data) {
   if (level === "ERROR") console.error(line);
   else console.log(line);
 }
-async function post(baseUrl, route, body) {
+async function post(baseUrl, route, body, requestId) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS);
   try {
     const res = await fetch(`${baseUrl}${route}`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", "Accept": "application/json" },
+      headers: { "Content-Type": "application/json", "Accept": "application/json", ...correlationHeaders({ requestId }) },
       body: JSON.stringify(body),
       signal: controller.signal
     });
@@ -53,7 +78,8 @@ function applyTlsPolicy() {
   }
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
 }
-var handler = async () => {
+var handler = async (_event, context) => {
+  const requestId = context?.awsRequestId;
   const secretName = required("PLATFORM_SECRET_NAME");
   const days = Number(process.env.RENEW_DAYS || "30");
   if (!Number.isFinite(days) || days < 1 || days > 365) {
@@ -72,7 +98,7 @@ var handler = async () => {
     key: oldKey,
     name: `${stored.serviceAccountName || "rotated"}-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`,
     expiresIn: days * 24 * 60 * 60
-  });
+  }, requestId);
   if (rotate.status < 200 || rotate.status >= 300) {
     throw new Error(
       `Key rotation refused (${rotate.status}): ${rotate.body.message || "unknown reason"}. The stored key is unchanged and still live.`
@@ -102,7 +128,7 @@ var handler = async () => {
     log("WARN", "Secret recorded no previous keyId \u2014 nothing to revoke (it expires on its own)", { secretName });
     return;
   }
-  const revoke = await post(platformUrl, "/api/auth/key/revoke", { key: newKey, keyId: oldKeyId }).catch((err) => ({ status: 0, body: { message: err instanceof Error ? err.message : String(err) } }));
+  const revoke = await post(platformUrl, "/api/auth/key/revoke", { key: newKey, keyId: oldKeyId }, requestId).catch((err) => ({ status: 0, body: { message: err instanceof Error ? err.message : String(err) } }));
   if (revoke.status < 200 || revoke.status >= 300) {
     log("ERROR", "Rotated and stored the new key, but could NOT revoke its predecessor \u2014 it stays valid until it expires", {
       secretName,

package/dist/templates/events-stack.json

@@ -120,6 +120,16 @@
                 "Action": "codepipeline:ListTagsForResource",
                 "Resource": { "Fn::Sub": "arn:aws:codepipeline:*:${AWS::AccountId}:*" }
               },
+              {
+                "Effect": "Allow",
+                "Action": "codebuild:BatchGetBuilds",
+                "Resource": { "Fn::Sub": "arn:aws:codebuild:*:${AWS::AccountId}:project/*" }
+              },
+              {
+                "Effect": "Allow",
+                "Action": "logs:FilterLogEvents",
+                "Resource": { "Fn::Sub": "arn:aws:logs:*:${AWS::AccountId}:log-group:/aws/codebuild/*:*" }
+              },
               {
                 "Fn::If": ["DoraOn", {
                   "Effect": "Allow",

package/dist/utils/api-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-client.d.ts","sourceRoot":"","sources":["../../src/utils/api-client.ts"],"names":[],"mappings":"AAKA,OAAO,QAAQ,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAMjD;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAS;IAEvB,YAAY,MAAM,EAAE,MAAM,EAsDzB;IAED,OAAO,CAAC,WAAW;IAkDb,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGlH;IAED;;;;;;;;;OASG;IACG,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAQ3G;IAEK,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGjG;IAEK,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CASzG;IAEK,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGhG;IAEK,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGnF;IAEK,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGlG;IAED,SAAS,IAAI,MAAM,CAAwB;IAC3C,UAAU,IAAI,MAAM,CAAoC;IACxD,eAAe,IAAI,OAAO,CAAsC;IAEhE;;;OAGG;IACH,OAAO,CAAC,gBAAgB;CASzB"}
+{"version":3,"file":"api-client.d.ts","sourceRoot":"","sources":["../../src/utils/api-client.ts"],"names":[],"mappings":"AAMA,OAAO,QAAQ,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAOjD;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAS;IAEvB,YAAY,MAAM,EAAE,MAAM,EA+DzB;IAED,OAAO,CAAC,WAAW;IAuDb,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGlH;IAED;;;;;;;;;OASG;IACG,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAQ3G;IAEK,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGjG;IAEK,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CASzG;IAEK,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGhG;IAEK,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGnF;IAEK,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGlG;IAED,SAAS,IAAI,MAAM,CAAwB;IAC3C,UAAU,IAAI,MAAM,CAAoC;IACxD,eAAe,IAAI,OAAO,CAAsC;IAEhE;;;OAGG;IACH,OAAO,CAAC,gBAAgB;CASzB"}

package/dist/utils/api-client.js

@@ -1,12 +1,14 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import https from 'https';
+import { describeQuotaExceeded, platformCaList } from '@pipeline-builder/pipeline-core';
 import axios, { AxiosError } from 'axios';
 import FormData from 'form-data';
 import { decodeTokenPayload } from './auth-guard.js';
 import {} from './config-loader.js';
 import { NetworkError } from './error-handler.js';
 import { printDebug, printError, printWarning } from './output-utils.js';
+import { requestCorrelationHeaders } from './request-context.js';
 import { TIMEOUTS } from '../config/cli.constants.js';
 import { ApiError } from '../types/index.js';
 /**
@@ -22,8 +24,12 @@ export class ApiClient {
         }
         // Warn if token appears expired (advisory — server validates authoritatively)
         this.checkTokenExpiry(config.auth.token);
+        // A private-CA platform (PLATFORM_CA_BUNDLE) is trusted on top of Node's
+        // roots — verified, not skipped. See pipeline-core core/platform-tls.ts.
+        const ca = platformCaList();
         const httpsAgent = new https.Agent({
             rejectUnauthorized: config.api.rejectUnauthorized ?? true,
+            ...(ca && { ca }),
         });
         if (config.api.rejectUnauthorized === false) {
             printWarning('Certificate validation is disabled');
@@ -37,6 +43,11 @@ export class ApiClient {
         // Auth interceptor
         this.client.interceptors.request.use((requestConfig) => {
             requestConfig.headers.Authorization = `Bearer ${config.auth.token}`;
+            // Audit correlation (X-Request-Id, and in CodeBuild the build + execution
+            // ids) so the server's audit row joins back to this run. See request-context.
+            for (const [name, value] of Object.entries(requestCorrelationHeaders())) {
+                requestConfig.headers[name] = value;
+            }
             printDebug('API Request', {
                 method: requestConfig.method?.toUpperCase(),
                 url: requestConfig.url,
@@ -69,6 +80,11 @@ export class ApiClient {
             if (data && typeof data === 'object' && 'message' in data && typeof data.message === 'string') {
                 message = data.message;
             }
+            // A QUOTA refusal reads as what it is — which quota, how much, when it
+            // resets and where to raise it — not as a rate limit to wait out. A 429
+            // without the QUOTA_EXCEEDED code keeps the server's message.
+            if (status === 429)
+                message = describeQuotaExceeded(data, this.config.api.baseUrl) ?? message;
             return Promise.reject(new ApiError(message, status, error.response));
         }
         else if (error.request) {
@@ -89,8 +105,9 @@ export class ApiClient {
                 ENOTFOUND: 'DNS lookup failed — check the hostname in baseUrl',
                 ERR_BAD_REQUEST: 'Request was malformed — check the endpoint and payload',
                 CERT_HAS_EXPIRED: 'SSL certificate expired — use --no-verify-ssl for dev',
-                DEPTH_ZERO_SELF_SIGNED_CERT: 'Self-signed certificate — use --no-verify-ssl',
-                UNABLE_TO_VERIFY_LEAF_SIGNATURE: 'SSL chain incomplete — use --no-verify-ssl for dev',
+                DEPTH_ZERO_SELF_SIGNED_CERT: 'Self-signed certificate — set PLATFORM_CA_BUNDLE to its CA (PEM), or --no-verify-ssl for dev',
+                UNABLE_TO_VERIFY_LEAF_SIGNATURE: 'SSL chain incomplete — set PLATFORM_CA_BUNDLE to the issuing CA (PEM), or --no-verify-ssl for dev',
+                SELF_SIGNED_CERT_IN_CHAIN: 'Private CA in chain — set PLATFORM_CA_BUNDLE to that CA (PEM)',
             };
             const hint = hints[code] || 'Check network connectivity and server status';
             const message = `${code}: ${hint} (url: ${url})`;
@@ -167,4 +184,4 @@ export class ApiClient {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-client.js","sourceRoot":"","sources":["../../src/utils/api-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport https from 'https';\nimport axios, { type AxiosInstance, AxiosError } from 'axios';\nimport FormData from 'form-data';\nimport { decodeTokenPayload } from './auth-guard.js';\nimport { type Config } from './config-loader.js';\nimport { NetworkError } from './error-handler.js';\nimport { printDebug, printError, printWarning } from './output-utils.js';\nimport { TIMEOUTS } from '../config/cli.constants.js';\nimport { ApiError } from '../types/index.js';\n\n/**\n * API Client for making HTTP requests to the platform API\n */\nexport class ApiClient {\n  private client: AxiosInstance;\n  private config: Config;\n\n  constructor(config: Config) {\n    this.config = config;\n\n    if (!config.auth?.token) {\n      throw new Error('Authentication token is required. Set PLATFORM_TOKEN environment variable.');\n    }\n\n    // Warn if token appears expired (advisory — server validates authoritatively)\n    this.checkTokenExpiry(config.auth.token);\n\n    const httpsAgent = new https.Agent({\n      rejectUnauthorized: config.api.rejectUnauthorized ?? true,\n    });\n\n    if (config.api.rejectUnauthorized === false) {\n      printWarning('Certificate validation is disabled');\n    }\n\n    this.client = axios.create({\n      baseURL: config.api.baseUrl,\n      timeout: config.api.timeout || TIMEOUTS.HTTP_REQUEST,\n      httpsAgent,\n      headers: { 'Content-Type': 'application/json' },\n    });\n\n    // Auth interceptor\n    this.client.interceptors.request.use(\n      (requestConfig) => {\n        requestConfig.headers.Authorization = `Bearer ${config.auth.token}`;\n        printDebug('API Request', {\n          method: requestConfig.method?.toUpperCase(),\n          url: requestConfig.url,\n          baseURL: requestConfig.baseURL,\n        });\n        return requestConfig;\n      },\n      (error) => {\n        printError('Request interceptor error', { error: error.message });\n        return Promise.reject(error);\n      },\n    );\n\n    // Response interceptor\n    this.client.interceptors.response.use(\n      (response) => {\n        printDebug('API Response', {\n          status: response.status,\n          statusText: response.statusText,\n          url: response.config.url,\n        });\n        return response;\n      },\n      (error: AxiosError) => this.handleError(error),\n    );\n  }\n\n  private handleError(error: AxiosError): Promise<never> {\n    if (error.response) {\n      const { status, statusText, data } = error.response;\n      const url = error.config?.url;\n\n      // The response body (`data`) can carry tokens/PII, and printError always writes\n      // (not gated on DEBUG) — keep it out of the always-on line; surface it only under DEBUG.\n      printError('API request failed', { status, statusText, url });\n      printDebug('API error response body', { data });\n\n      let message = `API request failed with status ${status}`;\n      if (data && typeof data === 'object' && 'message' in data && typeof (data as { message: unknown }).message === 'string') {\n        message = (data as { message: string }).message;\n      }\n\n      return Promise.reject(new ApiError(message, status, error.response));\n    } else if (error.request) {\n      const code = error.code || 'UNKNOWN';\n      const url = error.config?.url;\n      const timeout = error.config?.timeout;\n      const cause = error.cause;\n\n      printError('No response received from API', {\n        url,\n        timeout,\n        code,\n        ...(cause instanceof Error ? { cause: cause.message } : {}),\n      });\n\n      const hints: Record<string, string> = {\n        ECONNREFUSED: 'Server is not running or port is wrong',\n        ECONNRESET: 'Server closed the connection unexpectedly',\n        ETIMEDOUT: 'Connection timed out — server unreachable or too slow',\n        ENOTFOUND: 'DNS lookup failed — check the hostname in baseUrl',\n        ERR_BAD_REQUEST: 'Request was malformed — check the endpoint and payload',\n        CERT_HAS_EXPIRED: 'SSL certificate expired — use --no-verify-ssl for dev',\n        DEPTH_ZERO_SELF_SIGNED_CERT: 'Self-signed certificate — use --no-verify-ssl',\n        UNABLE_TO_VERIFY_LEAF_SIGNATURE: 'SSL chain incomplete — use --no-verify-ssl for dev',\n      };\n\n      const hint = hints[code] || 'Check network connectivity and server status';\n      const message = `${code}: ${hint} (url: ${url})`;\n\n      return Promise.reject(new NetworkError(message, url, error, timeout));\n    } else {\n      printError('API request error', { error: error.message });\n      return Promise.reject(error);\n    }\n  }\n\n  async get<T = unknown>(url: string, params?: Record<string, unknown>, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.get<T>(url, { params, headers });\n    return response.data;\n  }\n\n  /**\n   * A BINARY download (a report PDF): the bytes, plus the file name the server chose.\n   *\n   * `responseType: 'arraybuffer'` because the default would hand back a UTF-8 string and\n   * corrupt every byte above 0x7f — a PDF written that way opens as a damaged file, which\n   * looks like a server bug rather than a client one.\n   *\n   * The server's `Content-Disposition` name is preferred over anything the caller guesses:\n   * it knows the report's title and whether the run is a revision.\n   */\n  async getBinary(url: string, headers?: Record<string, string>): Promise<{ data: Buffer; filename?: string }> {\n    const response = await this.client.get<ArrayBuffer>(url, { headers, responseType: 'arraybuffer' });\n    const disposition = String(response.headers['content-disposition'] ?? '');\n    const match = /filename=\"([^\"]+)\"/.exec(disposition);\n    return {\n      data: Buffer.from(response.data),\n      ...(match?.[1] ? { filename: match[1] } : {}),\n    };\n  }\n\n  async post<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.post<T>(url, data, { headers });\n    return response.data;\n  }\n\n  async postForm<T = unknown>(url: string, formData: FormData, headers?: Record<string, string>): Promise<T> {\n    const uploadTimeout = this.config.api.uploadTimeout || 15 * 60 * 1000; // default 15 minutes\n    const response = await this.client.post<T>(url, formData, {\n      headers: { ...formData.getHeaders(), ...headers },\n      maxContentLength: Infinity,\n      maxBodyLength: Infinity,\n      timeout: uploadTimeout,\n    });\n    return response.data;\n  }\n\n  async put<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.put<T>(url, data, { headers });\n    return response.data;\n  }\n\n  async delete<T = unknown>(url: string, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.delete<T>(url, { headers });\n    return response.data;\n  }\n\n  async patch<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.patch<T>(url, data, { headers });\n    return response.data;\n  }\n\n  getConfig(): Config { return this.config; }\n  getBaseUrl(): string { return this.config.api.baseUrl; }\n  isAuthenticated(): boolean { return !!this.config.auth?.token; }\n\n  /**\n   * Advisory check: decode JWT exp claim and warn if expired.\n   * Does NOT verify signature — server handles that.\n   */\n  private checkTokenExpiry(token: string): void {\n    const payload = decodeTokenPayload(token);\n    if (payload && typeof payload.exp === 'number') {\n      const expiresAt = new Date(payload.exp * 1000);\n      if (expiresAt.getTime() < Date.now()) {\n        printWarning(`Token expired at ${expiresAt.toISOString()} — run \"pipeline-manager auth login\" to refresh`);\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-client.js","sourceRoot":"","sources":["../../src/utils/api-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport https from 'https';\nimport { describeQuotaExceeded, platformCaList } from '@pipeline-builder/pipeline-core';\nimport axios, { type AxiosInstance, AxiosError } from 'axios';\nimport FormData from 'form-data';\nimport { decodeTokenPayload } from './auth-guard.js';\nimport { type Config } from './config-loader.js';\nimport { NetworkError } from './error-handler.js';\nimport { printDebug, printError, printWarning } from './output-utils.js';\nimport { requestCorrelationHeaders } from './request-context.js';\nimport { TIMEOUTS } from '../config/cli.constants.js';\nimport { ApiError } from '../types/index.js';\n\n/**\n * API Client for making HTTP requests to the platform API\n */\nexport class ApiClient {\n  private client: AxiosInstance;\n  private config: Config;\n\n  constructor(config: Config) {\n    this.config = config;\n\n    if (!config.auth?.token) {\n      throw new Error('Authentication token is required. Set PLATFORM_TOKEN environment variable.');\n    }\n\n    // Warn if token appears expired (advisory — server validates authoritatively)\n    this.checkTokenExpiry(config.auth.token);\n\n    // A private-CA platform (PLATFORM_CA_BUNDLE) is trusted on top of Node's\n    // roots — verified, not skipped. See pipeline-core core/platform-tls.ts.\n    const ca = platformCaList();\n    const httpsAgent = new https.Agent({\n      rejectUnauthorized: config.api.rejectUnauthorized ?? true,\n      ...(ca && { ca }),\n    });\n\n    if (config.api.rejectUnauthorized === false) {\n      printWarning('Certificate validation is disabled');\n    }\n\n    this.client = axios.create({\n      baseURL: config.api.baseUrl,\n      timeout: config.api.timeout || TIMEOUTS.HTTP_REQUEST,\n      httpsAgent,\n      headers: { 'Content-Type': 'application/json' },\n    });\n\n    // Auth interceptor\n    this.client.interceptors.request.use(\n      (requestConfig) => {\n        requestConfig.headers.Authorization = `Bearer ${config.auth.token}`;\n        // Audit correlation (X-Request-Id, and in CodeBuild the build + execution\n        // ids) so the server's audit row joins back to this run. See request-context.\n        for (const [name, value] of Object.entries(requestCorrelationHeaders())) {\n          requestConfig.headers[name] = value;\n        }\n        printDebug('API Request', {\n          method: requestConfig.method?.toUpperCase(),\n          url: requestConfig.url,\n          baseURL: requestConfig.baseURL,\n        });\n        return requestConfig;\n      },\n      (error) => {\n        printError('Request interceptor error', { error: error.message });\n        return Promise.reject(error);\n      },\n    );\n\n    // Response interceptor\n    this.client.interceptors.response.use(\n      (response) => {\n        printDebug('API Response', {\n          status: response.status,\n          statusText: response.statusText,\n          url: response.config.url,\n        });\n        return response;\n      },\n      (error: AxiosError) => this.handleError(error),\n    );\n  }\n\n  private handleError(error: AxiosError): Promise<never> {\n    if (error.response) {\n      const { status, statusText, data } = error.response;\n      const url = error.config?.url;\n\n      // The response body (`data`) can carry tokens/PII, and printError always writes\n      // (not gated on DEBUG) — keep it out of the always-on line; surface it only under DEBUG.\n      printError('API request failed', { status, statusText, url });\n      printDebug('API error response body', { data });\n\n      let message = `API request failed with status ${status}`;\n      if (data && typeof data === 'object' && 'message' in data && typeof (data as { message: unknown }).message === 'string') {\n        message = (data as { message: string }).message;\n      }\n      // A QUOTA refusal reads as what it is — which quota, how much, when it\n      // resets and where to raise it — not as a rate limit to wait out. A 429\n      // without the QUOTA_EXCEEDED code keeps the server's message.\n      if (status === 429) message = describeQuotaExceeded(data, this.config.api.baseUrl) ?? message;\n\n      return Promise.reject(new ApiError(message, status, error.response));\n    } else if (error.request) {\n      const code = error.code || 'UNKNOWN';\n      const url = error.config?.url;\n      const timeout = error.config?.timeout;\n      const cause = error.cause;\n\n      printError('No response received from API', {\n        url,\n        timeout,\n        code,\n        ...(cause instanceof Error ? { cause: cause.message } : {}),\n      });\n\n      const hints: Record<string, string> = {\n        ECONNREFUSED: 'Server is not running or port is wrong',\n        ECONNRESET: 'Server closed the connection unexpectedly',\n        ETIMEDOUT: 'Connection timed out — server unreachable or too slow',\n        ENOTFOUND: 'DNS lookup failed — check the hostname in baseUrl',\n        ERR_BAD_REQUEST: 'Request was malformed — check the endpoint and payload',\n        CERT_HAS_EXPIRED: 'SSL certificate expired — use --no-verify-ssl for dev',\n        DEPTH_ZERO_SELF_SIGNED_CERT: 'Self-signed certificate — set PLATFORM_CA_BUNDLE to its CA (PEM), or --no-verify-ssl for dev',\n        UNABLE_TO_VERIFY_LEAF_SIGNATURE: 'SSL chain incomplete — set PLATFORM_CA_BUNDLE to the issuing CA (PEM), or --no-verify-ssl for dev',\n        SELF_SIGNED_CERT_IN_CHAIN: 'Private CA in chain — set PLATFORM_CA_BUNDLE to that CA (PEM)',\n      };\n\n      const hint = hints[code] || 'Check network connectivity and server status';\n      const message = `${code}: ${hint} (url: ${url})`;\n\n      return Promise.reject(new NetworkError(message, url, error, timeout));\n    } else {\n      printError('API request error', { error: error.message });\n      return Promise.reject(error);\n    }\n  }\n\n  async get<T = unknown>(url: string, params?: Record<string, unknown>, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.get<T>(url, { params, headers });\n    return response.data;\n  }\n\n  /**\n   * A BINARY download (a report PDF): the bytes, plus the file name the server chose.\n   *\n   * `responseType: 'arraybuffer'` because the default would hand back a UTF-8 string and\n   * corrupt every byte above 0x7f — a PDF written that way opens as a damaged file, which\n   * looks like a server bug rather than a client one.\n   *\n   * The server's `Content-Disposition` name is preferred over anything the caller guesses:\n   * it knows the report's title and whether the run is a revision.\n   */\n  async getBinary(url: string, headers?: Record<string, string>): Promise<{ data: Buffer; filename?: string }> {\n    const response = await this.client.get<ArrayBuffer>(url, { headers, responseType: 'arraybuffer' });\n    const disposition = String(response.headers['content-disposition'] ?? '');\n    const match = /filename=\"([^\"]+)\"/.exec(disposition);\n    return {\n      data: Buffer.from(response.data),\n      ...(match?.[1] ? { filename: match[1] } : {}),\n    };\n  }\n\n  async post<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.post<T>(url, data, { headers });\n    return response.data;\n  }\n\n  async postForm<T = unknown>(url: string, formData: FormData, headers?: Record<string, string>): Promise<T> {\n    const uploadTimeout = this.config.api.uploadTimeout || 15 * 60 * 1000; // default 15 minutes\n    const response = await this.client.post<T>(url, formData, {\n      headers: { ...formData.getHeaders(), ...headers },\n      maxContentLength: Infinity,\n      maxBodyLength: Infinity,\n      timeout: uploadTimeout,\n    });\n    return response.data;\n  }\n\n  async put<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.put<T>(url, data, { headers });\n    return response.data;\n  }\n\n  async delete<T = unknown>(url: string, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.delete<T>(url, { headers });\n    return response.data;\n  }\n\n  async patch<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.patch<T>(url, data, { headers });\n    return response.data;\n  }\n\n  getConfig(): Config { return this.config; }\n  getBaseUrl(): string { return this.config.api.baseUrl; }\n  isAuthenticated(): boolean { return !!this.config.auth?.token; }\n\n  /**\n   * Advisory check: decode JWT exp claim and warn if expired.\n   * Does NOT verify signature — server handles that.\n   */\n  private checkTokenExpiry(token: string): void {\n    const payload = decodeTokenPayload(token);\n    if (payload && typeof payload.exp === 'number') {\n      const expiresAt = new Date(payload.exp * 1000);\n      if (expiresAt.getTime() < Date.now()) {\n        printWarning(`Token expired at ${expiresAt.toISOString()} — run \"pipeline-manager auth login\" to refresh`);\n      }\n    }\n  }\n}\n"]}

package/dist/utils/auth-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth-utils.d.ts","sourceRoot":"","sources":["../../src/utils/auth-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,aAAa,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAK/E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,KAAK,CAAC,KAAK,CAEhF;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,aAAa,CAAC,CAwBzB"}
+{"version":3,"file":"auth-utils.d.ts","sourceRoot":"","sources":["../../src/utils/auth-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAC;AAO1B;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,aAAa,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAK/E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,KAAK,CAAC,KAAK,CAEhF;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,aAAa,CAAC,CAyBzB"}

package/dist/utils/auth-utils.js

@@ -4,6 +4,7 @@ import https from 'https';
 import axios from 'axios';
 import { ERROR_CODES } from './error-handler.js';
 import { printDebug, printError, printSuccess } from './output-utils.js';
+import { requestCorrelationHeaders } from './request-context.js';
 import { isProductionEnv } from './tls.js';
 /**
  * Guard the credential-transmitting commands (`login`, `pat`) against disabling
@@ -48,6 +49,7 @@ export async function switchOrganization(params) {
             'Authorization': `Bearer ${params.accessToken}`,
             // Declares the body transport for the re-issued refresh token.
             'X-Pb-Client': 'cli',
+            ...requestCorrelationHeaders(),
         },
         httpsAgent: params.httpsAgent,
         timeout: params.timeout,
@@ -61,4 +63,4 @@ export async function switchOrganization(params) {
         printSuccess(`Switched to organization ${params.orgId}`);
     return switched;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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