@pipeline-builder/pipeline-events 4.0.10 → 4.0.12

package/lib/auth.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Trade the stored key for a short-lived platform token, cached per warm
+ * container until it is 80% through its life. Throws on any failure, which fails
+ * the batch so SQS retries it — an unauthenticated ship is never an option.
+ */
+export declare function getAuthToken(): Promise<string>;
+/**
+ * Drop everything the container holds about its credential after a 401/403 from
+ * the API: the token, and the KEY — the token-renew Lambda rotates the secret
+ * underneath us, so a warm container that only re-exchanged would keep
+ * presenting the retired key forever. An env-provided key cannot change without
+ * a new container, so it is kept.
+ */
+export declare function invalidateCredential(): void;

package/lib/auth.js

@@ -0,0 +1,99 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Reporting-API authentication. The stored credential is an OPAQUE
+ * service-account key (`pb_sa_…`), traded at platform for a short-lived JWT.
+ * Nothing is verified here: an opaque key has no claims and no signature, and
+ * the exchange re-reads the account, its org and the key's own state every time,
+ * which is what makes a revocation take effect within one token lifetime.
+ *
+ * Contract: cache the token in the warm container, refresh EARLY (before
+ * expiry) so a batch never presents a token that dies mid-flight, and fail the
+ * batch on an exchange failure rather than shipping events unauthenticated.
+ */
+import { createPlatformCredential } from '@pipeline-builder/pipeline-core/lib/handlers/platform-credential.js';
+import { log } from './util.js';
+/** Refresh at this fraction of the token's life — never at the last moment. */
+const TOKEN_REFRESH_FRACTION = 0.8;
+/** Floor on the cached lifetime, so a surprisingly short TTL can't cause a
+ *  refresh storm (one exchange per batch at worst). */
+const MIN_TOKEN_CACHE_MS = 30_000;
+/** Per-request timeout for the exchange call. */
+const EXCHANGE_TIMEOUT_MS = 5000;
+/**
+ * The service-account key: `PLATFORM_ACCESS_KEY` if set, otherwise the
+ * `password` field of the Secrets Manager secret named by `PLATFORM_SECRET_NAME`.
+ * A stored JWT is refused loudly, naming the fix, instead of failing later as an
+ * opaque 401 from the reporting API.
+ */
+const credential = createPlatformCredential({
+    secretName: () => process.env.PLATFORM_SECRET_NAME,
+    envKeyVar: 'PLATFORM_ACCESS_KEY',
+});
+let cachedToken = null;
+let cachedTokenExpiresAt = 0;
+/**
+ * Trade the stored key for a short-lived platform token, cached per warm
+ * container until it is 80% through its life. Throws on any failure, which fails
+ * the batch so SQS retries it — an unauthenticated ship is never an option.
+ */
+export async function getAuthToken() {
+    if (cachedToken && Date.now() < cachedTokenExpiresAt)
+        return cachedToken;
+    const baseUrl = (process.env.PLATFORM_BASE_URL || '').replace(/\/+$/, '');
+    if (!baseUrl)
+        throw new Error('PLATFORM_BASE_URL environment variable is required');
+    const key = await credential.getKey();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), EXCHANGE_TIMEOUT_MS);
+    let res;
+    try {
+        res = await fetch(`${baseUrl}/api/auth/token/exchange`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+            body: JSON.stringify({ key }),
+            signal: controller.signal,
+        });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!res.ok) {
+        // A rejected key is the one failure an operator has to act on, and platform
+        // deliberately answers every refusal the same way — so say what to check
+        // rather than echoing an undifferentiated 401.
+        if (res.status === 401 || res.status === 403) {
+            throw new Error(`Access-key exchange refused (${res.status}) — the stored key is unknown, revoked, expired, `
+                + 'its service account is disabled, or this address is outside the key’s IP allowlist');
+        }
+        throw new Error(`Access-key exchange failed: ${res.status}`);
+    }
+    const body = await res.json().catch(() => ({}));
+    const accessToken = body.data?.accessToken;
+    if (!accessToken)
+        throw new Error('Access-key exchange returned no access token');
+    const ttlMs = (typeof body.data?.expiresIn === 'number' && body.data.expiresIn > 0 ? body.data.expiresIn : 300) * 1000;
+    cachedToken = accessToken;
+    cachedTokenExpiresAt = Date.now() + Math.max(MIN_TOKEN_CACHE_MS, ttlMs * TOKEN_REFRESH_FRACTION);
+    log.info('Exchanged the stored service-account key for a platform token');
+    return accessToken;
+}
+/**
+ * Drop everything the container holds about its credential after a 401/403 from
+ * the API: the token, and the KEY — the token-renew Lambda rotates the secret
+ * underneath us, so a warm container that only re-exchanged would keep
+ * presenting the retired key forever. An env-provided key cannot change without
+ * a new container, so it is kept.
+ */
+export function invalidateCredential() {
+    cachedToken = null;
+    cachedTokenExpiresAt = 0;
+    credential.invalidate();
+}
+/** @internal Test-only: forget every cached credential. */
+export function _resetAuthForTests() {
+    cachedToken = null;
+    cachedTokenExpiresAt = 0;
+    credential.reset();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Reporting-API authentication. The stored credential is an OPAQUE\n * service-account key (`pb_sa_…`), traded at platform for a short-lived JWT.\n * Nothing is verified here: an opaque key has no claims and no signature, and\n * the exchange re-reads the account, its org and the key's own state every time,\n * which is what makes a revocation take effect within one token lifetime.\n *\n * Contract: cache the token in the warm container, refresh EARLY (before\n * expiry) so a batch never presents a token that dies mid-flight, and fail the\n * batch on an exchange failure rather than shipping events unauthenticated.\n */\n\nimport { createPlatformCredential } from '@pipeline-builder/pipeline-core/lib/handlers/platform-credential.js';\nimport { log } from './util.js';\n\n/** Refresh at this fraction of the token's life — never at the last moment. */\nconst TOKEN_REFRESH_FRACTION = 0.8;\n/** Floor on the cached lifetime, so a surprisingly short TTL can't cause a\n *  refresh storm (one exchange per batch at worst). */\nconst MIN_TOKEN_CACHE_MS = 30_000;\n/** Per-request timeout for the exchange call. */\nconst EXCHANGE_TIMEOUT_MS = 5000;\n\n/**\n * The service-account key: `PLATFORM_ACCESS_KEY` if set, otherwise the\n * `password` field of the Secrets Manager secret named by `PLATFORM_SECRET_NAME`.\n * A stored JWT is refused loudly, naming the fix, instead of failing later as an\n * opaque 401 from the reporting API.\n */\nconst credential = createPlatformCredential({\n  secretName: () => process.env.PLATFORM_SECRET_NAME,\n  envKeyVar: 'PLATFORM_ACCESS_KEY',\n});\n\nlet cachedToken: string | null = null;\nlet cachedTokenExpiresAt = 0;\n\n/**\n * Trade the stored key for a short-lived platform token, cached per warm\n * container until it is 80% through its life. Throws on any failure, which fails\n * the batch so SQS retries it — an unauthenticated ship is never an option.\n */\nexport async function getAuthToken(): Promise<string> {\n  if (cachedToken && Date.now() < cachedTokenExpiresAt) return cachedToken;\n\n  const baseUrl = (process.env.PLATFORM_BASE_URL || '').replace(/\\/+$/, '');\n  if (!baseUrl) throw new Error('PLATFORM_BASE_URL environment variable is required');\n  const key = await credential.getKey();\n\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), EXCHANGE_TIMEOUT_MS);\n  let res: Response;\n  try {\n    res = await fetch(`${baseUrl}/api/auth/token/exchange`, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },\n      body: JSON.stringify({ key }),\n      signal: controller.signal,\n    });\n  } finally {\n    clearTimeout(timer);\n  }\n\n  if (!res.ok) {\n    // A rejected key is the one failure an operator has to act on, and platform\n    // deliberately answers every refusal the same way — so say what to check\n    // rather than echoing an undifferentiated 401.\n    if (res.status === 401 || res.status === 403) {\n      throw new Error(\n        `Access-key exchange refused (${res.status}) — the stored key is unknown, revoked, expired, `\n        + 'its service account is disabled, or this address is outside the key’s IP allowlist',\n      );\n    }\n    throw new Error(`Access-key exchange failed: ${res.status}`);\n  }\n\n  const body = await res.json().catch(() => ({})) as { data?: { accessToken?: string; expiresIn?: number } };\n  const accessToken = body.data?.accessToken;\n  if (!accessToken) throw new Error('Access-key exchange returned no access token');\n\n  const ttlMs = (typeof body.data?.expiresIn === 'number' && body.data.expiresIn > 0 ? body.data.expiresIn : 300) * 1000;\n  cachedToken = accessToken;\n  cachedTokenExpiresAt = Date.now() + Math.max(MIN_TOKEN_CACHE_MS, ttlMs * TOKEN_REFRESH_FRACTION);\n  log.info('Exchanged the stored service-account key for a platform token');\n  return accessToken;\n}\n\n/**\n * Drop everything the container holds about its credential after a 401/403 from\n * the API: the token, and the KEY — the token-renew Lambda rotates the secret\n * underneath us, so a warm container that only re-exchanged would keep\n * presenting the retired key forever. An env-provided key cannot change without\n * a new container, so it is kept.\n */\nexport function invalidateCredential(): void {\n  cachedToken = null;\n  cachedTokenExpiresAt = 0;\n  credential.invalidate();\n}\n\n/** @internal Test-only: forget every cached credential. */\nexport function _resetAuthForTests(): void {\n  cachedToken = null;\n  cachedTokenExpiresAt = 0;\n  credential.reset();\n}\n"]}

package/lib/health.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Throttled, best-effort post-success work: emit per-org ingest-health and self-heal
+ * the DLQ. Never throws. `forwarded`/`lastEventAt` accumulate PER ORG across batches
+ * between health posts; `dropped` is the shared fleet DLQ depth snapshot. A per-org
+ * counter is zeroed only after that org's health POST is confirmed 2xx.
+ */
+export declare function reportHealthAndRedrive(baseUrl: string, mainQueueArn: string | undefined): Promise<void>;
+/** Count a forwarded batch toward each resolved org's delivery-health report. */
+export declare function recordForwarded(events: ReadonlyArray<{
+    orgId: string | null;
+    completedAt?: string;
+    startedAt?: string;
+}>): void;

package/lib/health.js

@@ -0,0 +1,191 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { getAuthToken } from './auth.js';
+import { BoundedMap, CACHE_MAX_ENTRIES, loadSdk, log } from './util.js';
+let sqsMod;
+let sqsClientsByRegion;
+async function sqsClient(region) {
+    if (!sqsMod)
+        sqsMod = await loadSdk('@aws-sdk/client-sqs');
+    if (!sqsClientsByRegion)
+        sqsClientsByRegion = new Map();
+    let client = sqsClientsByRegion.get(region);
+    if (!client) {
+        client = new sqsMod.SQSClient({ region });
+        sqsClientsByRegion.set(region, client);
+    }
+    return client;
+}
+// Delivery-health counters are attributed PER RESOLVED ORG (the forwarder is a fleet
+// Lambda serving many orgs; a single global counter would mis-attribute one org's
+// throughput to another). Keyed by orgId ('' bucket = pipeline with no OrgId tag).
+// The DLQ depth (`dropped`) is genuinely fleet-global — one shared DLQ — so it is a
+// single snapshot posted alongside each org's health, documented as the shared depth.
+const forwardedByOrg = new BoundedMap(CACHE_MAX_ENTRIES);
+const lastEventAtByOrg = new BoundedMap(CACHE_MAX_ENTRIES);
+let lastHealthAt = 0;
+let lastRedriveAt = 0;
+const HEALTH_THROTTLE_MS = 60 * 1000;
+const REDRIVE_THROTTLE_MS = 5 * 60 * 1000;
+// Poison-message ceiling: if the oldest DLQ message is older than this, we STOP
+// redriving it (DLQ→main→fail→DLQ would loop forever). Such messages are left for an
+// alarm / manual inspection instead of churning the fleet indefinitely.
+const MAX_DLQ_REDRIVE_AGE_SEC = 6 * 60 * 60; // 6 hours
+/** Parse the SQS trigger ARN and derive the main + DLQ ARNs and the DLQ URL. */
+function deriveQueues(mainQueueArn) {
+    if (!mainQueueArn)
+        return undefined;
+    // arn:aws:sqs:{region}:{account}:{name}
+    const parts = mainQueueArn.split(':');
+    if (parts.length < 6 || parts[2] !== 'sqs')
+        return undefined;
+    const [, , , region, account, name] = parts;
+    const dlqArn = process.env.EVENT_DLQ_ARN || `arn:aws:sqs:${region}:${account}:${name}-dlq`;
+    const dlqName = dlqArn.split(':').pop() ?? `${name}-dlq`;
+    const dlqUrl = `https://sqs.${region}.amazonaws.com/${account}/${dlqName}`;
+    return { region, mainArn: mainQueueArn, dlqArn, dlqUrl };
+}
+/** Snapshot the DLQ depth + the age (seconds) of its oldest message (for the
+ *  poison-message redrive ceiling). Missing/NaN attributes fall back to 0. */
+async function dlqStats(region, dlqUrl) {
+    if (!sqsMod)
+        sqsMod = await loadSdk('@aws-sdk/client-sqs');
+    const client = await sqsClient(region);
+    const out = await client.send(new sqsMod.GetQueueAttributesCommand({
+        QueueUrl: dlqUrl,
+        AttributeNames: ['ApproximateNumberOfMessages', 'ApproximateAgeOfOldestMessage'],
+    }));
+    const n = Number(out.Attributes?.ApproximateNumberOfMessages ?? '0');
+    const age = Number(out.Attributes?.ApproximateAgeOfOldestMessage ?? '0');
+    return {
+        depth: Number.isFinite(n) ? n : 0,
+        oldestAgeSec: Number.isFinite(age) ? age : 0,
+    };
+}
+async function hasActiveMoveTask(region, dlqArn) {
+    if (!sqsMod)
+        sqsMod = await loadSdk('@aws-sdk/client-sqs');
+    const client = await sqsClient(region);
+    const out = await client.send(new sqsMod.ListMessageMoveTasksCommand({ SourceArn: dlqArn }));
+    return (out.Results ?? []).some(t => t.Status === 'RUNNING');
+}
+async function startMoveTask(region, dlqArn, mainArn) {
+    if (!sqsMod)
+        sqsMod = await loadSdk('@aws-sdk/client-sqs');
+    const client = await sqsClient(region);
+    await client.send(new sqsMod.StartMessageMoveTaskCommand({ SourceArn: dlqArn, DestinationArn: mainArn }));
+}
+/** POST one org's ingest-health signal. Returns true only on a confirmed 2xx so the
+ *  caller resets that org's `forwarded` counter ONLY when the signal was accepted
+ *  (a dropped/failed POST must not silently zero the accumulated count). */
+async function postIngestHealth(baseUrl, body) {
+    try {
+        const token = await getAuthToken();
+        const res = await fetch(`${baseUrl}/api/reports/ingest-health`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            log.warn('ingest-health POST returned non-2xx (ignored)', { status: res.status, orgId: body.orgId });
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        log.warn('ingest-health POST failed (ignored)', { error: String(err), orgId: body.orgId });
+        return false;
+    }
+}
+/**
+ * Throttled, best-effort post-success work: emit per-org ingest-health and self-heal
+ * the DLQ. Never throws. `forwarded`/`lastEventAt` accumulate PER ORG across batches
+ * between health posts; `dropped` is the shared fleet DLQ depth snapshot. A per-org
+ * counter is zeroed only after that org's health POST is confirmed 2xx.
+ */
+export async function reportHealthAndRedrive(baseUrl, mainQueueArn) {
+    const now = Date.now();
+    if (now - lastHealthAt < HEALTH_THROTTLE_MS)
+        return;
+    lastHealthAt = now;
+    try {
+        const q = deriveQueues(mainQueueArn);
+        let depth = 0;
+        let oldestAgeSec = 0;
+        if (q) {
+            try {
+                const stats = await dlqStats(q.region, q.dlqUrl);
+                depth = stats.depth;
+                oldestAgeSec = stats.oldestAgeSec;
+            }
+            catch (err) {
+                log.warn('DLQ stats check failed (ignored)', { error: err?.name ?? String(err) });
+            }
+        }
+        // Post one health signal per resolved org, attributing its own forwarded count +
+        // last event time. `dropped` (the shared fleet DLQ depth) rides along on each.
+        // Snapshot the keys first so we don't mutate the map while iterating.
+        const orgKeys = new Set([...forwardedByOrg.keys(), ...lastEventAtByOrg.keys()]);
+        if (orgKeys.size === 0)
+            orgKeys.add(''); // nothing forwarded yet → still report depth
+        for (const key of orgKeys) {
+            const forwarded = forwardedByOrg.get(key) ?? 0;
+            const lastEventAt = lastEventAtByOrg.get(key);
+            const ok = await postIngestHealth(baseUrl, {
+                ...(key ? { orgId: key } : {}),
+                forwarded,
+                dropped: depth,
+                lastEventAt,
+            });
+            // Reset the forwarded counter ONLY on a confirmed 2xx — a failed/dropped POST
+            // keeps the count so the next tick re-reports it instead of losing it.
+            if (ok)
+                forwardedByOrg.set(key, 0);
+        }
+        if (q && depth > 0 && now - lastRedriveAt >= REDRIVE_THROTTLE_MS) {
+            // Poison-message ceiling: never redrive a DLQ whose oldest message has aged
+            // past the ceiling — that message keeps failing and would loop DLQ→main→DLQ.
+            if (oldestAgeSec > MAX_DLQ_REDRIVE_AGE_SEC) {
+                log.warn('DLQ oldest message exceeds poison-age ceiling — skipping redrive (needs manual attention)', {
+                    dlqArn: q.dlqArn, dropped: depth, oldestAgeSec, ceilingSec: MAX_DLQ_REDRIVE_AGE_SEC,
+                });
+            }
+            else {
+                try {
+                    if (!(await hasActiveMoveTask(q.region, q.dlqArn))) {
+                        lastRedriveAt = now;
+                        await startMoveTask(q.region, q.dlqArn, q.mainArn);
+                        log.info('Started self-healing DLQ→main redrive', { dlqArn: q.dlqArn, dropped: depth, oldestAgeSec });
+                    }
+                }
+                catch (err) {
+                    log.warn('DLQ redrive failed (ignored)', { error: err?.name ?? String(err) });
+                }
+            }
+        }
+    }
+    catch (err) {
+        log.warn('health/redrive step failed (ignored)', { error: String(err) });
+    }
+}
+/** Count a forwarded batch toward each resolved org's delivery-health report. */
+export function recordForwarded(events) {
+    for (const e of events) {
+        const key = e.orgId ?? '';
+        forwardedByOrg.set(key, (forwardedByOrg.get(key) ?? 0) + 1);
+        const at = e.completedAt || e.startedAt;
+        if (at) {
+            const prev = lastEventAtByOrg.get(key);
+            if (!prev || at > prev)
+                lastEventAtByOrg.set(key, at);
+        }
+    }
+}
+/** @internal Test-only: forget health counters and throttles. */
+export function _resetHealthForTests() {
+    forwardedByOrg.clear();
+    lastEventAtByOrg.clear();
+    lastHealthAt = 0;
+    lastRedriveAt = 0;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"health.js","sourceRoot":"","sources":["../src/health.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { getAuthToken } from './auth.js';\nimport { BoundedMap, CACHE_MAX_ENTRIES, loadSdk, log } from './util.js';\n\n// Delivery health + self-healing DLQ redrive.\n// After a SUCCESSFUL batch POST we (throttled, best-effort):\n//   1. POST an ingest-health signal to /api/reports/ingest-health so the Reports UI\n//      can show flowing / stale / dropping.\n//   2. If the DLQ is non-empty, no move task is already running, AND the oldest DLQ\n//      message is younger than the poison-age ceiling, kick off an SQS\n//      MessageMoveTask (DLQ → main queue) so retryable failures self-heal without a\n//      new AWS service. The reporting ingest's partial-unique index dedupes any\n//      redelivered event, so a redrive can't double-count.\n// Guards: only on success, one-at-a-time (ListMessageMoveTasks), a poison-age ceiling\n// (so a message that always fails can't loop DLQ→main→DLQ forever), and throttled via\n// module timestamps. NEVER throws — a failure here must not fail the batch.\n//\n// IAM required (document only — granted on the events stack):\n//   sqs:GetQueueAttributes, sqs:ListMessageMoveTasks, sqs:StartMessageMoveTask (on the DLQ)\n\ninterface SqsClientLike { send(command: unknown): Promise<unknown> }\ninterface SqsModule {\n  SQSClient: new (config: { region: string }) => SqsClientLike;\n  GetQueueAttributesCommand: new (input: { QueueUrl: string; AttributeNames: string[] }) => unknown;\n  ListMessageMoveTasksCommand: new (input: { SourceArn: string }) => unknown;\n  StartMessageMoveTaskCommand: new (input: { SourceArn: string; DestinationArn?: string }) => unknown;\n}\nlet sqsMod: SqsModule | undefined;\nlet sqsClientsByRegion: Map<string, SqsClientLike> | undefined;\nasync function sqsClient(region: string): Promise<SqsClientLike> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  if (!sqsClientsByRegion) sqsClientsByRegion = new Map();\n  let client = sqsClientsByRegion.get(region);\n  if (!client) {\n    client = new sqsMod.SQSClient({ region });\n    sqsClientsByRegion.set(region, client);\n  }\n  return client;\n}\n\n// Delivery-health counters are attributed PER RESOLVED ORG (the forwarder is a fleet\n// Lambda serving many orgs; a single global counter would mis-attribute one org's\n// throughput to another). Keyed by orgId ('' bucket = pipeline with no OrgId tag).\n// The DLQ depth (`dropped`) is genuinely fleet-global — one shared DLQ — so it is a\n// single snapshot posted alongside each org's health, documented as the shared depth.\nconst forwardedByOrg = new BoundedMap<string, number>(CACHE_MAX_ENTRIES);\nconst lastEventAtByOrg = new BoundedMap<string, string>(CACHE_MAX_ENTRIES);\nlet lastHealthAt = 0;\nlet lastRedriveAt = 0;\nconst HEALTH_THROTTLE_MS = 60 * 1000;\nconst REDRIVE_THROTTLE_MS = 5 * 60 * 1000;\n// Poison-message ceiling: if the oldest DLQ message is older than this, we STOP\n// redriving it (DLQ→main→fail→DLQ would loop forever). Such messages are left for an\n// alarm / manual inspection instead of churning the fleet indefinitely.\nconst MAX_DLQ_REDRIVE_AGE_SEC = 6 * 60 * 60; // 6 hours\n\n/** Parse the SQS trigger ARN and derive the main + DLQ ARNs and the DLQ URL. */\nfunction deriveQueues(mainQueueArn: string | undefined): { region: string; mainArn: string; dlqArn: string; dlqUrl: string } | undefined {\n  if (!mainQueueArn) return undefined;\n  // arn:aws:sqs:{region}:{account}:{name}\n  const parts = mainQueueArn.split(':');\n  if (parts.length < 6 || parts[2] !== 'sqs') return undefined;\n  const [, , , region, account, name] = parts;\n  const dlqArn = process.env.EVENT_DLQ_ARN || `arn:aws:sqs:${region}:${account}:${name}-dlq`;\n  const dlqName = dlqArn.split(':').pop() ?? `${name}-dlq`;\n  const dlqUrl = `https://sqs.${region}.amazonaws.com/${account}/${dlqName}`;\n  return { region, mainArn: mainQueueArn, dlqArn, dlqUrl };\n}\n\n/** Snapshot the DLQ depth + the age (seconds) of its oldest message (for the\n *  poison-message redrive ceiling). Missing/NaN attributes fall back to 0. */\nasync function dlqStats(region: string, dlqUrl: string): Promise<{ depth: number; oldestAgeSec: number }> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  const client = await sqsClient(region);\n  const out = await client.send(new sqsMod.GetQueueAttributesCommand({\n    QueueUrl: dlqUrl,\n    AttributeNames: ['ApproximateNumberOfMessages', 'ApproximateAgeOfOldestMessage'],\n  })) as { Attributes?: { ApproximateNumberOfMessages?: string; ApproximateAgeOfOldestMessage?: string } };\n  const n = Number(out.Attributes?.ApproximateNumberOfMessages ?? '0');\n  const age = Number(out.Attributes?.ApproximateAgeOfOldestMessage ?? '0');\n  return {\n    depth: Number.isFinite(n) ? n : 0,\n    oldestAgeSec: Number.isFinite(age) ? age : 0,\n  };\n}\n\nasync function hasActiveMoveTask(region: string, dlqArn: string): Promise<boolean> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  const client = await sqsClient(region);\n  const out = await client.send(new sqsMod.ListMessageMoveTasksCommand({ SourceArn: dlqArn })) as {\n    Results?: Array<{ Status?: string }>;\n  };\n  return (out.Results ?? []).some(t => t.Status === 'RUNNING');\n}\n\nasync function startMoveTask(region: string, dlqArn: string, mainArn: string): Promise<void> {\n  if (!sqsMod) sqsMod = await loadSdk<SqsModule>('@aws-sdk/client-sqs');\n  const client = await sqsClient(region);\n  await client.send(new sqsMod.StartMessageMoveTaskCommand({ SourceArn: dlqArn, DestinationArn: mainArn }));\n}\n\n/** POST one org's ingest-health signal. Returns true only on a confirmed 2xx so the\n *  caller resets that org's `forwarded` counter ONLY when the signal was accepted\n *  (a dropped/failed POST must not silently zero the accumulated count). */\nasync function postIngestHealth(baseUrl: string, body: { orgId?: string; forwarded: number; dropped: number; lastEventAt?: string }): Promise<boolean> {\n  try {\n    const token = await getAuthToken();\n    const res = await fetch(`${baseUrl}/api/reports/ingest-health`, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },\n      body: JSON.stringify(body),\n    });\n    if (!res.ok) {\n      log.warn('ingest-health POST returned non-2xx (ignored)', { status: res.status, orgId: body.orgId });\n      return false;\n    }\n    return true;\n  } catch (err) {\n    log.warn('ingest-health POST failed (ignored)', { error: String(err), orgId: body.orgId });\n    return false;\n  }\n}\n\n/**\n * Throttled, best-effort post-success work: emit per-org ingest-health and self-heal\n * the DLQ. Never throws. `forwarded`/`lastEventAt` accumulate PER ORG across batches\n * between health posts; `dropped` is the shared fleet DLQ depth snapshot. A per-org\n * counter is zeroed only after that org's health POST is confirmed 2xx.\n */\nexport async function reportHealthAndRedrive(baseUrl: string, mainQueueArn: string | undefined): Promise<void> {\n  const now = Date.now();\n  if (now - lastHealthAt < HEALTH_THROTTLE_MS) return;\n  lastHealthAt = now;\n  try {\n    const q = deriveQueues(mainQueueArn);\n    let depth = 0;\n    let oldestAgeSec = 0;\n    if (q) {\n      try {\n        const stats = await dlqStats(q.region, q.dlqUrl);\n        depth = stats.depth;\n        oldestAgeSec = stats.oldestAgeSec;\n      } catch (err) {\n        log.warn('DLQ stats check failed (ignored)', { error: (err as { name?: string })?.name ?? String(err) });\n      }\n    }\n\n    // Post one health signal per resolved org, attributing its own forwarded count +\n    // last event time. `dropped` (the shared fleet DLQ depth) rides along on each.\n    // Snapshot the keys first so we don't mutate the map while iterating.\n    const orgKeys = new Set([...forwardedByOrg.keys(), ...lastEventAtByOrg.keys()]);\n    if (orgKeys.size === 0) orgKeys.add(''); // nothing forwarded yet → still report depth\n    for (const key of orgKeys) {\n      const forwarded = forwardedByOrg.get(key) ?? 0;\n      const lastEventAt = lastEventAtByOrg.get(key);\n      const ok = await postIngestHealth(baseUrl, {\n        ...(key ? { orgId: key } : {}),\n        forwarded,\n        dropped: depth,\n        lastEventAt,\n      });\n      // Reset the forwarded counter ONLY on a confirmed 2xx — a failed/dropped POST\n      // keeps the count so the next tick re-reports it instead of losing it.\n      if (ok) forwardedByOrg.set(key, 0);\n    }\n\n    if (q && depth > 0 && now - lastRedriveAt >= REDRIVE_THROTTLE_MS) {\n      // Poison-message ceiling: never redrive a DLQ whose oldest message has aged\n      // past the ceiling — that message keeps failing and would loop DLQ→main→DLQ.\n      if (oldestAgeSec > MAX_DLQ_REDRIVE_AGE_SEC) {\n        log.warn('DLQ oldest message exceeds poison-age ceiling — skipping redrive (needs manual attention)', {\n          dlqArn: q.dlqArn, dropped: depth, oldestAgeSec, ceilingSec: MAX_DLQ_REDRIVE_AGE_SEC,\n        });\n      } else {\n        try {\n          if (!(await hasActiveMoveTask(q.region, q.dlqArn))) {\n            lastRedriveAt = now;\n            await startMoveTask(q.region, q.dlqArn, q.mainArn);\n            log.info('Started self-healing DLQ→main redrive', { dlqArn: q.dlqArn, dropped: depth, oldestAgeSec });\n          }\n        } catch (err) {\n          log.warn('DLQ redrive failed (ignored)', { error: (err as { name?: string })?.name ?? String(err) });\n        }\n      }\n    }\n  } catch (err) {\n    log.warn('health/redrive step failed (ignored)', { error: String(err) });\n  }\n}\n\n/** Count a forwarded batch toward each resolved org's delivery-health report. */\nexport function recordForwarded(events: ReadonlyArray<{ orgId: string | null; completedAt?: string; startedAt?: string }>): void {\n  for (const e of events) {\n    const key = e.orgId ?? '';\n    forwardedByOrg.set(key, (forwardedByOrg.get(key) ?? 0) + 1);\n    const at = e.completedAt || e.startedAt;\n    if (at) {\n      const prev = lastEventAtByOrg.get(key);\n      if (!prev || at > prev) lastEventAtByOrg.set(key, at);\n    }\n  }\n}\n\n/** @internal Test-only: forget health counters and throttles. */\nexport function _resetHealthForTests(): void {\n  forwardedByOrg.clear();\n  lastEventAtByOrg.clear();\n  lastHealthAt = 0;\n  lastRedriveAt = 0;\n}\n"]}

package/lib/index.d.ts

@@ -1,2 +1,27 @@
 import type { SQSEvent } from 'aws-lambda';
+/**
+ * Pipeline event ingestion Lambda handler.
+ *
+ * Receives CodePipeline/CodeBuild events from SQS (sourced by EventBridge),
+ * parses them into a normalized format, and POSTs them to the reporting service
+ * via PLATFORM_BASE_URL.
+ *
+ * Authentication (service-account keys):
+ * The Lambda holds an opaque SERVICE-ACCOUNT KEY (`pb_sa_…`), never a JWT, and
+ * trades it at platform's `/auth/token/exchange` for a 5-minute token per batch.
+ * It verifies NOTHING locally: an opaque key carries no claims to check, and the
+ * exchange is the authority (a revoked key stops working within one token
+ * lifetime, which is the entire point of the shape). The key is minted by
+ * `pipeline-manager infra store-token` and rotated in place by the token-renew
+ * Lambda, so the secret's value changes underneath a warm container — which is
+ * why an auth failure re-reads the SECRET, not just the token.
+ *
+ * Environment variables:
+ * - PLATFORM_BASE_URL — Base URL of the platform
+ * - PLATFORM_ACCESS_KEY — the `pb_sa_…` key set directly (no Secrets Manager call), or
+ * - PLATFORM_SECRET_NAME — Secrets Manager secret containing { password: <pb_sa_ key> }
+ * - EVENT_DLQ_ARN — (optional) override for the dead-letter queue ARN used by the
+ *   self-healing redrive; defaults to `<main-queue-arn>-dlq` derived from the SQS
+ *   trigger's eventSourceARN.
+ */
 export declare const handler: (event: SQSEvent) => Promise<void>;