@pipeline-builder/api-server 4.1.3 → 4.1.5

package/lib/api/rate-limit-by-org.js

@@ -1,8 +1,8 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { sendError, ErrorCode, createLogger, verifyServicePrincipal, createEnvRedisClient, safeCreateRequire } from '@pipeline-builder/api-core';
+import { sendError, ErrorCode, verifyServicePrincipal } from '@pipeline-builder/api-core';
 import rateLimit, { ipKeyGenerator } from 'express-rate-limit';
-const logger = createLogger('rate-limit-by-org');
+import { createSharedRateLimitStore } from './rate-limit-store.js';
 /**
  * Per-ORGANIZATION rate limiter for a specific hot/expensive route, keyed on the
  * VERIFIED auth org — the complement to the coarse global per-IP limiter in
@@ -29,11 +29,18 @@ export function rateLimitByOrg(opts) {
         legacyHeaders: false,
         // Exempt cryptographically-verified internal service callers (signed JWT).
         skip: (req) => verifyServicePrincipal(req),
-        // Bucket by VERIFIED org (set by requireAuth), NOT the spoofable `x-org-id`
-        // header. Fall back to a normalized client-IP bucket when unauthenticated so
-        // the limiter still bounds pre-auth traffic. Namespaced (`org:`/`ip:`) so an
-        // IP literal can never collide with an org id.
+        // Redis store failure degrades to "not limited", never a 500 on the route.
+        passOnStoreError: true,
+        // Bucket by VERIFIED identity (set by requireAuth), NOT the spoofable
+        // `x-org-id` header. An ORG SERVICE ACCOUNT gets its OWN bucket rather than
+        // its org's: automation is exactly the traffic shape that would otherwise
+        // drain the window its org's people share, and the plan requires machine
+        // rate limits to be keyed per account. Falls back to a normalized client-IP
+        // bucket when unauthenticated so pre-auth traffic is still bounded.
+        // Namespaced (`sa:`/`org:`/`ip:`) so no two id spaces can collide.
         keyGenerator: (req) => {
+            if (req.user?.principalType === 'service_account' && req.user.sub)
+                return `sa:${req.user.sub}`;
             const orgId = req.user?.organizationId;
             return orgId ? `org:${orgId.toLowerCase()}` : `ip:${ipKeyGenerator(req.ip || 'anon', 64)}`;
         },
@@ -41,24 +48,11 @@ export function rateLimitByOrg(opts) {
             sendError(res, 429, message ?? `Too many ${name} requests, please slow down.`, ErrorCode.RATE_LIMIT_EXCEEDED);
         },
     };
-    // Shared Redis store for cross-replica buckets when Redis is configured;
-    // namespaced per limiter so distinct limiters don't share a bucket. Fail-open:
-    // no Redis / a load failure falls back to per-process in-memory limiting.
-    const redis = createEnvRedisClient(`rate-limit-${name}`);
-    if (redis) {
-        try {
-            const require = safeCreateRequire(import.meta.url);
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const { RedisStore } = require('rate-limit-redis');
-            options.store = new RedisStore({
-                prefix: `rl:${name}:`,
-                sendCommand: (...args) => redis.call(...args),
-            });
-        }
-        catch {
-            logger.warn('Redis store unavailable; per-org limiter falls back to in-memory', { name });
-        }
-    }
+    // Shared cross-replica store (one process-wide Redis connection) when Redis is
+    // configured, else per-process memory. Namespaced by service AND limiter name so
+    // distinct limiters — or same-named limiters in different services — never
+    // share a counter.
+    options.store = createSharedRateLimitStore(`${process.env.SERVICE_NAME || 'api'}:${name}`);
     return rateLimit(options);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/rate-limit-store.d.ts

@@ -0,0 +1,16 @@
+import type { Store } from 'express-rate-limit';
+/**
+ * A cross-replica rate-limit store under `rl:<namespace>:`, or `undefined` when
+ * Redis isn't configured (express-rate-limit then uses its per-process memory
+ * store, which is right for a single replica).
+ *
+ * Without a shared store every limit is really `max × replicas`, and weakest
+ * exactly when an HPA has scaled out under load. Use a namespace unique to the
+ * service AND limiter, so separate limiters never share a counter. Pair it with
+ * `passOnStoreError: true`: a Redis outage then lets requests through instead of
+ * failing them. A store whose scripts can't load at startup (Redis not yet
+ * connected) is tolerated by express-rate-limit and reloads on first use.
+ */
+export declare function createSharedRateLimitStore(namespace: string): Store | undefined;
+/** Test-only: forget the memoized client. */
+export declare function __resetSharedRateLimitStoreForTests(): void;

package/lib/api/rate-limit-store.js

