@pipeline-builder/api-server 4.1.3 → 4.1.5

package/lib/http/sse-relay.js

@@ -3,32 +3,46 @@
 import { createLogger, createEnvRedisClient } from '@pipeline-builder/api-core';
 const logger = createLogger('sse-relay');
 /**
- * Single channel carrying every relayed frame. `requestId` rides in the message
- * body rather than the channel name so each pod SUBSCRIBES exactly once on
- * startup — no per-subject subscribe/unsubscribe churn as clients come and go.
+ * The relay channel for one service. Every replica of a service shares it, and
+ * no other service does: an SSE subject (an org id, a build requestId) only has
+ * meaning inside the service whose clients subscribed to it, so a shared channel
+ * made every service's pods parse — and re-emit to same-named subjects — every
+ * other service's frames. `requestId` rides in the message body rather than the
+ * channel name so each pod SUBSCRIBES exactly once on startup — no per-subject
+ * subscribe/unsubscribe churn as clients come and go.
  */
-const RELAY_CHANNEL = 'sse:relay';
+export function sseRelayChannel(serviceName) {
+    return `sse:relay:${serviceName}`;
+}
+/** Backoff bounds for the startup SUBSCRIBE retry. */
+const SUBSCRIBE_RETRY_MIN_MS = 500;
+const SUBSCRIBE_RETRY_MAX_MS = 30_000;
 /**
  * Redis-backed relay. Uses the given client for PUBLISH and a `duplicate()` for
  * SUBSCRIBE (ioredis forbids mixing subscribe with normal commands on one
  * connection). Publish is fire-and-forget with a swallowed rejection; a subscribe
  * handler that throws is isolated so one bad frame can't kill the subscriber.
  */
