@pipeline-builder/api-server 0.0.1

package/lib/http/sse-relay.d.ts

@@ -0,0 +1,63 @@
+import type { SSEPayload } from './sse-connection-manager.js';
+/**
+ * A relayed SSE frame. `origin` is the id of the SSEManager instance that
+ * published it, so the publishing pod can ignore its own echo (it already wrote
+ * the frame to its local clients before publishing). `kind` distinguishes a
+ * per-subject `send` (carries `requestId`) from a `broadcast` (no subject —
+ * every pod re-emits to ALL of its local clients).
+ */
+export interface SSERelayMessage {
+    origin: string;
+    kind: 'send' | 'broadcast';
+    /** Present for `send`; the stream subject the payload targets. */
+    requestId?: string;
+    payload: SSEPayload;
+}
+/**
+ * Cross-pod fan-out bus for SSE frames.
+ *
+ * Under multiple replicas the producer of a log frame (e.g. a plugin build
+ * worker on pod A) and the consumer (a browser EventSource on pod B) are on
+ * DIFFERENT pods. The in-process client map only reaches the producer's own
+ * pod, so B's stream would silently miss frames. The relay closes that: every
+ * pod SUBSCRIBES once on startup and re-emits received frames to its LOCAL
+ * clients, while `send()`/`broadcast()` PUBLISH to the bus (in addition to
+ * writing locally). The origin tag prevents a pod from double-delivering its own
+ * frame when it receives its own publish back.
+ *
+ * All methods are best-effort / fail-safe: a bus outage must degrade to
+ * local-only delivery (today's single-replica behavior), never crash the stream.
+ */
+export interface SSERelay {
+    /** Fire-and-forget publish of a frame to every subscribed pod. Never throws. */
+    publish(msg: SSERelayMessage): void;
+    /** Subscribe this pod's re-emit handler. Called once on manager construction. */
+    subscribe(handler: (msg: SSERelayMessage) => void): void;
+    /** Tear down the underlying connection(s). */
+    close(): Promise<void>;
+}
+/**
+ * Minimal ioredis pub/sub surface the Redis relay needs. `subscribe` requires a
+ * DEDICATED connection (a subscribed ioredis client can't run other commands),
+ * so the relay `duplicate()`s the publisher for the subscriber side.
+ */
+export interface RedisPubSubClient {
+    publish(channel: string, message: string): Promise<number>;
+    subscribe(...channels: string[]): Promise<unknown>;
+    on(event: 'message', cb: (channel: string, message: string) => void): void;
+    duplicate(): RedisPubSubClient;
+    quit(): Promise<unknown>;
+}
+/**
+ * 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 declare function createRedisSSERelay(publisher: RedisPubSubClient): SSERelay;
+/**
+ * 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.
+ */
+export declare function createEnvRedisSSERelay(): SSERelay | null;

package/lib/http/sse-relay.js