@@ -0,0 +1,39 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createEnvRedisClient, createLogger, safeCreateRequire } from '@pipeline-builder/api-core';
+const logger = createLogger('rate-limit-store');
+/** One Redis connection for every rate limiter in the process.
+ *  undefined = not built yet; null = Redis not configured. */
+let client;
+/**
+ * A cross-replica rate-limit store under `rl:<namespace>:`, or `undefined` when
+ * Redis isn't configured (express-rate-limit then uses its per-process memory
+ * store, which is right for a single replica).
+ *
+ * Without a shared store every limit is really `max × replicas`, and weakest
+ * exactly when an HPA has scaled out under load. Use a namespace unique to the
+ * service AND limiter, so separate limiters never share a counter. Pair it with
+ * `passOnStoreError: true`: a Redis outage then lets requests through instead of
+ * failing them. A store whose scripts can't load at startup (Redis not yet
+ * connected) is tolerated by express-rate-limit and reloads on first use.
+ */
+export function createSharedRateLimitStore(namespace) {
+    if (client === undefined)
+        client = createEnvRedisClient('rate-limit');
+    if (!client)
+        return undefined;
+    const redis = client;
+    const require = safeCreateRequire(import.meta.url);
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { RedisStore } = require('rate-limit-redis');
+    logger.debug('Shared rate-limit store created', { namespace });
+    return new RedisStore({
+        prefix: `rl:${namespace}:`,
+        sendCommand: (...args) => redis.call(...args),
+    });
+}
+/** Test-only: forget the memoized client. */
+export function __resetSharedRateLimitStoreForTests() {
+    client = undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/request-types.d.ts

@@ -23,7 +23,7 @@ export interface RequestContext {
     requestId: string;
     /** Identity from headers */
     identity: RequestIdentity;
-    /** Logging function that sends to console and SSE */
+    /** Logging function: logger always, plus the SSE log stream when the service enables it */
     log: RequestLogger;
 }
 /**

package/lib/api/request-types.js

@@ -49,12 +49,17 @@ export function createRequestContext(req, sseManager) {
                 logger.info(message, meta);
                 break;
         }
+        // Only a service that serves a log stream (createApp `logStream: true`)
+        // pushes the line to SSE — otherwise every log line of every service would
+        // be serialized, written and relayed across Redis for no subscriber.
         // The Winston call above is redacted by the logger's `redactFormat`, but the
         // SSE frame bypasses the logger entirely — apply the SAME key-pattern
         // redaction to `data` before it's pushed to the client so a secret in the
         // log payload (e.g. an accidental `token`/`password` field) isn't streamed
         // out over the build-log SSE channel.
-        sseManager.send(requestId, type, message, redactSensitive(data));
+        if (sseManager.logStreamEnabled) {
+            sseManager.send(requestId, type, message, redactSensitive(data));
+        }
     };
     return {
         requestId,
@@ -62,4 +67,4 @@ export function createRequestContext(req, sseManager) {
         log,
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/server.js

@@ -1,7 +1,7 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { Server } from 'http';
-import { createLogger, errorMessage, installCrashHandlers } from '@pipeline-builder/api-core';
+import { buildRouteTable, createLogger, errorMessage, installCrashHandlers, resolveRedisConnection, summarizeRouteTable } from '@pipeline-builder/api-core';
 import { Config } from '@pipeline-builder/pipeline-core';
 import { getConnection, closeConnection } from '@pipeline-builder/pipeline-data';
 import { setReady, isReady } from './readiness.js';
@@ -113,6 +113,22 @@ export async function startServer(app, options = {}) {
     const port = options.port ?? serverConfig.port;
     // Validate auth configuration at server startup (not during CDK synthesis)
     Config.validateAuth();
+    // Fail fast if this service has no internal signing key of its own, or no
+    // public bundle to verify its peers with (#14). Without them it would mint
+    // tokens on an EPHEMERAL in-process key that no peer accepts, and reject every
+    // peer's token — i.e. silently lose all service-to-service traffic. Checked
+    // HERE rather than in `createApp` because it is a property of the running
+    // deployment, not of the app object: route-table builders and test suites
+    // assemble an app without ever signing anything.
+    for (const envVar of ['SERVICE_SIGNING_KEY_FILE', 'SERVICE_KEY_BUNDLE_FILE']) {
+        if (!process.env[envVar]) {
+            throw new Error(`${envVar} environment variable is required (generate with deploy/bin/service-signing-keys.sh). Set it before starting the server.`);
+        }
+    }
+    // Fail fast on an unusable Redis configuration (throws RedisConfigError) — a
+    // Redis client is created lazily on first use, so without this a bad config
+    // would surface as request-time errors instead of a failed start.
+    resolveRedisConnection();
     logger.info(`Starting ${name}...`);
     // Mark NotReady synchronously, BEFORE the port opens, so no request slips
     // through the readiness guard before the supervisor has run. The supervisor
@@ -214,6 +230,11 @@ export async function startServer(app, options = {}) {
  * ```
  */
 export function runServer(app, options = {}) {
+    // Route table of the fully assembled app (see api-core's route-table.ts): the
+    // same introspection the per-service coverage test asserts on, logged once at
+    // boot so an ungated or unaudited write route is visible in the running
+    // service, not only in CI.
+    logger.info('Route table built', summarizeRouteTable(buildRouteTable(app)));
     // Last-resort fault handlers for the production entrypoint: an unhandled
     // rejection / uncaught exception is logged (not silently fatal) then the
     // process exits for the orchestrator to restart. No-op under NODE_ENV=test.
@@ -231,4 +252,4 @@ export function runServer(app, options = {}) {
         process.exit(1);
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/api/server.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Server } from 'http';\nimport { createLogger, errorMessage, installCrashHandlers } from '@pipeline-builder/api-core';\nimport { Config } from '@pipeline-builder/pipeline-core';\nimport { getConnection, closeConnection } from '@pipeline-builder/pipeline-data';\nimport type { Express } from 'express';\nimport { setReady, isReady } from './readiness.js';\nimport { shutdownTracing } from './tracing.js';\nimport { SSEManager } from '../http/sse-connection-manager.js';\n\nconst logger = createLogger('server');\n\nconst sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));\n\n// Dependency-supervisor cadence. Initial connect retries with capped backoff;\n// once connected, re-checks at a steady interval so a later outage flips the\n// service NotReady (draining traffic) and a recovery flips it back — without\n// ever exiting / restarting the process.\nconst READY_RETRY_BASE_MS = 1000;\nconst READY_RETRY_MAX_MS = 10000;\nconst READY_MONITOR_INTERVAL_MS = parseInt(process.env.READINESS_MONITOR_INTERVAL_MS || '15000', 10);\n\n/**\n * Establish and continuously monitor the service's datastore dependency,\n * flipping readiness state instead of crash-looping.\n *\n * - Establish phase: retry `onBeforeStart` (e.g. connectMongo) with capped\n *   backoff until it succeeds — a cold datastore must never exit the process.\n * - Monitor phase: poll `testDatabase` for the life of the process; flip\n *   ready/NotReady on transitions. While NotReady the readiness guard 503s\n *   business traffic and orchestrator readiness probes drain the instance.\n *\n * Runs in the background (the HTTP server is already listening). Stops when\n * `aborted()` returns true (graceful shutdown), so it never keeps a closing\n * process alive.\n */\nasync function superviseDependencies(\n  name: string,\n  onBeforeStart: (() => Promise<void>) | undefined,\n  testDatabase: (() => Promise<boolean>) | false | undefined,\n  aborted: () => boolean,\n): Promise<void> {\n  if (onBeforeStart) {\n    let delay = READY_RETRY_BASE_MS;\n    while (!aborted()) {\n      try {\n        await onBeforeStart();\n        break;\n      } catch (error) {\n        logger.warn(`${name}: dependency init failed, retrying in ${delay}ms`, { error: errorMessage(error) });\n        await sleep(delay);\n        delay = Math.min(delay * 2, READY_RETRY_MAX_MS);\n      }\n    }\n  }\n\n  // No datastore to gate on → ready as soon as we are listening.\n  if (testDatabase === false) {\n    setReady(true);\n    logger.info(`${name} ready (no datastore dependency)`);\n    return;\n  }\n\n  const probe = testDatabase ?? (() => getConnection().testConnection());\n  let waitDelay = READY_RETRY_BASE_MS;\n  while (!aborted()) {\n    let ok = false;\n    try {\n      ok = await probe();\n    } catch {\n      ok = false;\n    }\n\n    if (ok && !isReady()) {\n      setReady(true);\n      waitDelay = READY_RETRY_BASE_MS;\n      logger.info(`${name} ready — dependencies connected`);\n    } else if (!ok && isReady()) {\n      setReady(false);\n      logger.warn(`${name} degraded — dependency check failing (now NotReady)`);\n    }\n\n    // Steady cadence once ready; faster backoff while waiting so we flip to\n    // ready promptly when the datastore comes up.\n    if (isReady()) {\n      await sleep(READY_MONITOR_INTERVAL_MS);\n    } else {\n      await sleep(waitDelay);\n      waitDelay = Math.min(waitDelay * 2, READY_RETRY_MAX_MS);\n    }\n  }\n}\n\n/**\n * Options for starting a server\n */\nexport interface StartServerOptions {\n  /** Service name for logging */\n  name?: string;\n  /** Port to listen on (default: from config) */\n  port?: number;\n  /** SSE manager for graceful shutdown */\n  sseManager?: SSEManager;\n  /** Shutdown timeout in milliseconds (default: 15000) */\n  shutdownTimeoutMs?: number;\n  /** Callback after server starts */\n  onStart?: (port: number) => void;\n  /** Callback before shutdown */\n  onShutdown?: () => Promise<void>;\n  /** Runs before database check (e.g., initialize external connections) */\n  onBeforeStart?: () => Promise<void>;\n  /** Custom database health check, or false to skip. Default: PostgreSQL testConnection */\n  testDatabase?: (() => Promise<boolean>) | false;\n  /** Custom database close, or false to skip. Default: PostgreSQL closeConnection */\n  closeDatabase?: (() => Promise<void>) | false;\n}\n\n/**\n * Result of starting a server\n */\nexport interface StartServerResult {\n  /** HTTP server instance */\n  server: Server;\n  /** Port the server is listening on */\n  port: number;\n  /** Function to manually trigger shutdown */\n  shutdown: () => Promise<void>;\n}\n\n/**\n * Start an Express server with graceful shutdown handling\n *\n * Features:\n * - Automatic database connection testing\n * - Graceful shutdown on SIGINT/SIGTERM\n * - SSE connection cleanup\n * - Configurable shutdown timeout\n *\n * @param app - Express application\n * @param options - Server options\n * @returns Server instance and control functions\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, handler);\n *\n * await startServer(app, {\n *   name: 'My Microservice',\n *   sseManager,\n *   onStart: (port) => console.log(`Listening on ${port}`),\n * });\n * ```\n */\nexport async function startServer(\n  app: Express,\n  options: StartServerOptions = {},\n): Promise<StartServerResult> {\n  const serverConfig = Config.get('server');\n  const {\n    name = 'Microservice',\n    sseManager,\n    shutdownTimeoutMs = 15000,\n    onStart,\n    onShutdown,\n    onBeforeStart,\n    testDatabase,\n    closeDatabase,\n  } = options;\n  const port = options.port ?? serverConfig.port;\n\n  // Validate auth configuration at server startup (not during CDK synthesis)\n  Config.validateAuth();\n\n  logger.info(`Starting ${name}...`);\n\n  // Mark NotReady synchronously, BEFORE the port opens, so no request slips\n  // through the readiness guard before the supervisor has run. The supervisor\n  // flips it true once dependencies connect.\n  setReady(false);\n\n  // Listen FIRST. Previously the process tested the DB and `process.exit(1)`'d\n  // on failure (to be restarted), so during a cold-DB stampede services\n  // crash-looped and never even opened their port. Now we open the port\n  // immediately — /health (liveness), /ready (readiness) and the readiness\n  // guard all respond at once — and establish + monitor the datastore in the\n  // background, reporting NotReady until it connects instead of exiting.\n  const server = app.listen(port, () => {\n    logger.info(`${name} listening on port: ${port}`);\n    logger.info(`Platform URL: ${serverConfig.platformUrl}`);\n    onStart?.(port);\n  });\n\n  // Shutdown handler (guarded against concurrent signals)\n  let shuttingDown = false;\n\n  // Background dependency supervisor — established + monitored after listen,\n  // stopped on shutdown so it never keeps a closing process alive. Guard the\n  // floating promise: every expected failure is handled inside, so a rejection\n  // here means a programming error — log it and leave the service NotReady\n  // rather than letting it become an unhandledRejection that crash-exits the\n  // process (which would defeat the whole \"never exit on dependency trouble\"\n  // goal).\n  superviseDependencies(name, onBeforeStart, testDatabase, () => shuttingDown).catch((error) => {\n    logger.error('Dependency supervisor crashed; service will remain NotReady', { error: errorMessage(error) });\n  });\n\n  const shutdown = async (signal?: string) => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n\n    if (signal) {\n      logger.info(`${signal} received, shutting down gracefully...`);\n    }\n\n    // Custom shutdown callback\n    if (onShutdown) {\n      try {\n        await onShutdown();\n      } catch (error) {\n        logger.error('Error in onShutdown callback', { error });\n      }\n    }\n\n    // Close SSE connections\n    if (sseManager) {\n      sseManager.shutdown();\n      logger.info('SSE connections closed');\n    }\n\n    // Close HTTP server\n    server.close(async () => {\n      logger.info('HTTP server closed');\n\n      // Shutdown OpenTelemetry tracing\n      await shutdownTracing().catch(err => logger.error('Error shutting down tracing', { error: err }));\n\n      // Close database connection\n      if (closeDatabase !== false) {\n        try {\n          if (closeDatabase) {\n            await closeDatabase();\n          } else {\n            await closeConnection();\n          }\n          logger.info('Database connection closed');\n        } catch (error) {\n          logger.error('Error closing database', { error });\n        }\n      }\n\n      process.exit(0);\n    });\n\n    // Force shutdown after timeout\n    setTimeout(() => {\n      logger.error('Forced shutdown after timeout');\n      process.exit(1);\n    }, shutdownTimeoutMs).unref();\n  };\n\n  // Register signal handlers\n  process.once('SIGINT', () => void shutdown('SIGINT'));\n  process.once('SIGTERM', () => void shutdown('SIGTERM'));\n\n  return {\n    server,\n    port,\n    shutdown: () => shutdown(),\n  };\n}\n\n/**\n * Simple server start wrapper with error handling\n *\n * @param app - Express application\n * @param options - Server options\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n * app.post('/api/resource', handler);\n *\n * void runServer(app, { name: 'My Service', sseManager });\n * ```\n */\nexport function runServer(app: Express, options: StartServerOptions = {}): void {\n  // Last-resort fault handlers for the production entrypoint: an unhandled\n  // rejection / uncaught exception is logged (not silently fatal) then the\n  // process exits for the orchestrator to restart. No-op under NODE_ENV=test.\n  installCrashHandlers(logger);\n  startServer(app, options).catch((error) => {\n    // startServer now listens-first and supervises the DB in the background, so\n    // it only rejects on a genuinely fatal SETUP error (invalid auth config, a\n    // failed onStart, the port already in use). Log message + stack explicitly:\n    // an Error in winston metadata serializes to `{}` (message/stack are\n    // non-enumerable), which would otherwise hide the cause behind `{error:{}}`.\n    logger.error('Failed to start server', {\n      error: error instanceof Error ? error.message : String(error),\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n    process.exit(1);\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/api/server.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Server } from 'http';\nimport { buildRouteTable, createLogger, errorMessage, installCrashHandlers, resolveRedisConnection, summarizeRouteTable } from '@pipeline-builder/api-core';\nimport { Config } from '@pipeline-builder/pipeline-core';\nimport { getConnection, closeConnection } from '@pipeline-builder/pipeline-data';\nimport type { Express } from 'express';\nimport { setReady, isReady } from './readiness.js';\nimport { shutdownTracing } from './tracing.js';\nimport { SSEManager } from '../http/sse-connection-manager.js';\n\nconst logger = createLogger('server');\n\nconst sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));\n\n// Dependency-supervisor cadence. Initial connect retries with capped backoff;\n// once connected, re-checks at a steady interval so a later outage flips the\n// service NotReady (draining traffic) and a recovery flips it back — without\n// ever exiting / restarting the process.\nconst READY_RETRY_BASE_MS = 1000;\nconst READY_RETRY_MAX_MS = 10000;\nconst READY_MONITOR_INTERVAL_MS = parseInt(process.env.READINESS_MONITOR_INTERVAL_MS || '15000', 10);\n\n/**\n * Establish and continuously monitor the service's datastore dependency,\n * flipping readiness state instead of crash-looping.\n *\n * - Establish phase: retry `onBeforeStart` (e.g. connectMongo) with capped\n *   backoff until it succeeds — a cold datastore must never exit the process.\n * - Monitor phase: poll `testDatabase` for the life of the process; flip\n *   ready/NotReady on transitions. While NotReady the readiness guard 503s\n *   business traffic and orchestrator readiness probes drain the instance.\n *\n * Runs in the background (the HTTP server is already listening). Stops when\n * `aborted()` returns true (graceful shutdown), so it never keeps a closing\n * process alive.\n */\nasync function superviseDependencies(\n  name: string,\n  onBeforeStart: (() => Promise<void>) | undefined,\n  testDatabase: (() => Promise<boolean>) | false | undefined,\n  aborted: () => boolean,\n): Promise<void> {\n  if (onBeforeStart) {\n    let delay = READY_RETRY_BASE_MS;\n    while (!aborted()) {\n      try {\n        await onBeforeStart();\n        break;\n      } catch (error) {\n        logger.warn(`${name}: dependency init failed, retrying in ${delay}ms`, { error: errorMessage(error) });\n        await sleep(delay);\n        delay = Math.min(delay * 2, READY_RETRY_MAX_MS);\n      }\n    }\n  }\n\n  // No datastore to gate on → ready as soon as we are listening.\n  if (testDatabase === false) {\n    setReady(true);\n    logger.info(`${name} ready (no datastore dependency)`);\n    return;\n  }\n\n  const probe = testDatabase ?? (() => getConnection().testConnection());\n  let waitDelay = READY_RETRY_BASE_MS;\n  while (!aborted()) {\n    let ok = false;\n    try {\n      ok = await probe();\n    } catch {\n      ok = false;\n    }\n\n    if (ok && !isReady()) {\n      setReady(true);\n      waitDelay = READY_RETRY_BASE_MS;\n      logger.info(`${name} ready — dependencies connected`);\n    } else if (!ok && isReady()) {\n      setReady(false);\n      logger.warn(`${name} degraded — dependency check failing (now NotReady)`);\n    }\n\n    // Steady cadence once ready; faster backoff while waiting so we flip to\n    // ready promptly when the datastore comes up.\n    if (isReady()) {\n      await sleep(READY_MONITOR_INTERVAL_MS);\n    } else {\n      await sleep(waitDelay);\n      waitDelay = Math.min(waitDelay * 2, READY_RETRY_MAX_MS);\n    }\n  }\n}\n\n/**\n * Options for starting a server\n */\nexport interface StartServerOptions {\n  /** Service name for logging */\n  name?: string;\n  /** Port to listen on (default: from config) */\n  port?: number;\n  /** SSE manager for graceful shutdown */\n  sseManager?: SSEManager;\n  /** Shutdown timeout in milliseconds (default: 15000) */\n  shutdownTimeoutMs?: number;\n  /** Callback after server starts */\n  onStart?: (port: number) => void;\n  /** Callback before shutdown */\n  onShutdown?: () => Promise<void>;\n  /** Runs before database check (e.g., initialize external connections) */\n  onBeforeStart?: () => Promise<void>;\n  /** Custom database health check, or false to skip. Default: PostgreSQL testConnection */\n  testDatabase?: (() => Promise<boolean>) | false;\n  /** Custom database close, or false to skip. Default: PostgreSQL closeConnection */\n  closeDatabase?: (() => Promise<void>) | false;\n}\n\n/**\n * Result of starting a server\n */\nexport interface StartServerResult {\n  /** HTTP server instance */\n  server: Server;\n  /** Port the server is listening on */\n  port: number;\n  /** Function to manually trigger shutdown */\n  shutdown: () => Promise<void>;\n}\n\n/**\n * Start an Express server with graceful shutdown handling\n *\n * Features:\n * - Automatic database connection testing\n * - Graceful shutdown on SIGINT/SIGTERM\n * - SSE connection cleanup\n * - Configurable shutdown timeout\n *\n * @param app - Express application\n * @param options - Server options\n * @returns Server instance and control functions\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, handler);\n *\n * await startServer(app, {\n *   name: 'My Microservice',\n *   sseManager,\n *   onStart: (port) => console.log(`Listening on ${port}`),\n * });\n * ```\n */\nexport async function startServer(\n  app: Express,\n  options: StartServerOptions = {},\n): Promise<StartServerResult> {\n  const serverConfig = Config.get('server');\n  const {\n    name = 'Microservice',\n    sseManager,\n    shutdownTimeoutMs = 15000,\n    onStart,\n    onShutdown,\n    onBeforeStart,\n    testDatabase,\n    closeDatabase,\n  } = options;\n  const port = options.port ?? serverConfig.port;\n\n  // Validate auth configuration at server startup (not during CDK synthesis)\n  Config.validateAuth();\n  // Fail fast if this service has no internal signing key of its own, or no\n  // public bundle to verify its peers with (#14). Without them it would mint\n  // tokens on an EPHEMERAL in-process key that no peer accepts, and reject every\n  // peer's token — i.e. silently lose all service-to-service traffic. Checked\n  // HERE rather than in `createApp` because it is a property of the running\n  // deployment, not of the app object: route-table builders and test suites\n  // assemble an app without ever signing anything.\n  for (const envVar of ['SERVICE_SIGNING_KEY_FILE', 'SERVICE_KEY_BUNDLE_FILE'] as const) {\n    if (!process.env[envVar]) {\n      throw new Error(`${envVar} environment variable is required (generate with deploy/bin/service-signing-keys.sh). Set it before starting the server.`);\n    }\n  }\n  // Fail fast on an unusable Redis configuration (throws RedisConfigError) — a\n  // Redis client is created lazily on first use, so without this a bad config\n  // would surface as request-time errors instead of a failed start.\n  resolveRedisConnection();\n\n  logger.info(`Starting ${name}...`);\n\n  // Mark NotReady synchronously, BEFORE the port opens, so no request slips\n  // through the readiness guard before the supervisor has run. The supervisor\n  // flips it true once dependencies connect.\n  setReady(false);\n\n  // Listen FIRST. Previously the process tested the DB and `process.exit(1)`'d\n  // on failure (to be restarted), so during a cold-DB stampede services\n  // crash-looped and never even opened their port. Now we open the port\n  // immediately — /health (liveness), /ready (readiness) and the readiness\n  // guard all respond at once — and establish + monitor the datastore in the\n  // background, reporting NotReady until it connects instead of exiting.\n  const server = app.listen(port, () => {\n    logger.info(`${name} listening on port: ${port}`);\n    logger.info(`Platform URL: ${serverConfig.platformUrl}`);\n    onStart?.(port);\n  });\n\n  // Shutdown handler (guarded against concurrent signals)\n  let shuttingDown = false;\n\n  // Background dependency supervisor — established + monitored after listen,\n  // stopped on shutdown so it never keeps a closing process alive. Guard the\n  // floating promise: every expected failure is handled inside, so a rejection\n  // here means a programming error — log it and leave the service NotReady\n  // rather than letting it become an unhandledRejection that crash-exits the\n  // process (which would defeat the whole \"never exit on dependency trouble\"\n  // goal).\n  superviseDependencies(name, onBeforeStart, testDatabase, () => shuttingDown).catch((error) => {\n    logger.error('Dependency supervisor crashed; service will remain NotReady', { error: errorMessage(error) });\n  });\n\n  const shutdown = async (signal?: string) => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n\n    if (signal) {\n      logger.info(`${signal} received, shutting down gracefully...`);\n    }\n\n    // Custom shutdown callback\n    if (onShutdown) {\n      try {\n        await onShutdown();\n      } catch (error) {\n        logger.error('Error in onShutdown callback', { error });\n      }\n    }\n\n    // Close SSE connections\n    if (sseManager) {\n      sseManager.shutdown();\n      logger.info('SSE connections closed');\n    }\n\n    // Close HTTP server\n    server.close(async () => {\n      logger.info('HTTP server closed');\n\n      // Shutdown OpenTelemetry tracing\n      await shutdownTracing().catch(err => logger.error('Error shutting down tracing', { error: err }));\n\n      // Close database connection\n      if (closeDatabase !== false) {\n        try {\n          if (closeDatabase) {\n            await closeDatabase();\n          } else {\n            await closeConnection();\n          }\n          logger.info('Database connection closed');\n        } catch (error) {\n          logger.error('Error closing database', { error });\n        }\n      }\n\n      process.exit(0);\n    });\n\n    // Force shutdown after timeout\n    setTimeout(() => {\n      logger.error('Forced shutdown after timeout');\n      process.exit(1);\n    }, shutdownTimeoutMs).unref();\n  };\n\n  // Register signal handlers\n  process.once('SIGINT', () => void shutdown('SIGINT'));\n  process.once('SIGTERM', () => void shutdown('SIGTERM'));\n\n  return {\n    server,\n    port,\n    shutdown: () => shutdown(),\n  };\n}\n\n/**\n * Simple server start wrapper with error handling\n *\n * @param app - Express application\n * @param options - Server options\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n * app.post('/api/resource', handler);\n *\n * void runServer(app, { name: 'My Service', sseManager });\n * ```\n */\nexport function runServer(app: Express, options: StartServerOptions = {}): void {\n  // Route table of the fully assembled app (see api-core's route-table.ts): the\n  // same introspection the per-service coverage test asserts on, logged once at\n  // boot so an ungated or unaudited write route is visible in the running\n  // service, not only in CI.\n  logger.info('Route table built', summarizeRouteTable(buildRouteTable(app)));\n\n  // Last-resort fault handlers for the production entrypoint: an unhandled\n  // rejection / uncaught exception is logged (not silently fatal) then the\n  // process exits for the orchestrator to restart. No-op under NODE_ENV=test.\n  installCrashHandlers(logger);\n  startServer(app, options).catch((error) => {\n    // startServer now listens-first and supervises the DB in the background, so\n    // it only rejects on a genuinely fatal SETUP error (invalid auth config, a\n    // failed onStart, the port already in use). Log message + stack explicitly:\n    // an Error in winston metadata serializes to `{}` (message/stack are\n    // non-enumerable), which would otherwise hide the cause behind `{error:{}}`.\n    logger.error('Failed to start server', {\n      error: error instanceof Error ? error.message : String(error),\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n    process.exit(1);\n  });\n}\n"]}

