@pipeline-builder/api-server 4.4.2 → 4.4.4

package/lib/api/ai-call-reservation.d.ts

@@ -0,0 +1,95 @@
+import { type AiKeySource, type QuotaReserveResult, type QuotaUsageAttribution } from '@pipeline-builder/api-core';
+import type { Request } from 'express';
+import { type QuotaReservationOptions, type QuotaReservationOutcome, type QuotaSlot } from './quota-reservation.js';
+/**
+ * Which product surface an AI call belongs to — the usage ledger's `feature`
+ * dimension. `agent-tool:<name>` is a generation an agent TOOL runs in-process
+ * (its own slot, beside the turn's).
+ */
+export type AiFeature = 'ask' | 'agent' | `agent-tool:${string}` | 'pipeline-generate' | 'plugin-generate' | 'report-summary';
+/** The part of a resolved model selection the reservation reads (ai-core `ResolvedModelSelection` fits). */
+export interface AiCallSelection {
+    provider: string;
+    modelId: string;
+    keySource: AiKeySource;
+}
+/**
+ * Why an AI call spent no `aiCalls` unit:
+ *  - `byok` — the org's own key or the caller's request key served it
+ *    (`keySource !== 'platform'`): the customer pays the provider, not us;
+ *  - `impersonation` — a sysadmin impersonation session: vendor staff neither
+ *    spend the tenant's budget nor get locked out by it (mirrors the apiCalls
+ *    exemption; the call is still audited);
+ *  - `unweighted` — the model's `AI_MODEL_WEIGHTS` weight is 0 (by default the
+ *    self-hosted OpenAI-compatible provider).
+ * A waived call is still recorded in the usage ledger (zero units, its tokens).
+ */
+export type AiSlotWaiver = 'byok' | 'impersonation' | 'unweighted';
+/** Token counts as the AI SDK / ai-core report them (missing → 0). */
+export interface AiCallTokens {
+    inputTokens?: number;
+    outputTokens?: number;
+}
+/** A settled-by-rule `aiCalls` slot, plus what the AI path needs on top of {@link QuotaSlot}. */
+export interface AiCallSlot extends QuotaSlot {
+    /** Units reserved: the model's weight, or 0 when {@link waived}. */
+    readonly amount: number;
+    /** Set when no unit was reserved, and why. */
+    readonly waived?: AiSlotWaiver;
+    /** The attribution the reserve, refund and usage report carry. */
+    readonly attribution: QuotaUsageAttribution;
+    /**
+     * Report the call's token usage to the usage ledger (once; later calls are
+     * ignored). Fire-and-forget. Call it after the call settles — success, abort or
+     * failure — with whatever usage the provider reported.
+     */
+    reportUsage(tokens: AiCallTokens | undefined): void;
+}
+export interface AiCallReservationOptions extends Omit<QuotaReservationOptions, 'type' | 'amount' | 'attribution'> {
+    feature: AiFeature;
+    /**
+     * The inbound request, when there is one: its route pattern + verified
+     * principal become the attribution, and an impersonation session waives the
+     * slot. Absent for scheduled work, which passes {@link attribution} instead.
+     */
+    req?: Pick<Request, 'user' | 'route' | 'method' | 'baseUrl' | 'params' | 'headers'>;
+    /** Attribution merged OVER the request's (a scheduler names its principal + route here). */
+    attribution?: QuotaUsageAttribution;
+}
+/**
+ * Reserve the `aiCalls` slot for ONE AI call on an already-resolved model —
+ * or waive it — and return the handle; the caller settles it (`markConsumed()`
+ * on the provider's first response, `refund()` on a pre-contact failure,
+ * `reportUsage()` once settled). The primitive under
+ * {@link withAiCallReservation}, for work that does not fit one callback (an
+ * agent tool's in-process generation, a scheduled report summary).
+ *
+ * The model is resolved FIRST because it decides the charge:
+ *  - a BYOK key (`keySource` `org` / `request`), an impersonation session or a
+ *    weight-0 model reserves NOTHING ({@link AiSlotWaiver});
+ *  - otherwise the reservation is `aiCallWeight(selection)` units (1 unless
+ *    `AI_MODEL_WEIGHTS` says otherwise), attributed to the route, principal,
+ *    feature, model and key source.
+ * The quota service also applies the org's optional AI controls to that
+ * reservation (per-member share, token budget) and answers a distinct 429 code.
+ */
+export declare function reserveAiCallSlot(opts: AiCallReservationOptions, selection: AiCallSelection): Promise<{
+    status: 'denied';
+    reservation: QuotaReserveResult;
+} | {
+    status: 'reserved';
+    slot: AiCallSlot;
+}>;
+/**
+ * Resolve the model, reserve (or waive) its `aiCalls` slot, run `body`, and
+ * settle by the {@link withQuotaReservation} rule — keep once consumed, refund
+ * when the body fails first.
+ *
+ * `resolve` runs BEFORE any reservation (its result decides the charge — see
+ * {@link reserveAiCallSlot}); a resolution failure (AI switched off, an
+ * unloadable org key, nothing configured) goes to `onError` with no slot taken.
+ * Denied → `{ status: 'denied' }`, answered on `res` when given.
+ */
+export declare function withAiCallReservation<T, S extends AiCallSelection>(opts: AiCallReservationOptions & {
+    resolve: () => Promise<S>;
+}, body: (slot: AiCallSlot, selection: S) => Promise<T>, onError?: (error: unknown) => void | Promise<void>): Promise<QuotaReservationOutcome<T>>;

package/lib/api/ai-call-reservation.js