-export function createRedisSSERelay(publisher) {
+export function createRedisSSERelay(publisher, channel) {
     const subscriber = publisher.duplicate();
+    // A duplicated ioredis connection doesn't inherit the publisher's listeners;
+    // without its own, a dropped connection is an unhandled 'error' that crashes Node.
+    subscriber.on('error', (err) => {
+        logger.warn('SSE relay subscriber connection error', { channel, error: err instanceof Error ? err.message : String(err) });
+    });
     let closed = false;
     return {
         publish(msg) {
             if (closed)
                 return;
             // Fire-and-forget: never await, never surface a rejection to the caller.
-            void Promise.resolve(publisher.publish(RELAY_CHANNEL, JSON.stringify(msg))).catch((err) => {
+            void Promise.resolve(publisher.publish(channel, JSON.stringify(msg))).catch((err) => {
                 logger.warn('SSE relay publish failed', { error: err instanceof Error ? err.message : String(err) });
             });
         },
         subscribe(handler) {
-            subscriber.on('message', (channel, message) => {
-                if (channel !== RELAY_CHANNEL)
+            subscriber.on('message', (received, message) => {
+                if (received !== channel)
                     return;
                 let parsed;
                 try {
@@ -45,9 +59,22 @@ export function createRedisSSERelay(publisher) {
                     logger.warn('SSE relay handler threw', { error: err instanceof Error ? err.message : String(err) });
                 }
             });
-            void Promise.resolve(subscriber.subscribe(RELAY_CHANNEL)).catch((err) => {
-                logger.warn('SSE relay subscribe failed — falling back to local-only delivery', { error: err instanceof Error ? err.message : String(err) });
-            });
+            // Retry until subscribed: at startup the connection usually isn't up yet,
+            // and giving up after one attempt left the pod on local-only delivery for
+            // its whole life. Once subscribed, ioredis re-subscribes after reconnects.
+            let delayMs = SUBSCRIBE_RETRY_MIN_MS;
+            const attempt = () => {
+                if (closed)
+                    return;
+                void Promise.resolve(subscriber.subscribe(channel)).then(() => logger.info('SSE relay subscribed', { channel }), (err) => {
+                    logger.warn('SSE relay subscribe failed; retrying (local-only delivery meanwhile)', {
+                        retryInMs: delayMs, error: err instanceof Error ? err.message : String(err),
+                    });
+                    setTimeout(attempt, delayMs).unref?.();
+                    delayMs = Math.min(delayMs * 2, SUBSCRIBE_RETRY_MAX_MS);
+                });
+            };
+            attempt();
         },
         async close() {
             closed = true;
@@ -56,15 +83,16 @@ export function createRedisSSERelay(publisher) {
     };
 }
 /**
- * Build a Redis-backed SSE relay from the shared env Redis (same wiring as the
- * SSE ticket store / rate-limiter / audit-spool). Returns null when Redis isn't
- * configured so the caller keeps local-only delivery. Never throws.
+ * Build a Redis-backed SSE relay from the shared env Redis, on this service's
+ * own channel (`SERVICE_NAME`). Returns null when Redis isn't configured so the
+ * caller keeps local-only delivery.
  */
-export function createEnvRedisSSERelay() {
+export function createEnvRedisSSERelay(serviceName = process.env.SERVICE_NAME || 'api') {
     const client = createEnvRedisClient('sse-relay');
     if (!client)
         return null;
-    logger.info('Redis SSE relay initialized (cross-pod fan-out enabled)');
-    return createRedisSSERelay(client);
+    const channel = sseRelayChannel(serviceName);
+    logger.info('Redis SSE relay initialized (cross-pod fan-out enabled)', { channel });
+    return createRedisSSERelay(client, channel);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-relay.js","sourceRoot":"","sources":["../../src/http/sse-relay.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger, createEnvRedisClient } from '@pipeline-builder/api-core';\nimport type { SSEPayload } from './sse-connection-manager.js';\n\nconst logger = createLogger('sse-relay');\n\n/**\n * A relayed SSE frame. `origin` is the id of the SSEManager instance that\n * published it, so the publishing pod can ignore its own echo (it already wrote\n * the frame to its local clients before publishing). `kind` distinguishes a\n * per-subject `send` (carries `requestId`) from a `broadcast` (no subject —\n * every pod re-emits to ALL of its local clients).\n */\nexport interface SSERelayMessage {\n  origin: string;\n  kind: 'send' | 'broadcast';\n  /** Present for `send`; the stream subject the payload targets. */\n  requestId?: string;\n  payload: SSEPayload;\n}\n\n/**\n * Cross-pod fan-out bus for SSE frames.\n *\n * Under multiple replicas the producer of a log frame (e.g. a plugin build\n * worker on pod A) and the consumer (a browser EventSource on pod B) are on\n * DIFFERENT pods. The in-process client map only reaches the producer's own\n * pod, so B's stream would silently miss frames. The relay closes that: every\n * pod SUBSCRIBES once on startup and re-emits received frames to its LOCAL\n * clients, while `send()`/`broadcast()` PUBLISH to the bus (in addition to\n * writing locally). The origin tag prevents a pod from double-delivering its own\n * frame when it receives its own publish back.\n *\n * All methods are best-effort / fail-safe: a bus outage must degrade to\n * local-only delivery (today's single-replica behavior), never crash the stream.\n */\nexport interface SSERelay {\n  /** Fire-and-forget publish of a frame to every subscribed pod. Never throws. */\n  publish(msg: SSERelayMessage): void;\n  /** Subscribe this pod's re-emit handler. Called once on manager construction. */\n  subscribe(handler: (msg: SSERelayMessage) => void): void;\n  /** Tear down the underlying connection(s). */\n  close(): Promise<void>;\n}\n\n/**\n * Minimal ioredis pub/sub surface the Redis relay needs. `subscribe` requires a\n * DEDICATED connection (a subscribed ioredis client can't run other commands),\n * so the relay `duplicate()`s the publisher for the subscriber side.\n */\nexport interface RedisPubSubClient {\n  publish(channel: string, message: string): Promise<number>;\n  subscribe(...channels: string[]): Promise<unknown>;\n  on(event: 'message', cb: (channel: string, message: string) => void): void;\n  duplicate(): RedisPubSubClient;\n  quit(): Promise<unknown>;\n}\n\n/**\n * Single channel carrying every relayed frame. `requestId` rides in the message\n * body rather than the channel name so each pod SUBSCRIBES exactly once on\n * startup — no per-subject subscribe/unsubscribe churn as clients come and go.\n */\nconst RELAY_CHANNEL = 'sse:relay';\n\n/**\n * Redis-backed relay. Uses the given client for PUBLISH and a `duplicate()` for\n * SUBSCRIBE (ioredis forbids mixing subscribe with normal commands on one\n * connection). Publish is fire-and-forget with a swallowed rejection; a subscribe\n * handler that throws is isolated so one bad frame can't kill the subscriber.\n */\nexport function createRedisSSERelay(publisher: RedisPubSubClient): SSERelay {\n  const subscriber = publisher.duplicate();\n  let closed = false;\n\n  return {\n    publish(msg) {\n      if (closed) return;\n      // Fire-and-forget: never await, never surface a rejection to the caller.\n      void Promise.resolve(publisher.publish(RELAY_CHANNEL, JSON.stringify(msg))).catch((err) => {\n        logger.warn('SSE relay publish failed', { error: err instanceof Error ? err.message : String(err) });\n      });\n    },\n    subscribe(handler) {\n      subscriber.on('message', (channel, message) => {\n        if (channel !== RELAY_CHANNEL) return;\n        let parsed: SSERelayMessage;\n        try {\n          parsed = JSON.parse(message) as SSERelayMessage;\n        } catch (err) {\n          logger.warn('SSE relay received unparseable frame', { error: err instanceof Error ? err.message : String(err) });\n          return;\n        }\n        try {\n          handler(parsed);\n        } catch (err) {\n          logger.warn('SSE relay handler threw', { error: err instanceof Error ? err.message : String(err) });\n        }\n      });\n      void Promise.resolve(subscriber.subscribe(RELAY_CHANNEL)).catch((err) => {\n        logger.warn('SSE relay subscribe failed — falling back to local-only delivery', { error: err instanceof Error ? err.message : String(err) });\n      });\n    },\n    async close() {\n      closed = true;\n      await Promise.allSettled([publisher.quit(), subscriber.quit()]);\n    },\n  };\n}\n\n/**\n * Build a Redis-backed SSE relay from the shared env Redis (same wiring as the\n * SSE ticket store / rate-limiter / audit-spool). Returns null when Redis isn't\n * configured so the caller keeps local-only delivery. Never throws.\n */\nexport function createEnvRedisSSERelay(): SSERelay | null {\n  const client = createEnvRedisClient<RedisPubSubClient>('sse-relay');\n  if (!client) return null;\n  logger.info('Redis SSE relay initialized (cross-pod fan-out enabled)');\n  return createRedisSSERelay(client);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-relay.js","sourceRoot":"","sources":["../../src/http/sse-relay.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger, createEnvRedisClient } from '@pipeline-builder/api-core';\nimport type { SSEPayload } from './sse-connection-manager.js';\n\nconst logger = createLogger('sse-relay');\n\n/**\n * A relayed SSE frame. `origin` is the id of the SSEManager instance that\n * published it, so the publishing pod can ignore its own echo (it already wrote\n * the frame to its local clients before publishing). `kind` distinguishes a\n * per-subject `send` (carries `requestId`) from a `broadcast` (no subject —\n * every pod re-emits to ALL of its local clients).\n */\nexport interface SSERelayMessage {\n  origin: string;\n  kind: 'send' | 'broadcast';\n  /** Present for `send`; the stream subject the payload targets. */\n  requestId?: string;\n  payload: SSEPayload;\n}\n\n/**\n * Cross-pod fan-out bus for SSE frames.\n *\n * Under multiple replicas the producer of a log frame (e.g. a plugin build\n * worker on pod A) and the consumer (a browser EventSource on pod B) are on\n * DIFFERENT pods. The in-process client map only reaches the producer's own\n * pod, so B's stream would silently miss frames. The relay closes that: every\n * pod SUBSCRIBES once on startup and re-emits received frames to its LOCAL\n * clients, while `send()`/`broadcast()` PUBLISH to the bus (in addition to\n * writing locally). The origin tag prevents a pod from double-delivering its own\n * frame when it receives its own publish back.\n *\n * All methods are best-effort / fail-safe: a bus outage must degrade to\n * local-only delivery (today's single-replica behavior), never crash the stream.\n */\nexport interface SSERelay {\n  /** Fire-and-forget publish of a frame to every subscribed pod. Never throws. */\n  publish(msg: SSERelayMessage): void;\n  /** Subscribe this pod's re-emit handler. Called once on manager construction. */\n  subscribe(handler: (msg: SSERelayMessage) => void): void;\n  /** Tear down the underlying connection(s). */\n  close(): Promise<void>;\n}\n\n/**\n * Minimal ioredis pub/sub surface the Redis relay needs. `subscribe` requires a\n * DEDICATED connection (a subscribed ioredis client can't run other commands),\n * so the relay `duplicate()`s the publisher for the subscriber side.\n */\nexport interface RedisPubSubClient {\n  publish(channel: string, message: string): Promise<number>;\n  subscribe(...channels: string[]): Promise<unknown>;\n  on(event: 'message', cb: (channel: string, message: string) => void): void;\n  on(event: 'error', cb: (err: unknown) => void): void;\n  duplicate(): RedisPubSubClient;\n  quit(): Promise<unknown>;\n}\n\n/**\n * The relay channel for one service. Every replica of a service shares it, and\n * no other service does: an SSE subject (an org id, a build requestId) only has\n * meaning inside the service whose clients subscribed to it, so a shared channel\n * made every service's pods parse — and re-emit to same-named subjects — every\n * other service's frames. `requestId` rides in the message body rather than the\n * channel name so each pod SUBSCRIBES exactly once on startup — no per-subject\n * subscribe/unsubscribe churn as clients come and go.\n */\nexport function sseRelayChannel(serviceName: string): string {\n  return `sse:relay:${serviceName}`;\n}\n\n/** Backoff bounds for the startup SUBSCRIBE retry. */\nconst SUBSCRIBE_RETRY_MIN_MS = 500;\nconst SUBSCRIBE_RETRY_MAX_MS = 30_000;\n\n/**\n * Redis-backed relay. Uses the given client for PUBLISH and a `duplicate()` for\n * SUBSCRIBE (ioredis forbids mixing subscribe with normal commands on one\n * connection). Publish is fire-and-forget with a swallowed rejection; a subscribe\n * handler that throws is isolated so one bad frame can't kill the subscriber.\n */\nexport function createRedisSSERelay(publisher: RedisPubSubClient, channel: string): SSERelay {\n  const subscriber = publisher.duplicate();\n  // A duplicated ioredis connection doesn't inherit the publisher's listeners;\n  // without its own, a dropped connection is an unhandled 'error' that crashes Node.\n  subscriber.on('error', (err) => {\n    logger.warn('SSE relay subscriber connection error', { channel, error: err instanceof Error ? err.message : String(err) });\n  });\n  let closed = false;\n\n  return {\n    publish(msg) {\n      if (closed) return;\n      // Fire-and-forget: never await, never surface a rejection to the caller.\n      void Promise.resolve(publisher.publish(channel, JSON.stringify(msg))).catch((err) => {\n        logger.warn('SSE relay publish failed', { error: err instanceof Error ? err.message : String(err) });\n      });\n    },\n    subscribe(handler) {\n      subscriber.on('message', (received, message) => {\n        if (received !== channel) return;\n        let parsed: SSERelayMessage;\n        try {\n          parsed = JSON.parse(message) as SSERelayMessage;\n        } catch (err) {\n          logger.warn('SSE relay received unparseable frame', { error: err instanceof Error ? err.message : String(err) });\n          return;\n        }\n        try {\n          handler(parsed);\n        } catch (err) {\n          logger.warn('SSE relay handler threw', { error: err instanceof Error ? err.message : String(err) });\n        }\n      });\n      // Retry until subscribed: at startup the connection usually isn't up yet,\n      // and giving up after one attempt left the pod on local-only delivery for\n      // its whole life. Once subscribed, ioredis re-subscribes after reconnects.\n      let delayMs = SUBSCRIBE_RETRY_MIN_MS;\n      const attempt = (): void => {\n        if (closed) return;\n        void Promise.resolve(subscriber.subscribe(channel)).then(\n          () => logger.info('SSE relay subscribed', { channel }),\n          (err) => {\n            logger.warn('SSE relay subscribe failed; retrying (local-only delivery meanwhile)', {\n              retryInMs: delayMs, error: err instanceof Error ? err.message : String(err),\n            });\n            setTimeout(attempt, delayMs).unref?.();\n            delayMs = Math.min(delayMs * 2, SUBSCRIBE_RETRY_MAX_MS);\n          },\n        );\n      };\n      attempt();\n    },\n    async close() {\n      closed = true;\n      await Promise.allSettled([publisher.quit(), subscriber.quit()]);\n    },\n  };\n}\n\n/**\n * Build a Redis-backed SSE relay from the shared env Redis, on this service's\n * own channel (`SERVICE_NAME`). Returns null when Redis isn't configured so the\n * caller keeps local-only delivery.\n */\nexport function createEnvRedisSSERelay(serviceName: string = process.env.SERVICE_NAME || 'api'): SSERelay | null {\n  const client = createEnvRedisClient<RedisPubSubClient>('sse-relay');\n  if (!client) return null;\n  const channel = sseRelayChannel(serviceName);\n  logger.info('Redis SSE relay initialized (cross-pod fan-out enabled)', { channel });\n  return createRedisSSERelay(client, channel);\n}\n"]}

package/lib/http/sse-ticket-channel.d.ts

@@ -19,8 +19,10 @@ export interface SseTicketChannelOptions {
  * Register a per-ORG SSE channel: a POST that exchanges the caller's VERIFIED JWT
  * org for a single-use, org-bound ticket, and a GET that redeems the ticket and
  * attaches an EventSource keyed by that org. The org IS the stream subject, so a
- * producer reaches subscribers with `sseManager.send(orgId, …)` (cross-pod via the
- * relay). Shared by the message-notification and reporting execution-status
+ * producer reaches subscribers with `sseManager.send(orgId, …)`. Registering a
+ * channel turns on the manager's cross-pod relay (this service's own relay
+ * channel), so a frame produced on one replica reaches a subscriber on another.
+ * Shared by the message-notification and reporting execution-status
  * channels so the subtle bits — the ticket→addClient→flushHeaders ordering (a 429
  * MUST precede flushHeaders, which commits the 200) and the capacity semantics —
  * live in exactly one place.

package/lib/http/sse-ticket-channel.js

@@ -1,13 +1,15 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { requireAuth, sendSuccess, sendError, ErrorCode, createLogger } from '@pipeline-builder/api-core';
+import { requireAuth, sendSuccess, sendError, ErrorCode, createLogger, writeSseHeaders } from '@pipeline-builder/api-core';
 const logger = createLogger('sse-ticket-channel');
 /**
  * Register a per-ORG SSE channel: a POST that exchanges the caller's VERIFIED JWT
  * org for a single-use, org-bound ticket, and a GET that redeems the ticket and
  * attaches an EventSource keyed by that org. The org IS the stream subject, so a
- * producer reaches subscribers with `sseManager.send(orgId, …)` (cross-pod via the
- * relay). Shared by the message-notification and reporting execution-status
+ * producer reaches subscribers with `sseManager.send(orgId, …)`. Registering a
+ * channel turns on the manager's cross-pod relay (this service's own relay
+ * channel), so a frame produced on one replica reaches a subscriber on another.
+ * Shared by the message-notification and reporting execution-status
  * channels so the subtle bits — the ticket→addClient→flushHeaders ordering (a 429
  * MUST precede flushHeaders, which commits the 200) and the capacity semantics —
  * live in exactly one place.
@@ -17,6 +19,7 @@ const logger = createLogger('sse-ticket-channel');
  */
 export function registerSseTicketChannel(app, opts) {
     const { ticketPath, streamPath, ticketStore, sseManager, label, ticketGuards = [] } = opts;
+    sseManager.enableRelay();
     app.post(ticketPath, requireAuth, ...ticketGuards, async (req, res) => {
         const orgId = req.user?.organizationId?.toLowerCase();
         if (!orgId)
@@ -34,19 +37,19 @@ export function registerSseTicketChannel(app, opts) {
         if (!ticketId)
             return void sendError(res, 401, 'Missing ticket parameter', ErrorCode.UNAUTHORIZED);
         const ticket = await ticketStore.consume(ticketId); // atomic single-use
-        if (!ticket)
+        // An org channel's ticket is org-bound only; a subject-bound ticket (e.g. a
+        // build-log ticket from a store sharing this namespace) doesn't open it.
+        if (!ticket || ticket.subject !== undefined)
             return void sendError(res, 401, 'Invalid or expired ticket', ErrorCode.UNAUTHORIZED);
         // Reserve the connection slot BEFORE flushing SSE headers: once flushHeaders
         // runs the response is committed at 200 and a later 429 is silently dropped.
-        const added = sseManager.addClient(ticket.orgId, res);
+        // The org is the subject, so the per-ORG cap applies (not the per-request one).
+        const added = sseManager.addOrgClient(ticket.orgId, res);
         if (!added)
             return void sendError(res, 429, `Too many ${label} connections`, ErrorCode.QUOTA_EXCEEDED);
-        res.setHeader('Content-Type', 'text/event-stream');
-        res.setHeader('Cache-Control', 'no-cache');
-        res.setHeader('Connection', 'keep-alive');
-        res.setHeader('X-Accel-Buffering', 'no');
+        writeSseHeaders(res);
         res.flushHeaders();
         logger.info('SSE client connected', { channel: label, orgId: ticket.orgId });
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-ticket-channel.js","sourceRoot":"","sources":["../../src/http/sse-ticket-channel.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAuB,MAAM,4BAA4B,CAAC;AAI/H,MAAM,MAAM,GAAG,YAAY,CAAC,oBAAoB,CAAC,CAAC;AAiBlD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,wBAAwB,CAAC,GAAY,EAAE,IAA6B;IAClF,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC;IAE3F,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,GAAG,YAAY,EAAE,KAAK,EAAE,GAAY,EAAE,GAAa,EAAE,EAAE;QACvF,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC;QACtD,IAAI,CAAC,KAAK;YAAE,OAAO,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,4BAA4B,EAAE,SAAS,CAAC,gBAAgB,CAAC,CAAC;QACjG,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC9C,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;YACf,OAAO,MAAM,CAAC,MAAM,KAAK,OAAO;gBAC9B,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,KAAK,2BAA2B,EAAE,SAAS,CAAC,cAAc,CAAC;gBACxF,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,YAAY,KAAK,iBAAiB,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;QACxF,CAAC;QACD,OAAO,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IAC1D,CAAC,CAAC,CAAC;IAEH,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,GAAY,EAAE,GAAa,EAAE,EAAE;QACxD,MAAM,QAAQ,GAAG,GAAG,CAAC,KAAK,CAAC,MAA4B,CAAC;QACxD,IAAI,CAAC,QAAQ;YAAE,OAAO,KAAK,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,0BAA0B,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QACnG,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,oBAAoB;QACxE,IAAI,CAAC,MAAM;YAAE,OAAO,KAAK,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,2BAA2B,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QAClG,6EAA6E;QAC7E,6EAA6E;QAC7E,MAAM,KAAK,GAAG,UAAU,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACtD,IAAI,CAAC,KAAK;YAAE,OAAO,KAAK,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,YAAY,KAAK,cAAc,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;QACvG,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAC;QACnD,GAAG,CAAC,SAAS,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;QAC3C,GAAG,CAAC,SAAS,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;QAC1C,GAAG,CAAC,SAAS,CAAC,mBAAmB,EAAE,IAAI,CAAC,CAAC;QACzC,GAAG,CAAC,YAAY,EAAE,CAAC;QACnB,MAAM,CAAC,IAAI,CAAC,sBAAsB,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IAC/E,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { requireAuth, sendSuccess, sendError, ErrorCode, createLogger, type SseTicketStore } from '@pipeline-builder/api-core';\nimport type { Express, Request, RequestHandler, Response } from 'express';\nimport type { SSEManager } from './sse-connection-manager.js';\n\nconst logger = createLogger('sse-ticket-channel');\n\nexport interface SseTicketChannelOptions {\n  /** POST route that exchanges the JWT for a single-use ticket (e.g. '/messages/notifications/ticket'). */\n  ticketPath: string;\n  /** GET route that redeems the ticket and opens the EventSource (e.g. '/messages/notifications'). */\n  streamPath: string;\n  /** Org-scoped, single-use ticket store (Redis-backed for multi-replica). */\n  ticketStore: SseTicketStore;\n  /** SSE manager — the org id is the stream subject (`sseManager.send(orgId, …)`). */\n  sseManager: SSEManager;\n  /** Noun used in capacity/connection error messages (e.g. 'notification', 'execution-stream'). */\n  label: string;\n  /** Extra middleware applied AFTER requireAuth on the mint route (e.g. requirePermission('reports:read')). */\n  ticketGuards?: RequestHandler[];\n}\n\n/**\n * Register a per-ORG SSE channel: a POST that exchanges the caller's VERIFIED JWT\n * org for a single-use, org-bound ticket, and a GET that redeems the ticket and\n * attaches an EventSource keyed by that org. The org IS the stream subject, so a\n * producer reaches subscribers with `sseManager.send(orgId, …)` (cross-pod via the\n * relay). Shared by the message-notification and reporting execution-status\n * channels so the subtle bits — the ticket→addClient→flushHeaders ordering (a 429\n * MUST precede flushHeaders, which commits the 200) and the capacity semantics —\n * live in exactly one place.\n *\n * Distinct from app-factory's `/logs` channel, which is SUBJECT-bound (per build,\n * via SSEManager.createTicket) rather than org-bound.\n */\nexport function registerSseTicketChannel(app: Express, opts: SseTicketChannelOptions): void {\n  const { ticketPath, streamPath, ticketStore, sseManager, label, ticketGuards = [] } = opts;\n\n  app.post(ticketPath, requireAuth, ...ticketGuards, async (req: Request, res: Response) => {\n    const orgId = req.user?.organizationId?.toLowerCase();\n    if (!orgId) return sendError(res, 400, 'Token missing organization', ErrorCode.VALIDATION_ERROR);\n    const result = await ticketStore.issue(orgId);\n    if (!result.ok) {\n      return result.reason === 'total'\n        ? sendError(res, 503, `The ${label} subsystem is at capacity`, ErrorCode.QUOTA_EXCEEDED)\n        : sendError(res, 429, `Too many ${label} tickets issued`, ErrorCode.QUOTA_EXCEEDED);\n    }\n    return sendSuccess(res, 200, { ticket: result.ticket });\n  });\n\n  app.get(streamPath, async (req: Request, res: Response) => {\n    const ticketId = req.query.ticket as string | undefined;\n    if (!ticketId) return void sendError(res, 401, 'Missing ticket parameter', ErrorCode.UNAUTHORIZED);\n    const ticket = await ticketStore.consume(ticketId); // atomic single-use\n    if (!ticket) return void sendError(res, 401, 'Invalid or expired ticket', ErrorCode.UNAUTHORIZED);\n    // Reserve the connection slot BEFORE flushing SSE headers: once flushHeaders\n    // runs the response is committed at 200 and a later 429 is silently dropped.\n    const added = sseManager.addClient(ticket.orgId, res);\n    if (!added) return void sendError(res, 429, `Too many ${label} connections`, ErrorCode.QUOTA_EXCEEDED);\n    res.setHeader('Content-Type', 'text/event-stream');\n    res.setHeader('Cache-Control', 'no-cache');\n    res.setHeader('Connection', 'keep-alive');\n    res.setHeader('X-Accel-Buffering', 'no');\n    res.flushHeaders();\n    logger.info('SSE client connected', { channel: label, orgId: ticket.orgId });\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-ticket-channel.js","sourceRoot":"","sources":["../../src/http/sse-ticket-channel.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,eAAe,EAAuB,MAAM,4BAA4B,CAAC;AAIhJ,MAAM,MAAM,GAAG,YAAY,CAAC,oBAAoB,CAAC,CAAC;AAiBlD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,wBAAwB,CAAC,GAAY,EAAE,IAA6B;IAClF,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC;IAC3F,UAAU,CAAC,WAAW,EAAE,CAAC;IAEzB,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,GAAG,YAAY,EAAE,KAAK,EAAE,GAAY,EAAE,GAAa,EAAE,EAAE;QACvF,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC;QACtD,IAAI,CAAC,KAAK;YAAE,OAAO,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,4BAA4B,EAAE,SAAS,CAAC,gBAAgB,CAAC,CAAC;QACjG,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC9C,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;YACf,OAAO,MAAM,CAAC,MAAM,KAAK,OAAO;gBAC9B,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,KAAK,2BAA2B,EAAE,SAAS,CAAC,cAAc,CAAC;gBACxF,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,YAAY,KAAK,iBAAiB,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;QACxF,CAAC;QACD,OAAO,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IAC1D,CAAC,CAAC,CAAC;IAEH,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,GAAY,EAAE,GAAa,EAAE,EAAE;QACxD,MAAM,QAAQ,GAAG,GAAG,CAAC,KAAK,CAAC,MAA4B,CAAC;QACxD,IAAI,CAAC,QAAQ;YAAE,OAAO,KAAK,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,0BAA0B,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QACnG,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,oBAAoB;QACxE,4EAA4E;QAC5E,yEAAyE;QACzE,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS;YAAE,OAAO,KAAK,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,2BAA2B,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QAClI,6EAA6E;QAC7E,6EAA6E;QAC7E,gFAAgF;QAChF,MAAM,KAAK,GAAG,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACzD,IAAI,CAAC,KAAK;YAAE,OAAO,KAAK,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,YAAY,KAAK,cAAc,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;QACvG,eAAe,CAAC,GAAG,CAAC,CAAC;QACrB,GAAG,CAAC,YAAY,EAAE,CAAC;QACnB,MAAM,CAAC,IAAI,CAAC,sBAAsB,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IAC/E,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { requireAuth, sendSuccess, sendError, ErrorCode, createLogger, writeSseHeaders, type SseTicketStore } from '@pipeline-builder/api-core';\nimport type { Express, Request, RequestHandler, Response } from 'express';\nimport type { SSEManager } from './sse-connection-manager.js';\n\nconst logger = createLogger('sse-ticket-channel');\n\nexport interface SseTicketChannelOptions {\n  /** POST route that exchanges the JWT for a single-use ticket (e.g. '/messages/notifications/ticket'). */\n  ticketPath: string;\n  /** GET route that redeems the ticket and opens the EventSource (e.g. '/messages/notifications'). */\n  streamPath: string;\n  /** Org-scoped, single-use ticket store (Redis-backed for multi-replica). */\n  ticketStore: SseTicketStore;\n  /** SSE manager — the org id is the stream subject (`sseManager.send(orgId, …)`). */\n  sseManager: SSEManager;\n  /** Noun used in capacity/connection error messages (e.g. 'notification', 'execution-stream'). */\n  label: string;\n  /** Extra middleware applied AFTER requireAuth on the mint route (e.g. requirePermission('reports:read')). */\n  ticketGuards?: RequestHandler[];\n}\n\n/**\n * Register a per-ORG SSE channel: a POST that exchanges the caller's VERIFIED JWT\n * org for a single-use, org-bound ticket, and a GET that redeems the ticket and\n * attaches an EventSource keyed by that org. The org IS the stream subject, so a\n * producer reaches subscribers with `sseManager.send(orgId, …)`. Registering a\n * channel turns on the manager's cross-pod relay (this service's own relay\n * channel), so a frame produced on one replica reaches a subscriber on another.\n * Shared by the message-notification and reporting execution-status\n * channels so the subtle bits — the ticket→addClient→flushHeaders ordering (a 429\n * MUST precede flushHeaders, which commits the 200) and the capacity semantics —\n * live in exactly one place.\n *\n * Distinct from app-factory's `/logs` channel, which is SUBJECT-bound (per build,\n * via SSEManager.createTicket) rather than org-bound.\n */\nexport function registerSseTicketChannel(app: Express, opts: SseTicketChannelOptions): void {\n  const { ticketPath, streamPath, ticketStore, sseManager, label, ticketGuards = [] } = opts;\n  sseManager.enableRelay();\n\n  app.post(ticketPath, requireAuth, ...ticketGuards, async (req: Request, res: Response) => {\n    const orgId = req.user?.organizationId?.toLowerCase();\n    if (!orgId) return sendError(res, 400, 'Token missing organization', ErrorCode.VALIDATION_ERROR);\n    const result = await ticketStore.issue(orgId);\n    if (!result.ok) {\n      return result.reason === 'total'\n        ? sendError(res, 503, `The ${label} subsystem is at capacity`, ErrorCode.QUOTA_EXCEEDED)\n        : sendError(res, 429, `Too many ${label} tickets issued`, ErrorCode.QUOTA_EXCEEDED);\n    }\n    return sendSuccess(res, 200, { ticket: result.ticket });\n  });\n\n  app.get(streamPath, async (req: Request, res: Response) => {\n    const ticketId = req.query.ticket as string | undefined;\n    if (!ticketId) return void sendError(res, 401, 'Missing ticket parameter', ErrorCode.UNAUTHORIZED);\n    const ticket = await ticketStore.consume(ticketId); // atomic single-use\n    // An org channel's ticket is org-bound only; a subject-bound ticket (e.g. a\n    // build-log ticket from a store sharing this namespace) doesn't open it.\n    if (!ticket || ticket.subject !== undefined) return void sendError(res, 401, 'Invalid or expired ticket', ErrorCode.UNAUTHORIZED);\n    // Reserve the connection slot BEFORE flushing SSE headers: once flushHeaders\n    // runs the response is committed at 200 and a later 429 is silently dropped.\n    // The org is the subject, so the per-ORG cap applies (not the per-request one).\n    const added = sseManager.addOrgClient(ticket.orgId, res);\n    if (!added) return void sendError(res, 429, `Too many ${label} connections`, ErrorCode.QUOTA_EXCEEDED);\n    writeSseHeaders(res);\n    res.flushHeaders();\n    logger.info('SSE client connected', { channel: label, orgId: ticket.orgId });\n  });\n}\n"]}

package/package.json

@@ -23,6 +23,7 @@
     "eslint-plugin-import": "^2.32.0",
     "jest": "30.4.2",
     "jest-junit": "^17",
+    "jsonwebtoken": "9.0.3",
     "ts-jest": "29.4.12",
     "typescript": "npm:@typescript/typescript6@^6.0.2"
   },
@@ -38,15 +39,13 @@
     "express": "5.2.1",
     "express-rate-limit": "8.6.1",
     "helmet": "8.3.0",
-    "ioredis": "6.0.0",
-    "jsonwebtoken": "9.0.3",
     "prom-client": "15.1.3",
     "rate-limit-redis": "6.0.0",
     "swagger-ui-express": "5.0.1",
     "uuid": "14.0.1",
-    "@pipeline-builder/api-core": "4.1.2",
-    "@pipeline-builder/pipeline-core": "4.1.3",
-    "@pipeline-builder/pipeline-data": "4.1.3"
+    "@pipeline-builder/api-core": "4.1.4",
+    "@pipeline-builder/pipeline-data": "4.1.5",
+    "@pipeline-builder/pipeline-core": "4.1.5"
   },
   "keywords": [
     "ci-cd",
@@ -102,7 +101,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "4.1.3",
+  "version": "4.1.5",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },

package/lib/api/middleware.d.ts

@@ -1 +0,0 @@
-export { requireAuth } from '@pipeline-builder/api-core';

package/lib/api/middleware.js

@@ -1,8 +0,0 @@
-// Copyright 2026 Pipeline Builder Contributors
-// SPDX-License-Identifier: Apache-2.0
-// Convenience re-export: api-server consumers usually compose middleware
-// already imported from this package, so `requireAuth` is exposed here too.
-// Other auth middleware (requireFeature, requireSystemAdmin, isSystemAdmin) is
-// consumed directly from api-core where it's defined.
-export { requireAuth } from '@pipeline-builder/api-core';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcGkvbWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLHlFQUF5RTtBQUN6RSw0RUFBNEU7QUFDNUUsK0VBQStFO0FBQy9FLHNEQUFzRDtBQUN0RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuLy8gQ29udmVuaWVuY2UgcmUtZXhwb3J0OiBhcGktc2VydmVyIGNvbnN1bWVycyB1c3VhbGx5IGNvbXBvc2UgbWlkZGxld2FyZVxuLy8gYWxyZWFkeSBpbXBvcnRlZCBmcm9tIHRoaXMgcGFja2FnZSwgc28gYHJlcXVpcmVBdXRoYCBpcyBleHBvc2VkIGhlcmUgdG9vLlxuLy8gT3RoZXIgYXV0aCBtaWRkbGV3YXJlIChyZXF1aXJlRmVhdHVyZSwgcmVxdWlyZVN5c3RlbUFkbWluLCBpc1N5c3RlbUFkbWluKSBpc1xuLy8gY29uc3VtZWQgZGlyZWN0bHkgZnJvbSBhcGktY29yZSB3aGVyZSBpdCdzIGRlZmluZWQuXG5leHBvcnQgeyByZXF1aXJlQXV0aCB9IGZyb20gJ0BwaXBlbGluZS1idWlsZGVyL2FwaS1jb3JlJztcbiJdfQ==

package/lib/http/sse-ticket-store.d.ts

@@ -1,75 +0,0 @@
-/** A minted ticket's bound identity: owning org + normalized stream subject. */
-export interface SSEStreamTicketRecord {
-    orgId: string;
-    /** Normalized (dashes stripped, lowercased) stream subject id. */
-    requestId: string;
-}
-/**
- * Pluggable backend for SSE log-stream tickets AND stream-ownership.
- *
- * NOTE: distinct from api-core's `SseTicketStore` (services/sse-ticket-store.ts),
- * which is the message-service ticket store (issue + abuse counters). This one
- * (api-server) additionally tracks stream ownership. The names deliberately differ
- * (`SSEStreamTicketStore` here vs `SseTicketStore` there) so consumers don't pick
- * the wrong one.
- *
- * Two concerns share one store because both must be consistent across pods:
- * - **Tickets** — short-lived, single-use, bound to (org, subject). The default
- *   in-memory store is correct only single-replica; the Redis store makes the
- *   mint (one pod) / redeem (another pod) exchange work behind a load balancer.
- * - **Stream ownership** — which org OWNS a given stream subject. The stream
- *   producer (platform, a different service) records this so ticket minting can
- *   assert the caller's org owns the subject, closing the cross-tenant attach
- *   gap where any org could mint a ticket for a guessed requestId.
- *
- * All methods are async (Redis is async) and best-effort on the failure side per
- * their doc — a store outage must degrade gracefully, never crash the stream.
- */
-export interface SSEStreamTicketStore {
-    /** Persist a single-use ticket bound to `record`, expiring after `ttlMs`. */
-    put(ticketId: string, record: SSEStreamTicketRecord, ttlMs: number): Promise<void>;
-    /** Atomically fetch-and-delete a ticket (single-use). Null if absent/expired. */
-    consume(ticketId: string): Promise<SSEStreamTicketRecord | null>;
-    /** Count of live (unexpired) tickets held for an org (per-org cap). */
-    countForOrg(orgId: string): Promise<number>;
-    /** Count of all live tickets across the store (capacity cap). */
-    total(): Promise<number>;
-    /** Record the org that OWNS a stream subject (producer-side), TTL `ttlMs`. */
-    bindStreamOwner(requestId: string, orgId: string, ttlMs: number): Promise<void>;
-    /** The owning org of a stream subject, or null when none is bound. */
-    getStreamOwner(requestId: string): Promise<string | null>;
-    /** Optional hygiene sweep of expired entries (Redis TTL makes this a no-op). */
-    sweep?(): Promise<void>;
-}
-/**
- * In-memory ticket store — the default. Correct for a single replica only;
- * mirrors the behavior the SSEManager previously implemented inline.
- */
-export declare function createMemoryTicketStore(): SSEStreamTicketStore;
-/**
- * Minimal ioredis surface the Redis ticket store needs. `set` takes the variadic
- * option tail (`EX <s>`); `zadd`/`zremrangebyscore`/`zcard` back the cap counters.
- */
-export interface RedisTicketClient {
-    get(key: string): Promise<string | null>;
-    set(key: string, value: string, ...args: (string | number)[]): Promise<string | null>;
-    del(...keys: string[]): Promise<number>;
-    zadd(key: string, score: number, member: string): Promise<number>;
-    zrem(key: string, ...members: string[]): Promise<number>;
-    zcard(key: string): Promise<number>;
-    zremrangebyscore(key: string, min: number | string, max: number | string): Promise<number>;
-    expire(key: string, seconds: number): Promise<number>;
-}
-/**
- * Redis-backed ticket store — required for multi-pod correctness. Tickets are
- * per-key with native TTL; cap counters are ZSETs scored by expiry (pruned on
- * read). Stream ownership is a per-subject key with its own TTL. All reads are
- * fail-safe (null / 0) so a Redis blip never wedges the stream.
- */
-export declare function createRedisTicketStore(redis: RedisTicketClient): SSEStreamTicketStore;
-/**
- * Build a Redis-backed ticket store from the shared env Redis (same wiring as
- * the rate-limiter / audit-spool). Returns null when Redis isn't configured so
- * the caller keeps the in-memory default. Never throws.
- */
-export declare function createEnvRedisTicketStore(): SSEStreamTicketStore | null;

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

@@ -1,160 +0,0 @@
-// Copyright 2026 Pipeline Builder Contributors
-// SPDX-License-Identifier: Apache-2.0
-import { createLogger, createEnvRedisClient } from '@pipeline-builder/api-core';
-const logger = createLogger('sse-ticket-store');
-/**
- * In-memory ticket store — the default. Correct for a single replica only;
- * mirrors the behavior the SSEManager previously implemented inline.
- */
-export function createMemoryTicketStore() {
-    const tickets = new Map();
-    const owners = new Map();
-    return {
-        async put(ticketId, record, ttlMs) {
-            tickets.set(ticketId, { ...record, expiresAt: Date.now() + ttlMs });
-        },
-        async consume(ticketId) {
-            const t = tickets.get(ticketId);
-            tickets.delete(ticketId); // single-use — remove whether or not valid
-            if (!t || Date.now() > t.expiresAt)
-                return null;
-            return { orgId: t.orgId, requestId: t.requestId };
-        },
-        async countForOrg(orgId) {
-            const now = Date.now();
-            let n = 0;
-            for (const t of tickets.values())
-                if (t.orgId === orgId && t.expiresAt > now)
-                    n++;
-            return n;
-        },
-        async total() {
-            const now = Date.now();
-            let n = 0;
-            for (const t of tickets.values())
-                if (t.expiresAt > now)
-                    n++;
-            return n;
-        },
-        async bindStreamOwner(requestId, orgId, ttlMs) {
-            owners.set(requestId, { orgId, expiresAt: Date.now() + ttlMs });
-        },
-        async getStreamOwner(requestId) {
-            const o = owners.get(requestId);
-            if (!o)
-                return null;
-            if (Date.now() > o.expiresAt) {
-                owners.delete(requestId);
-                return null;
-            }
-            return o.orgId;
-        },
-        async sweep() {
-            const now = Date.now();
-            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 TICKET_PREFIX = 'sse:tkt:';
-const ORG_ZSET_PREFIX = 'sse:tkt:org:';
-const ALL_ZSET = 'sse:tkt:all';
-const OWNER_PREFIX = 'sse:owner:';
-/**
- * Redis-backed ticket store — required for multi-pod correctness. Tickets are
- * per-key with native TTL; cap counters are ZSETs scored by expiry (pruned on
- * read). Stream ownership is a per-subject key with its own TTL. All reads are
- * fail-safe (null / 0) so a Redis blip never wedges the stream.
- */
-export function createRedisTicketStore(redis) {
-    const tkey = (id) => `${TICKET_PREFIX}${id}`;
-    const orgKey = (orgId) => `${ORG_ZSET_PREFIX}${orgId}`;
-    const ownerKey = (requestId) => `${OWNER_PREFIX}${requestId}`;
-    const ttlSec = (ttlMs) => Math.max(1, Math.ceil(ttlMs / 1000));
-    return {
-        async put(ticketId, record, ttlMs) {
-            const expiresAt = Date.now() + ttlMs;
-            const sec = ttlSec(ttlMs);
-            try {
-                await redis.set(tkey(ticketId), JSON.stringify(record), 'EX', sec);
-                // Track for the caps. Score = expiry so pruning is a range delete.
-                await redis.zadd(orgKey(record.orgId), expiresAt, ticketId);
-                await redis.zadd(ALL_ZSET, expiresAt, ticketId);
-                // Bound the per-org ZSET's own lifetime so an idle org's key can't leak.
-                await redis.expire(orgKey(record.orgId), sec);
-            }
-            catch (err) {
-                logger.warn('SSE ticket put failed', { error: err instanceof Error ? err.message : String(err) });
-            }
-        },
-        async consume(ticketId) {
-            try {
-                const raw = await redis.get(tkey(ticketId));
-                // Single-use: delete regardless. A concurrent double-redeem: at most one
-                // saw a non-null value before the delete; the ZREM cleans the counters.
-                await redis.del(tkey(ticketId));
-                if (!raw)
-                    return null;
-                const rec = JSON.parse(raw);
-                await redis.zrem(orgKey(rec.orgId), ticketId);
-                await redis.zrem(ALL_ZSET, ticketId);
-                return rec;
-            }
-            catch (err) {
-                logger.warn('SSE ticket consume failed', { error: err instanceof Error ? err.message : String(err) });
-                return null;
-            }
-        },
-        async countForOrg(orgId) {
-            try {
-                await redis.zremrangebyscore(orgKey(orgId), 0, Date.now());
-                return await redis.zcard(orgKey(orgId));
-            }
-            catch {
-                return 0;
-            }
-        },
-        async total() {
-            try {
-                await redis.zremrangebyscore(ALL_ZSET, 0, Date.now());
-                return await redis.zcard(ALL_ZSET);
-            }
-            catch {
-                return 0;
-            }
-        },
-        async bindStreamOwner(requestId, orgId, ttlMs) {
-            try {
-                await redis.set(ownerKey(requestId), orgId, 'EX', ttlSec(ttlMs));
-            }
-            catch (err) {
-                logger.warn('SSE stream-owner bind failed', { error: err instanceof Error ? err.message : String(err) });
-            }
-        },
-        async getStreamOwner(requestId) {
-            try {
-                return await redis.get(ownerKey(requestId));
-            }
-            catch {
-                return null;
-            }
-        },
-    };
-}
-/**
- * Build a Redis-backed ticket store from the shared env Redis (same wiring as
- * the rate-limiter / audit-spool). Returns null when Redis isn't configured so
- * the caller keeps the in-memory default. Never throws.
- */
-export function createEnvRedisTicketStore() {
-    const client = createEnvRedisClient('sse-ticket');
-    if (!client)
-        return null;
-    logger.info('Redis SSE ticket store initialized');
-    return createRedisTicketStore(client);
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-ticket-store.js","sourceRoot":"","sources":["../../src/http/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 { createLogger, createEnvRedisClient } from '@pipeline-builder/api-core';\n\nconst logger = createLogger('sse-ticket-store');\n\n/** A minted ticket's bound identity: owning org + normalized stream subject. */\nexport interface SSEStreamTicketRecord {\n  orgId: string;\n  /** Normalized (dashes stripped, lowercased) stream subject id. */\n  requestId: string;\n}\n\n/**\n * Pluggable backend for SSE log-stream tickets AND stream-ownership.\n *\n * NOTE: distinct from api-core's `SseTicketStore` (services/sse-ticket-store.ts),\n * which is the message-service ticket store (issue + abuse counters). This one\n * (api-server) additionally tracks stream ownership. The names deliberately differ\n * (`SSEStreamTicketStore` here vs `SseTicketStore` there) so consumers don't pick\n * the wrong one.\n *\n * Two concerns share one store because both must be consistent across pods:\n * - **Tickets** — short-lived, single-use, bound to (org, subject). The default\n *   in-memory store is correct only single-replica; the Redis store makes the\n *   mint (one pod) / redeem (another pod) exchange work behind a load balancer.\n * - **Stream ownership** — which org OWNS a given stream subject. The stream\n *   producer (platform, a different service) records this so ticket minting can\n *   assert the caller's org owns the subject, closing the cross-tenant attach\n *   gap where any org could mint a ticket for a guessed requestId.\n *\n * All methods are async (Redis is async) and best-effort on the failure side per\n * their doc — a store outage must degrade gracefully, never crash the stream.\n */\nexport interface SSEStreamTicketStore {\n  /** Persist a single-use ticket bound to `record`, expiring after `ttlMs`. */\n  put(ticketId: string, record: SSEStreamTicketRecord, ttlMs: number): Promise<void>;\n  /** Atomically fetch-and-delete a ticket (single-use). Null if absent/expired. */\n  consume(ticketId: string): Promise<SSEStreamTicketRecord | null>;\n  /** Count of live (unexpired) tickets held for an org (per-org cap). */\n  countForOrg(orgId: string): Promise<number>;\n  /** Count of all live tickets across the store (capacity cap). */\n  total(): Promise<number>;\n  /** Record the org that OWNS a stream subject (producer-side), TTL `ttlMs`. */\n  bindStreamOwner(requestId: string, orgId: string, ttlMs: number): Promise<void>;\n  /** The owning org of a stream subject, or null when none is bound. */\n  getStreamOwner(requestId: string): Promise<string | null>;\n  /** Optional hygiene sweep of expired entries (Redis TTL makes this a no-op). */\n  sweep?(): Promise<void>;\n}\n\ninterface StoredTicket extends SSEStreamTicketRecord {\n  expiresAt: number;\n}\n\ninterface StoredOwner {\n  orgId: string;\n  expiresAt: number;\n}\n\n/**\n * In-memory ticket store — the default. Correct for a single replica only;\n * mirrors the behavior the SSEManager previously implemented inline.\n */\nexport function createMemoryTicketStore(): SSEStreamTicketStore {\n  const tickets = new Map<string, StoredTicket>();\n  const owners = new Map<string, StoredOwner>();\n\n  return {\n    async put(ticketId, record, ttlMs) {\n      tickets.set(ticketId, { ...record, expiresAt: Date.now() + ttlMs });\n    },\n    async consume(ticketId) {\n      const t = tickets.get(ticketId);\n      tickets.delete(ticketId); // single-use — remove whether or not valid\n      if (!t || Date.now() > t.expiresAt) return null;\n      return { orgId: t.orgId, requestId: t.requestId };\n    },\n    async countForOrg(orgId) {\n      const now = Date.now();\n      let n = 0;\n      for (const t of tickets.values()) if (t.orgId === orgId && t.expiresAt > now) n++;\n      return n;\n    },\n    async total() {\n      const now = Date.now();\n      let n = 0;\n      for (const t of tickets.values()) if (t.expiresAt > now) n++;\n      return n;\n    },\n    async bindStreamOwner(requestId, orgId, ttlMs) {\n      owners.set(requestId, { orgId, expiresAt: Date.now() + ttlMs });\n    },\n    async getStreamOwner(requestId) {\n      const o = owners.get(requestId);\n      if (!o) return null;\n      if (Date.now() > o.expiresAt) { owners.delete(requestId); return null; }\n      return o.orgId;\n    },\n    async sweep() {\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  };\n}\n\n/**\n * Minimal ioredis surface the Redis ticket store needs. `set` takes the variadic\n * option tail (`EX <s>`); `zadd`/`zremrangebyscore`/`zcard` back the cap counters.\n */\nexport interface RedisTicketClient {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, ...args: (string | number)[]): Promise<string | null>;\n  del(...keys: string[]): Promise<number>;\n  zadd(key: string, score: number, member: string): Promise<number>;\n  zrem(key: string, ...members: string[]): Promise<number>;\n  zcard(key: string): Promise<number>;\n  zremrangebyscore(key: string, min: number | string, max: number | string): Promise<number>;\n  expire(key: string, seconds: number): Promise<number>;\n}\n\nconst TICKET_PREFIX = 'sse:tkt:';\nconst ORG_ZSET_PREFIX = 'sse:tkt:org:';\nconst ALL_ZSET = 'sse:tkt:all';\nconst OWNER_PREFIX = 'sse:owner:';\n\n/**\n * Redis-backed ticket store — required for multi-pod correctness. Tickets are\n * per-key with native TTL; cap counters are ZSETs scored by expiry (pruned on\n * read). Stream ownership is a per-subject key with its own TTL. All reads are\n * fail-safe (null / 0) so a Redis blip never wedges the stream.\n */\nexport function createRedisTicketStore(redis: RedisTicketClient): SSEStreamTicketStore {\n  const tkey = (id: string): string => `${TICKET_PREFIX}${id}`;\n  const orgKey = (orgId: string): string => `${ORG_ZSET_PREFIX}${orgId}`;\n  const ownerKey = (requestId: string): string => `${OWNER_PREFIX}${requestId}`;\n  const ttlSec = (ttlMs: number): number => Math.max(1, Math.ceil(ttlMs / 1000));\n\n  return {\n    async put(ticketId, record, ttlMs) {\n      const expiresAt = Date.now() + ttlMs;\n      const sec = ttlSec(ttlMs);\n      try {\n        await redis.set(tkey(ticketId), JSON.stringify(record), 'EX', sec);\n        // Track for the caps. Score = expiry so pruning is a range delete.\n        await redis.zadd(orgKey(record.orgId), expiresAt, ticketId);\n        await redis.zadd(ALL_ZSET, expiresAt, ticketId);\n        // Bound the per-org ZSET's own lifetime so an idle org's key can't leak.\n        await redis.expire(orgKey(record.orgId), sec);\n      } catch (err) {\n        logger.warn('SSE ticket put failed', { error: err instanceof Error ? err.message : String(err) });\n      }\n    },\n    async consume(ticketId) {\n      try {\n        const raw = await redis.get(tkey(ticketId));\n        // Single-use: delete regardless. A concurrent double-redeem: at most one\n        // saw a non-null value before the delete; the ZREM cleans the counters.\n        await redis.del(tkey(ticketId));\n        if (!raw) return null;\n        const rec = JSON.parse(raw) as SSEStreamTicketRecord;\n        await redis.zrem(orgKey(rec.orgId), ticketId);\n        await redis.zrem(ALL_ZSET, ticketId);\n        return rec;\n      } catch (err) {\n        logger.warn('SSE ticket consume failed', { error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n    async countForOrg(orgId) {\n      try {\n        await redis.zremrangebyscore(orgKey(orgId), 0, Date.now());\n        return await redis.zcard(orgKey(orgId));\n      } catch { return 0; }\n    },\n    async total() {\n      try {\n        await redis.zremrangebyscore(ALL_ZSET, 0, Date.now());\n        return await redis.zcard(ALL_ZSET);\n      } catch { return 0; }\n    },\n    async bindStreamOwner(requestId, orgId, ttlMs) {\n      try {\n        await redis.set(ownerKey(requestId), orgId, 'EX', ttlSec(ttlMs));\n      } catch (err) {\n        logger.warn('SSE stream-owner bind failed', { error: err instanceof Error ? err.message : String(err) });\n      }\n    },\n    async getStreamOwner(requestId) {\n      try {\n        return await redis.get(ownerKey(requestId));\n      } catch { return null; }\n    },\n  };\n}\n\n/**\n * Build a Redis-backed ticket store from the shared env Redis (same wiring as\n * the rate-limiter / audit-spool). Returns null when Redis isn't configured so\n * the caller keeps the in-memory default. Never throws.\n */\nexport function createEnvRedisTicketStore(): SSEStreamTicketStore | null {\n  const client = createEnvRedisClient<RedisTicketClient>('sse-ticket');\n  if (!client) return null;\n  logger.info('Redis SSE ticket store initialized');\n  return createRedisTicketStore(client);\n}\n"]}