@@ -0,0 +1,70 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+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.
+ */
+const RELAY_CHANNEL = 'sse:relay';
+/**
+ * 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) {
+    const subscriber = publisher.duplicate();
+    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) => {
+                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)
+                    return;
+                let parsed;
+                try {
+                    parsed = JSON.parse(message);
+                }
+                catch (err) {
+                    logger.warn('SSE relay received unparseable frame', { error: err instanceof Error ? err.message : String(err) });
+                    return;
+                }
+                try {
+                    handler(parsed);
+                }
+                catch (err) {
+                    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) });
+            });
+        },
+        async close() {
+            closed = true;
+            await Promise.allSettled([publisher.quit(), subscriber.quit()]);
+        },
+    };
+}
+/**
+ * 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.
+ */
+export function createEnvRedisSSERelay() {
+    const client = createEnvRedisClient('sse-relay');
+    if (!client)
+        return null;
+    logger.info('Redis SSE relay initialized (cross-pod fan-out enabled)');
+    return createRedisSSERelay(client);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-relay.js","sourceRoot":"","sources":["../../src/http/sse-relay.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAGhF,MAAM,MAAM,GAAG,YAAY,CAAC,WAAW,CAAC,CAAC;AAsDzC;;;;GAIG;AACH,MAAM,aAAa,GAAG,WAAW,CAAC;AAElC;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,SAA4B;IAC9D,MAAM,UAAU,GAAG,SAAS,CAAC,SAAS,EAAE,CAAC;IACzC,IAAI,MAAM,GAAG,KAAK,CAAC;IAEnB,OAAO;QACL,OAAO,CAAC,GAAG;YACT,IAAI,MAAM;gBAAE,OAAO;YACnB,yEAAyE;YACzE,KAAK,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;gBACxF,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACvG,CAAC,CAAC,CAAC;QACL,CAAC;QACD,SAAS,CAAC,OAAO;YACf,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE;gBAC5C,IAAI,OAAO,KAAK,aAAa;oBAAE,OAAO;gBACtC,IAAI,MAAuB,CAAC;gBAC5B,IAAI,CAAC;oBACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAoB,CAAC;gBAClD,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,MAAM,CAAC,IAAI,CAAC,sCAAsC,EAAE,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBACjH,OAAO;gBACT,CAAC;gBACD,IAAI,CAAC;oBACH,OAAO,CAAC,MAAM,CAAC,CAAC;gBAClB,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,MAAM,CAAC,IAAI,CAAC,yBAAyB,EAAE,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACtG,CAAC;YACH,CAAC,CAAC,CAAC;YACH,KAAK,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;gBACtE,MAAM,CAAC,IAAI,CAAC,kEAAkE,EAAE,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC/I,CAAC,CAAC,CAAC;QACL,CAAC;QACD,KAAK,CAAC,KAAK;YACT,MAAM,GAAG,IAAI,CAAC;YACd,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,EAAE,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAClE,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB;IACpC,MAAM,MAAM,GAAG,oBAAoB,CAAoB,WAAW,CAAC,CAAC;IACpE,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,MAAM,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;IACvE,OAAO,mBAAmB,CAAC,MAAM,CAAC,CAAC;AACrC,CAAC","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"]}

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

@@ -0,0 +1,31 @@
+import { type SseTicketStore } from '@pipeline-builder/api-core';
+import type { Express, RequestHandler } from 'express';
+import type { SSEManager } from './sse-connection-manager.js';
+export interface SseTicketChannelOptions {
+    /** POST route that exchanges the JWT for a single-use ticket (e.g. '/messages/notifications/ticket'). */
+    ticketPath: string;
+    /** GET route that redeems the ticket and opens the EventSource (e.g. '/messages/notifications'). */
+    streamPath: string;
+    /** Org-scoped, single-use ticket store (Redis-backed for multi-replica). */
+    ticketStore: SseTicketStore;
+    /** SSE manager — the org id is the stream subject (`sseManager.send(orgId, …)`). */
+    sseManager: SSEManager;
+    /** Noun used in capacity/connection error messages (e.g. 'notification', 'execution-stream'). */
+    label: string;
+    /** Extra middleware applied AFTER requireAuth on the mint route (e.g. requirePermission('reports:read')). */
+    ticketGuards?: RequestHandler[];
+}
+/**
+ * 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
+ * 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.
+ *
+ * Distinct from app-factory's `/logs` channel, which is SUBJECT-bound (per build,
+ * via SSEManager.createTicket) rather than org-bound.
+ */
+export declare function registerSseTicketChannel(app: Express, opts: SseTicketChannelOptions): void;

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

@@ -0,0 +1,52 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { requireAuth, sendSuccess, sendError, ErrorCode, createLogger } 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
+ * 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.
+ *
+ * Distinct from app-factory's `/logs` channel, which is SUBJECT-bound (per build,
+ * via SSEManager.createTicket) rather than org-bound.
+ */
+export function registerSseTicketChannel(app, opts) {
+    const { ticketPath, streamPath, ticketStore, sseManager, label, ticketGuards = [] } = opts;
+    app.post(ticketPath, requireAuth, ...ticketGuards, async (req, res) => {
+        const orgId = req.user?.organizationId?.toLowerCase();
+        if (!orgId)
+            return sendError(res, 400, 'Token missing organization', ErrorCode.VALIDATION_ERROR);
+        const result = await ticketStore.issue(orgId);
+        if (!result.ok) {
+            return result.reason === 'total'
+                ? sendError(res, 503, `The ${label} subsystem is at capacity`, ErrorCode.QUOTA_EXCEEDED)
+                : sendError(res, 429, `Too many ${label} tickets issued`, ErrorCode.QUOTA_EXCEEDED);
+        }
+        return sendSuccess(res, 200, { ticket: result.ticket });
+    });
+    app.get(streamPath, async (req, res) => {
+        const ticketId = req.query.ticket;
+        if (!ticketId)
+            return void sendError(res, 401, 'Missing ticket parameter', ErrorCode.UNAUTHORIZED);
+        const ticket = await ticketStore.consume(ticketId); // atomic single-use
+        if (!ticket)
+            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);
+        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');
+        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":"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","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"]}

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

@@ -0,0 +1,75 @@
+/** 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

@@ -0,0 +1,160 @@
+// 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"]}

package/lib/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module @pipeline-builder/api-server
+ *
+ * Express server infrastructure and request lifecycle utilities.
+ *
+ * **App Factory**
+ * - createApp — creates a configured Express app with CORS, Helmet, rate limiting
+ * - runServer, startServer — server lifecycle with graceful shutdown
+ *
+ * **Middleware**
+ * - attachRequestContext / createRequestContext — attaches identity + logging to each request
+ * - requireOrgId — validates organization ID is present on the request
+ * - withTenantContext — opens the RLS tenant scope for the request
+ * - checkQuota — quota enforcement middleware
+ * - idempotencyMiddleware — idempotent request handling
+ * - createProtectedRoute / createAuthenticatedWithOrgRoute — composable middleware chains
+ *
+ * **Route Helpers**
+ * - withRoute — wraps async route handlers with context extraction, orgId validation, and error handling
+ * - getContext — retrieves RequestContext from the Express request
+ * - RouteContext, RequestContext — route and request context types
+ *
+ * **SSE**
+ * - SSEManager — Server-Sent Events connection manager
+ *
+ * **Observability**
+ * - Tracing and metrics collection utilities
+ */
+export * from './api/index.js';
+export * from './http/index.js';

package/lib/index.js

@@ -0,0 +1,35 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * @module @pipeline-builder/api-server
+ *
+ * Express server infrastructure and request lifecycle utilities.
+ *
+ * **App Factory**
+ * - createApp — creates a configured Express app with CORS, Helmet, rate limiting
+ * - runServer, startServer — server lifecycle with graceful shutdown
+ *
+ * **Middleware**
+ * - attachRequestContext / createRequestContext — attaches identity + logging to each request
+ * - requireOrgId — validates organization ID is present on the request
+ * - withTenantContext — opens the RLS tenant scope for the request
+ * - checkQuota — quota enforcement middleware
+ * - idempotencyMiddleware — idempotent request handling
+ * - createProtectedRoute / createAuthenticatedWithOrgRoute — composable middleware chains
+ *
+ * **Route Helpers**
+ * - withRoute — wraps async route handlers with context extraction, orgId validation, and error handling
+ * - getContext — retrieves RequestContext from the Express request
+ * - RouteContext, RequestContext — route and request context types
+ *
+ * **SSE**
+ * - SSEManager — Server-Sent Events connection manager
+ *
+ * **Observability**
+ * - Tracing and metrics collection utilities
+ */
+// API Infrastructure
+export * from './api/index.js';
+// HTTP Utilities
+export * from './http/index.js';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/otel-bootstrap.d.ts

@@ -0,0 +1 @@
+export {};