@@ -0,0 +1,121 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { aiCallWeight, emitCounter, getServiceAuthHeader, quotaAttributionFromRequest, serviceIdentity, } from '@pipeline-builder/api-core';
+import { reserveQuotaSlot, runWithSlot, } from './quota-reservation.js';
+/** The synthetic reservation a waived slot carries (nothing was reserved). */
+function waivedReservation() {
+    return { exceeded: false, quota: { type: 'aiCalls', limit: -1, used: 0, remaining: -1 } };
+}
+/** Attribution for one AI call: request (or explicit) + feature, model, keySource. */
+function aiAttribution(opts, selection) {
+    return {
+        ...(opts.req ? quotaAttributionFromRequest(opts.req) : {}),
+        ...opts.attribution,
+        feature: opts.feature,
+        model: selection.modelId.slice(0, 200),
+        keySource: selection.keySource,
+    };
+}
+function waiverFor(opts, selection, weight) {
+    if (selection.keySource !== 'platform')
+        return 'byok';
+    if (opts.req?.user?.impersonatorId)
+        return 'impersonation';
+    if (weight <= 0)
+        return 'unweighted';
+    return undefined;
+}
+/**
+ * Reserve the `aiCalls` slot for ONE AI call on an already-resolved model —
+ * or waive it — and return the handle; the caller settles it (`markConsumed()`
+ * on the provider's first response, `refund()` on a pre-contact failure,
+ * `reportUsage()` once settled). The primitive under
+ * {@link withAiCallReservation}, for work that does not fit one callback (an
+ * agent tool's in-process generation, a scheduled report summary).
+ *
+ * The model is resolved FIRST because it decides the charge:
+ *  - a BYOK key (`keySource` `org` / `request`), an impersonation session or a
+ *    weight-0 model reserves NOTHING ({@link AiSlotWaiver});
+ *  - otherwise the reservation is `aiCallWeight(selection)` units (1 unless
+ *    `AI_MODEL_WEIGHTS` says otherwise), attributed to the route, principal,
+ *    feature, model and key source.
+ * The quota service also applies the org's optional AI controls to that
+ * reservation (per-member share, token budget) and answers a distinct 429 code.
+ */
+export async function reserveAiCallSlot(opts, selection) {
+    const weight = aiCallWeight(selection);
+    const waived = waiverFor(opts, selection, weight);
+    const attribution = aiAttribution(opts, selection);
+    let base;
+    if (waived) {
+        emitCounter('ai_quota_waived_total', { feature: featureLabel(opts.feature), reason: waived });
+        // Nothing reserved, so nothing to keep or give back.
+        base = {
+            serviceAuth: getServiceAuthHeader({ serviceName: opts.serviceName ?? serviceIdentity(), orgId: opts.orgId, role: 'member' }),
+            reservation: waivedReservation(),
+            markConsumed: () => undefined,
+            refund: () => undefined,
+        };
+    }
+    else {
+        const reserved = await reserveQuotaSlot({ ...opts, type: 'aiCalls', amount: weight, attribution });
+        if (reserved.status === 'denied')
+            return reserved;
+        base = reserved.slot;
+    }
+    let consumed = false;
+    let reported = false;
+    const slot = {
+        serviceAuth: base.serviceAuth,
+        reservation: base.reservation,
+        amount: waived ? 0 : weight,
+        ...(waived ? { waived } : {}),
+        attribution,
+        markConsumed: () => { consumed = true; base.markConsumed(); },
+        refund: () => base.refund(),
+        reportUsage: (tokens) => {
+            if (reported)
+                return;
+            reported = true;
+            const tokensIn = tokens?.inputTokens ?? 0;
+            const tokensOut = tokens?.outputTokens ?? 0;
+            // A call that never reached the provider and spent no tokens has nothing
+            // to record (its reservation, if any, was refunded and ledgered as such).
+            if (tokensIn + tokensOut === 0 && !(waived && consumed))
+                return;
+            void opts.quotaService.reportUsage?.(opts.orgId, 'aiCalls', base.serviceAuth, { tokensIn, tokensOut }, attribution);
+        },
+    };
+    return { status: 'reserved', slot };
+}
+/**
+ * Resolve the model, reserve (or waive) its `aiCalls` slot, run `body`, and
+ * settle by the {@link withQuotaReservation} rule — keep once consumed, refund
+ * when the body fails first.
+ *
+ * `resolve` runs BEFORE any reservation (its result decides the charge — see
+ * {@link reserveAiCallSlot}); a resolution failure (AI switched off, an
+ * unloadable org key, nothing configured) goes to `onError` with no slot taken.
+ * Denied → `{ status: 'denied' }`, answered on `res` when given.
+ */
+export async function withAiCallReservation(opts, body, onError) {
+    let selection;
+    try {
+        selection = await opts.resolve();
+    }
+    catch (error) {
+        if (!onError)
+            throw error;
+        await onError(error);
+        return { status: 'failed', error };
+    }
+    const reserved = await reserveAiCallSlot(opts, selection);
+    if (reserved.status === 'denied')
+        return reserved;
+    return runWithSlot(reserved.slot, (slot) => body(slot, selection), onError);
+}
+/** Bounded metric label: `agent-tool:<name>` collapses to `agent-tool`. */
+function featureLabel(feature) {
+    return feature.startsWith('agent-tool:') ? 'agent-tool' : feature;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-call-reservation.js","sourceRoot":"","sources":["../../src/api/ai-call-reservation.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  aiCallWeight,\n  emitCounter,\n  getServiceAuthHeader,\n  quotaAttributionFromRequest,\n  serviceIdentity,\n  type AiKeySource,\n  type QuotaReserveResult,\n  type QuotaUsageAttribution,\n} from '@pipeline-builder/api-core';\nimport type { Request } from 'express';\n\nimport {\n  reserveQuotaSlot,\n  runWithSlot,\n  type QuotaReservationOptions,\n  type QuotaReservationOutcome,\n  type QuotaSlot,\n} from './quota-reservation.js';\n\n/**\n * Which product surface an AI call belongs to — the usage ledger's `feature`\n * dimension. `agent-tool:<name>` is a generation an agent TOOL runs in-process\n * (its own slot, beside the turn's).\n */\nexport type AiFeature =\n  | 'ask'\n  | 'agent'\n  | `agent-tool:${string}`\n  | 'pipeline-generate'\n  | 'plugin-generate'\n  | 'report-summary';\n\n/** The part of a resolved model selection the reservation reads (ai-core `ResolvedModelSelection` fits). */\nexport interface AiCallSelection {\n  provider: string;\n  modelId: string;\n  keySource: AiKeySource;\n}\n\n/**\n * Why an AI call spent no `aiCalls` unit:\n *  - `byok` — the org's own key or the caller's request key served it\n *    (`keySource !== 'platform'`): the customer pays the provider, not us;\n *  - `impersonation` — a sysadmin impersonation session: vendor staff neither\n *    spend the tenant's budget nor get locked out by it (mirrors the apiCalls\n *    exemption; the call is still audited);\n *  - `unweighted` — the model's `AI_MODEL_WEIGHTS` weight is 0 (by default the\n *    self-hosted OpenAI-compatible provider).\n * A waived call is still recorded in the usage ledger (zero units, its tokens).\n */\nexport type AiSlotWaiver = 'byok' | 'impersonation' | 'unweighted';\n\n/** Token counts as the AI SDK / ai-core report them (missing → 0). */\nexport interface AiCallTokens {\n  inputTokens?: number;\n  outputTokens?: number;\n}\n\n/** A settled-by-rule `aiCalls` slot, plus what the AI path needs on top of {@link QuotaSlot}. */\nexport interface AiCallSlot extends QuotaSlot {\n  /** Units reserved: the model's weight, or 0 when {@link waived}. */\n  readonly amount: number;\n  /** Set when no unit was reserved, and why. */\n  readonly waived?: AiSlotWaiver;\n  /** The attribution the reserve, refund and usage report carry. */\n  readonly attribution: QuotaUsageAttribution;\n  /**\n   * Report the call's token usage to the usage ledger (once; later calls are\n   * ignored). Fire-and-forget. Call it after the call settles — success, abort or\n   * failure — with whatever usage the provider reported.\n   */\n  reportUsage(tokens: AiCallTokens | undefined): void;\n}\n\nexport interface AiCallReservationOptions extends Omit<QuotaReservationOptions, 'type' | 'amount' | 'attribution'> {\n  feature: AiFeature;\n  /**\n   * The inbound request, when there is one: its route pattern + verified\n   * principal become the attribution, and an impersonation session waives the\n   * slot. Absent for scheduled work, which passes {@link attribution} instead.\n   */\n  req?: Pick<Request, 'user' | 'route' | 'method' | 'baseUrl' | 'params' | 'headers'>;\n  /** Attribution merged OVER the request's (a scheduler names its principal + route here). */\n  attribution?: QuotaUsageAttribution;\n}\n\n/** The synthetic reservation a waived slot carries (nothing was reserved). */\nfunction waivedReservation(): QuotaReserveResult {\n  return { exceeded: false, quota: { type: 'aiCalls', limit: -1, used: 0, remaining: -1 } };\n}\n\n/** Attribution for one AI call: request (or explicit) + feature, model, keySource. */\nfunction aiAttribution(opts: AiCallReservationOptions, selection: AiCallSelection): QuotaUsageAttribution {\n  return {\n    ...(opts.req ? quotaAttributionFromRequest(opts.req as Request) : {}),\n    ...opts.attribution,\n    feature: opts.feature,\n    model: selection.modelId.slice(0, 200),\n    keySource: selection.keySource,\n  };\n}\n\nfunction waiverFor(opts: AiCallReservationOptions, selection: AiCallSelection, weight: number): AiSlotWaiver | undefined {\n  if (selection.keySource !== 'platform') return 'byok';\n  if (opts.req?.user?.impersonatorId) return 'impersonation';\n  if (weight <= 0) return 'unweighted';\n  return undefined;\n}\n\n/**\n * Reserve the `aiCalls` slot for ONE AI call on an already-resolved model —\n * or waive it — and return the handle; the caller settles it (`markConsumed()`\n * on the provider's first response, `refund()` on a pre-contact failure,\n * `reportUsage()` once settled). The primitive under\n * {@link withAiCallReservation}, for work that does not fit one callback (an\n * agent tool's in-process generation, a scheduled report summary).\n *\n * The model is resolved FIRST because it decides the charge:\n *  - a BYOK key (`keySource` `org` / `request`), an impersonation session or a\n *    weight-0 model reserves NOTHING ({@link AiSlotWaiver});\n *  - otherwise the reservation is `aiCallWeight(selection)` units (1 unless\n *    `AI_MODEL_WEIGHTS` says otherwise), attributed to the route, principal,\n *    feature, model and key source.\n * The quota service also applies the org's optional AI controls to that\n * reservation (per-member share, token budget) and answers a distinct 429 code.\n */\nexport async function reserveAiCallSlot(\n  opts: AiCallReservationOptions,\n  selection: AiCallSelection,\n): Promise<{ status: 'denied'; reservation: QuotaReserveResult } | { status: 'reserved'; slot: AiCallSlot }> {\n  const weight = aiCallWeight(selection);\n  const waived = waiverFor(opts, selection, weight);\n  const attribution = aiAttribution(opts, selection);\n\n  let base: QuotaSlot;\n  if (waived) {\n    emitCounter('ai_quota_waived_total', { feature: featureLabel(opts.feature), reason: waived });\n    // Nothing reserved, so nothing to keep or give back.\n    base = {\n      serviceAuth: getServiceAuthHeader({ serviceName: opts.serviceName ?? serviceIdentity(), orgId: opts.orgId, role: 'member' }),\n      reservation: waivedReservation(),\n      markConsumed: () => undefined,\n      refund: () => undefined,\n    };\n  } else {\n    const reserved = await reserveQuotaSlot({ ...opts, type: 'aiCalls', amount: weight, attribution });\n    if (reserved.status === 'denied') return reserved;\n    base = reserved.slot;\n  }\n\n  let consumed = false;\n  let reported = false;\n  const slot: AiCallSlot = {\n    serviceAuth: base.serviceAuth,\n    reservation: base.reservation,\n    amount: waived ? 0 : weight,\n    ...(waived ? { waived } : {}),\n    attribution,\n    markConsumed: () => { consumed = true; base.markConsumed(); },\n    refund: () => base.refund(),\n    reportUsage: (tokens) => {\n      if (reported) return;\n      reported = true;\n      const tokensIn = tokens?.inputTokens ?? 0;\n      const tokensOut = tokens?.outputTokens ?? 0;\n      // A call that never reached the provider and spent no tokens has nothing\n      // to record (its reservation, if any, was refunded and ledgered as such).\n      if (tokensIn + tokensOut === 0 && !(waived && consumed)) return;\n      void opts.quotaService.reportUsage?.(opts.orgId, 'aiCalls', base.serviceAuth, { tokensIn, tokensOut }, attribution);\n    },\n  };\n  return { status: 'reserved', slot };\n}\n\n/**\n * Resolve the model, reserve (or waive) its `aiCalls` slot, run `body`, and\n * settle by the {@link withQuotaReservation} rule — keep once consumed, refund\n * when the body fails first.\n *\n * `resolve` runs BEFORE any reservation (its result decides the charge — see\n * {@link reserveAiCallSlot}); a resolution failure (AI switched off, an\n * unloadable org key, nothing configured) goes to `onError` with no slot taken.\n * Denied → `{ status: 'denied' }`, answered on `res` when given.\n */\nexport async function withAiCallReservation<T, S extends AiCallSelection>(\n  opts: AiCallReservationOptions & { resolve: () => Promise<S> },\n  body: (slot: AiCallSlot, selection: S) => Promise<T>,\n  onError?: (error: unknown) => void | Promise<void>,\n): Promise<QuotaReservationOutcome<T>> {\n  let selection: S;\n  try {\n    selection = await opts.resolve();\n  } catch (error) {\n    if (!onError) throw error;\n    await onError(error);\n    return { status: 'failed', error };\n  }\n  const reserved = await reserveAiCallSlot(opts, selection);\n  if (reserved.status === 'denied') return reserved;\n  return runWithSlot(reserved.slot, (slot) => body(slot, selection), onError);\n}\n\n/** Bounded metric label: `agent-tool:<name>` collapses to `agent-tool`. */\nfunction featureLabel(feature: AiFeature): string {\n  return feature.startsWith('agent-tool:') ? 'agent-tool' : feature;\n}\n"]}

package/lib/api/app-factory.js

@@ -1,6 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { sendSuccess, sendError, generateOpenApiSpec, ErrorCode, createLogger, verifyServicePrincipal, createHealthRouter, setCounterEmitter, setGaugeEmitter, requireAuth, safeEqual, createEnvSseTicketStore, SSE_TICKET_TTL_MS } from '@pipeline-builder/api-core';
+import { sendSuccess, sendError, generateOpenApiSpec, ErrorCode, createLogger, verifyServicePrincipal, createHealthRouter, setCounterEmitter, setGaugeEmitter, requireAuth, safeEqual, createEnvSseTicketStore, SSE_TICKET_TTL_MS, auditContextFromRequest, runWithAuditContext, sanitizeCorrelationId } from '@pipeline-builder/api-core';
 import { Config, CoreConstants } from '@pipeline-builder/pipeline-core';
 import { getConnection } from '@pipeline-builder/pipeline-data';
 import compression from 'compression';
@@ -15,6 +15,7 @@ import { createEnvRedisIdempotencyStore, setIdempotencyStore } from './idempoten
 import { metricsMiddleware, metricsHandler, incCounter, setGauge } from './metrics.js';
 import { createSharedRateLimitStore } from './rate-limit-store.js';
 import { readinessGuard } from './readiness.js';
+import { currentTraceId } from './tracing.js';
 import { SSEManager, SSE_REQUEST_ID_RE } from '../http/sse-connection-manager.js';
 import { createEnvRedisSSERelay } from '../http/sse-relay.js';
 // Wire api-core's counter shim to the real prom-client registry. This is
@@ -363,13 +364,20 @@ export function createApp(options = {}) {
     applyBodyParsing(app, options);
     // Trust proxy (must be set before rate limiter so req.ip resolves correctly)
     app.set('trust proxy', Config.get('server').trustProxy);
-    // Request ID — prefer existing header from nginx, otherwise generate one
+    // Request ID + audit context. Prefer the inbound `X-Request-Id` (nginx, or a
+    // peer service / CLI forwarding its own) when it is a bounded opaque token —
+    // an oversized or junk value is replaced, not stored — otherwise generate one.
+    // The rest of the request then runs inside an audit-context scope, so every
+    // `recordAudit` it makes carries the request id, trace id, client ip / UA, the
+    // verified credential (read lazily, after `requireAuth`) and any inbound
+    // `X-Pipeline-Execution-Id` / `X-CodeBuild-Build-Id` / `X-Source-Event-Id`
+    // with no call-site change. Mounted after `trust proxy` so `req.ip` is real.
     app.use((req, res, next) => {
         const hdr = req.headers['x-request-id'];
-        const requestId = (Array.isArray(hdr) ? hdr[0] : hdr) || uuid();
+        const requestId = sanitizeCorrelationId(Array.isArray(hdr) ? hdr[0] : hdr) ?? uuid();
         req.requestId = requestId;
         res.setHeader('X-Request-Id', requestId);
-        next();
+        runWithAuditContext(auditContextFromRequest(req, { requestId, traceId: currentTraceId() }), next);
     });
     mountInfraEndpoints(app, options, serviceName, enableOpenApi);
     if (enableRateLimit)
@@ -385,4 +393,4 @@ export function createApp(options = {}) {
         wireSse(app, sseManager);
     return { app, sseManager };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-factory.js","sourceRoot":"","sources":["../../src/api/app-factory.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { sendSuccess, sendError, generateOpenApiSpec, ErrorCode, createLogger, verifyServicePrincipal, createHealthRouter, setCounterEmitter, setGaugeEmitter, requireAuth, safeEqual, createEnvSseTicketStore, SSE_TICKET_TTL_MS } from '@pipeline-builder/api-core';\nimport type { OpenApiSpecOptions } from '@pipeline-builder/api-core';\nimport { Config, CoreConstants } from '@pipeline-builder/pipeline-core';\nimport { getConnection } from '@pipeline-builder/pipeline-data';\nimport compression from 'compression';\nimport cors from 'cors';\nimport express, { type Express, type NextFunction, type Request, type Response } from 'express';\nimport rateLimit, { ipKeyGenerator } from 'express-rate-limit';\nimport helmet from 'helmet';\nimport swaggerUi from 'swagger-ui-express';\nimport { v7 as uuid } from 'uuid';\nimport { etagMiddleware } from './etag-middleware.js';\nimport { createEnvRedisIdempotencyStore, setIdempotencyStore, type IdempotencyStore } from './idempotency-middleware.js';\nimport { metricsMiddleware, metricsHandler, incCounter, setGauge } from './metrics.js';\nimport { createSharedRateLimitStore } from './rate-limit-store.js';\nimport { readinessGuard } from './readiness.js';\nimport { SSEManager, SSE_REQUEST_ID_RE } from '../http/sse-connection-manager.js';\nimport { createEnvRedisSSERelay } from '../http/sse-relay.js';\n\n// Wire api-core's counter shim to the real prom-client registry. This is\n// a no-op until incCounter is called for the first time (lazy registration\n// in metrics.ts), and lets api-core helpers like the quota client record\n// `quota_fail_open_total` without taking a hard dep on api-server.\nsetCounterEmitter(incCounter);\n// Same seam for GAUGES. pipeline-data's read-replica lag sampler needs it:\n// replay lag and the state of the read fallback circuit are sampled\n// point-in-time values, so emitting them as counters would make every query\n// over them wrong. pipeline-data depends on api-core and must not depend on\n// api-server, hence the shim rather than a direct import.\nsetGaugeEmitter(setGauge);\n\n/**\n * Options for creating an Express application\n */\nexport interface CreateAppOptions {\n  /** Enable CORS (default: true) */\n  enableCors?: boolean;\n  /** Enable Helmet security headers (default: true) */\n  enableHelmet?: boolean;\n  /** Enable rate limiting (default: true) */\n  enableRateLimit?: boolean;\n  /** Enable JSON body parsing (default: true) */\n  enableJsonBody?: boolean;\n  /** JSON body size limit (default: '1mb') */\n  jsonLimit?: string;\n  /**\n   * Path prefixes the global JSON body parser must NOT touch — for routes that need\n   * the raw body (e.g. a Stripe webhook whose HMAC is computed over the exact bytes).\n   * Without this the global parser consumes the body first and a later `express.raw()`\n   * on the same path is a no-op, breaking signature verification.\n   */\n  jsonBodyExclude?: string[];\n  /** Enable URL-encoded body parsing (default: true) */\n  enableUrlEncoded?: boolean;\n  /** URL-encoded body size limit (default: '1mb') */\n  urlEncodedLimit?: string;\n  /** Custom SSE manager instance */\n  sseManager?: SSEManager;\n  /**\n   * Serve the per-request build-log stream: `POST /logs/ticket` +\n   * `GET /logs/:requestId`, a log ticket store, the cross-pod relay, and\n   * `ctx.log` frames pushed to SSE. Default false — a service without it has no\n   * `/logs` routes and `ctx.log` only writes to the logger.\n   */\n  logStream?: boolean;\n  /** Health check dependency checker — if provided, /health reports dependency status */\n  checkDependencies?: () => Promise<Record<string, 'connected' | 'disconnected' | 'unknown'>>;\n  /**\n   * Serve the OpenAPI spec at `/docs/openapi.json` and Swagger UI at `/docs`.\n   *\n   * Defaults to OFF under `NODE_ENV=production`: the routes are registered above\n   * the rate limiter and are not auth-gated, so in production they would publish\n   * the full route + schema inventory of every service to anyone who could reach\n   * the port. Pass `true` explicitly to serve them in production anyway.\n   */\n  enableOpenApi?: boolean;\n  /** OpenAPI spec customization options */\n  openApiOptions?: OpenApiSpecOptions;\n  /** Enable gzip/deflate response compression (default: true) */\n  enableCompression?: boolean;\n  /**\n   * Idempotency replay-cache backend for keyed mutation retries. When omitted,\n   * createApp auto-wires the shared env Redis store (multi-replica dedup) if\n   * Redis is configured, else keeps the in-memory default (single-replica).\n   * Pass an explicit store to inject a bespoke backend (e.g. a service's own\n   * ioredis connection).\n   */\n  idempotencyStore?: IdempotencyStore;\n  /**\n   * Extra warmup callbacks invoked by `GET /warmup` in addition to the\n   * default Postgres ping. Use for services that depend on Mongo, Redis,\n   * SQS, etc. — pre-warming opens connection pools before real traffic\n   * arrives. Each callback should resolve when its dependency is ready;\n   * any rejection causes /warmup to return 503.\n   */\n  warmupHooks?: Array<() => Promise<void>>;\n}\n\n/**\n * Result of creating an Express application\n */\nexport interface CreateAppResult {\n  /** Configured Express application */\n  app: Express;\n  /** SSE manager instance */\n  sseManager: SSEManager;\n}\n\n/** Helmet (strict CSP), CORS, compression and ETags. */\nfunction applySecurityHeaders(app: Express, options: CreateAppOptions, enableOpenApi: boolean): void {\n  const { enableCors = true, enableHelmet = true, enableCompression = true } = options;\n  // Swagger UI needs unsafe-inline + unsafe-eval for its bundled scripts —\n  // but CSP is only relaxed that far when (a) OpenAPI is enabled AND (b) we're\n  // not in production. In prod, Swagger should be served behind a separate\n  // host or auth-gated route; the main app keeps the strict CSP so a Stored\n  // XSS in any handler can't `eval()` arbitrary script.\n  const allowSwaggerCsp = enableOpenApi && process.env.NODE_ENV !== 'production';\n  if (enableHelmet) {\n    app.use(helmet({\n      contentSecurityPolicy: {\n        directives: {\n          defaultSrc: [\"'self'\"],\n          scriptSrc: allowSwaggerCsp\n            ? [\"'self'\", \"'unsafe-inline'\", \"'unsafe-eval'\"]\n            : [\"'self'\"],\n          styleSrc: [\"'self'\", \"'unsafe-inline'\"],\n          imgSrc: [\"'self'\", 'data:', 'blob:'],\n          connectSrc: [\"'self'\"],\n          fontSrc: [\"'self'\"],\n          objectSrc: [\"'none'\"],\n          frameAncestors: [\"'none'\"],\n          baseUri: [\"'self'\"],\n          formAction: [\"'self'\"],\n        },\n      },\n    }));\n  }\n\n  if (enableCors) {\n    app.use(cors(Config.get('server').cors));\n  }\n\n  // Response compression (gzip/deflate) — skip SSE streams\n  if (enableCompression) {\n    app.use(compression({\n      filter: (req: Request, res: Response) => {\n        // Don't compress SSE streams. Match by inclusion: the Accept header is\n        // often a list (e.g. \"text/event-stream, */*\"), which exact equality\n        // would miss, compressing/buffering the stream.\n        if ((req.headers.accept || '').includes('text/event-stream')) return false;\n        return compression.filter(req, res);\n      },\n      threshold: CoreConstants.COMPRESSION_THRESHOLD_BYTES,\n    }));\n  }\n\n  // ETag support for conditional GET requests (304 Not Modified)\n  app.use(etagMiddleware());\n}\n\n/** JSON + URL-encoded body parsers. */\nfunction applyBodyParsing(app: Express, options: CreateAppOptions): void {\n  const { enableJsonBody = true, jsonLimit = '1mb', enableUrlEncoded = true, urlEncodedLimit = '1mb' } = options;\n  if (enableJsonBody) {\n    const jsonParser = express.json({ limit: jsonLimit });\n    const exclude = options.jsonBodyExclude ?? [];\n    if (exclude.length > 0) {\n      // Skip the global JSON parser for raw-body paths so a per-path `express.raw()`\n      // can read the exact bytes (see `jsonBodyExclude`).\n      app.use((req, res, next) => (exclude.some((p) => req.path.startsWith(p)) ? next() : jsonParser(req, res, next)));\n    } else {\n      app.use(jsonParser);\n    }\n  }\n\n  if (enableUrlEncoded) {\n    app.use(express.urlencoded({ extended: true, limit: urlEncodedLimit }));\n  }\n}\n\n/**\n * Health, readiness guard, `/warmup`, `/metrics` and the OpenAPI docs — all\n * registered before the rate limiter so they are never throttled.\n */\nfunction mountInfraEndpoints(app: Express, options: CreateAppOptions, serviceName: string, enableOpenApi: boolean): void {\n  const { checkDependencies, openApiOptions, warmupHooks = [] } = options;\n\n  app.use(createHealthRouter({\n    serviceName,\n    checkDependencies,\n  }));\n\n  // Readiness guard — 503s business traffic while the service is NotReady\n  // (datastore still connecting at startup, or dropped). Mounted right after\n  // the health router and before everything else so a NotReady request is\n  // rejected cheaply, before rate-limit / idempotency / business handlers ever\n  // touch a disconnected datastore. It allowlists the infra endpoints\n  // (/metrics, /warmup, /docs, /logs) registered below, plus /health + /ready.\n  app.use(readinessGuard());\n\n  // Warm-up endpoint — pre-opens connection pools so the first real request\n  // doesn't pay cold-start latency. Always pings Postgres; services using\n  // Mongo / Redis / SQS pass `warmupHooks` so those are warmed in parallel.\n  //\n  // GATED to verified service principals. Every hit runs a Postgres round-trip\n  // plus all `warmupHooks` (Mongo/Redis/SQS), so an open endpoint would let an\n  // anonymous loop amplify into datastore load on every service in the fleet —\n  // and it is registered above the rate limiter, so nothing would throttle it.\n  // `verifyServicePrincipal` checks the bearer token cryptographically, so it is\n  // safe here, above `requireAuth`.\n  app.get('/warmup', async (req: Request, res: Response) => {\n    if (!verifyServicePrincipal(req)) {\n      sendError(res, 404, 'Not found');\n      return;\n    }\n    try {\n      await Promise.all([\n        getConnection().testConnection(),\n        ...warmupHooks.map((hook) => hook()),\n      ]);\n      sendSuccess(res, 200, { warmed: true, hooks: warmupHooks.length });\n    } catch {\n      sendError(res, 503, 'Warmup failed');\n    }\n  });\n\n  // Prometheus metrics endpoint — always registered (never throttled).\n  //\n  // Optionally gated: when `METRICS_SCRAPE_TOKEN` is set, the scraper must send\n  // it as a bearer token (Prometheus `bearer_token` / `bearer_token_file` in the\n  // scrape config). Left ungated when unset so enabling it is a deliberate,\n  // coordinated change rather than a silent monitoring outage — tenant ids stay\n  // out of the output regardless, because the per-org label defaults OFF (see\n  // HTTP_METRICS_ORG_SAMPLE_RATE in metrics.ts).\n  const metricsToken = process.env.METRICS_SCRAPE_TOKEN;\n  app.get('/metrics', (req: Request, res: Response, next: NextFunction) => {\n    if (!metricsToken) {\n      next();\n      return;\n    }\n    const header = req.headers.authorization;\n    const presented = header?.startsWith('Bearer ') ? header.slice(7) : undefined;\n    // Constant-time compare — a length-independent equality check here would\n    // leak the token a byte at a time.\n    if (!presented || !safeEqual(presented, metricsToken)) {\n      sendError(res, 404, 'Not found');\n      return;\n    }\n    next();\n  }, metricsHandler());\n\n  if (enableOpenApi) {\n    const spec = generateOpenApiSpec(openApiOptions);\n    app.get('/docs/openapi.json', (_req: Request, res: Response) => {\n      res.json(spec);\n    });\n    app.use('/docs', swaggerUi.serve, swaggerUi.setup(spec, {\n      customSiteTitle: openApiOptions?.title ?? 'Pipeline Builder API Docs',\n    }));\n  }\n}\n\n/** Global rate limiter — shared across replicas via the env Redis when configured. */\nfunction mountRateLimiter(app: Express, serviceName: string): void {\n  const rateLimitConfig = Config.get('rateLimit');\n\n  const rateLimitOptions: Parameters<typeof rateLimit>[0] = {\n    max: rateLimitConfig.max,\n    windowMs: rateLimitConfig.windowMs,\n    standardHeaders: true,\n    legacyHeaders: false,\n    // Skip rate limiting only for CRYPTOGRAPHICALLY-VERIFIED internal service\n    // callers. The limiter runs before requireAuth, so a plaintext header\n    // would be spoofable by any external client → total bypass.\n    // verifyServicePrincipal verifies the signed service JWT instead;\n    // inter-service callers all send one (getServiceAuthHeader).\n    skip: (req: Request) => verifyServicePrincipal(req),\n    // Key on client IP only. The limiter runs pre-auth, so `req.user` is unset\n    // and any org id would come from the caller-supplied `x-org-id` header —\n    // spoofable, letting an attacker rotate values to evade the bucket or\n    // flood a victim org's bucket. ipKeyGenerator normalizes IPv6 to a /64\n    // prefix (also required by express-rate-limit 8.x's validator).\n    keyGenerator: (req: Request) => ipKeyGenerator(req.ip || 'anon', 64),\n    // A store failure (Redis down / failing over) must degrade to \"not rate\n    // limited\", never to a 500 on every request of every service.\n    passOnStoreError: true,\n    handler: (_req: Request, res: Response) => {\n      sendError(res, 429, 'Too many requests, please try again later.', ErrorCode.RATE_LIMIT_EXCEEDED);\n    },\n    // Shared state across replicas (the process-wide rate-limit Redis connection;\n    // undefined without Redis → per-process memory store, right for one replica).\n    // Namespaced per SERVICE: every service shares one Redis, and an unprefixed\n    // `rl:<ip>` key would let one client's traffic to ANY service drain its\n    // budget on EVERY service.\n    store: createSharedRateLimitStore(`${serviceName}:global`),\n  };\n\n  app.use(rateLimit(rateLimitOptions));\n}\n\n/** Request timeout, duration logging and HTTP metrics. */\nfunction applyRequestTelemetry(app: Express): void {\n  // Express request timeout — uses CoreConstants to share the same default as Lambda handlers\n  const timeoutMs = CoreConstants.HANDLER_TIMEOUT_MS;\n  app.use((_req: Request, res: Response, next: NextFunction) => {\n    res.setTimeout(timeoutMs, () => {\n      if (!res.headersSent) {\n        sendError(res, 503, 'Request timeout');\n      }\n    });\n    next();\n  });\n\n  // Request duration logging\n  const durationLogger = createLogger('request-duration');\n  app.use((req: Request, res: Response, next: NextFunction) => {\n    const start = Date.now();\n    res.on('finish', () => {\n      const duration = Date.now() - start;\n      // Log `req.path` (no query string) — a stray `?token=`/`?ticket=` must not be\n      // persisted verbatim on every request (mirrors the authz-denial auditor's strip).\n      durationLogger.info(`${req.method} ${req.path} ${res.statusCode} ${duration}ms`, {\n        method: req.method,\n        path: req.path,\n        statusCode: res.statusCode,\n        durationMs: duration,\n        requestId: req.requestId,\n      });\n    });\n    next();\n  });\n\n  // Prometheus metrics middleware — records request duration and count\n  app.use(metricsMiddleware());\n}\n\n/**\n * The default SSE manager. The relay (this service's own Redis channel) is\n * built only when something streams: the log stream turns it on here, and an\n * org-keyed channel turns it on when registered (registerSseTicketChannel).\n * The log ticket store exists only with the log stream.\n */\nfunction createDefaultSseManager(serviceName: string, logStream: boolean): SSEManager {\n  const sseManager = new SSEManager({\n    logStream,\n    relayFactory: () => createEnvRedisSSERelay(serviceName),\n    ...(logStream && {\n      ticketStore: createEnvSseTicketStore({\n        ttlMs: SSE_TICKET_TTL_MS,\n        keyPrefix: `logs:${serviceName}`,\n      }),\n    }),\n  });\n  if (logStream) sseManager.enableRelay();\n  return sseManager;\n}\n\n/**\n * The per-request build-log stream: `POST /logs/ticket` + `GET /logs/:requestId`.\n *\n * Ticket-gated — the stream carries per-org build logs, so it must not be\n * world-readable. Clients first POST /logs/ticket (JWT-authenticated) to mint a\n * short-lived, single-use ticket bound to their org AND to the specific\n * `requestId` stream they intend to open, then open the EventSource with\n * ?ticket=<t>. This keeps the JWT out of query strings / access logs while\n * enforcing org ownership, per-subject authorization, and the per-org\n * connection cap on the stream. Mirrors the message-service notifications SSE\n * ticket exchange.\n */\nfunction wireSse(app: Express, sseManager: SSEManager): void {\n  app.post('/logs/ticket', requireAuth, async (req: Request, res: Response) => {\n    const orgId = req.user?.organizationId?.toLowerCase();\n    if (!orgId) {\n      sendError(res, 400, 'Token missing organization', ErrorCode.VALIDATION_ERROR);\n      return;\n    }\n    // The caller must name the stream subject up front so the ticket is bound to\n    // it. Without this, a ticket could be replayed against ANY requestId the\n    // org could guess, letting it attach to another org's log stream. Strictly\n    // format-validated so it can't carry an injection payload into the subject.\n    const requestId = (req.body as { requestId?: unknown } | undefined)?.requestId;\n    if (typeof requestId !== 'string' || !SSE_REQUEST_ID_RE.test(requestId)) {\n      sendError(res, 400, 'Missing or invalid requestId', ErrorCode.VALIDATION_ERROR);\n      return;\n    }\n    const result = await sseManager.createTicket(orgId, requestId);\n    if (!result.ok) {\n      if (result.reason === 'forbidden') {\n        // The subject is owned by another org — do not confirm it exists; a plain\n        // 403 is enough and leaks nothing about which requestIds are live.\n        sendError(res, 403, 'Not authorized for this log stream', ErrorCode.INSUFFICIENT_PERMISSIONS);\n      } else if (result.reason === 'org-limit') {\n        sendError(res, 429, 'Too many log stream tickets issued', ErrorCode.QUOTA_EXCEEDED);\n      } else {\n        sendError(res, 503, 'Log streaming subsystem at capacity', ErrorCode.QUOTA_EXCEEDED);\n      }\n      return;\n    }\n    sendSuccess(res, 200, { ticket: result.ticket });\n  });\n\n  // The stream itself resolves + consumes the ticket inside middleware() and\n  // rejects any anonymous / invalid / expired / already-used ticket with 401.\n  app.get('/logs/:requestId', sseManager.middleware());\n}\n\n/**\n * Create and configure an Express application with common middleware\n *\n * Sets up:\n * - CORS with configured origins\n * - Helmet security headers\n * - Rate limiting\n * - JSON and URL-encoded body parsing\n * - Trust proxy settings\n * - Health check endpoint (/health)\n * - Metrics endpoint (/metrics)\n * - SSE logs endpoint (/logs/:requestId) — only with `logStream: true`\n *\n * @param options - Configuration options\n * @returns Configured Express app and SSE manager\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, async (req, res) => {\n *   // Your route handler\n * });\n *\n * startServer(app, { name: 'My Service' });\n * ```\n */\nexport function createApp(options: CreateAppOptions = {}): CreateAppResult {\n  const {\n    enableRateLimit = true,\n    logStream = false,\n    enableOpenApi = process.env.NODE_ENV !== 'production',\n  } = options;\n\n  const serviceName = process.env.SERVICE_NAME || 'api';\n\n  // A caller-supplied `sseManager` skips the default construction entirely.\n  const sseManager = options.sseManager ?? createDefaultSseManager(serviceName, logStream);\n\n  // Wire the idempotency replay-cache backend used by the post-auth route\n  // factories (createProtectedRoute / createAuthenticatedWithOrgRoute). Prefer\n  // an explicitly injected store; otherwise auto-construct from the shared env\n  // Redis so keyed mutation retries dedupe across replicas. Falls back to the\n  // in-memory default when no Redis is configured (single-replica correctness).\n  const resolvedIdempotencyStore = options.idempotencyStore ?? createEnvRedisIdempotencyStore();\n  if (resolvedIdempotencyStore) {\n    setIdempotencyStore(resolvedIdempotencyStore);\n  }\n\n  // OpenTelemetry is NOT initialized here: by the time createApp runs, express\n  // and http have already been required, so the auto-instrumentation hooks\n  // would have nothing to patch (no inbound span → no trace id). Tracing is\n  // started by the `otel-bootstrap.js` preload instead (node -r … — see each\n  // service's Dockerfile CMD / start script), which runs before any\n  // instrumented module loads. `currentTraceId()` then reads the active span.\n\n  const app = express();\n\n  applySecurityHeaders(app, options, enableOpenApi);\n  applyBodyParsing(app, options);\n\n  // Trust proxy (must be set before rate limiter so req.ip resolves correctly)\n  app.set('trust proxy', Config.get('server').trustProxy);\n\n  // Request ID — prefer existing header from nginx, otherwise generate one\n  app.use((req: Request, res: Response, next: NextFunction) => {\n    const hdr = req.headers['x-request-id'];\n    const requestId = (Array.isArray(hdr) ? hdr[0] : hdr) || uuid();\n    req.requestId = requestId;\n    res.setHeader('X-Request-Id', requestId);\n    next();\n  });\n\n  mountInfraEndpoints(app, options, serviceName, enableOpenApi);\n  if (enableRateLimit) mountRateLimiter(app, serviceName);\n  applyRequestTelemetry(app);\n\n  // NOTE: idempotency is intentionally NOT mounted here. It needs the VERIFIED\n  // org id to namespace its replay cache, but this pre-auth position runs before\n  // `requireAuth`/`attachRequestContext` populate identity, so a global mount\n  // here is a permanent no-op (org always undefined → skip). It is instead wired\n  // into the post-auth route chains — see `createProtectedRoute` /\n  // `createAuthenticatedWithOrgRoute` in middleware-factory.ts.\n\n  if (logStream) wireSse(app, sseManager);\n\n  return { app, sseManager };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-factory.js","sourceRoot":"","sources":["../../src/api/app-factory.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { sendSuccess, sendError, generateOpenApiSpec, ErrorCode, createLogger, verifyServicePrincipal, createHealthRouter, setCounterEmitter, setGaugeEmitter, requireAuth, safeEqual, createEnvSseTicketStore, SSE_TICKET_TTL_MS, auditContextFromRequest, runWithAuditContext, sanitizeCorrelationId } from '@pipeline-builder/api-core';\nimport type { OpenApiSpecOptions } from '@pipeline-builder/api-core';\nimport { Config, CoreConstants } from '@pipeline-builder/pipeline-core';\nimport { getConnection } from '@pipeline-builder/pipeline-data';\nimport compression from 'compression';\nimport cors from 'cors';\nimport express, { type Express, type NextFunction, type Request, type Response } from 'express';\nimport rateLimit, { ipKeyGenerator } from 'express-rate-limit';\nimport helmet from 'helmet';\nimport swaggerUi from 'swagger-ui-express';\nimport { v7 as uuid } from 'uuid';\nimport { etagMiddleware } from './etag-middleware.js';\nimport { createEnvRedisIdempotencyStore, setIdempotencyStore, type IdempotencyStore } from './idempotency-middleware.js';\nimport { metricsMiddleware, metricsHandler, incCounter, setGauge } from './metrics.js';\nimport { createSharedRateLimitStore } from './rate-limit-store.js';\nimport { readinessGuard } from './readiness.js';\nimport { currentTraceId } from './tracing.js';\nimport { SSEManager, SSE_REQUEST_ID_RE } from '../http/sse-connection-manager.js';\nimport { createEnvRedisSSERelay } from '../http/sse-relay.js';\n\n// Wire api-core's counter shim to the real prom-client registry. This is\n// a no-op until incCounter is called for the first time (lazy registration\n// in metrics.ts), and lets api-core helpers like the quota client record\n// `quota_fail_open_total` without taking a hard dep on api-server.\nsetCounterEmitter(incCounter);\n// Same seam for GAUGES. pipeline-data's read-replica lag sampler needs it:\n// replay lag and the state of the read fallback circuit are sampled\n// point-in-time values, so emitting them as counters would make every query\n// over them wrong. pipeline-data depends on api-core and must not depend on\n// api-server, hence the shim rather than a direct import.\nsetGaugeEmitter(setGauge);\n\n/**\n * Options for creating an Express application\n */\nexport interface CreateAppOptions {\n  /** Enable CORS (default: true) */\n  enableCors?: boolean;\n  /** Enable Helmet security headers (default: true) */\n  enableHelmet?: boolean;\n  /** Enable rate limiting (default: true) */\n  enableRateLimit?: boolean;\n  /** Enable JSON body parsing (default: true) */\n  enableJsonBody?: boolean;\n  /** JSON body size limit (default: '1mb') */\n  jsonLimit?: string;\n  /**\n   * Path prefixes the global JSON body parser must NOT touch — for routes that need\n   * the raw body (e.g. a Stripe webhook whose HMAC is computed over the exact bytes).\n   * Without this the global parser consumes the body first and a later `express.raw()`\n   * on the same path is a no-op, breaking signature verification.\n   */\n  jsonBodyExclude?: string[];\n  /** Enable URL-encoded body parsing (default: true) */\n  enableUrlEncoded?: boolean;\n  /** URL-encoded body size limit (default: '1mb') */\n  urlEncodedLimit?: string;\n  /** Custom SSE manager instance */\n  sseManager?: SSEManager;\n  /**\n   * Serve the per-request build-log stream: `POST /logs/ticket` +\n   * `GET /logs/:requestId`, a log ticket store, the cross-pod relay, and\n   * `ctx.log` frames pushed to SSE. Default false — a service without it has no\n   * `/logs` routes and `ctx.log` only writes to the logger.\n   */\n  logStream?: boolean;\n  /** Health check dependency checker — if provided, /health reports dependency status */\n  checkDependencies?: () => Promise<Record<string, 'connected' | 'disconnected' | 'unknown'>>;\n  /**\n   * Serve the OpenAPI spec at `/docs/openapi.json` and Swagger UI at `/docs`.\n   *\n   * Defaults to OFF under `NODE_ENV=production`: the routes are registered above\n   * the rate limiter and are not auth-gated, so in production they would publish\n   * the full route + schema inventory of every service to anyone who could reach\n   * the port. Pass `true` explicitly to serve them in production anyway.\n   */\n  enableOpenApi?: boolean;\n  /** OpenAPI spec customization options */\n  openApiOptions?: OpenApiSpecOptions;\n  /** Enable gzip/deflate response compression (default: true) */\n  enableCompression?: boolean;\n  /**\n   * Idempotency replay-cache backend for keyed mutation retries. When omitted,\n   * createApp auto-wires the shared env Redis store (multi-replica dedup) if\n   * Redis is configured, else keeps the in-memory default (single-replica).\n   * Pass an explicit store to inject a bespoke backend (e.g. a service's own\n   * ioredis connection).\n   */\n  idempotencyStore?: IdempotencyStore;\n  /**\n   * Extra warmup callbacks invoked by `GET /warmup` in addition to the\n   * default Postgres ping. Use for services that depend on Mongo, Redis,\n   * SQS, etc. — pre-warming opens connection pools before real traffic\n   * arrives. Each callback should resolve when its dependency is ready;\n   * any rejection causes /warmup to return 503.\n   */\n  warmupHooks?: Array<() => Promise<void>>;\n}\n\n/**\n * Result of creating an Express application\n */\nexport interface CreateAppResult {\n  /** Configured Express application */\n  app: Express;\n  /** SSE manager instance */\n  sseManager: SSEManager;\n}\n\n/** Helmet (strict CSP), CORS, compression and ETags. */\nfunction applySecurityHeaders(app: Express, options: CreateAppOptions, enableOpenApi: boolean): void {\n  const { enableCors = true, enableHelmet = true, enableCompression = true } = options;\n  // Swagger UI needs unsafe-inline + unsafe-eval for its bundled scripts —\n  // but CSP is only relaxed that far when (a) OpenAPI is enabled AND (b) we're\n  // not in production. In prod, Swagger should be served behind a separate\n  // host or auth-gated route; the main app keeps the strict CSP so a Stored\n  // XSS in any handler can't `eval()` arbitrary script.\n  const allowSwaggerCsp = enableOpenApi && process.env.NODE_ENV !== 'production';\n  if (enableHelmet) {\n    app.use(helmet({\n      contentSecurityPolicy: {\n        directives: {\n          defaultSrc: [\"'self'\"],\n          scriptSrc: allowSwaggerCsp\n            ? [\"'self'\", \"'unsafe-inline'\", \"'unsafe-eval'\"]\n            : [\"'self'\"],\n          styleSrc: [\"'self'\", \"'unsafe-inline'\"],\n          imgSrc: [\"'self'\", 'data:', 'blob:'],\n          connectSrc: [\"'self'\"],\n          fontSrc: [\"'self'\"],\n          objectSrc: [\"'none'\"],\n          frameAncestors: [\"'none'\"],\n          baseUri: [\"'self'\"],\n          formAction: [\"'self'\"],\n        },\n      },\n    }));\n  }\n\n  if (enableCors) {\n    app.use(cors(Config.get('server').cors));\n  }\n\n  // Response compression (gzip/deflate) — skip SSE streams\n  if (enableCompression) {\n    app.use(compression({\n      filter: (req: Request, res: Response) => {\n        // Don't compress SSE streams. Match by inclusion: the Accept header is\n        // often a list (e.g. \"text/event-stream, */*\"), which exact equality\n        // would miss, compressing/buffering the stream.\n        if ((req.headers.accept || '').includes('text/event-stream')) return false;\n        return compression.filter(req, res);\n      },\n      threshold: CoreConstants.COMPRESSION_THRESHOLD_BYTES,\n    }));\n  }\n\n  // ETag support for conditional GET requests (304 Not Modified)\n  app.use(etagMiddleware());\n}\n\n/** JSON + URL-encoded body parsers. */\nfunction applyBodyParsing(app: Express, options: CreateAppOptions): void {\n  const { enableJsonBody = true, jsonLimit = '1mb', enableUrlEncoded = true, urlEncodedLimit = '1mb' } = options;\n  if (enableJsonBody) {\n    const jsonParser = express.json({ limit: jsonLimit });\n    const exclude = options.jsonBodyExclude ?? [];\n    if (exclude.length > 0) {\n      // Skip the global JSON parser for raw-body paths so a per-path `express.raw()`\n      // can read the exact bytes (see `jsonBodyExclude`).\n      app.use((req, res, next) => (exclude.some((p) => req.path.startsWith(p)) ? next() : jsonParser(req, res, next)));\n    } else {\n      app.use(jsonParser);\n    }\n  }\n\n  if (enableUrlEncoded) {\n    app.use(express.urlencoded({ extended: true, limit: urlEncodedLimit }));\n  }\n}\n\n/**\n * Health, readiness guard, `/warmup`, `/metrics` and the OpenAPI docs — all\n * registered before the rate limiter so they are never throttled.\n */\nfunction mountInfraEndpoints(app: Express, options: CreateAppOptions, serviceName: string, enableOpenApi: boolean): void {\n  const { checkDependencies, openApiOptions, warmupHooks = [] } = options;\n\n  app.use(createHealthRouter({\n    serviceName,\n    checkDependencies,\n  }));\n\n  // Readiness guard — 503s business traffic while the service is NotReady\n  // (datastore still connecting at startup, or dropped). Mounted right after\n  // the health router and before everything else so a NotReady request is\n  // rejected cheaply, before rate-limit / idempotency / business handlers ever\n  // touch a disconnected datastore. It allowlists the infra endpoints\n  // (/metrics, /warmup, /docs, /logs) registered below, plus /health + /ready.\n  app.use(readinessGuard());\n\n  // Warm-up endpoint — pre-opens connection pools so the first real request\n  // doesn't pay cold-start latency. Always pings Postgres; services using\n  // Mongo / Redis / SQS pass `warmupHooks` so those are warmed in parallel.\n  //\n  // GATED to verified service principals. Every hit runs a Postgres round-trip\n  // plus all `warmupHooks` (Mongo/Redis/SQS), so an open endpoint would let an\n  // anonymous loop amplify into datastore load on every service in the fleet —\n  // and it is registered above the rate limiter, so nothing would throttle it.\n  // `verifyServicePrincipal` checks the bearer token cryptographically, so it is\n  // safe here, above `requireAuth`.\n  app.get('/warmup', async (req: Request, res: Response) => {\n    if (!verifyServicePrincipal(req)) {\n      sendError(res, 404, 'Not found');\n      return;\n    }\n    try {\n      await Promise.all([\n        getConnection().testConnection(),\n        ...warmupHooks.map((hook) => hook()),\n      ]);\n      sendSuccess(res, 200, { warmed: true, hooks: warmupHooks.length });\n    } catch {\n      sendError(res, 503, 'Warmup failed');\n    }\n  });\n\n  // Prometheus metrics endpoint — always registered (never throttled).\n  //\n  // Optionally gated: when `METRICS_SCRAPE_TOKEN` is set, the scraper must send\n  // it as a bearer token (Prometheus `bearer_token` / `bearer_token_file` in the\n  // scrape config). Left ungated when unset so enabling it is a deliberate,\n  // coordinated change rather than a silent monitoring outage — tenant ids stay\n  // out of the output regardless, because the per-org label defaults OFF (see\n  // HTTP_METRICS_ORG_SAMPLE_RATE in metrics.ts).\n  const metricsToken = process.env.METRICS_SCRAPE_TOKEN;\n  app.get('/metrics', (req: Request, res: Response, next: NextFunction) => {\n    if (!metricsToken) {\n      next();\n      return;\n    }\n    const header = req.headers.authorization;\n    const presented = header?.startsWith('Bearer ') ? header.slice(7) : undefined;\n    // Constant-time compare — a length-independent equality check here would\n    // leak the token a byte at a time.\n    if (!presented || !safeEqual(presented, metricsToken)) {\n      sendError(res, 404, 'Not found');\n      return;\n    }\n    next();\n  }, metricsHandler());\n\n  if (enableOpenApi) {\n    const spec = generateOpenApiSpec(openApiOptions);\n    app.get('/docs/openapi.json', (_req: Request, res: Response) => {\n      res.json(spec);\n    });\n    app.use('/docs', swaggerUi.serve, swaggerUi.setup(spec, {\n      customSiteTitle: openApiOptions?.title ?? 'Pipeline Builder API Docs',\n    }));\n  }\n}\n\n/** Global rate limiter — shared across replicas via the env Redis when configured. */\nfunction mountRateLimiter(app: Express, serviceName: string): void {\n  const rateLimitConfig = Config.get('rateLimit');\n\n  const rateLimitOptions: Parameters<typeof rateLimit>[0] = {\n    max: rateLimitConfig.max,\n    windowMs: rateLimitConfig.windowMs,\n    standardHeaders: true,\n    legacyHeaders: false,\n    // Skip rate limiting only for CRYPTOGRAPHICALLY-VERIFIED internal service\n    // callers. The limiter runs before requireAuth, so a plaintext header\n    // would be spoofable by any external client → total bypass.\n    // verifyServicePrincipal verifies the signed service JWT instead;\n    // inter-service callers all send one (getServiceAuthHeader).\n    skip: (req: Request) => verifyServicePrincipal(req),\n    // Key on client IP only. The limiter runs pre-auth, so `req.user` is unset\n    // and any org id would come from the caller-supplied `x-org-id` header —\n    // spoofable, letting an attacker rotate values to evade the bucket or\n    // flood a victim org's bucket. ipKeyGenerator normalizes IPv6 to a /64\n    // prefix (also required by express-rate-limit 8.x's validator).\n    keyGenerator: (req: Request) => ipKeyGenerator(req.ip || 'anon', 64),\n    // A store failure (Redis down / failing over) must degrade to \"not rate\n    // limited\", never to a 500 on every request of every service.\n    passOnStoreError: true,\n    handler: (_req: Request, res: Response) => {\n      sendError(res, 429, 'Too many requests, please try again later.', ErrorCode.RATE_LIMIT_EXCEEDED);\n    },\n    // Shared state across replicas (the process-wide rate-limit Redis connection;\n    // undefined without Redis → per-process memory store, right for one replica).\n    // Namespaced per SERVICE: every service shares one Redis, and an unprefixed\n    // `rl:<ip>` key would let one client's traffic to ANY service drain its\n    // budget on EVERY service.\n    store: createSharedRateLimitStore(`${serviceName}:global`),\n  };\n\n  app.use(rateLimit(rateLimitOptions));\n}\n\n/** Request timeout, duration logging and HTTP metrics. */\nfunction applyRequestTelemetry(app: Express): void {\n  // Express request timeout — uses CoreConstants to share the same default as Lambda handlers\n  const timeoutMs = CoreConstants.HANDLER_TIMEOUT_MS;\n  app.use((_req: Request, res: Response, next: NextFunction) => {\n    res.setTimeout(timeoutMs, () => {\n      if (!res.headersSent) {\n        sendError(res, 503, 'Request timeout');\n      }\n    });\n    next();\n  });\n\n  // Request duration logging\n  const durationLogger = createLogger('request-duration');\n  app.use((req: Request, res: Response, next: NextFunction) => {\n    const start = Date.now();\n    res.on('finish', () => {\n      const duration = Date.now() - start;\n      // Log `req.path` (no query string) — a stray `?token=`/`?ticket=` must not be\n      // persisted verbatim on every request (mirrors the authz-denial auditor's strip).\n      durationLogger.info(`${req.method} ${req.path} ${res.statusCode} ${duration}ms`, {\n        method: req.method,\n        path: req.path,\n        statusCode: res.statusCode,\n        durationMs: duration,\n        requestId: req.requestId,\n      });\n    });\n    next();\n  });\n\n  // Prometheus metrics middleware — records request duration and count\n  app.use(metricsMiddleware());\n}\n\n/**\n * The default SSE manager. The relay (this service's own Redis channel) is\n * built only when something streams: the log stream turns it on here, and an\n * org-keyed channel turns it on when registered (registerSseTicketChannel).\n * The log ticket store exists only with the log stream.\n */\nfunction createDefaultSseManager(serviceName: string, logStream: boolean): SSEManager {\n  const sseManager = new SSEManager({\n    logStream,\n    relayFactory: () => createEnvRedisSSERelay(serviceName),\n    ...(logStream && {\n      ticketStore: createEnvSseTicketStore({\n        ttlMs: SSE_TICKET_TTL_MS,\n        keyPrefix: `logs:${serviceName}`,\n      }),\n    }),\n  });\n  if (logStream) sseManager.enableRelay();\n  return sseManager;\n}\n\n/**\n * The per-request build-log stream: `POST /logs/ticket` + `GET /logs/:requestId`.\n *\n * Ticket-gated — the stream carries per-org build logs, so it must not be\n * world-readable. Clients first POST /logs/ticket (JWT-authenticated) to mint a\n * short-lived, single-use ticket bound to their org AND to the specific\n * `requestId` stream they intend to open, then open the EventSource with\n * ?ticket=<t>. This keeps the JWT out of query strings / access logs while\n * enforcing org ownership, per-subject authorization, and the per-org\n * connection cap on the stream. Mirrors the message-service notifications SSE\n * ticket exchange.\n */\nfunction wireSse(app: Express, sseManager: SSEManager): void {\n  app.post('/logs/ticket', requireAuth, async (req: Request, res: Response) => {\n    const orgId = req.user?.organizationId?.toLowerCase();\n    if (!orgId) {\n      sendError(res, 400, 'Token missing organization', ErrorCode.VALIDATION_ERROR);\n      return;\n    }\n    // The caller must name the stream subject up front so the ticket is bound to\n    // it. Without this, a ticket could be replayed against ANY requestId the\n    // org could guess, letting it attach to another org's log stream. Strictly\n    // format-validated so it can't carry an injection payload into the subject.\n    const requestId = (req.body as { requestId?: unknown } | undefined)?.requestId;\n    if (typeof requestId !== 'string' || !SSE_REQUEST_ID_RE.test(requestId)) {\n      sendError(res, 400, 'Missing or invalid requestId', ErrorCode.VALIDATION_ERROR);\n      return;\n    }\n    const result = await sseManager.createTicket(orgId, requestId);\n    if (!result.ok) {\n      if (result.reason === 'forbidden') {\n        // The subject is owned by another org — do not confirm it exists; a plain\n        // 403 is enough and leaks nothing about which requestIds are live.\n        sendError(res, 403, 'Not authorized for this log stream', ErrorCode.INSUFFICIENT_PERMISSIONS);\n      } else if (result.reason === 'org-limit') {\n        sendError(res, 429, 'Too many log stream tickets issued', ErrorCode.QUOTA_EXCEEDED);\n      } else {\n        sendError(res, 503, 'Log streaming subsystem at capacity', ErrorCode.QUOTA_EXCEEDED);\n      }\n      return;\n    }\n    sendSuccess(res, 200, { ticket: result.ticket });\n  });\n\n  // The stream itself resolves + consumes the ticket inside middleware() and\n  // rejects any anonymous / invalid / expired / already-used ticket with 401.\n  app.get('/logs/:requestId', sseManager.middleware());\n}\n\n/**\n * Create and configure an Express application with common middleware\n *\n * Sets up:\n * - CORS with configured origins\n * - Helmet security headers\n * - Rate limiting\n * - JSON and URL-encoded body parsing\n * - Trust proxy settings\n * - Health check endpoint (/health)\n * - Metrics endpoint (/metrics)\n * - SSE logs endpoint (/logs/:requestId) — only with `logStream: true`\n *\n * @param options - Configuration options\n * @returns Configured Express app and SSE manager\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, async (req, res) => {\n *   // Your route handler\n * });\n *\n * startServer(app, { name: 'My Service' });\n * ```\n */\nexport function createApp(options: CreateAppOptions = {}): CreateAppResult {\n  const {\n    enableRateLimit = true,\n    logStream = false,\n    enableOpenApi = process.env.NODE_ENV !== 'production',\n  } = options;\n\n  const serviceName = process.env.SERVICE_NAME || 'api';\n\n  // A caller-supplied `sseManager` skips the default construction entirely.\n  const sseManager = options.sseManager ?? createDefaultSseManager(serviceName, logStream);\n\n  // Wire the idempotency replay-cache backend used by the post-auth route\n  // factories (createProtectedRoute / createAuthenticatedWithOrgRoute). Prefer\n  // an explicitly injected store; otherwise auto-construct from the shared env\n  // Redis so keyed mutation retries dedupe across replicas. Falls back to the\n  // in-memory default when no Redis is configured (single-replica correctness).\n  const resolvedIdempotencyStore = options.idempotencyStore ?? createEnvRedisIdempotencyStore();\n  if (resolvedIdempotencyStore) {\n    setIdempotencyStore(resolvedIdempotencyStore);\n  }\n\n  // OpenTelemetry is NOT initialized here: by the time createApp runs, express\n  // and http have already been required, so the auto-instrumentation hooks\n  // would have nothing to patch (no inbound span → no trace id). Tracing is\n  // started by the `otel-bootstrap.js` preload instead (node -r … — see each\n  // service's Dockerfile CMD / start script), which runs before any\n  // instrumented module loads. `currentTraceId()` then reads the active span.\n\n  const app = express();\n\n  applySecurityHeaders(app, options, enableOpenApi);\n  applyBodyParsing(app, options);\n\n  // Trust proxy (must be set before rate limiter so req.ip resolves correctly)\n  app.set('trust proxy', Config.get('server').trustProxy);\n\n  // Request ID + audit context. Prefer the inbound `X-Request-Id` (nginx, or a\n  // peer service / CLI forwarding its own) when it is a bounded opaque token —\n  // an oversized or junk value is replaced, not stored — otherwise generate one.\n  // The rest of the request then runs inside an audit-context scope, so every\n  // `recordAudit` it makes carries the request id, trace id, client ip / UA, the\n  // verified credential (read lazily, after `requireAuth`) and any inbound\n  // `X-Pipeline-Execution-Id` / `X-CodeBuild-Build-Id` / `X-Source-Event-Id`\n  // with no call-site change. Mounted after `trust proxy` so `req.ip` is real.\n  app.use((req: Request, res: Response, next: NextFunction) => {\n    const hdr = req.headers['x-request-id'];\n    const requestId = sanitizeCorrelationId(Array.isArray(hdr) ? hdr[0] : hdr) ?? uuid();\n    req.requestId = requestId;\n    res.setHeader('X-Request-Id', requestId);\n    runWithAuditContext(auditContextFromRequest(req, { requestId, traceId: currentTraceId() }), next);\n  });\n\n  mountInfraEndpoints(app, options, serviceName, enableOpenApi);\n  if (enableRateLimit) mountRateLimiter(app, serviceName);\n  applyRequestTelemetry(app);\n\n  // NOTE: idempotency is intentionally NOT mounted here. It needs the VERIFIED\n  // org id to namespace its replay cache, but this pre-auth position runs before\n  // `requireAuth`/`attachRequestContext` populate identity, so a global mount\n  // here is a permanent no-op (org always undefined → skip). It is instead wired\n  // into the post-auth route chains — see `createProtectedRoute` /\n  // `createAuthenticatedWithOrgRoute` in middleware-factory.ts.\n\n  if (logStream) wireSse(app, sseManager);\n\n  return { app, sseManager };\n}\n"]}

package/lib/api/check-quota.d.ts

@@ -1,13 +1,57 @@
 import type { QuotaType, QuotaService } from '@pipeline-builder/api-core';
-import type { Request, Response, NextFunction } from 'express';
+import type { Request, RequestHandler, Response, NextFunction } from 'express';
+/** TTL (ms) of a cached ALLOWED check. `0` disables the cache. */
+export declare const QUOTA_CHECK_CACHE_TTL_MS: number;
+/** Longest (ms) a DENIED check is reused before re-asking (it never outlives `resetAt`). */
+export declare const QUOTA_CHECK_DENIED_CACHE_MS: number;
+/** Drop every cached check (tests; also a safe operational reset). */
+export declare function clearQuotaCheckCache(): void;
 /**
  * Create middleware that checks a specific quota type before proceeding.
  *
- * On quota exceeded, returns a 429 response with quota details.
+ * On quota exceeded, returns a 429 response with quota details (quotaType,
+ * limit, used, resetAt, upgradeUrl — see api-core `sendQuotaExceeded`).
  * On quota service failure, fails open (allows the request).
  *
+ * `apiCalls` is split per request by principal: an org service account or a
+ * personal access key is checked against `automationCalls` instead
+ * ({@link meteredQuotaTypeFor}), the
+ * same type `meterQuotaOnSuccess` increments — so mount both with `'apiCalls'`.
+ *
+ * Skipped (passes through) exactly where the meter skips, so the gate never
+ * refuses a call the meter would not bill (`callQuotaExemption`):
+ * - a SERVICE PRINCIPAL (peer-service traffic is never metered, so a tenant at
+ *   its limit must not break the internal calls its own earlier actions caused);
+ * - for `apiCalls`: an IMPERSONATION session (vendor staff diagnosing an
+ *   exhausted org must not be locked out by it) and an ON-BEHALF hop (a user
+ *   token forwarded by ask/pipeline with a signed marker — the originating
+ *   request was already gated and metered);
+ * - an `apiCalls` request on the fleet-wide `QUOTA_EXEMPT_ROUTES` (console
+ *   polling — an exhausted org must still render the banner saying so);
+ * - an idempotent RETRY whose original already completed (the replay is served
+ *   from the idempotency cache, does no work and is never metered; refusing it
+ *   would 429 a client for asking what its own earlier request returned).
+ *
+ * Readings are cached per pod (see the cache notes above), and the read itself
+ * has a short budget (api-core `QUOTA_CHECK_TIMEOUT_MS`, no retry) — a slow
+ * quota service fails open quickly instead of stalling every request.
+ *
+ * Mountable at the app-routes level (`app.use(prefix, …auth, checkQuota(...))`):
+ * the org comes from the request context when one is attached, else from the
+ * verified `req.user.organizationId` — the same fallback the meter uses.
+ *
  * @param quotaService - Quota service client
  * @param quotaType - Which quota to check (e.g. 'apiCalls', 'pipelines', 'plugins')
  * @returns Express middleware
  */
-export declare function checkQuota(quotaService: QuotaService, quotaType: QuotaType): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+export declare function checkQuota(quotaService: QuotaService, baseQuotaType: QuotaType): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+/** The service-local request path, without the query string. */
+export declare function requestPath(req: Request): string;
+/**
+ * The DEFERRED form of {@link checkQuota}: arms the check at mount time and lets
+ * `requireAuth` run it once the caller is verified (api-core
+ * `armDeferredQuotaCheck`). For a prefix mount ahead of routers that
+ * authenticate per route — use {@link apiCallsQuota}, which pairs it with the
+ * meter. Tagged as the check gate, so the route table records it.
+ */
+export declare function deferredCheckQuota(quotaService: QuotaService, quotaType: QuotaType): RequestHandler;