@pipeline-builder/api-core 4.1.13 → 4.1.15

package/lib/services/sse-ticket-store.js

@@ -2,15 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 import crypto from 'crypto';
 import { createEnvRedisClient, createRedisReadyGate } from './env-redis.js';
+import { envInt } from '../utils/env.js';
 import { createLogger } from '../utils/logger.js';
 import { errorMessage } from '../utils/response.js';
 const logger = createLogger('sse-ticket-store');
 function newTicketId() {
     return crypto.randomBytes(24).toString('base64url');
 }
-function errMsg(err) {
-    return errorMessage(err);
-}
 /** In-memory backend — single-process fallback when Redis isn't configured. */
 export function createMemorySseTicketStore(config) {
     const tickets = new Map();
@@ -117,7 +115,7 @@ export function createRedisSseTicketStore(redis, config) {
                 return { ok: false, reason: outcome === 'org' ? 'org' : 'total' };
             }
             catch (err) {
-                logger.warn('SSE ticket issue failed (fail-closed)', { error: errMsg(err) });
+                logger.warn('SSE ticket issue failed (fail-closed)', { error: errorMessage(err) });
                 return { ok: false, reason: 'total' };
             }
         },
@@ -133,11 +131,11 @@ export function createRedisSseTicketStore(redis, config) {
                 // Free the live-count slots now rather than at expiry. Best-effort: a
                 // failure here only delays the slot until the member's expiry score.
                 await Promise.all([redis.zrem(orgSetKey(rec.orgId), ticketId), redis.zrem(totalSetKey, ticketId)])
-                    .catch((err) => logger.debug('SSE ticket slot release failed', { error: errMsg(err) }));
+                    .catch((err) => logger.debug('SSE ticket slot release failed', { error: errorMessage(err) }));
                 return rec;
             }
             catch (err) {
-                logger.warn('SSE ticket consume failed (fail-closed)', { error: errMsg(err) });
+                logger.warn('SSE ticket consume failed (fail-closed)', { error: errorMessage(err) });
                 return null;
             }
         },
@@ -147,7 +145,7 @@ export function createRedisSseTicketStore(redis, config) {
                 await redis.set(ownerKey(subject), orgId, 'PX', Math.max(1, Math.ceil(ownerTtlMs)));
             }
             catch (err) {
-                logger.warn('SSE stream-owner bind failed', { error: errMsg(err) });
+                logger.warn('SSE stream-owner bind failed', { error: errorMessage(err) });
             }
         },
         async getOwner(subject) {
@@ -157,12 +155,29 @@ export function createRedisSseTicketStore(redis, config) {
         stop() { },
     };
 }
+/**
+ * The deploy-wide ticket caps: `SSE_MAX_TOTAL_TICKETS` (default 1000) and
+ * `SSE_MAX_TICKETS_PER_ORG` (default 10). One reader so every channel parses
+ * them the same way.
+ */
+export function envSseTicketCaps() {
+    return {
+        maxTotal: envInt('SSE_MAX_TOTAL_TICKETS', 1000, { min: 1 }),
+        maxPerOrg: envInt('SSE_MAX_TICKETS_PER_ORG', 10, { min: 1 }),
+    };
+}
 /**
  * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or
  * `REDIS_SENTINELS`): the Redis backend when configured (multi-replica safe),
  * otherwise the in-memory single-process backend.
  */