package/lib/http/index.d.ts

@@ -1,4 +1,3 @@
 export * from './sse-connection-manager.js';
 export * from './sse-ticket-channel.js';
-export * from './sse-ticket-store.js';
 export * from './sse-relay.js';

package/lib/http/index.js

@@ -2,6 +2,5 @@
 // SPDX-License-Identifier: Apache-2.0
 export * from './sse-connection-manager.js';
 export * from './sse-ticket-channel.js';
-export * from './sse-ticket-store.js';
 export * from './sse-relay.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaHR0cC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9zc2UtY29ubmVjdGlvbi1tYW5hZ2VyLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc3NlLXRpY2tldC1jaGFubmVsLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc3NlLXRpY2tldC1zdG9yZS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NzZS1yZWxheS5qcyc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaHR0cC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmV4cG9ydCAqIGZyb20gJy4vc3NlLWNvbm5lY3Rpb24tbWFuYWdlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NzZS10aWNrZXQtY2hhbm5lbC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NzZS1yZWxheS5qcyc7XG4iXX0=

package/lib/http/sse-connection-manager.d.ts

@@ -1,6 +1,6 @@
+import { type SseTicketStore } from '@pipeline-builder/api-core';
 import type { Response } from 'express';
 import type { SSERelay } from './sse-relay.js';
