@pipeline-builder/api-server 0.0.1

package/lib/api/server.js

@@ -0,0 +1,234 @@
+// 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 { Config } from '@pipeline-builder/pipeline-core';
+import { getConnection, closeConnection } from '@pipeline-builder/pipeline-data';
+import { setReady, isReady } from './readiness.js';
+import { shutdownTracing } from './tracing.js';
+import { SSEManager } from '../http/sse-connection-manager.js';
+const logger = createLogger('server');
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// Dependency-supervisor cadence. Initial connect retries with capped backoff;
+// once connected, re-checks at a steady interval so a later outage flips the
+// service NotReady (draining traffic) and a recovery flips it back — without
+// ever exiting / restarting the process.
+const READY_RETRY_BASE_MS = 1000;
+const READY_RETRY_MAX_MS = 10000;
+const READY_MONITOR_INTERVAL_MS = parseInt(process.env.READINESS_MONITOR_INTERVAL_MS || '15000', 10);
+/**
+ * Establish and continuously monitor the service's datastore dependency,
+ * flipping readiness state instead of crash-looping.
+ *
+ * - Establish phase: retry `onBeforeStart` (e.g. connectMongo) with capped
+ *   backoff until it succeeds — a cold datastore must never exit the process.
+ * - Monitor phase: poll `testDatabase` for the life of the process; flip
+ *   ready/NotReady on transitions. While NotReady the readiness guard 503s
+ *   business traffic and orchestrator readiness probes drain the instance.
+ *
+ * Runs in the background (the HTTP server is already listening). Stops when
+ * `aborted()` returns true (graceful shutdown), so it never keeps a closing
+ * process alive.
+ */
+async function superviseDependencies(name, onBeforeStart, testDatabase, aborted) {
+    if (onBeforeStart) {
+        let delay = READY_RETRY_BASE_MS;
+        while (!aborted()) {
+            try {
+                await onBeforeStart();
+                break;
+            }
+            catch (error) {
+                logger.warn(`${name}: dependency init failed, retrying in ${delay}ms`, { error: errorMessage(error) });
+                await sleep(delay);
+                delay = Math.min(delay * 2, READY_RETRY_MAX_MS);
+            }
+        }
+    }
+    // No datastore to gate on → ready as soon as we are listening.
+    if (testDatabase === false) {
+        setReady(true);
+        logger.info(`${name} ready (no datastore dependency)`);
+        return;
+    }
+    const probe = testDatabase ?? (() => getConnection().testConnection());
+    let waitDelay = READY_RETRY_BASE_MS;
+    while (!aborted()) {
+        let ok = false;
+        try {
+            ok = await probe();
+        }
+        catch {
+            ok = false;
+        }
+        if (ok && !isReady()) {
+            setReady(true);
+            waitDelay = READY_RETRY_BASE_MS;
+            logger.info(`${name} ready — dependencies connected`);
+        }
+        else if (!ok && isReady()) {
+            setReady(false);
+            logger.warn(`${name} degraded — dependency check failing (now NotReady)`);
+        }
+        // Steady cadence once ready; faster backoff while waiting so we flip to
+        // ready promptly when the datastore comes up.
+        if (isReady()) {
+            await sleep(READY_MONITOR_INTERVAL_MS);
+        }
+        else {
+            await sleep(waitDelay);
+            waitDelay = Math.min(waitDelay * 2, READY_RETRY_MAX_MS);
+        }
+    }
+}
+/**
+ * Start an Express server with graceful shutdown handling
+ *
+ * Features:
+ * - Automatic database connection testing
+ * - Graceful shutdown on SIGINT/SIGTERM
+ * - SSE connection cleanup
+ * - Configurable shutdown timeout
+ *
+ * @param app - Express application
+ * @param options - Server options
+ * @returns Server instance and control functions
+ *
+ * @example
+ * ```typescript
+ * const { app, sseManager } = createApp();
+ *
+ * app.post('/api/resource', requireAuth, handler);
+ *
+ * await startServer(app, {
+ *   name: 'My Microservice',
+ *   sseManager,
+ *   onStart: (port) => console.log(`Listening on ${port}`),
+ * });
+ * ```
+ */
+export async function startServer(app, options = {}) {
+    const serverConfig = Config.get('server');
+    const { name = 'Microservice', sseManager, shutdownTimeoutMs = 15000, onStart, onShutdown, onBeforeStart, testDatabase, closeDatabase, } = options;
+    const port = options.port ?? serverConfig.port;
+    // Validate auth configuration at server startup (not during CDK synthesis)
+    Config.validateAuth();
+    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
+    // flips it true once dependencies connect.
+    setReady(false);
+    // Listen FIRST. Previously the process tested the DB and `process.exit(1)`'d
+    // on failure (to be restarted), so during a cold-DB stampede services
+    // crash-looped and never even opened their port. Now we open the port
+    // immediately — /health (liveness), /ready (readiness) and the readiness
+    // guard all respond at once — and establish + monitor the datastore in the
+    // background, reporting NotReady until it connects instead of exiting.
+    const server = app.listen(port, () => {
+        logger.info(`${name} listening on port: ${port}`);
+        logger.info(`Platform URL: ${serverConfig.platformUrl}`);
+        onStart?.(port);
+    });
+    // Shutdown handler (guarded against concurrent signals)
+    let shuttingDown = false;
+    // Background dependency supervisor — established + monitored after listen,
+    // stopped on shutdown so it never keeps a closing process alive. Guard the
+    // floating promise: every expected failure is handled inside, so a rejection
+    // here means a programming error — log it and leave the service NotReady
+    // rather than letting it become an unhandledRejection that crash-exits the
+    // process (which would defeat the whole "never exit on dependency trouble"
+    // goal).
+    superviseDependencies(name, onBeforeStart, testDatabase, () => shuttingDown).catch((error) => {
+        logger.error('Dependency supervisor crashed; service will remain NotReady', { error: errorMessage(error) });
+    });
+    const shutdown = async (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        if (signal) {
+            logger.info(`${signal} received, shutting down gracefully...`);
+        }
+        // Custom shutdown callback
+        if (onShutdown) {
+            try {
+                await onShutdown();
+            }
+            catch (error) {
+                logger.error('Error in onShutdown callback', { error });
+            }
+        }
+        // Close SSE connections
+        if (sseManager) {
+            sseManager.shutdown();
+            logger.info('SSE connections closed');
+        }
+        // Close HTTP server
+        server.close(async () => {
+            logger.info('HTTP server closed');
+            // Shutdown OpenTelemetry tracing
+            await shutdownTracing().catch(err => logger.error('Error shutting down tracing', { error: err }));
+            // Close database connection
+            if (closeDatabase !== false) {
+                try {
+                    if (closeDatabase) {
+                        await closeDatabase();
+                    }
+                    else {
+                        await closeConnection();
+                    }
+                    logger.info('Database connection closed');
+                }
+                catch (error) {
+                    logger.error('Error closing database', { error });
+                }
+            }
+            process.exit(0);
+        });
+        // Force shutdown after timeout
+        setTimeout(() => {
+            logger.error('Forced shutdown after timeout');
+            process.exit(1);
+        }, shutdownTimeoutMs).unref();
+    };
+    // Register signal handlers
+    process.once('SIGINT', () => void shutdown('SIGINT'));
+    process.once('SIGTERM', () => void shutdown('SIGTERM'));
+    return {
+        server,
+        port,
+        shutdown: () => shutdown(),
+    };
+}
+/**
+ * Simple server start wrapper with error handling
+ *
+ * @param app - Express application
+ * @param options - Server options
+ *
+ * @example
+ * ```typescript
+ * const { app, sseManager } = createApp();
+ * app.post('/api/resource', handler);
+ *
+ * void runServer(app, { name: 'My Service', sseManager });
+ * ```
+ */
+export function runServer(app, options = {}) {
+    // 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.
+    installCrashHandlers(logger);
+    startServer(app, options).catch((error) => {
+        // startServer now listens-first and supervises the DB in the background, so
+        // it only rejects on a genuinely fatal SETUP error (invalid auth config, a
+        // failed onStart, the port already in use). Log message + stack explicitly:
+        // an Error in winston metadata serializes to `{}` (message/stack are
+        // non-enumerable), which would otherwise hide the cause behind `{error:{}}`.
+        logger.error('Failed to start server', {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        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"]}

package/lib/api/tenant-context.d.ts

@@ -0,0 +1,28 @@
+import { type TenantContext } from '@pipeline-builder/pipeline-data';
+import type { Request, Response, NextFunction } from 'express';
+/**
+ * Resolves the RLS tenant scope for a request. The default reads the CALLER's
+ * authenticated identity org (`ctx.identity.orgId`, validated by requireOrgId) — NOT
+ * `getOrgId(req)`, which prefers route params (the queried scope), the wrong tenant for
+ * RLS. Services with a different request boundary supply their own resolver (e.g. platform
+ * sets the scope pre-auth from an unverified JWT peek so unauthenticated endpoints still
+ * get a sane default).
+ */
+export type TenantScopeResolver = (req: Request) => TenantContext;
+/**
+ * Establish the request's row-level-security tenant scope.
+ *
+ * Runs the rest of the request inside `runWithTenantContext({ orgId, isSuperAdmin })` (an
+ * AsyncLocalStorage scope) so every `withTenantTx` query downstream can `SET LOCAL` the
+ * Postgres GUCs that RLS policies read. Without this, reads against FORCE-RLS tables (e.g.
+ * `plugins`, `pipelines`) run with empty GUCs and silently return no rows — the "set once
+ * at the request boundary" bookend the RLS enforcement plan calls for.
+ *
+ * Default placement is AFTER `requireAuth` + `requireOrgId` (the route factories do this);
+ * pass a custom `resolve` for a different boundary. A thrown resolver means tenant identity
+ * could NOT be established (a wiring bug — this runs after auth) — we hard-FAIL the request
+ * (500 via next(err)) rather than proceed. Proceeding would run queries with empty RLS GUCs;
+ * under FORCE RLS that hides rows, but while RLS is in owner-bypass mode the app-layer WHERE
+ * clause is the only tenant gate, so a scopeless request must not silently continue.
+ */
+export declare function withTenantContext(resolve?: TenantScopeResolver): (req: Request, _res: Response, next: NextFunction) => void;

package/lib/api/tenant-context.js

@@ -0,0 +1,48 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { isSystemAdmin } from '@pipeline-builder/api-core';
+import { runWithTenantContext } from '@pipeline-builder/pipeline-data';
+import { getContext } from './get-context.js';
+/** Default resolver: the authenticated identity's org + super-admin flag, plus
+ *  the active-org parent (org → team hierarchy) so downstream side-effects can
+ *  reach it without a request, and the caller's user id for the app-layer
+ *  predicates that carry a per-user rung. */
+const identityScope = (req) => ({
+    // `identity.orgId` is already normalized (trimmed + lowercased) once at
+    // resolution in api-core's `getIdentity`, so the GUC set here matches the
+    // app-layer WHERE clauses exactly — no ad-hoc re-normalization needed.
+    orgId: getContext(req).identity.orgId,
+    userId: getContext(req).identity.userId || undefined,
+    isSuperAdmin: isSystemAdmin(req),
+    parentOrgId: req.user?.parentOrganizationId,
+});
+/**
+ * Establish the request's row-level-security tenant scope.
+ *
+ * Runs the rest of the request inside `runWithTenantContext({ orgId, isSuperAdmin })` (an
+ * AsyncLocalStorage scope) so every `withTenantTx` query downstream can `SET LOCAL` the
+ * Postgres GUCs that RLS policies read. Without this, reads against FORCE-RLS tables (e.g.
+ * `plugins`, `pipelines`) run with empty GUCs and silently return no rows — the "set once
+ * at the request boundary" bookend the RLS enforcement plan calls for.
+ *
+ * Default placement is AFTER `requireAuth` + `requireOrgId` (the route factories do this);
+ * pass a custom `resolve` for a different boundary. A thrown resolver means tenant identity
+ * could NOT be established (a wiring bug — this runs after auth) — we hard-FAIL the request
+ * (500 via next(err)) rather than proceed. Proceeding would run queries with empty RLS GUCs;
+ * under FORCE RLS that hides rows, but while RLS is in owner-bypass mode the app-layer WHERE
+ * clause is the only tenant gate, so a scopeless request must not silently continue.
+ */
+export function withTenantContext(resolve = identityScope) {
+    return (req, _res, next) => {
+        let scope;
+        try {
+            scope = resolve(req);
+        }
+        catch (err) {
+            next(err);
+            return;
+        }
+        runWithTenantContext(scope, () => next());
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/tracing.d.ts

@@ -0,0 +1,25 @@
+import { type Span, type Attributes } from '@opentelemetry/api';
+/**
+ * Run `fn` inside a new active span named `name`.
+ *
+ * Auto-instrumentation only covers inbound HTTP/express/mongo/pg; the paths that
+ * actually get debugged in an incident — AI generation, the out-of-band BullMQ
+ * plugin build (runs detached from any inbound span), long async work — show no
+ * span detail without a hand-authored one. Wrap those with this.
+ *
+ * Safe when tracing is disabled: with no SDK registered, `startActiveSpan` runs
+ * the callback with a no-op span, so this adds negligible overhead and never
+ * changes behavior. On throw, the span is marked ERROR and the exception
+ * recorded, then re-thrown unchanged. Always ends the span.
+ */
+export declare function withSpan<T>(name: string, fn: (span: Span) => Promise<T>, attributes?: Attributes): Promise<T>;
+/**
+ * Shutdown the OpenTelemetry SDK gracefully.
+ */
+export declare function shutdownTracing(): Promise<void>;
+/**
+ * Returns the current active trace ID, or undefined when tracing is
+ * disabled / no active span. Useful for enriching structured logs so an
+ * operator can correlate a request across services via its trace ID.
+ */
+export declare function currentTraceId(): string | undefined;

package/lib/api/tracing.js

@@ -0,0 +1,69 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { trace, SpanStatusCode } from '@opentelemetry/api';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { createLogger } from '@pipeline-builder/api-core';
+const logger = createLogger('tracing');
+/** Shared tracer for hand-authored spans. */
+const tracer = trace.getTracer('pipeline-builder');
+/**
+ * Run `fn` inside a new active span named `name`.
+ *
+ * Auto-instrumentation only covers inbound HTTP/express/mongo/pg; the paths that
+ * actually get debugged in an incident — AI generation, the out-of-band BullMQ
+ * plugin build (runs detached from any inbound span), long async work — show no
+ * span detail without a hand-authored one. Wrap those with this.
+ *
+ * Safe when tracing is disabled: with no SDK registered, `startActiveSpan` runs
+ * the callback with a no-op span, so this adds negligible overhead and never
+ * changes behavior. On throw, the span is marked ERROR and the exception
+ * recorded, then re-thrown unchanged. Always ends the span.
+ */
+export async function withSpan(name, fn, attributes) {
+    return tracer.startActiveSpan(name, async (span) => {
+        if (attributes)
+            span.setAttributes(attributes);
+        try {
+            const result = await fn(span);
+            span.setStatus({ code: SpanStatusCode.OK });
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            span.recordException(error);
+            span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    });
+}
+// Module-local SDK handle. Production services start tracing through the
+// `otel-bootstrap.js` `--import` preload, which registers its own SDK on the
+// global provider — so this stays null and `shutdownTracing()` is a no-op.
+// It is retained because `server.ts` calls `shutdownTracing()` on shutdown.
+let sdk = null;
+/**
+ * Shutdown the OpenTelemetry SDK gracefully.
+ */
+export async function shutdownTracing() {
+    if (sdk) {
+        await sdk.shutdown();
+        sdk = null;
+        logger.info('OpenTelemetry tracing shut down');
+    }
+}
+/**
+ * Returns the current active trace ID, or undefined when tracing is
+ * disabled / no active span. Useful for enriching structured logs so an
+ * operator can correlate a request across services via its trace ID.
+ */
+export function currentTraceId() {
+    // Read the globally-registered tracer provider's active span. The SDK is
+    // started by the `otel-bootstrap.js` `--import` preload, which registers the
+    // global provider via @opentelemetry/api. Returns undefined when tracing is
+    // disabled / there is no active span.
+    return trace.getActiveSpan()?.spanContext()?.traceId;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/http/index.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,7 @@
+// Copyright 2026 Pipeline Builder Contributors
+// 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=