@pipeline-builder/api-core 4.1.2 → 4.1.4

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

@@ -1,130 +1,173 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import crypto from 'crypto';
-import { createEnvRedisClient } from './env-redis.js';
+import { createEnvRedisClient, createRedisReadyGate } from './env-redis.js';
 import { createLogger } from '../utils/logger.js';
 const logger = createLogger('sse-ticket-store');
-/** Redis key namespaces. Ticket → orgId; windowed issue counters bound abuse. */
-const TICKET_KEY_PREFIX = 'sse:tk:';
-const ORG_COUNT_PREFIX = 'sse:tkc:';
-const TOTAL_COUNT_KEY = 'sse:tkc:__all__';
 function newTicketId() {
     return crypto.randomBytes(24).toString('base64url');
 }
-/**
- * In-memory backend — the original single-process behaviour. Counts LIVE
- * (unexpired) tickets per org and evicts expired entries on a timer. Correct
- * only within one process, so it is the fallback used when Redis isn't configured.
- */
-function createInMemorySseTicketStore(config) {
-    const store = new Map();
-    const cleanup = setInterval(() => {
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** In-memory backend — single-process fallback when Redis isn't configured. */
+export function createMemorySseTicketStore(config) {
+    const tickets = new Map();
+    const owners = new Map();
+    const sweep = () => {
         const now = Date.now();
-        for (const [id, t] of store)
-            if (now > t.expiresAt)
-                store.delete(id);
-    }, config.ttlMs);
-    cleanup.unref();
-    function countLiveForOrg(orgId, now) {
-        let count = 0;
-        for (const t of store.values())
-            if (t.orgId === orgId && t.expiresAt > now)
-                count++;
-        return count;
-    }
+        for (const [id, t] of tickets)
+            if (now >= t.expiresAt)
+                tickets.delete(id);
+        for (const [id, o] of owners)
+            if (now >= o.expiresAt)
+                owners.delete(id);
+    };
+    const timer = setInterval(sweep, Math.max(1_000, config.ttlMs));
+    timer.unref();
     return {
-        async issue(orgId) {
-            const now = Date.now();
-            if (store.size >= config.maxTotal)
+        async issue(orgId, subject) {
+            sweep();
+            if (tickets.size >= config.maxTotal)
                 return { ok: false, reason: 'total' };
-            if (countLiveForOrg(orgId, now) >= config.maxPerOrg)
+            let forOrg = 0;
+            for (const t of tickets.values())
+                if (t.orgId === orgId)
+                    forOrg++;
+            if (forOrg >= config.maxPerOrg)
                 return { ok: false, reason: 'org' };
             const ticket = newTicketId();
-            store.set(ticket, { orgId, expiresAt: now + config.ttlMs });
+            tickets.set(ticket, { orgId, ...(subject !== undefined && { subject }), expiresAt: Date.now() + config.ttlMs });
             return { ok: true, ticket };
         },
         async consume(ticketId) {
-            const t = store.get(ticketId);
-            store.delete(ticketId); // single-use — consume immediately
-            if (!t || Date.now() > t.expiresAt)
+            const t = tickets.get(ticketId);
+            tickets.delete(ticketId); // single-use — gone whether or not it was valid
+            if (!t || Date.now() >= t.expiresAt)
                 return null;
-            return { orgId: t.orgId };
+            return { orgId: t.orgId, ...(t.subject !== undefined && { subject: t.subject }) };
+        },
+        async bindOwner(subject, orgId, ttlMs) {
+            owners.set(subject, { orgId, expiresAt: Date.now() + ttlMs });
+        },
+        async getOwner(subject) {
+            const o = owners.get(subject);
+            if (!o)
+                return null;
+            if (Date.now() >= o.expiresAt) {
+                owners.delete(subject);
+                return null;
+            }
+            return o.orgId;
         },
-        stop() { clearInterval(cleanup); },
+        stop() { clearInterval(timer); },
     };
 }
 /**
- * Redis backend — multi-replica safe. Tickets live under a TTL'd key so any pod
- * can redeem one; {@link SseTicketStore.consume} uses GETDEL so redemption is
- * atomic (two pods can't both spend the same ticket). The per-org / global caps
- * become windowed rate limits (max mints per TTL window) via INCR + first-hit
- * EXPIRE — equivalent abuse bounding to the in-memory live-count, and it also
- * caps churn.
+ * Atomic live-count issue. Prunes expired members from both cap sets, checks the
+ * total then the per-org cap, and only then stores the ticket and records it in
+ * both sets — so concurrent mints can't overshoot a cap and a cap can never
+ * stick (every member carries its own expiry score and every key a TTL).
  *
- * Fail-CLOSED by design (unlike the fail-open token-revocation reader): if Redis
- * errors, `issue` returns a cap rejection and `consume` returns null, so a Redis
- * outage degrades to "no live notifications" rather than handing out or
- * accepting unvalidated tickets. SSE notifications are non-critical, so failing
- * closed here costs only real-time delivery, never correctness.
+ * KEYS: total zset, org zset, ticket key.
+ * ARGV: ttlMs, maxTotal, maxPerOrg, ticketId, record JSON.
+ * Uses the server clock so every pod agrees on "expired".
  */
-function createRedisSseTicketStore(redis, config) {
-    const ttlSec = Math.max(1, Math.ceil(config.ttlMs / 1000));
-    // Per-channel namespace so two services' ticket stores don't share keys.
+const ISSUE_SCRIPT = `
+local t = redis.call('TIME')
+local now = tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000)
+local ttl = tonumber(ARGV[1])
+redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', now)
+redis.call('ZREMRANGEBYSCORE', KEYS[2], '-inf', now)
+if redis.call('ZCARD', KEYS[1]) >= tonumber(ARGV[2]) then return 'total' end
+if redis.call('ZCARD', KEYS[2]) >= tonumber(ARGV[3]) then return 'org' end
+redis.call('SET', KEYS[3], ARGV[5], 'PX', ttl)
+redis.call('ZADD', KEYS[1], now + ttl, ARGV[4])
+redis.call('ZADD', KEYS[2], now + ttl, ARGV[4])
+redis.call('PEXPIRE', KEYS[1], ttl)
+redis.call('PEXPIRE', KEYS[2], ttl)
+return 'ok'`;
+/**
+ * Redis backend — multi-replica safe.
+ *
+ * Fail-CLOSED: a Redis error makes `issue` reject (`total`), `consume` return
+ * null and `getOwner` throw, so an outage degrades to "no live stream" rather
+ * than handing out or accepting unvalidated tickets. `bindOwner` is best-effort.
+ */
+export function createRedisSseTicketStore(redis, config) {
     const ns = config.keyPrefix ? `${config.keyPrefix}:` : '';
-    const ticketKey = (t) => `${ns}${TICKET_KEY_PREFIX}${t}`;
-    const orgCountKey = (o) => `${ns}${ORG_COUNT_PREFIX}${o}`;
-    const totalCountKey = `${ns}${TOTAL_COUNT_KEY}`;
-    // Windowed counter: INCR, and on the first hit of a window set the TTL so it
-    // auto-resets. Returns true while still within `limit` for this window.
-    async function withinWindow(key, limit) {
-        const n = await redis.incr(key);
-        if (n === 1)
-            await redis.expire(key, ttlSec);
-        return n <= limit;
-    }
+    const ticketKey = (t) => `${ns}sse:tk:${t}`;
+    const orgSetKey = (o) => `${ns}sse:tkz:org:${o}`;
+    const totalSetKey = `${ns}sse:tkz:all`;
+    const ownerKey = (s) => `${ns}sse:owner:${s}`;
+    const ttlMs = Math.max(1, Math.ceil(config.ttlMs));
+    // The env client has no offline queue: wait (bounded) for the first connection
+    // so the first mint/redeem after boot isn't rejected outright.
+    const ready = createRedisReadyGate(redis);
     return {
-        async issue(orgId) {
+        async issue(orgId, subject) {
             try {
-                if (!(await withinWindow(totalCountKey, config.maxTotal)))
-                    return { ok: false, reason: 'total' };
-                if (!(await withinWindow(orgCountKey(orgId), config.maxPerOrg)))
-                    return { ok: false, reason: 'org' };
+                await ready();
                 const ticket = newTicketId();
-                await redis.set(ticketKey(ticket), orgId, 'EX', ttlSec);
-                return { ok: true, ticket };
+                const record = { orgId, ...(subject !== undefined && { subject }) };
+                const outcome = await redis.eval(ISSUE_SCRIPT, 3, totalSetKey, orgSetKey(orgId), ticketKey(ticket), ttlMs, config.maxTotal, config.maxPerOrg, ticket, JSON.stringify(record));
+                if (outcome === 'ok')
+                    return { ok: true, ticket };
+                return { ok: false, reason: outcome === 'org' ? 'org' : 'total' };
             }
             catch (err) {
-                logger.warn('SSE ticket issue failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });
+                logger.warn('SSE ticket issue failed (fail-closed)', { error: errMsg(err) });
                 return { ok: false, reason: 'total' };
             }
         },
         async consume(ticketId) {
             try {
-                const orgId = await redis.getdel(ticketKey(ticketId));
-                return orgId ? { orgId } : null;
+                await ready();
+                const raw = await redis.getdel(ticketKey(ticketId));
+                if (!raw)
+                    return null;
+                const rec = JSON.parse(raw);
+                if (typeof rec?.orgId !== 'string')
+                    return null;
+                // 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) }));
+                return rec;
             }
             catch (err) {
-                logger.warn('SSE ticket consume failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });
+                logger.warn('SSE ticket consume failed (fail-closed)', { error: errMsg(err) });
                 return null;
             }
         },
+        async bindOwner(subject, orgId, ownerTtlMs) {
+            try {
+                await ready();
+                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) });
+            }
+        },
+        async getOwner(subject) {
+            await ready();
+            return redis.get(ownerKey(subject));
+        },
         stop() { },
     };
 }
 /**
  * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or
- * `REDIS_HOST`/`REDIS_PORT`). Uses the Redis backend when configured
- * (multi-replica safe), otherwise falls back to the in-memory single-process
- * backend. A service opts in with one boot line:
- *   `const tickets = createEnvSseTicketStore({ ttlMs, maxTotal, maxPerOrg });`
+ * `REDIS_SENTINELS`): the Redis backend when configured (multi-replica safe),
+ * otherwise the in-memory single-process backend.
  */
 export function createEnvSseTicketStore(config) {
     const redis = createEnvRedisClient('sse-ticket');
     if (redis) {
-        logger.info('SSE ticket store: Redis backend (multi-replica)');
+        logger.info('SSE ticket store: Redis backend (multi-replica)', { keyPrefix: config.keyPrefix });
         return createRedisSseTicketStore(redis, config);
     }
-    logger.info('SSE ticket store: in-memory backend (single-process fallback)');
-    return createInMemorySseTicketStore(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":"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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 } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('sse-ticket-store');\n\n/** Redis key namespaces. Ticket → orgId; windowed issue counters bound abuse. */\nconst TICKET_KEY_PREFIX = 'sse:tk:';\nconst ORG_COUNT_PREFIX = 'sse:tkc:';\nconst TOTAL_COUNT_KEY = 'sse:tkc:__all__';\n\n/** Result of {@link SseTicketStore.issue}. */\nexport type SseTicketIssueResult =\n  | { ok: true; ticket: string }\n  | { ok: false; reason: 'total' | 'org' };\n\n/**\n * Store for short-lived, single-use SSE auth tickets. A client exchanges its JWT\n * for a ticket (so the token never lands in an EventSource query string / access\n * log), then redeems it on the SSE `GET`.\n *\n * The store is the multi-replica correctness boundary: a ticket minted on pod A\n * MUST be redeemable on pod B. The Redis backend makes that true; the in-memory\n * backend is a single-process fallback for dev / single-replica installs.\n */\nexport interface SseTicketStore {\n  /** Mint a ticket for `orgId`, or reject when a rate window is saturated. */\n  issue(orgId: string): Promise<SseTicketIssueResult>;\n  /** Atomically redeem a ticket exactly once; returns its org or null if invalid/expired/spent. */\n  consume(ticketId: string): Promise<{ orgId: 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  /** Hard cap on tickets minted per TTL window across all orgs (abuse bound). */\n  maxTotal: number;\n  /** Per-org cap on tickets minted per TTL window (single-tenant abuse bound). */\n  maxPerOrg: number;\n  /**\n   * Optional Redis key namespace so independent channels (e.g. message\n   * notifications vs. reporting execution-status) don't share one ticket\n   * keyspace — a ticket minted for one channel must not be redeemable on\n   * another. Omit for the default (shared) namespace.\n   */\n  keyPrefix?: string;\n}\n\n/** Minimal ioredis surface this store needs (GETDEL requires Redis ≥ 6.2). */\ninterface SseRedis {\n  incr(key: string): Promise<number>;\n  expire(key: string, seconds: number): Promise<unknown>;\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  getdel(key: string): Promise<string | null>;\n}\n\nfunction newTicketId(): string {\n  return crypto.randomBytes(24).toString('base64url');\n}\n\n/**\n * In-memory backend — the original single-process behaviour. Counts LIVE\n * (unexpired) tickets per org and evicts expired entries on a timer. Correct\n * only within one process, so it is the fallback used when Redis isn't configured.\n */\nfunction createInMemorySseTicketStore(config: SseTicketStoreConfig): SseTicketStore {\n  interface Entry { orgId: string; expiresAt: number }\n  const store = new Map<string, Entry>();\n\n  const cleanup = setInterval(() => {\n    const now = Date.now();\n    for (const [id, t] of store) if (now > t.expiresAt) store.delete(id);\n  }, config.ttlMs);\n  cleanup.unref();\n\n  function countLiveForOrg(orgId: string, now: number): number {\n    let count = 0;\n    for (const t of store.values()) if (t.orgId === orgId && t.expiresAt > now) count++;\n    return count;\n  }\n\n  return {\n    async issue(orgId: string): Promise<SseTicketIssueResult> {\n      const now = Date.now();\n      if (store.size >= config.maxTotal) return { ok: false, reason: 'total' };\n      if (countLiveForOrg(orgId, now) >= config.maxPerOrg) return { ok: false, reason: 'org' };\n      const ticket = newTicketId();\n      store.set(ticket, { orgId, expiresAt: now + config.ttlMs });\n      return { ok: true, ticket };\n    },\n    async consume(ticketId: string): Promise<{ orgId: string } | null> {\n      const t = store.get(ticketId);\n      store.delete(ticketId); // single-use — consume immediately\n      if (!t || Date.now() > t.expiresAt) return null;\n      return { orgId: t.orgId };\n    },\n    stop(): void { clearInterval(cleanup); },\n  };\n}\n\n/**\n * Redis backend — multi-replica safe. Tickets live under a TTL'd key so any pod\n * can redeem one; {@link SseTicketStore.consume} uses GETDEL so redemption is\n * atomic (two pods can't both spend the same ticket). The per-org / global caps\n * become windowed rate limits (max mints per TTL window) via INCR + first-hit\n * EXPIRE — equivalent abuse bounding to the in-memory live-count, and it also\n * caps churn.\n *\n * Fail-CLOSED by design (unlike the fail-open token-revocation reader): if Redis\n * errors, `issue` returns a cap rejection and `consume` returns null, so a Redis\n * outage degrades to \"no live notifications\" rather than handing out or\n * accepting unvalidated tickets. SSE notifications are non-critical, so failing\n * closed here costs only real-time delivery, never correctness.\n */\nfunction createRedisSseTicketStore(redis: SseRedis, config: SseTicketStoreConfig): SseTicketStore {\n  const ttlSec = Math.max(1, Math.ceil(config.ttlMs / 1000));\n  // Per-channel namespace so two services' ticket stores don't share keys.\n  const ns = config.keyPrefix ? `${config.keyPrefix}:` : '';\n  const ticketKey = (t: string) => `${ns}${TICKET_KEY_PREFIX}${t}`;\n  const orgCountKey = (o: string) => `${ns}${ORG_COUNT_PREFIX}${o}`;\n  const totalCountKey = `${ns}${TOTAL_COUNT_KEY}`;\n\n  // Windowed counter: INCR, and on the first hit of a window set the TTL so it\n  // auto-resets. Returns true while still within `limit` for this window.\n  async function withinWindow(key: string, limit: number): Promise<boolean> {\n    const n = await redis.incr(key);\n    if (n === 1) await redis.expire(key, ttlSec);\n    return n <= limit;\n  }\n\n  return {\n    async issue(orgId: string): Promise<SseTicketIssueResult> {\n      try {\n        if (!(await withinWindow(totalCountKey, config.maxTotal))) return { ok: false, reason: 'total' };\n        if (!(await withinWindow(orgCountKey(orgId), config.maxPerOrg))) return { ok: false, reason: 'org' };\n        const ticket = newTicketId();\n        await redis.set(ticketKey(ticket), orgId, 'EX', ttlSec);\n        return { ok: true, ticket };\n      } catch (err) {\n        logger.warn('SSE ticket issue failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });\n        return { ok: false, reason: 'total' };\n      }\n    },\n    async consume(ticketId: string): Promise<{ orgId: string } | null> {\n      try {\n        const orgId = await redis.getdel(ticketKey(ticketId));\n        return orgId ? { orgId } : null;\n      } catch (err) {\n        logger.warn('SSE ticket consume failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n    stop(): void { /* Redis keys expire on their own TTL — nothing to release. */ },\n  };\n}\n\n/**\n * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or\n * `REDIS_HOST`/`REDIS_PORT`). Uses the Redis backend when configured\n * (multi-replica safe), otherwise falls back to the in-memory single-process\n * backend. A service opts in with one boot line:\n *   `const tickets = createEnvSseTicketStore({ ttlMs, maxTotal, maxPerOrg });`\n */\nexport function createEnvSseTicketStore(config: SseTicketStoreConfig): SseTicketStore {\n  const redis = createEnvRedisClient<SseRedis>('sse-ticket');\n  if (redis) {\n    logger.info('SSE ticket store: Redis backend (multi-replica)');\n    return createRedisSseTicketStore(redis, config);\n  }\n  logger.info('SSE ticket store: in-memory backend (single-process fallback)');\n  return createInMemorySseTicketStore(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 { createLogger } from '../utils/logger.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 err instanceof Error ? err.message : String(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"]}

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

@@ -30,7 +30,7 @@ export declare function sessionRevocationKey(jti: string): string;
 export declare function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore;
 /**
  * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily
- * constructed from the standard `REDIS_URL` or `REDIS_HOST`/`REDIS_PORT` env —
+ * constructed from the standard `REDIS_URL` or `REDIS_SENTINELS` env —
  * for a stateless service that keeps NO Redis client of its own. The client is
  * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via
  * a guarded dynamic require so merely importing this never breaks a build/test

package/lib/services/token-revocation.js

@@ -1,6 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { createEnvRedisClient } from './env-redis.js';
+import { createEnvRedisClient, createRedisReadyGate } from './env-redis.js';
 import { createLogger } from '../utils/logger.js';
 import { emitCounter } from '../utils/metric-emitter.js';
 const logger = createLogger('token-revocation');
@@ -84,7 +84,7 @@ export function createRedisTokenRevocationStore(redis) {
 }
 /**
  * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily
- * constructed from the standard `REDIS_URL` or `REDIS_HOST`/`REDIS_PORT` env —
+ * constructed from the standard `REDIS_URL` or `REDIS_SENTINELS` env —
  * for a stateless service that keeps NO Redis client of its own. The client is
  * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via
  * a guarded dynamic require so merely importing this never breaks a build/test
@@ -99,34 +99,46 @@ export function createRedisTokenRevocationStore(redis) {
 export function createEnvRedisTokenRevocationStore() {
     // undefined = not yet attempted; null = attempted and unavailable (stay off).
     let cached;
-    function build() {
-        // Shared env-configured ioredis construction (fail-open, error-listener
-        // attached, null when Redis isn't configured/available); the reader stays
-        // fail-open — a null client just falls back to natural token expiry.
-        const inst = createEnvRedisClient('revocation-reader');
-        if (inst)
-            logger.info('Redis token-revocation reader initialized');
-        return inst;
+    let ready;
+    /**
+     * The reader client, built on first use. The env client has no offline queue,
+     * so a GET before the first connection completes is rejected — which made the
+     * FIRST impersonation check on every pod read 'unavailable' (401). Wait
+     * (bounded, never rejecting) for readiness; a genuinely down Redis then keeps
+     * the existing fail-open / 'unavailable' semantics.
+     */
+    async function client() {
+        if (cached === undefined) {
+            // Shared env-configured ioredis construction (error listener attached, null
+            // when Redis isn't configured); the reader stays fail-open — a null client
+            // just falls back to natural token expiry.
+            cached = createEnvRedisClient('revocation-reader');
+            if (cached) {
+                logger.info('Redis token-revocation reader initialized');
+                ready = createRedisReadyGate(cached);
+            }
+        }
+        if (ready)
+            await ready();
+        return cached;
     }
     return {
         async getCurrentVersion(userId) {
-            if (cached === undefined)
-                cached = build();
-            if (!cached)
+            const redis = await client();
+            if (!redis)
                 return null;
-            return createRedisTokenRevocationStore(cached).getCurrentVersion(userId);
+            return createRedisTokenRevocationStore(redis).getCurrentVersion(userId);
         },
         async getSessionRevocation(jti) {
-            if (cached === undefined)
-                cached = build();
+            const redis = await client();
             // No Redis configured ⇒ there is no way to learn a session was ended, so
             // an impersonation token can't be trusted. Every real deployment runs Redis
             // (the build queue needs it), so this only bites a misconfigured service.
-            if (!cached) {
+            if (!redis) {
                 emitCounter('session_revocation_unavailable_total', { reason: 'not-configured' });
                 return 'unavailable';
             }
-            return createRedisTokenRevocationStore(cached).getSessionRevocation(jti);
+            return createRedisTokenRevocationStore(redis).getSessionRevocation(jti);
         },
     };
 }
@@ -181,4 +193,4 @@ 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 } 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';\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: err instanceof Error ? err.message : String(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: err instanceof Error ? err.message : String(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_HOST`/`REDIS_PORT` 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  // undefined = not yet attempted; null = attempted and unavailable (stay off).\n  let cached: RedisCacheClient | null | undefined;\n\n  function build(): RedisCacheClient | null {\n    // Shared env-configured ioredis construction (fail-open, error-listener\n    // attached, null when Redis isn't configured/available); the reader stays\n    // fail-open — a null client just falls back to natural token expiry.\n    const inst = createEnvRedisClient<RedisCacheClient>('revocation-reader');\n    if (inst) logger.info('Redis token-revocation reader initialized');\n    return inst;\n  }\n\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      if (cached === undefined) cached = build();\n      if (!cached) return null;\n      return createRedisTokenRevocationStore(cached).getCurrentVersion(userId);\n    },\n    async getSessionRevocation(jti: string): Promise<SessionRevocationState> {\n      if (cached === undefined) cached = build();\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 (!cached) {\n        emitCounter('session_revocation_unavailable_total', { reason: 'not-configured' });\n        return 'unavailable';\n      }\n      return createRedisTokenRevocationStore(cached).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: err instanceof Error ? err.message : String(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: err instanceof Error ? err.message : String(err),\n    });\n    return false;\n  }\n}\n"]}
+//# 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';\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: err instanceof Error ? err.message : String(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: err instanceof Error ? err.message : String(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: err instanceof Error ? err.message : String(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: err instanceof Error ? err.message : String(err),\n    });\n    return false;\n  }\n}\n"]}

package/lib/testing/route-coverage.d.ts

@@ -0,0 +1,64 @@
+import { type RouteTableEntry } from '../middleware/route-table.js';
+/** A rule a route is allowed not to satisfy, with the reason it is exempt. */
+export interface RouteCoverageException {
+    /** HTTP method, or '*' for any. */
+    method?: string;
+    /** Exact route path, or a pattern matched against `METHOD /path`. */
+    path: string | RegExp;
+    /** Which rule is waived: the permission gate, the audit declaration, or both. */
+    waive: 'permission' | 'audit' | 'all';
+    /** Why this route can't carry the gate/audit. Required — no silent allowlisting. */
+    reason: string;
+    /**
+     * Skip the staleness check for this entry. Only for the shared
+     * {@link INFRA_ROUTE_EXCEPTIONS}, whose routes depend on per-service
+     * `createApp` options (OpenAPI docs, log stream) — a service that doesn't
+     * enable them would otherwise fail on an "unused" shared exception.
+     */
+    optional?: boolean;
+}
+/**
+ * Exceptions every service inherits from `createApp`'s infrastructure routes:
+ * unauthenticated probes, the service-principal-gated warm-up, the metrics
+ * scrape endpoint, the OpenAPI docs, and the ticket-gated SSE log stream.
+ */
+export declare const INFRA_ROUTE_EXCEPTIONS: readonly RouteCoverageException[];
+/** The outcome of a coverage check: what fails, and which exceptions went unused. */
+export interface RouteCoverageResult {
+    /** One human-readable line per uncovered route (empty ⇒ full coverage). */
+    violations: string[];
+    /** Exceptions that waived nothing — stale entries to delete. */
+    unusedExceptions: string[];
+}
+/** Check a service's route table against the coverage rules. */
+export declare function findRouteCoverageViolations(table: readonly RouteTableEntry[], exceptions?: readonly RouteCoverageException[]): RouteCoverageResult;
+/** One internal route a service declares, and the services allowed to call it. */
+export interface InternalRouteDeclaration {
+    method: string;
+    path: string;
+    /** The `callers` passed to `requireInternalService` — also what the mesh policy names. */
+    callers: string[];
+}
+/**
+ * Check a service's INTERNAL routes (#14) against what it declares.
+ *
+ * The declaration is the single list a service maintains, and it is checked in
+ * BOTH directions, so neither side can drift:
+ *
+ *  - every declared route must exist and be gated by `requireInternalService`
+ *    with exactly the declared callers (and `requireAuth` before it);
+ *  - every route the table says is internal must be declared — so adding one
+ *    forces a visible change here, and the Istio `AuthorizationPolicy` that
+ *    names the same callers (`deploy/*​/k8s/istio-internal-routes.yaml`) has
+ *    one authoritative list to be reviewed against.
+ */
+export declare function findInternalRouteViolations(table: readonly RouteTableEntry[], declared: readonly InternalRouteDeclaration[]): string[];
+/** Every audit action declared anywhere in a route table. */
+export declare function declaredAuditActions(table: readonly RouteTableEntry[]): string[];
+/**
+ * Compare a service's route table to its checked-in copy under
+ * `frontend/src/generated/route-table/` — the file the frontend's `can(...)`
+ * tests read. Returns a diff message, or `null` when they match. Set
+ * `UPDATE_ROUTE_TABLES=1` to rewrite the file after an intended route change.
+ */
+export declare function compareRouteTableSnapshot(table: readonly RouteTableEntry[], file: string): string | null;