-import { type SSEStreamTicketStore } from './sse-ticket-store.js';
 /**
  * Event types for SSE logging
  */
@@ -55,42 +55,51 @@ export interface SSEManagerOptions {
      */
     maxClientsPerOrg?: number;
     /**
-     * Hard cap on total live (unconsumed, unexpired) SSE tickets across the
-     * process. Defaults to 1000 from `SSE_MAX_TOTAL_TICKETS`. Bounds memory
-     * under abuse — `createTicket` returns `{ ok: false, reason: 'capacity' }`
-     * once reached.
+     * Cap on live log-stream tickets across the process, for the DEFAULT
+     * in-memory ticket store. Defaults to 1000 from `SSE_MAX_TOTAL_TICKETS`.
+     * Ignored when `ticketStore` is injected (the store carries its own caps).
      */
     maxTotalTickets?: number;
     /**
-     * Per-org cap on live SSE tickets. Defaults to 10 from
-     * `SSE_MAX_TICKETS_PER_ORG`. Prevents a single tenant from saturating the
-     * ticket table — `createTicket` returns `{ ok: false, reason: 'org-limit' }`
-     * once reached.
+     * Per-org cap on live log-stream tickets, for the DEFAULT in-memory ticket
+     * store. Defaults to 10 from `SSE_MAX_TICKETS_PER_ORG`. Ignored when
+     * `ticketStore` is injected.
      */
     maxTicketsPerOrg?: number;
-    /** Ticket TTL in ms (default: `SSE_TICKET_TTL_MS` from api-core). */
+    /** Ticket TTL in ms for the default store (default: `SSE_TICKET_TTL_MS` from api-core). */
     ticketTtlMs?: number;
     /**
-     * Ticket + stream-ownership backend. Defaults to an in-memory store (correct
-     * single-replica only). Inject `createEnvRedisTicketStore()` (or a bespoke
-     * `SSEStreamTicketStore`) so ticket mint/redeem AND stream ownership work across
-     * horizontally-scaled pods and — critically — so the platform stream producer
-     * (a different service) can bind ownership that this service reads.
+     * Ticket + stream-ownership backend for the subject-bound log stream. Defaults
+     * to an in-memory store (single replica only), built on first use. Inject an
+     * api-core `createEnvSseTicketStore(...)` so mint/redeem and stream ownership
+     * work across pods.
      */
-    ticketStore?: SSEStreamTicketStore;
+    ticketStore?: SseTicketStore;
+    /**
+     * Whether this service streams per-request logs (`ctx.log` frames keyed by
+     * requestId, the `/logs` channel). Default false: `ctx.log` then only writes
+     * to the logger, so a service that never serves a log stream doesn't push
+     * every log line through SSE (and over Redis).
+     */
+    logStream?: boolean;
     /**
      * TTL for a stream-ownership binding (default: `SSE_STREAM_OWNER_TTL_MS` env or
      * 1h). Long enough to outlive a build; the producer re-binds as needed.
      */
     streamOwnerTtlMs?: number;
     /**
-     * Cross-pod fan-out bus for `send()`/`broadcast()`. Optional — when omitted,
-     * delivery is LOCAL-ONLY (correct single-replica; today's behavior). Inject
-     * `createEnvRedisSSERelay()` so a frame produced on one pod reaches an
-     * EventSource attached on a DIFFERENT pod. Degrades to local-only automatically
-     * when Redis is unset (the factory returns null) or during a Redis outage.
+     * Cross-pod fan-out bus for `send()`/`broadcast()`, wired at construction.
+     * When omitted (and no `relayFactory` is enabled) delivery is LOCAL-ONLY.
+     * Degrades to local-only during a Redis outage.
      */
     relay?: SSERelay;
+    /**
+     * Builds the relay on demand — see {@link SSEManager.enableRelay}. Lets a
+     * service open a relay connection only when it actually has a streaming
+     * channel (the log stream, or an org-keyed channel). Returning null (Redis
+     * not configured) keeps local-only delivery.
+     */
+    relayFactory?: () => SSERelay | null;
 }
 /**
  * A build-log stream subject id: either a dashed UUID (api-server's `uuid()`)
@@ -141,10 +150,10 @@ export declare class SSEManager {
      *  map mirrors `clients[].orgId` counts at all times. Orgs reach zero are
      *  deleted to keep the map bounded. */
     private orgClientCounts;