-export function createEnvSseTicketStore(config) {
+export function createEnvSseTicketStore(options) {
+    const caps = envSseTicketCaps();
+    const config = {
+        ...options,
+        maxTotal: options.maxTotal ?? caps.maxTotal,
+        maxPerOrg: options.maxPerOrg ?? caps.maxPerOrg,
+    };
     const redis = createEnvRedisClient('sse-ticket');
     if (redis) {
         logger.info('SSE ticket store: Redis backend (multi-replica)', { keyPrefix: config.keyPrefix });
@@ -171,4 +186,4 @@ export function createEnvSseTicketStore(config) {
     logger.info('SSE ticket store: in-memory backend (single-process fallback)', { keyPrefix: config.keyPrefix });
     return createMemorySseTicketStore(config);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-ticket-store.js","sourceRoot":"","sources":["../../src/services/sse-ticket-store.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAwB,MAAM,gBAAgB,CAAC;AAClG,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,MAAM,MAAM,GAAG,YAAY,CAAC,kBAAkB,CAAC,CAAC;AA6DhD,SAAS,WAAW;IAClB,OAAO,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AACtD,CAAC;AAED,SAAS,MAAM,CAAC,GAAY;IAC1B,OAAO,YAAY,CAAC,GAAG,CAAC,CAAC;AAC3B,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,0BAA0B,CAAC,MAA4B;IAErE,MAAM,OAAO,GAAG,IAAI,GAAG,EAAiB,CAAC;IACzC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAgD,CAAC;IAEvE,MAAM,KAAK,GAAG,GAAS,EAAE;QACvB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,KAAK,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,OAAO;YAAE,IAAI,GAAG,IAAI,CAAC,CAAC,SAAS;gBAAE,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAC1E,KAAK,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,MAAM;YAAE,IAAI,GAAG,IAAI,CAAC,CAAC,SAAS;gBAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAC1E,CAAC,CAAC;IACF,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IAChE,KAAK,CAAC,KAAK,EAAE,CAAC;IAEd,OAAO;QACL,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO;YACxB,KAAK,EAAE,CAAC;YACR,IAAI,OAAO,CAAC,IAAI,IAAI,MAAM,CAAC,QAAQ;gBAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;YAC3E,IAAI,MAAM,GAAG,CAAC,CAAC;YACf,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,MAAM,EAAE;gBAAE,IAAI,CAAC,CAAC,KAAK,KAAK,KAAK;oBAAE,MAAM,EAAE,CAAC;YAClE,IAAI,MAAM,IAAI,MAAM,CAAC,SAAS;gBAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;YACpE,MAAM,MAAM,GAAG,WAAW,EAAE,CAAC;YAC7B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;YAChH,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAC9B,CAAC;QACD,KAAK,CAAC,OAAO,CAAC,QAAQ;YACpB,MAAM,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAChC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,gDAAgD;YAC1E,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,SAAS;gBAAE,OAAO,IAAI,CAAC;YACjD,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC;QACpF,CAAC;QACD,KAAK,CAAC,SAAS,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK;YACnC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;QAChE,CAAC;QACD,KAAK,CAAC,QAAQ,CAAC,OAAO;YACpB,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAC9B,IAAI,CAAC,CAAC;gBAAE,OAAO,IAAI,CAAC;YACpB,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,SAAS,EAAE,CAAC;gBAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;gBAAC,OAAO,IAAI,CAAC;YAAC,CAAC;YACvE,OAAO,CAAC,CAAC,KAAK,CAAC;QACjB,CAAC;QACD,IAAI,KAAK,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;KACjC,CAAC;AACJ,CAAC;AAWD;;;;;;;;;GASG;AACH,MAAM,YAAY,GAAG;;;;;;;;;;;;;YAaT,CAAC;AAEb;;;;;;GAMG;AACH,MAAM,UAAU,yBAAyB,CAAC,KAAqB,EAAE,MAA4B;IAC3F,MAAM,EAAE,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1D,MAAM,SAAS,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE,CAAC;IACpD,MAAM,SAAS,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,GAAG,EAAE,eAAe,CAAC,EAAE,CAAC;IACzD,MAAM,WAAW,GAAG,GAAG,EAAE,aAAa,CAAC;IACvC,MAAM,QAAQ,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,GAAG,EAAE,aAAa,CAAC,EAAE,CAAC;IACtD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACnD,+EAA+E;IAC/E,+DAA+D;IAC/D,MAAM,KAAK,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAE1C,OAAO;QACL,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO;YACxB,IAAI,CAAC;gBACH,MAAM,KAAK,EAAE,CAAC;gBACd,MAAM,MAAM,GAAG,WAAW,EAAE,CAAC;gBAC7B,MAAM,MAAM,GAAoB,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;gBACrF,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,IAAI,CAC9B,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,EACjE,KAAK,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CACzE,CAAC;gBACF,IAAI,OAAO,KAAK,IAAI;oBAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;gBAClD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;YACpE,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,IAAI,CAAC,uCAAuC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBAC7E,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;YACxC,CAAC;QACH,CAAC;QACD,KAAK,CAAC,OAAO,CAAC,QAAQ;YACpB,IAAI,CAAC;gBACH,MAAM,KAAK,EAAE,CAAC;gBACd,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;gBACpD,IAAI,CAAC,GAAG;oBAAE,OAAO,IAAI,CAAC;gBACtB,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAoB,CAAC;gBAC/C,IAAI,OAAO,GAAG,EAAE,KAAK,KAAK,QAAQ;oBAAE,OAAO,IAAI,CAAC;gBAChD,sEAAsE;gBACtE,qEAAqE;gBACrE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;qBAC/F,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;gBACnG,OAAO,GAAG,CAAC;YACb,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,IAAI,CAAC,yCAAyC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBAC/E,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QACD,KAAK,CAAC,SAAS,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU;YACxC,IAAI,CAAC;gBACH,MAAM,KAAK,EAAE,CAAC;gBACd,MAAM,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YACtF,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,IAAI,CAAC,8BAA8B,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACtE,CAAC;QACH,CAAC;QACD,KAAK,CAAC,QAAQ,CAAC,OAAO;YACpB,MAAM,KAAK,EAAE,CAAC;YACd,OAAO,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;QACtC,CAAC;QACD,IAAI,KAAwC,CAAC;KAC9C,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,MAA4B;IAClE,MAAM,KAAK,GAAG,oBAAoB,CAAiB,YAAY,CAAC,CAAC;IACjE,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,CAAC,IAAI,CAAC,iDAAiD,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;QAChG,OAAO,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAClD,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,+DAA+D,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;IAC9G,OAAO,0BAA0B,CAAC,MAAM,CAAC,CAAC;AAC5C,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport crypto from 'crypto';\n\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { errorMessage } from '../utils/response.js';\n\nconst logger = createLogger('sse-ticket-store');\n\n/** What a ticket authorizes: the owning org and, for subject-bound channels, the stream subject. */\nexport interface SseTicketRecord {\n  orgId: string;\n  /** Stream subject the ticket is bound to (e.g. a build-log requestId). Absent for org-keyed channels. */\n  subject?: string;\n}\n\n/** Result of {@link SseTicketStore.issue}. */\nexport type SseTicketIssueResult =\n  | { ok: true; ticket: string }\n  | { ok: false; reason: 'total' | 'org' };\n\n/**\n * The ONE store for short-lived, single-use SSE auth tickets, plus the\n * stream-ownership bindings subject-bound channels need.\n *\n * A client exchanges its JWT for a ticket (so the token never lands in an\n * EventSource query string / access log), then redeems it on the SSE `GET`.\n *\n * - **Tickets** are single-use across pods: the Redis backend redeems with\n *   `GETDEL`, so two pods can never both spend one ticket.\n * - **Caps count LIVE tickets** (issued, not yet redeemed, not expired) — per org\n *   and in total. A redeemed or expired ticket frees its slot immediately.\n * - **Ownership** records which org owns a stream subject, so a subject-bound\n *   channel can refuse to mint a ticket for another org's stream.\n *\n * Both backends share these semantics; the in-memory one is correct for a\n * single process only.\n */\nexport interface SseTicketStore {\n  /** Mint a ticket for `orgId` (optionally bound to `subject`), or reject when a live-ticket cap is reached. */\n  issue(orgId: string, subject?: string): Promise<SseTicketIssueResult>;\n  /** Redeem a ticket exactly once; null when unknown, expired or already spent. */\n  consume(ticketId: string): Promise<SseTicketRecord | null>;\n  /** Record the org that owns `subject` for `ttlMs`. */\n  bindOwner(subject: string, orgId: string, ttlMs: number): Promise<void>;\n  /** The org that owns `subject`, or null when none is bound. Throws when the backend can't answer. */\n  getOwner(subject: string): Promise<string | null>;\n  /** Release timers/resources. In-memory clears its sweep interval; Redis is a no-op. */\n  stop(): void;\n}\n\n/** Caps + TTL for the ticket store. */\nexport interface SseTicketStoreConfig {\n  /** Ticket lifetime — long enough for the client to open the EventSource. */\n  ttlMs: number;\n  /** Cap on LIVE tickets across all orgs (abuse / memory bound). */\n  maxTotal: number;\n  /** Cap on LIVE tickets per org (single-tenant fairness bound). */\n  maxPerOrg: number;\n  /**\n   * Key namespace so independent channels (message notifications, reporting\n   * execution-status, a service's build-log stream) never share tickets, caps\n   * or ownership bindings — a ticket minted for one channel must not be\n   * redeemable on another. Omit for the default namespace.\n   */\n  keyPrefix?: string;\n}\n\nfunction newTicketId(): string {\n  return crypto.randomBytes(24).toString('base64url');\n}\n\nfunction errMsg(err: unknown): string {\n  return errorMessage(err);\n}\n\n/** In-memory backend — single-process fallback when Redis isn't configured. */\nexport function createMemorySseTicketStore(config: SseTicketStoreConfig): SseTicketStore {\n  interface Entry extends SseTicketRecord { expiresAt: number }\n  const tickets = new Map<string, Entry>();\n  const owners = new Map<string, { orgId: string; expiresAt: number }>();\n\n  const sweep = (): void => {\n    const now = Date.now();\n    for (const [id, t] of tickets) if (now >= t.expiresAt) tickets.delete(id);\n    for (const [id, o] of owners) if (now >= o.expiresAt) owners.delete(id);\n  };\n  const timer = setInterval(sweep, Math.max(1_000, config.ttlMs));\n  timer.unref();\n\n  return {\n    async issue(orgId, subject) {\n      sweep();\n      if (tickets.size >= config.maxTotal) return { ok: false, reason: 'total' };\n      let forOrg = 0;\n      for (const t of tickets.values()) if (t.orgId === orgId) forOrg++;\n      if (forOrg >= config.maxPerOrg) return { ok: false, reason: 'org' };\n      const ticket = newTicketId();\n      tickets.set(ticket, { orgId, ...(subject !== undefined && { subject }), expiresAt: Date.now() + config.ttlMs });\n      return { ok: true, ticket };\n    },\n    async consume(ticketId) {\n      const t = tickets.get(ticketId);\n      tickets.delete(ticketId); // single-use — gone whether or not it was valid\n      if (!t || Date.now() >= t.expiresAt) return null;\n      return { orgId: t.orgId, ...(t.subject !== undefined && { subject: t.subject }) };\n    },\n    async bindOwner(subject, orgId, ttlMs) {\n      owners.set(subject, { orgId, expiresAt: Date.now() + ttlMs });\n    },\n    async getOwner(subject) {\n      const o = owners.get(subject);\n      if (!o) return null;\n      if (Date.now() >= o.expiresAt) { owners.delete(subject); return null; }\n      return o.orgId;\n    },\n    stop() { clearInterval(timer); },\n  };\n}\n\n/** Minimal ioredis surface the Redis backend needs (GETDEL requires Redis ≥ 6.2). */\nexport interface SseTicketRedis extends ReadyAwareRedis {\n  eval(script: string, numKeys: number, ...args: (string | number)[]): Promise<unknown>;\n  getdel(key: string): Promise<string | null>;\n  zrem(key: string, ...members: string[]): Promise<number>;\n  set(key: string, value: string, ...args: (string | number)[]): Promise<unknown>;\n  get(key: string): Promise<string | null>;\n}\n\n/**\n * Atomic live-count issue. Prunes expired members from both cap sets, checks the\n * total then the per-org cap, and only then stores the ticket and records it in\n * both sets — so concurrent mints can't overshoot a cap and a cap can never\n * stick (every member carries its own expiry score and every key a TTL).\n *\n * KEYS: total zset, org zset, ticket key.\n * ARGV: ttlMs, maxTotal, maxPerOrg, ticketId, record JSON.\n * Uses the server clock so every pod agrees on \"expired\".\n */\nconst ISSUE_SCRIPT = `\nlocal t = redis.call('TIME')\nlocal now = tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000)\nlocal ttl = tonumber(ARGV[1])\nredis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', now)\nredis.call('ZREMRANGEBYSCORE', KEYS[2], '-inf', now)\nif redis.call('ZCARD', KEYS[1]) >= tonumber(ARGV[2]) then return 'total' end\nif redis.call('ZCARD', KEYS[2]) >= tonumber(ARGV[3]) then return 'org' end\nredis.call('SET', KEYS[3], ARGV[5], 'PX', ttl)\nredis.call('ZADD', KEYS[1], now + ttl, ARGV[4])\nredis.call('ZADD', KEYS[2], now + ttl, ARGV[4])\nredis.call('PEXPIRE', KEYS[1], ttl)\nredis.call('PEXPIRE', KEYS[2], ttl)\nreturn 'ok'`;\n\n/**\n * Redis backend — multi-replica safe.\n *\n * Fail-CLOSED: a Redis error makes `issue` reject (`total`), `consume` return\n * null and `getOwner` throw, so an outage degrades to \"no live stream\" rather\n * than handing out or accepting unvalidated tickets. `bindOwner` is best-effort.\n */\nexport function createRedisSseTicketStore(redis: SseTicketRedis, config: SseTicketStoreConfig): SseTicketStore {\n  const ns = config.keyPrefix ? `${config.keyPrefix}:` : '';\n  const ticketKey = (t: string) => `${ns}sse:tk:${t}`;\n  const orgSetKey = (o: string) => `${ns}sse:tkz:org:${o}`;\n  const totalSetKey = `${ns}sse:tkz:all`;\n  const ownerKey = (s: string) => `${ns}sse:owner:${s}`;\n  const ttlMs = Math.max(1, Math.ceil(config.ttlMs));\n  // The env client has no offline queue: wait (bounded) for the first connection\n  // so the first mint/redeem after boot isn't rejected outright.\n  const ready = createRedisReadyGate(redis);\n\n  return {\n    async issue(orgId, subject) {\n      try {\n        await ready();\n        const ticket = newTicketId();\n        const record: SseTicketRecord = { orgId, ...(subject !== undefined && { subject }) };\n        const outcome = await redis.eval(\n          ISSUE_SCRIPT, 3, totalSetKey, orgSetKey(orgId), ticketKey(ticket),\n          ttlMs, config.maxTotal, config.maxPerOrg, ticket, JSON.stringify(record),\n        );\n        if (outcome === 'ok') return { ok: true, ticket };\n        return { ok: false, reason: outcome === 'org' ? 'org' : 'total' };\n      } catch (err) {\n        logger.warn('SSE ticket issue failed (fail-closed)', { error: errMsg(err) });\n        return { ok: false, reason: 'total' };\n      }\n    },\n    async consume(ticketId) {\n      try {\n        await ready();\n        const raw = await redis.getdel(ticketKey(ticketId));\n        if (!raw) return null;\n        const rec = JSON.parse(raw) as SseTicketRecord;\n        if (typeof rec?.orgId !== 'string') return null;\n        // Free the live-count slots now rather than at expiry. Best-effort: a\n        // failure here only delays the slot until the member's expiry score.\n        await Promise.all([redis.zrem(orgSetKey(rec.orgId), ticketId), redis.zrem(totalSetKey, ticketId)])\n          .catch((err: unknown) => logger.debug('SSE ticket slot release failed', { error: errMsg(err) }));\n        return rec;\n      } catch (err) {\n        logger.warn('SSE ticket consume failed (fail-closed)', { error: errMsg(err) });\n        return null;\n      }\n    },\n    async bindOwner(subject, orgId, ownerTtlMs) {\n      try {\n        await ready();\n        await redis.set(ownerKey(subject), orgId, 'PX', Math.max(1, Math.ceil(ownerTtlMs)));\n      } catch (err) {\n        logger.warn('SSE stream-owner bind failed', { error: errMsg(err) });\n      }\n    },\n    async getOwner(subject) {\n      await ready();\n      return redis.get(ownerKey(subject));\n    },\n    stop() { /* keys expire on their own TTL */ },\n  };\n}\n\n/**\n * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or\n * `REDIS_SENTINELS`): the Redis backend when configured (multi-replica safe),\n * otherwise the in-memory single-process backend.\n */\nexport function createEnvSseTicketStore(config: SseTicketStoreConfig): SseTicketStore {\n  const redis = createEnvRedisClient<SseTicketRedis>('sse-ticket');\n  if (redis) {\n    logger.info('SSE ticket store: Redis backend (multi-replica)', { keyPrefix: config.keyPrefix });\n    return createRedisSseTicketStore(redis, config);\n  }\n  logger.info('SSE ticket store: in-memory backend (single-process fallback)', { keyPrefix: config.keyPrefix });\n  return createMemorySseTicketStore(config);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-ticket-store.js","sourceRoot":"","sources":["../../src/services/sse-ticket-store.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport crypto from 'crypto';\n\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } from './env-redis.js';\nimport { envInt } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { errorMessage } from '../utils/response.js';\n\nconst logger = createLogger('sse-ticket-store');\n\n/** What a ticket authorizes: the owning org and, for subject-bound channels, the stream subject. */\nexport interface SseTicketRecord {\n  orgId: string;\n  /** Stream subject the ticket is bound to (e.g. a build-log requestId). Absent for org-keyed channels. */\n  subject?: string;\n}\n\n/** Result of {@link SseTicketStore.issue}. */\nexport type SseTicketIssueResult =\n  | { ok: true; ticket: string }\n  | { ok: false; reason: 'total' | 'org' };\n\n/**\n * The ONE store for short-lived, single-use SSE auth tickets, plus the\n * stream-ownership bindings subject-bound channels need.\n *\n * A client exchanges its JWT for a ticket (so the token never lands in an\n * EventSource query string / access log), then redeems it on the SSE `GET`.\n *\n * - **Tickets** are single-use across pods: the Redis backend redeems with\n *   `GETDEL`, so two pods can never both spend one ticket.\n * - **Caps count LIVE tickets** (issued, not yet redeemed, not expired) — per org\n *   and in total. A redeemed or expired ticket frees its slot immediately.\n * - **Ownership** records which org owns a stream subject, so a subject-bound\n *   channel can refuse to mint a ticket for another org's stream.\n *\n * Both backends share these semantics; the in-memory one is correct for a\n * single process only.\n */\nexport interface SseTicketStore {\n  /** Mint a ticket for `orgId` (optionally bound to `subject`), or reject when a live-ticket cap is reached. */\n  issue(orgId: string, subject?: string): Promise<SseTicketIssueResult>;\n  /** Redeem a ticket exactly once; null when unknown, expired or already spent. */\n  consume(ticketId: string): Promise<SseTicketRecord | null>;\n  /** Record the org that owns `subject` for `ttlMs`. */\n  bindOwner(subject: string, orgId: string, ttlMs: number): Promise<void>;\n  /** The org that owns `subject`, or null when none is bound. Throws when the backend can't answer. */\n  getOwner(subject: string): Promise<string | null>;\n  /** Release timers/resources. In-memory clears its sweep interval; Redis is a no-op. */\n  stop(): void;\n}\n\n/** Caps + TTL for the ticket store. */\nexport interface SseTicketStoreConfig {\n  /** Ticket lifetime — long enough for the client to open the EventSource. */\n  ttlMs: number;\n  /** Cap on LIVE tickets across all orgs (abuse / memory bound). */\n  maxTotal: number;\n  /** Cap on LIVE tickets per org (single-tenant fairness bound). */\n  maxPerOrg: number;\n  /**\n   * Key namespace so independent channels (message notifications, reporting\n   * execution-status, a service's build-log stream) never share tickets, caps\n   * or ownership bindings — a ticket minted for one channel must not be\n   * redeemable on another. Omit for the default namespace.\n   */\n  keyPrefix?: string;\n}\n\nfunction newTicketId(): string {\n  return crypto.randomBytes(24).toString('base64url');\n}\n\n/** In-memory backend — single-process fallback when Redis isn't configured. */\nexport function createMemorySseTicketStore(config: SseTicketStoreConfig): SseTicketStore {\n  interface Entry extends SseTicketRecord { expiresAt: number }\n  const tickets = new Map<string, Entry>();\n  const owners = new Map<string, { orgId: string; expiresAt: number }>();\n\n  const sweep = (): void => {\n    const now = Date.now();\n    for (const [id, t] of tickets) if (now >= t.expiresAt) tickets.delete(id);\n    for (const [id, o] of owners) if (now >= o.expiresAt) owners.delete(id);\n  };\n  const timer = setInterval(sweep, Math.max(1_000, config.ttlMs));\n  timer.unref();\n\n  return {\n    async issue(orgId, subject) {\n      sweep();\n      if (tickets.size >= config.maxTotal) return { ok: false, reason: 'total' };\n      let forOrg = 0;\n      for (const t of tickets.values()) if (t.orgId === orgId) forOrg++;\n      if (forOrg >= config.maxPerOrg) return { ok: false, reason: 'org' };\n      const ticket = newTicketId();\n      tickets.set(ticket, { orgId, ...(subject !== undefined && { subject }), expiresAt: Date.now() + config.ttlMs });\n      return { ok: true, ticket };\n    },\n    async consume(ticketId) {\n      const t = tickets.get(ticketId);\n      tickets.delete(ticketId); // single-use — gone whether or not it was valid\n      if (!t || Date.now() >= t.expiresAt) return null;\n      return { orgId: t.orgId, ...(t.subject !== undefined && { subject: t.subject }) };\n    },\n    async bindOwner(subject, orgId, ttlMs) {\n      owners.set(subject, { orgId, expiresAt: Date.now() + ttlMs });\n    },\n    async getOwner(subject) {\n      const o = owners.get(subject);\n      if (!o) return null;\n      if (Date.now() >= o.expiresAt) { owners.delete(subject); return null; }\n      return o.orgId;\n    },\n    stop() { clearInterval(timer); },\n  };\n}\n\n/** Minimal ioredis surface the Redis backend needs (GETDEL requires Redis ≥ 6.2). */\nexport interface SseTicketRedis extends ReadyAwareRedis {\n  eval(script: string, numKeys: number, ...args: (string | number)[]): Promise<unknown>;\n  getdel(key: string): Promise<string | null>;\n  zrem(key: string, ...members: string[]): Promise<number>;\n  set(key: string, value: string, ...args: (string | number)[]): Promise<unknown>;\n  get(key: string): Promise<string | null>;\n}\n\n/**\n * Atomic live-count issue. Prunes expired members from both cap sets, checks the\n * total then the per-org cap, and only then stores the ticket and records it in\n * both sets — so concurrent mints can't overshoot a cap and a cap can never\n * stick (every member carries its own expiry score and every key a TTL).\n *\n * KEYS: total zset, org zset, ticket key.\n * ARGV: ttlMs, maxTotal, maxPerOrg, ticketId, record JSON.\n * Uses the server clock so every pod agrees on \"expired\".\n */\nconst ISSUE_SCRIPT = `\nlocal t = redis.call('TIME')\nlocal now = tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000)\nlocal ttl = tonumber(ARGV[1])\nredis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', now)\nredis.call('ZREMRANGEBYSCORE', KEYS[2], '-inf', now)\nif redis.call('ZCARD', KEYS[1]) >= tonumber(ARGV[2]) then return 'total' end\nif redis.call('ZCARD', KEYS[2]) >= tonumber(ARGV[3]) then return 'org' end\nredis.call('SET', KEYS[3], ARGV[5], 'PX', ttl)\nredis.call('ZADD', KEYS[1], now + ttl, ARGV[4])\nredis.call('ZADD', KEYS[2], now + ttl, ARGV[4])\nredis.call('PEXPIRE', KEYS[1], ttl)\nredis.call('PEXPIRE', KEYS[2], ttl)\nreturn 'ok'`;\n\n/**\n * Redis backend — multi-replica safe.\n *\n * Fail-CLOSED: a Redis error makes `issue` reject (`total`), `consume` return\n * null and `getOwner` throw, so an outage degrades to \"no live stream\" rather\n * than handing out or accepting unvalidated tickets. `bindOwner` is best-effort.\n */\nexport function createRedisSseTicketStore(redis: SseTicketRedis, config: SseTicketStoreConfig): SseTicketStore {\n  const ns = config.keyPrefix ? `${config.keyPrefix}:` : '';\n  const ticketKey = (t: string) => `${ns}sse:tk:${t}`;\n  const orgSetKey = (o: string) => `${ns}sse:tkz:org:${o}`;\n  const totalSetKey = `${ns}sse:tkz:all`;\n  const ownerKey = (s: string) => `${ns}sse:owner:${s}`;\n  const ttlMs = Math.max(1, Math.ceil(config.ttlMs));\n  // The env client has no offline queue: wait (bounded) for the first connection\n  // so the first mint/redeem after boot isn't rejected outright.\n  const ready = createRedisReadyGate(redis);\n\n  return {\n    async issue(orgId, subject) {\n      try {\n        await ready();\n        const ticket = newTicketId();\n        const record: SseTicketRecord = { orgId, ...(subject !== undefined && { subject }) };\n        const outcome = await redis.eval(\n          ISSUE_SCRIPT, 3, totalSetKey, orgSetKey(orgId), ticketKey(ticket),\n          ttlMs, config.maxTotal, config.maxPerOrg, ticket, JSON.stringify(record),\n        );\n        if (outcome === 'ok') return { ok: true, ticket };\n        return { ok: false, reason: outcome === 'org' ? 'org' : 'total' };\n      } catch (err) {\n        logger.warn('SSE ticket issue failed (fail-closed)', { error: errorMessage(err) });\n        return { ok: false, reason: 'total' };\n      }\n    },\n    async consume(ticketId) {\n      try {\n        await ready();\n        const raw = await redis.getdel(ticketKey(ticketId));\n        if (!raw) return null;\n        const rec = JSON.parse(raw) as SseTicketRecord;\n        if (typeof rec?.orgId !== 'string') return null;\n        // Free the live-count slots now rather than at expiry. Best-effort: a\n        // failure here only delays the slot until the member's expiry score.\n        await Promise.all([redis.zrem(orgSetKey(rec.orgId), ticketId), redis.zrem(totalSetKey, ticketId)])\n          .catch((err: unknown) => logger.debug('SSE ticket slot release failed', { error: errorMessage(err) }));\n        return rec;\n      } catch (err) {\n        logger.warn('SSE ticket consume failed (fail-closed)', { error: errorMessage(err) });\n        return null;\n      }\n    },\n    async bindOwner(subject, orgId, ownerTtlMs) {\n      try {\n        await ready();\n        await redis.set(ownerKey(subject), orgId, 'PX', Math.max(1, Math.ceil(ownerTtlMs)));\n      } catch (err) {\n        logger.warn('SSE stream-owner bind failed', { error: errorMessage(err) });\n      }\n    },\n    async getOwner(subject) {\n      await ready();\n      return redis.get(ownerKey(subject));\n    },\n    stop() { /* keys expire on their own TTL */ },\n  };\n}\n\n/**\n * The deploy-wide ticket caps: `SSE_MAX_TOTAL_TICKETS` (default 1000) and\n * `SSE_MAX_TICKETS_PER_ORG` (default 10). One reader so every channel parses\n * them the same way.\n */\nexport function envSseTicketCaps(): Pick<SseTicketStoreConfig, 'maxTotal' | 'maxPerOrg'> {\n  return {\n    maxTotal: envInt('SSE_MAX_TOTAL_TICKETS', 1000, { min: 1 }),\n    maxPerOrg: envInt('SSE_MAX_TICKETS_PER_ORG', 10, { min: 1 }),\n  };\n}\n\n/** {@link createEnvSseTicketStore} config: the caps default to {@link envSseTicketCaps}. */\nexport type EnvSseTicketStoreConfig = Omit<SseTicketStoreConfig, 'maxTotal' | 'maxPerOrg'>\n  & Partial<Pick<SseTicketStoreConfig, 'maxTotal' | 'maxPerOrg'>>;\n\n/**\n * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or\n * `REDIS_SENTINELS`): the Redis backend when configured (multi-replica safe),\n * otherwise the in-memory single-process backend.\n */\nexport function createEnvSseTicketStore(options: EnvSseTicketStoreConfig): SseTicketStore {\n  const caps = envSseTicketCaps();\n  const config: SseTicketStoreConfig = {\n    ...options,\n    maxTotal: options.maxTotal ?? caps.maxTotal,\n    maxPerOrg: options.maxPerOrg ?? caps.maxPerOrg,\n  };\n  const redis = createEnvRedisClient<SseTicketRedis>('sse-ticket');\n  if (redis) {\n    logger.info('SSE ticket store: Redis backend (multi-replica)', { keyPrefix: config.keyPrefix });\n    return createRedisSseTicketStore(redis, config);\n  }\n  logger.info('SSE ticket store: in-memory backend (single-process fallback)', { keyPrefix: config.keyPrefix });\n  return createMemorySseTicketStore(config);\n}\n"]}

package/lib/services/system-notification.d.ts

@@ -0,0 +1,27 @@
+import type { ServiceConfig } from '../types/common.js';
+import type { MessagePriority } from '../types/wire-vocabulary.js';
+/** The message service's service-to-service notification route. */
+export declare const SYSTEM_NOTIFY_PATH = "/messages/internal/notify";
+/** A SYSTEM-authored in-app message for a recipient org, optionally one user. */
+export interface SystemNotification {
+    recipientOrgId: string;
+    recipientUserId?: string;
+    subject: string;
+    content: string;
+    priority?: MessagePriority;
+}
+/**
+ * Drop a SYSTEM-authored message into a recipient org's inbox via the message
+ * service's internal notify route (which also pushes the real-time SSE ping).
+ * Authenticates with this process's signed service token, scoped to the
+ * recipient org.
+ *
+ * REPORTS whether the message was persisted: true only on a 2xx. Never throws —
+ * an unreachable service or a refusal is logged and returns false, so a caller
+ * whose non-delivery costs something (a retried reminder, a notification log)
+ * can act on it.
+ */
+export declare function sendSystemNotification(notification: SystemNotification, opts?: {
+    service?: ServiceConfig;
+    serviceName?: string;
+}): Promise<boolean>;

package/lib/services/system-notification.js

@@ -0,0 +1,50 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createSafeClient } from './http-client.js';
+import { serviceIdentity } from './service-keys.js';
+import { getServiceAuthHeader } from '../middleware/service-tokens.js';
+import { createLogger } from '../utils/logger.js';
+import { errorMessage } from '../utils/response.js';
+import { serviceEndpoint } from '../utils/service-registry.js';
+const logger = createLogger('system-notification');
+/** The message service's service-to-service notification route. */
+export const SYSTEM_NOTIFY_PATH = '/messages/internal/notify';
+/**
+ * Drop a SYSTEM-authored message into a recipient org's inbox via the message
+ * service's internal notify route (which also pushes the real-time SSE ping).
+ * Authenticates with this process's signed service token, scoped to the
+ * recipient org.
+ *
+ * REPORTS whether the message was persisted: true only on a 2xx. Never throws —
+ * an unreachable service or a refusal is logged and returns false, so a caller
+ * whose non-delivery costs something (a retried reminder, a notification log)
+ * can act on it.
+ */
+export async function sendSystemNotification(notification, opts = {}) {
+    try {
+        const client = createSafeClient(opts.service ?? serviceEndpoint('message'));
+        const result = await client.post(SYSTEM_NOTIFY_PATH, notification, {
+            headers: {
+                authorization: getServiceAuthHeader({
+                    serviceName: opts.serviceName ?? serviceIdentity(),
+                    orgId: notification.recipientOrgId,
+                    role: 'member',
+                }),
+            },
+        });
+        // The safe client resolves null on a transport failure rather than throwing.
+        if (result === null || result.statusCode < 200 || result.statusCode >= 300) {
+            logger.warn('System notification not delivered', {
+                recipientOrgId: notification.recipientOrgId,
+                statusCode: result?.statusCode ?? 'unreachable',
+            });
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        logger.warn('System notification failed', { recipientOrgId: notification.recipientOrgId, error: errorMessage(err) });
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/token-revocation.d.ts

@@ -1,5 +1,5 @@
 import type { RedisCacheClient } from './cache-service.js';
-import type { TokenRevocationStore } from '../middleware/auth.js';
+import type { TokenRevocationStore } from '../middleware/revocation.js';
 /**
  * Redis key namespace for the per-user current `tokenVersion`. The platform
  * PUBLISHES to this key on every privilege change; the stateless services READ
@@ -18,6 +18,38 @@ export declare function tokenRevocationKey(userId: string): string;
 export declare const SESSION_REVOCATION_KEY_PREFIX = "authrev:jti:";
 /** The revocation key for one session's token id. */
 export declare function sessionRevocationKey(jti: string): string;
+/**
+ * Redis key namespaces for revoking ONE credential rather than a whole user:
+ *
+ * - `revoke:sid:<sid>`   — one refresh-session slot (a signed-out device, a
+ *                          revoked machine session). Rejects every access token
+ *                          whose `sid` claim names it.
+ * - `revoke:key:<keyId>` — one access key (PAT or service-account key). Rejects
+ *                          the key's exchanged token (`token_use: 'api_key'`,
+ *                          `jti` = key id) and anything derived from it
+ *                          (`parentKeyId`).
+ *
+ * Platform PUBLISHES these ({@link publishCredentialRevocation}); every service
+ * READS them in `requireAuth`. Presence is the whole signal — the value is `1`.
+ */
+export declare const CREDENTIAL_REVOCATION_PREFIX: {
+    readonly sid: 'revoke:sid:';
+    readonly key: 'revoke:key:';
+};
+/** Which credential a {@link credentialRevocationKey} names. */
+export type CredentialKind = keyof typeof CREDENTIAL_REVOCATION_PREFIX;
+/** The revocation key for one session slot (`sid`) or one access key (`key`). */
+export declare function credentialRevocationKey(kind: CredentialKind, id: string): string;
+/**
+ * Atomic "set if greater" for the per-user tokenVersion. A plain SET let two
+ * concurrent publishes land out of order — an older version overwriting a newer
+ * one silently UN-revoked every token between them. The script only ever raises
+ * the stored version, and only ever lengthens the entry's TTL.
+ *
+ * KEYS[1] = revocation key; ARGV[1] = version; ARGV[2] = ttl seconds.
+ * Returns 1 when it wrote, 0 when an equal-or-newer version was already there.
+ */
+export declare const SET_IF_GREATER_LUA = "\nlocal cur = tonumber(redis.call('GET', KEYS[1]))\nlocal v = tonumber(ARGV[1])\nlocal ttl = tonumber(ARGV[2])\nif cur and cur >= v then\n  if redis.call('TTL', KEYS[1]) < ttl then redis.call('EXPIRE', KEYS[1], ttl) end\n  return 0\nend\nredis.call('SET', KEYS[1], ARGV[1], 'EX', ttl)\nreturn 1\n";
 /**
  * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless
  * service to register via `setTokenRevocationStore`. Reads the current
@@ -48,6 +80,9 @@ export declare function createEnvRedisTokenRevocationStore(): TokenRevocationSto
  * revocation immediately (platform side). Best-effort — never throws; a failure
  * just means the services fall back to natural token expiry for this change.
  *
+ * The write is an atomic set-if-greater ({@link SET_IF_GREATER_LUA}), so an
+ * out-of-order publish can never lower the stored version.
+ *
  * The key is written with a TTL equal to the access-token lifetime: any token
  * that could still carry an older version has expired by the time the entry
  * lapses, so an expired entry can never cause a false "revoked" nor a missed one.
@@ -73,3 +108,17 @@ export declare function publishTokenRevocation(redis: RedisCacheClient, userId:
  * @param ttlMs - time remaining on the session's token
  */
 export declare function publishSessionRevocation(redis: RedisCacheClient, jti: string, ttlMs: number): Promise<boolean>;
+/**
+ * Publish that ONE credential — a session slot (`sid`) or an access key
+ * (`key`) — has been revoked, so every service rejects the tokens that name it
+ * on the next request (platform side).
+ *
+ * `ttlSeconds` MUST be at least the longest lifetime of any token that can
+ * carry this id (an access token minted from the slot, an exchanged key token,
+ * or a token derived from one): the entry lapsing first would read as "not
+ * revoked" while such a token is still alive.
+ *
+ * Returns whether the publish landed, so the caller can report a revocation
+ * that did not reach the other services instead of claiming success.
+ */
+export declare function publishCredentialRevocation(redis: RedisCacheClient, kind: CredentialKind, id: string, ttlSeconds: number): Promise<boolean>;

package/lib/services/token-revocation.js

@@ -27,6 +27,48 @@ export const SESSION_REVOCATION_KEY_PREFIX = 'authrev:jti:';
 export function sessionRevocationKey(jti) {
     return `${SESSION_REVOCATION_KEY_PREFIX}${jti}`;
 }
+/**
+ * Redis key namespaces for revoking ONE credential rather than a whole user:
+ *
+ * - `revoke:sid:<sid>`   — one refresh-session slot (a signed-out device, a
+ *                          revoked machine session). Rejects every access token
+ *                          whose `sid` claim names it.
+ * - `revoke:key:<keyId>` — one access key (PAT or service-account key). Rejects
+ *                          the key's exchanged token (`token_use: 'api_key'`,
+ *                          `jti` = key id) and anything derived from it
+ *                          (`parentKeyId`).
+ *
+ * Platform PUBLISHES these ({@link publishCredentialRevocation}); every service
+ * READS them in `requireAuth`. Presence is the whole signal — the value is `1`.
+ */
+export const CREDENTIAL_REVOCATION_PREFIX = {
+    sid: 'revoke:sid:',
+    key: 'revoke:key:',
+};
+/** The revocation key for one session slot (`sid`) or one access key (`key`). */
+export function credentialRevocationKey(kind, id) {
+    return `${CREDENTIAL_REVOCATION_PREFIX[kind]}${id}`;
+}
+/**
+ * Atomic "set if greater" for the per-user tokenVersion. A plain SET let two
+ * concurrent publishes land out of order — an older version overwriting a newer
+ * one silently UN-revoked every token between them. The script only ever raises
+ * the stored version, and only ever lengthens the entry's TTL.
+ *
+ * KEYS[1] = revocation key; ARGV[1] = version; ARGV[2] = ttl seconds.
+ * Returns 1 when it wrote, 0 when an equal-or-newer version was already there.
+ */
+export const SET_IF_GREATER_LUA = `
+local cur = tonumber(redis.call('GET', KEYS[1]))
+local v = tonumber(ARGV[1])
+local ttl = tonumber(ARGV[2])
+if cur and cur >= v then
+  if redis.call('TTL', KEYS[1]) < ttl then redis.call('EXPIRE', KEYS[1], ttl) end
+  return 0
+end
+redis.call('SET', KEYS[1], ARGV[1], 'EX', ttl)
+return 1
+`;
 /**
  * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless
  * service to register via `setTokenRevocationStore`. Reads the current
@@ -81,6 +123,26 @@ export function createRedisTokenRevocationStore(redis) {
                 return 'unavailable';
             }
         },
+        async isCredentialRevoked(refs) {
+            const keys = [
+                ...(refs.sid ? [credentialRevocationKey('sid', refs.sid)] : []),
+                ...refs.keyIds.map((id) => credentialRevocationKey('key', id)),
+            ];
+            if (keys.length === 0)
+                return false;
+            try {
+                const values = await Promise.all(keys.map((k) => redis.get(k)));
+                return values.some((v) => v !== null && v !== undefined);
+            }
+            catch (err) {
+                // Fail-open, like getCurrentVersion: a one-credential revocation is the
+                // same class of signal as a tokenVersion bump, and a Redis outage must
+                // not lock every session out. Counted so it is alertable.
+                emitCounter('token_revocation_fail_open_total', { reason: 'credential-read-error' });
+                logger.debug('Credential-revocation read failed (fail-open)', { error: errorMessage(err) });
+                return false;
+            }
+        },
     };
 }
 /**
@@ -141,6 +203,12 @@ export function createEnvRedisTokenRevocationStore() {
             }
             return createRedisTokenRevocationStore(redis).getSessionRevocation(jti);
         },
+        async isCredentialRevoked(refs) {
+            const redis = await client();
+            if (!redis)
+                return false;
+            return createRedisTokenRevocationStore(redis).isCredentialRevoked(refs);
+        },
     };
 }
 /**
@@ -148,6 +216,9 @@ export function createEnvRedisTokenRevocationStore() {
  * revocation immediately (platform side). Best-effort — never throws; a failure
  * just means the services fall back to natural token expiry for this change.
  *
+ * The write is an atomic set-if-greater ({@link SET_IF_GREATER_LUA}), so an
+ * out-of-order publish can never lower the stored version.
+ *
  * The key is written with a TTL equal to the access-token lifetime: any token
  * that could still carry an older version has expired by the time the entry
  * lapses, so an expired entry can never cause a false "revoked" nor a missed one.
@@ -159,8 +230,12 @@ export function createEnvRedisTokenRevocationStore() {
  */
 export async function publishTokenRevocation(redis, userId, tokenVersion, ttlSeconds) {
     try {
-        // ioredis-style variadic SET with expiry: SET key val EX ttl.
-        await redis.set(tokenRevocationKey(userId), String(tokenVersion), 'EX', Math.max(1, Math.floor(ttlSeconds)));
+        // Atomic set-if-greater: concurrent publishes can arrive out of order, and a
+        // plain SET would let the older version win. A client that can't run Lua is
+        // refused (caught below) rather than written racily.
+        if (typeof redis.eval !== 'function')
+            throw new Error('Redis client cannot run scripts (eval unavailable)');
+        await redis.eval(SET_IF_GREATER_LUA, 1, tokenRevocationKey(userId), String(tokenVersion), Math.max(1, Math.floor(ttlSeconds)));
     }
     catch (err) {
         logger.warn('Token-revocation publish failed (services fall back to token expiry)', {
@@ -194,4 +269,29 @@ export async function publishSessionRevocation(redis, jti, ttlMs) {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-revocation.js","sourceRoot":"","sources":["../../src/services/token-revocation.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { RedisCacheClient } from './cache-service.js';\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } from './env-redis.js';\nimport type { SessionRevocationState, TokenRevocationStore } from '../middleware/auth.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\n\nconst logger = createLogger('token-revocation');\n\n/**\n * Redis key namespace for the per-user current `tokenVersion`. The platform\n * PUBLISHES to this key on every privilege change; the stateless services READ\n * it in `requireAuth` (via {@link createRedisTokenRevocationStore}) to reject\n * tokens minted before that change. Publisher and readers MUST share this exact\n * prefix — hence both helpers live here, in one place.\n */\nexport const TOKEN_REVOCATION_KEY_PREFIX = 'authrev:tv:';\n\n/** The revocation key for a user id. */\nexport function tokenRevocationKey(userId: string): string {\n  return `${TOKEN_REVOCATION_KEY_PREFIX}${userId}`;\n}\n\n/**\n * Redis key namespace for ended IMPERSONATION sessions, by token `jti`. Same\n * publish/read split as the tokenVersion keys above, and kept beside them for the\n * same reason: publisher and readers must agree on this exact prefix.\n */\nexport const SESSION_REVOCATION_KEY_PREFIX = 'authrev:jti:';\n\n/** The revocation key for one session's token id. */\nexport function sessionRevocationKey(jti: string): string {\n  return `${SESSION_REVOCATION_KEY_PREFIX}${jti}`;\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless\n * service to register via `setTokenRevocationStore`. Reads the current\n * `tokenVersion` the platform published for the user.\n *\n * Fail-open by contract: a miss, a parse failure, or a Redis error all yield\n * `null` (— `requireAuth` treats that as \"no known revocation\"), so a Redis\n * outage degrades to the pre-existing behaviour rather than locking users out.\n */\nexport function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore {\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      try {\n        const raw = await redis.get(tokenRevocationKey(userId));\n        if (raw === null || raw === undefined || raw.trim() === '') return null;\n        // Strict integer parse: `Number` (unlike `parseInt`) rejects trailing\n        // garbage (\"5abc\" → NaN), so a corrupted entry fails open (null → \"not\n        // revoked\") rather than being read as a bogus version. The empty-string\n        // guard above matters because `Number('')` is 0, not NaN.\n        const n = Number(raw);\n        return Number.isInteger(n) ? n : null;\n      } catch (err) {\n        // Redis was reachable enough to try but the read errored — this is a\n        // DEGRADATION: while it persists, forced logouts / privilege revocations\n        // silently stop taking effect until natural token expiry. Emit a counter\n        // so `TokenRevocationFailingOpen` can alert on a SUSTAINED rate (mirrors\n        // the quota_fail_open_total pattern). Not emitted for the \"Redis not\n        // configured\" path (createEnvRedisTokenRevocationStore → null client),\n        // which is a deliberate opt-out, not a degradation.\n        emitCounter('token_revocation_fail_open_total', { reason: 'read-error' });\n        logger.debug('Token-revocation read failed (fail-open)', {\n          userId, error: errorMessage(err),\n        });\n        return null;\n      }\n    },\n    async getSessionRevocation(jti: string): Promise<SessionRevocationState> {\n      try {\n        const raw = await redis.get(sessionRevocationKey(jti));\n        return raw === null || raw === undefined ? 'live' : 'revoked';\n      } catch (err) {\n        // NOT fail-open, unlike getCurrentVersion above: `unavailable` rejects\n        // the impersonation token. Counted so a sustained outage — which stops\n        // support impersonation everywhere — is visible and alertable.\n        emitCounter('session_revocation_unavailable_total', { reason: 'read-error' });\n        logger.debug('Session-revocation read failed (rejecting impersonation token)', {\n          error: errorMessage(err),\n        });\n        return 'unavailable';\n      }\n    },\n  };\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily\n * constructed from the standard `REDIS_URL` or `REDIS_SENTINELS` env —\n * for a stateless service that keeps NO Redis client of its own. The client is\n * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via\n * a guarded dynamic require so merely importing this never breaks a build/test\n * where Redis isn't present.\n *\n * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,\n * or any read failure all resolve to `null` (\"no known revocation\"), so a\n * service degrades to natural token expiry rather than locking users out. A\n * service opts in with a single boot line:\n *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`\n */\nexport function createEnvRedisTokenRevocationStore(): TokenRevocationStore {\n  type ReaderRedis = RedisCacheClient & ReadyAwareRedis;\n  // undefined = not yet attempted; null = attempted and unavailable (stay off).\n  let cached: ReaderRedis | null | undefined;\n  let ready: (() => Promise<void>) | undefined;\n\n  /**\n   * The reader client, built on first use. The env client has no offline queue,\n   * so a GET before the first connection completes is rejected — which made the\n   * FIRST impersonation check on every pod read 'unavailable' (401). Wait\n   * (bounded, never rejecting) for readiness; a genuinely down Redis then keeps\n   * the existing fail-open / 'unavailable' semantics.\n   */\n  async function client(): Promise<ReaderRedis | null> {\n    if (cached === undefined) {\n      // Shared env-configured ioredis construction (error listener attached, null\n      // when Redis isn't configured); the reader stays fail-open — a null client\n      // just falls back to natural token expiry.\n      cached = createEnvRedisClient<ReaderRedis>('revocation-reader');\n      if (cached) {\n        logger.info('Redis token-revocation reader initialized');\n        ready = createRedisReadyGate(cached);\n      }\n    }\n    if (ready) await ready();\n    return cached;\n  }\n\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      const redis = await client();\n      if (!redis) return null;\n      return createRedisTokenRevocationStore(redis).getCurrentVersion(userId);\n    },\n    async getSessionRevocation(jti: string): Promise<SessionRevocationState> {\n      const redis = await client();\n      // No Redis configured ⇒ there is no way to learn a session was ended, so\n      // an impersonation token can't be trusted. Every real deployment runs Redis\n      // (the build queue needs it), so this only bites a misconfigured service.\n      if (!redis) {\n        emitCounter('session_revocation_unavailable_total', { reason: 'not-configured' });\n        return 'unavailable';\n      }\n      return createRedisTokenRevocationStore(redis).getSessionRevocation!(jti);\n    },\n  };\n}\n\n/**\n * Publish a user's current `tokenVersion` so the stateless services see the\n * revocation immediately (platform side). Best-effort — never throws; a failure\n * just means the services fall back to natural token expiry for this change.\n *\n * The key is written with a TTL equal to the access-token lifetime: any token\n * that could still carry an older version has expired by the time the entry\n * lapses, so an expired entry can never cause a false \"revoked\" nor a missed one.\n *\n * @param redis - the platform's Redis client\n * @param userId - the user whose sessions changed\n * @param tokenVersion - the user's NEW (post-increment) tokenVersion\n * @param ttlSeconds - access-token lifetime in seconds\n */\nexport async function publishTokenRevocation(\n  redis: RedisCacheClient,\n  userId: string,\n  tokenVersion: number,\n  ttlSeconds: number,\n): Promise<void> {\n  try {\n    // ioredis-style variadic SET with expiry: SET key val EX ttl.\n    await redis.set(tokenRevocationKey(userId), String(tokenVersion), 'EX', Math.max(1, Math.floor(ttlSeconds)));\n  } catch (err) {\n    logger.warn('Token-revocation publish failed (services fall back to token expiry)', {\n      userId, error: errorMessage(err),\n    });\n  }\n}\n\n/**\n * Publish that one IMPERSONATION session has ended, so every stateless service\n * rejects its token on the next request (platform side).\n *\n * Returns whether the publish landed — unlike `publishTokenRevocation`, which is\n * fire-and-forget. The caller must be able to tell the person who ended the\n * session that it did NOT end everywhere, rather than reporting success while\n * the token still works against other services.\n *\n * The entry expires with the session: once the token itself can no longer be\n * used, there is nothing left to revoke, so the key cleans itself up.\n *\n * @param ttlMs - time remaining on the session's token\n */\nexport async function publishSessionRevocation(\n  redis: RedisCacheClient,\n  jti: string,\n  ttlMs: number,\n): Promise<boolean> {\n  try {\n    await redis.set(sessionRevocationKey(jti), '1', 'PX', Math.max(1000, Math.ceil(ttlMs)));\n    return true;\n  } catch (err) {\n    logger.warn('Session-revocation publish failed (other services will honour the token until it expires)', {\n      error: errorMessage(err),\n    });\n    return false;\n  }\n}\n"]}
+/**
+ * Publish that ONE credential — a session slot (`sid`) or an access key
+ * (`key`) — has been revoked, so every service rejects the tokens that name it
+ * on the next request (platform side).
+ *
+ * `ttlSeconds` MUST be at least the longest lifetime of any token that can
+ * carry this id (an access token minted from the slot, an exchanged key token,
+ * or a token derived from one): the entry lapsing first would read as "not
+ * revoked" while such a token is still alive.
+ *
+ * Returns whether the publish landed, so the caller can report a revocation
+ * that did not reach the other services instead of claiming success.
+ */
+export async function publishCredentialRevocation(redis, kind, id, ttlSeconds) {
+    try {
+        await redis.set(credentialRevocationKey(kind, id), '1', 'EX', Math.max(1, Math.ceil(ttlSeconds)));
+        return true;
+    }
+    catch (err) {
+        logger.warn('Credential-revocation publish failed (services honour the credential until its tokens expire)', {
+            kind, error: errorMessage(err),
+        });
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-revocation.js","sourceRoot":"","sources":["../../src/services/token-revocation.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { RedisCacheClient } from './cache-service.js';\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } from './env-redis.js';\nimport type { CredentialRevocationRefs, SessionRevocationState, TokenRevocationStore } from '../middleware/revocation.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\n\nconst logger = createLogger('token-revocation');\n\n/**\n * Redis key namespace for the per-user current `tokenVersion`. The platform\n * PUBLISHES to this key on every privilege change; the stateless services READ\n * it in `requireAuth` (via {@link createRedisTokenRevocationStore}) to reject\n * tokens minted before that change. Publisher and readers MUST share this exact\n * prefix — hence both helpers live here, in one place.\n */\nexport const TOKEN_REVOCATION_KEY_PREFIX = 'authrev:tv:';\n\n/** The revocation key for a user id. */\nexport function tokenRevocationKey(userId: string): string {\n  return `${TOKEN_REVOCATION_KEY_PREFIX}${userId}`;\n}\n\n/**\n * Redis key namespace for ended IMPERSONATION sessions, by token `jti`. Same\n * publish/read split as the tokenVersion keys above, and kept beside them for the\n * same reason: publisher and readers must agree on this exact prefix.\n */\nexport const SESSION_REVOCATION_KEY_PREFIX = 'authrev:jti:';\n\n/** The revocation key for one session's token id. */\nexport function sessionRevocationKey(jti: string): string {\n  return `${SESSION_REVOCATION_KEY_PREFIX}${jti}`;\n}\n\n/**\n * Redis key namespaces for revoking ONE credential rather than a whole user:\n *\n * - `revoke:sid:<sid>`   — one refresh-session slot (a signed-out device, a\n *                          revoked machine session). Rejects every access token\n *                          whose `sid` claim names it.\n * - `revoke:key:<keyId>` — one access key (PAT or service-account key). Rejects\n *                          the key's exchanged token (`token_use: 'api_key'`,\n *                          `jti` = key id) and anything derived from it\n *                          (`parentKeyId`).\n *\n * Platform PUBLISHES these ({@link publishCredentialRevocation}); every service\n * READS them in `requireAuth`. Presence is the whole signal — the value is `1`.\n */\nexport const CREDENTIAL_REVOCATION_PREFIX = {\n  sid: 'revoke:sid:',\n  key: 'revoke:key:',\n} as const;\n\n/** Which credential a {@link credentialRevocationKey} names. */\nexport type CredentialKind = keyof typeof CREDENTIAL_REVOCATION_PREFIX;\n\n/** The revocation key for one session slot (`sid`) or one access key (`key`). */\nexport function credentialRevocationKey(kind: CredentialKind, id: string): string {\n  return `${CREDENTIAL_REVOCATION_PREFIX[kind]}${id}`;\n}\n\n/**\n * Atomic \"set if greater\" for the per-user tokenVersion. A plain SET let two\n * concurrent publishes land out of order — an older version overwriting a newer\n * one silently UN-revoked every token between them. The script only ever raises\n * the stored version, and only ever lengthens the entry's TTL.\n *\n * KEYS[1] = revocation key; ARGV[1] = version; ARGV[2] = ttl seconds.\n * Returns 1 when it wrote, 0 when an equal-or-newer version was already there.\n */\nexport const SET_IF_GREATER_LUA = `\nlocal cur = tonumber(redis.call('GET', KEYS[1]))\nlocal v = tonumber(ARGV[1])\nlocal ttl = tonumber(ARGV[2])\nif cur and cur >= v then\n  if redis.call('TTL', KEYS[1]) < ttl then redis.call('EXPIRE', KEYS[1], ttl) end\n  return 0\nend\nredis.call('SET', KEYS[1], ARGV[1], 'EX', ttl)\nreturn 1\n`;\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless\n * service to register via `setTokenRevocationStore`. Reads the current\n * `tokenVersion` the platform published for the user.\n *\n * Fail-open by contract: a miss, a parse failure, or a Redis error all yield\n * `null` (— `requireAuth` treats that as \"no known revocation\"), so a Redis\n * outage degrades to the pre-existing behaviour rather than locking users out.\n */\nexport function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore {\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      try {\n        const raw = await redis.get(tokenRevocationKey(userId));\n        if (raw === null || raw === undefined || raw.trim() === '') return null;\n        // Strict integer parse: `Number` (unlike `parseInt`) rejects trailing\n        // garbage (\"5abc\" → NaN), so a corrupted entry fails open (null → \"not\n        // revoked\") rather than being read as a bogus version. The empty-string\n        // guard above matters because `Number('')` is 0, not NaN.\n        const n = Number(raw);\n        return Number.isInteger(n) ? n : null;\n      } catch (err) {\n        // Redis was reachable enough to try but the read errored — this is a\n        // DEGRADATION: while it persists, forced logouts / privilege revocations\n        // silently stop taking effect until natural token expiry. Emit a counter\n        // so `TokenRevocationFailingOpen` can alert on a SUSTAINED rate (mirrors\n        // the quota_fail_open_total pattern). Not emitted for the \"Redis not\n        // configured\" path (createEnvRedisTokenRevocationStore → null client),\n        // which is a deliberate opt-out, not a degradation.\n        emitCounter('token_revocation_fail_open_total', { reason: 'read-error' });\n        logger.debug('Token-revocation read failed (fail-open)', {\n          userId, error: errorMessage(err),\n        });\n        return null;\n      }\n    },\n    async getSessionRevocation(jti: string): Promise<SessionRevocationState> {\n      try {\n        const raw = await redis.get(sessionRevocationKey(jti));\n        return raw === null || raw === undefined ? 'live' : 'revoked';\n      } catch (err) {\n        // NOT fail-open, unlike getCurrentVersion above: `unavailable` rejects\n        // the impersonation token. Counted so a sustained outage — which stops\n        // support impersonation everywhere — is visible and alertable.\n        emitCounter('session_revocation_unavailable_total', { reason: 'read-error' });\n        logger.debug('Session-revocation read failed (rejecting impersonation token)', {\n          error: errorMessage(err),\n        });\n        return 'unavailable';\n      }\n    },\n    async isCredentialRevoked(refs: CredentialRevocationRefs): Promise<boolean> {\n      const keys = [\n        ...(refs.sid ? [credentialRevocationKey('sid', refs.sid)] : []),\n        ...refs.keyIds.map((id) => credentialRevocationKey('key', id)),\n      ];\n      if (keys.length === 0) return false;\n      try {\n        const values = await Promise.all(keys.map((k) => redis.get(k)));\n        return values.some((v) => v !== null && v !== undefined);\n      } catch (err) {\n        // Fail-open, like getCurrentVersion: a one-credential revocation is the\n        // same class of signal as a tokenVersion bump, and a Redis outage must\n        // not lock every session out. Counted so it is alertable.\n        emitCounter('token_revocation_fail_open_total', { reason: 'credential-read-error' });\n        logger.debug('Credential-revocation read failed (fail-open)', { error: errorMessage(err) });\n        return false;\n      }\n    },\n  };\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily\n * constructed from the standard `REDIS_URL` or `REDIS_SENTINELS` env —\n * for a stateless service that keeps NO Redis client of its own. The client is\n * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via\n * a guarded dynamic require so merely importing this never breaks a build/test\n * where Redis isn't present.\n *\n * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,\n * or any read failure all resolve to `null` (\"no known revocation\"), so a\n * service degrades to natural token expiry rather than locking users out. A\n * service opts in with a single boot line:\n *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`\n */\nexport function createEnvRedisTokenRevocationStore(): TokenRevocationStore {\n  type ReaderRedis = RedisCacheClient & ReadyAwareRedis;\n  // undefined = not yet attempted; null = attempted and unavailable (stay off).\n  let cached: ReaderRedis | null | undefined;\n  let ready: (() => Promise<void>) | undefined;\n\n  /**\n   * The reader client, built on first use. The env client has no offline queue,\n   * so a GET before the first connection completes is rejected — which made the\n   * FIRST impersonation check on every pod read 'unavailable' (401). Wait\n   * (bounded, never rejecting) for readiness; a genuinely down Redis then keeps\n   * the existing fail-open / 'unavailable' semantics.\n   */\n  async function client(): Promise<ReaderRedis | null> {\n    if (cached === undefined) {\n      // Shared env-configured ioredis construction (error listener attached, null\n      // when Redis isn't configured); the reader stays fail-open — a null client\n      // just falls back to natural token expiry.\n      cached = createEnvRedisClient<ReaderRedis>('revocation-reader');\n      if (cached) {\n        logger.info('Redis token-revocation reader initialized');\n        ready = createRedisReadyGate(cached);\n      }\n    }\n    if (ready) await ready();\n    return cached;\n  }\n\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      const redis = await client();\n      if (!redis) return null;\n      return createRedisTokenRevocationStore(redis).getCurrentVersion(userId);\n    },\n    async getSessionRevocation(jti: string): Promise<SessionRevocationState> {\n      const redis = await client();\n      // No Redis configured ⇒ there is no way to learn a session was ended, so\n      // an impersonation token can't be trusted. Every real deployment runs Redis\n      // (the build queue needs it), so this only bites a misconfigured service.\n      if (!redis) {\n        emitCounter('session_revocation_unavailable_total', { reason: 'not-configured' });\n        return 'unavailable';\n      }\n      return createRedisTokenRevocationStore(redis).getSessionRevocation!(jti);\n    },\n    async isCredentialRevoked(refs: CredentialRevocationRefs): Promise<boolean> {\n      const redis = await client();\n      if (!redis) return false;\n      return createRedisTokenRevocationStore(redis).isCredentialRevoked!(refs);\n    },\n  };\n}\n\n/**\n * Publish a user's current `tokenVersion` so the stateless services see the\n * revocation immediately (platform side). Best-effort — never throws; a failure\n * just means the services fall back to natural token expiry for this change.\n *\n * The write is an atomic set-if-greater ({@link SET_IF_GREATER_LUA}), so an\n * out-of-order publish can never lower the stored version.\n *\n * The key is written with a TTL equal to the access-token lifetime: any token\n * that could still carry an older version has expired by the time the entry\n * lapses, so an expired entry can never cause a false \"revoked\" nor a missed one.\n *\n * @param redis - the platform's Redis client\n * @param userId - the user whose sessions changed\n * @param tokenVersion - the user's NEW (post-increment) tokenVersion\n * @param ttlSeconds - access-token lifetime in seconds\n */\nexport async function publishTokenRevocation(\n  redis: RedisCacheClient,\n  userId: string,\n  tokenVersion: number,\n  ttlSeconds: number,\n): Promise<void> {\n  try {\n    // Atomic set-if-greater: concurrent publishes can arrive out of order, and a\n    // plain SET would let the older version win. A client that can't run Lua is\n    // refused (caught below) rather than written racily.\n    if (typeof redis.eval !== 'function') throw new Error('Redis client cannot run scripts (eval unavailable)');\n    await redis.eval(SET_IF_GREATER_LUA, 1, tokenRevocationKey(userId), String(tokenVersion), Math.max(1, Math.floor(ttlSeconds)));\n  } catch (err) {\n    logger.warn('Token-revocation publish failed (services fall back to token expiry)', {\n      userId, error: errorMessage(err),\n    });\n  }\n}\n\n/**\n * Publish that one IMPERSONATION session has ended, so every stateless service\n * rejects its token on the next request (platform side).\n *\n * Returns whether the publish landed — unlike `publishTokenRevocation`, which is\n * fire-and-forget. The caller must be able to tell the person who ended the\n * session that it did NOT end everywhere, rather than reporting success while\n * the token still works against other services.\n *\n * The entry expires with the session: once the token itself can no longer be\n * used, there is nothing left to revoke, so the key cleans itself up.\n *\n * @param ttlMs - time remaining on the session's token\n */\nexport async function publishSessionRevocation(\n  redis: RedisCacheClient,\n  jti: string,\n  ttlMs: number,\n): Promise<boolean> {\n  try {\n    await redis.set(sessionRevocationKey(jti), '1', 'PX', Math.max(1000, Math.ceil(ttlMs)));\n    return true;\n  } catch (err) {\n    logger.warn('Session-revocation publish failed (other services will honour the token until it expires)', {\n      error: errorMessage(err),\n    });\n    return false;\n  }\n}\n\n/**\n * Publish that ONE credential — a session slot (`sid`) or an access key\n * (`key`) — has been revoked, so every service rejects the tokens that name it\n * on the next request (platform side).\n *\n * `ttlSeconds` MUST be at least the longest lifetime of any token that can\n * carry this id (an access token minted from the slot, an exchanged key token,\n * or a token derived from one): the entry lapsing first would read as \"not\n * revoked\" while such a token is still alive.\n *\n * Returns whether the publish landed, so the caller can report a revocation\n * that did not reach the other services instead of claiming success.\n */\nexport async function publishCredentialRevocation(\n  redis: RedisCacheClient,\n  kind: CredentialKind,\n  id: string,\n  ttlSeconds: number,\n): Promise<boolean> {\n  try {\n    await redis.set(credentialRevocationKey(kind, id), '1', 'EX', Math.max(1, Math.ceil(ttlSeconds)));\n    return true;\n  } catch (err) {\n    logger.warn('Credential-revocation publish failed (services honour the credential until its tokens expire)', {\n      kind, error: errorMessage(err),\n    });\n    return false;\n  }\n}\n"]}

package/lib/types/audit-events.d.ts

@@ -4,19 +4,19 @@
  * Platform's own audit events (user.login, org.create, …) live in MongoDB
  * via the AuditEvent model — that's a separate persistence path scoped to
  * the platform service. The events below are emitted by other services
- * (image-registry, etc.) via the `emitAudit` helper as structured log
+ * (image-registry, etc.) via the `logAuditEvent` helper as structured log
  * lines with `eventCategory: 'audit'`, scraped by Loki for queryable
  * audit history.
  *
  * Add a new event:
  *   1. Extend the union type below.
- *   2. Document it in `docs/audit-events.md` (or wherever the audit-events
- *      doc lives) including any payload-specific fields.
- *   3. Emit via `emitAudit(logger, 'event.name', { … })` from the route.
+ *   2. Document it in `docs/audit-events.md`, including any payload-specific
+ *      fields.
+ *   3. Emit via `logAuditEvent(logger, { event: 'event.name', … })` from the route.
  */
 /**
- * Correlation context shared by every cross-service audit event. Optional so
- * existing emit sites compile unchanged; when populated, these let an operator
+ * Correlation context shared by every cross-service audit event. Optional;
+ * when populated, these let an operator
  * pivot a Loki audit line to the originating HTTP request (`requestId`) or the
  * end-to-end distributed trace (`traceId`) — and line them up with platform's
  * MongoDB audit events, which carry the same two fields.