-    /** Ticket + stream-ownership backend (in-memory default; Redis for multi-pod).
-     *  Bounded by `maxTotalTickets` / `maxTicketsPerOrg`, enforced in createTicket;
-     *  expiry is validated at consume time and swept on the cleanup interval. */
-    private readonly ticketStore;
+    /** Injected ticket + stream-ownership backend, or the lazily built in-memory default. */
+    private ticketStoreInstance?;
+    /** True when this manager built its ticket store (so shutdown stops it). */
+    private ownsTicketStore;
     private readonly maxClientsPerRequest;
     private readonly maxTotalClients;
     private readonly maxClientsPerOrg;
@@ -155,10 +164,22 @@ export declare class SSEManager {
     private readonly clientTimeoutMs;
     private cleanupInterval;
     /** Cross-pod fan-out bus (undefined ⇒ local-only delivery). */
-    private readonly relay?;
+    private relay?;
+    private readonly relayFactory?;
+    /** Whether `ctx.log` frames are streamed (see {@link SSEManagerOptions.logStream}). */
+    readonly logStreamEnabled: boolean;
     /** This manager instance's id — tags relayed frames so we ignore our own echo. */
     private readonly nodeId;
     constructor(options?: SSEManagerOptions);
+    private attachRelay;
+    /**
+     * Turn on cross-pod delivery using the configured `relayFactory`. Idempotent;
+     * a no-op when a relay is already wired or no factory was given, and when the
+     * factory returns null (Redis not configured → local-only delivery).
+     */
+    enableRelay(): void;
+    /** The ticket store, building the in-memory default on first use. */
+    private get ticketStore();
     /**
      * Handle a frame received from another pod via the relay. We already delivered
      * our OWN frames to local clients before publishing, so ignore our echo. A
@@ -221,8 +242,8 @@ export declare class SSEManager {
      * wiring not yet present), minting falls back to binding the ticket to the
      * caller's own org, preserving current behavior.
      *
-     * Bounded by `maxTotalTickets` (process-wide) and `maxTicketsPerOrg`
-     * (per-tenant). Mirrors the message-service notifications ticket store.
+     * Bounded by the ticket store's live-ticket caps (total and per org). An
+     * ownership lookup the store can't answer is refused as `capacity`.
      *
      * @param orgId - Owning org (normalized internally via normalizeOrgId).
      * @param requestId - The build-log stream subject this ticket authorizes.
@@ -259,9 +280,18 @@ export declare class SSEManager {
      * @param res - Express Response object
      * @param orgId - Authenticated org id (optional). When set, enforces the
      *   per-org cap and the counter is decremented on disconnect/cleanup.
+     * @param maxClientsForSubject - Per-subject cap override (default
+     *   `maxClientsPerRequest`). An org-keyed channel's subject IS the org, so it
+     *   must not inherit the small per-build-request cap — see {@link addOrgClient}.
      * @returns true if client was added, false if rejected (limit reached)
      */
-    addClient(requestId: string, res: Response, orgId?: string): boolean;
+    addClient(requestId: string, res: Response, orgId?: string, maxClientsForSubject?: number): boolean;
+    /**
+     * Attach a client to an ORG-keyed stream (the org is the subject). Counts
+     * against the per-org cap, and the org — not the per-request cap — bounds how
+     * many streams share the subject.
+     */
+    addOrgClient(orgId: string, res: Response): boolean;
     /** Drop one from the per-org counter. Idempotent: a counter at 0 stays at 0
      *  and the org key is removed from the map. */
     private decrementOrgCount;