@pipeline-builder/api-core 3.4.110 → 3.4.111

package/lib/helpers/org-hierarchy-http.d.ts

@@ -47,3 +47,15 @@ export declare function fetchParentOrgId(orgId: string, opts: OrgHierarchyHttpOp
  * `string[]`.
  */
 export declare function fetchOrgDescendants(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string[] | undefined>;
+/**
+ * Check whether `userId` is an ACTIVE member of `orgId` via platform's
+ * `GET /organization/:id/members/:userId/exists`. Returns the boolean the
+ * platform reports.
+ *
+ * Returns `undefined` (— "couldn't determine") on a non-2xx response, and
+ * throws only on a transport failure (connection/timeout) — so the caller
+ * distinguishes a definitive not-a-member (`false`) from an indeterminate
+ * lookup (`undefined`) and applies its own fail-open/closed policy. The `path`
+ * differs from the parent/descendants shape, so this builds its own request.
+ */
+export declare function fetchOrgMembership(orgId: string, userId: string, opts: OrgHierarchyHttpOptions): Promise<boolean | undefined>;

package/lib/helpers/org-hierarchy-http.js

@@ -74,4 +74,32 @@ export async function fetchOrgDescendants(orgId, opts) {
     // Only meaningful when the (validated) subtree is larger than the org itself.
     return orgIds.length > 1 ? orgIds : undefined;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-hierarchy-http.js","sourceRoot":"","sources":["../../src/helpers/org-hierarchy-http.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AA+BhE,SAAS,YAAY,CACnB,KAAa,EACb,MAAgC,EAChC,IAA6B;IAE7B,MAAM,MAAM,GAAG,IAAI,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACpD,MAAM,IAAI,GAAG,iBAAiB,kBAAkB,CAAC,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;IACpE,MAAM,OAAO,GAA2B;QACtC,aAAa,EAAE,oBAAoB,CAAC;YAClC,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,KAAK,EAAE,IAAI,CAAC,SAAS,IAAI,KAAK;YAC9B,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,QAAQ;SAC5B,CAAC;QACF,GAAG,IAAI,CAAC,OAAO;KAChB,CAAC;IACF,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AACnC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,KAAa,EAAE,IAA6B;IACjF,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;IACtE,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,GAAG,CAA6C,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IACnH,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG,EAAE,CAAC;QAC1B,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,gCAAgC,KAAK,UAAU,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC;QACnF,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,IAAI,SAAS,CAAC;AAClD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,KAAa,EAAE,IAA6B;IACpF,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;IAC3E,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,GAAG,CAAkC,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IACxG,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG;QAAE,OAAO,SAAS,CAAC;IAC5C,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC;IACnC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IAC1C,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,EAAgB,EAAE,CAAC,OAAO,EAAE,KAAK,QAAQ,CAAC,CAAC;IACxE,8EAA8E;IAC9E,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AAChD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Org → team hierarchy lookups over HTTP against the platform service.\n *\n * The Mongoose-based traversal in {@link ./org-hierarchy} is for services that\n * own the org table (platform, quota). Everyone else reads the hierarchy over\n * the wire from platform's authoritative `/organization/:id/*` endpoints. This\n * module centralizes the transport for those reads — URL construction, the\n * signed service-token auth header, and timeout+retry via the shared\n * {@link InternalHttpClient} — so compliance, reporting, and any future caller\n * share ONE mechanism instead of each hand-rolling a `fetch`/client with its\n * own auth and failure semantics.\n *\n * These functions deliberately do NOT swallow transport errors: a connection\n * failure/timeout propagates so each caller keeps its own fallback policy (log\n * level, degrade-to-self vs. return-undefined). A non-2xx response is treated\n * as \"no data\" (returns undefined), matching what the callers previously did.\n */\n\nimport { getServiceAuthHeader } from '../middleware/auth.js';\nimport { InternalHttpClient } from '../services/http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\n\n/** Options shared by the platform org-hierarchy HTTP lookups. */\nexport interface OrgHierarchyHttpOptions {\n  /** Platform service host/port (+ optional default timeout) for the client. */\n  service: ServiceConfig;\n  /** Service name minted into the service-auth JWT `sub` (e.g. 'compliance'). */\n  serviceName: string;\n  /**\n   * Org id embedded in the signed service token's org context. Defaults to the\n   * queried `orgId`; pass a system org id for a system-scoped lookup.\n   */\n  authOrgId?: string;\n  /** Role carried by the service token (default 'member' — least privilege). */\n  role?: 'owner' | 'admin' | 'member';\n  /** Extra request headers merged after `Authorization` (e.g. `x-org-id`). */\n  headers?: Record<string, string>;\n  /** Per-request timeout override in ms (falls back to the client default). */\n  timeout?: number;\n  /**\n   * When true, a non-2xx response THROWS instead of resolving to `undefined`.\n   * Default false (a 4xx/5xx maps to `undefined`, the fail-soft policy the\n   * message/reporting root-resolution callers rely on). A caller for whom a\n   * failed lookup must fail-CLOSED — e.g. a compliance scan, where treating a\n   * team org as parent-less would silently skip inherited blocking rules — sets\n   * this so it can distinguish \"root org\" (`undefined`) from \"lookup failed\".\n   */\n  throwOnHttpError?: boolean;\n}\n\nfunction buildRequest(\n  orgId: string,\n  suffix: 'parent' | 'descendants',\n  opts: OrgHierarchyHttpOptions,\n): { client: InternalHttpClient; path: string; headers: Record<string, string> } {\n  const client = new InternalHttpClient(opts.service);\n  const path = `/organization/${encodeURIComponent(orgId)}/${suffix}`;\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      orgId: opts.authOrgId ?? orgId,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  return { client, path, headers };\n}\n\n/**\n * Resolve an org's direct parent id via platform's\n * `GET /organization/:id/parent`. Returns `undefined` for a root org. A non-2xx\n * response resolves to `undefined` by default, or THROWS when\n * `throwOnHttpError` is set. Always throws on a transport failure\n * (connection/timeout) so the caller can apply its own fallback.\n */\nexport async function fetchParentOrgId(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'parent', opts);\n  const res = await client.get<{ data?: { parentOrgId?: string | null } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) {\n    if (opts.throwOnHttpError) {\n      throw new Error(`parent-org lookup failed for ${orgId}: HTTP ${res.statusCode}`);\n    }\n    return undefined;\n  }\n  return res.body?.data?.parentOrgId ?? undefined;\n}\n\n/**\n * Resolve `[self, ...descendantOrgIds]` for an org via platform's\n * `GET /organization/:id/descendants`. Returns the id list only when it is\n * larger than the org itself (a real subtree), else `undefined`; also\n * `undefined` on a non-2xx response. Throws on a transport failure so the\n * caller can apply its own fallback.\n *\n * This is a trust boundary: the response is validated element-by-element rather\n * than cast — every entry must be a string, and any non-string is dropped — so\n * a malformed payload can never smuggle a non-string into the returned\n * `string[]`.\n */\nexport async function fetchOrgDescendants(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string[] | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'descendants', opts);\n  const res = await client.get<{ data?: { orgIds?: unknown } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  const ids = res.body?.data?.orgIds;\n  if (!Array.isArray(ids)) return undefined;\n  const orgIds = ids.filter((id): id is string => typeof id === 'string');\n  // Only meaningful when the (validated) subtree is larger than the org itself.\n  return orgIds.length > 1 ? orgIds : undefined;\n}\n"]}
+/**
+ * Check whether `userId` is an ACTIVE member of `orgId` via platform's
+ * `GET /organization/:id/members/:userId/exists`. Returns the boolean the
+ * platform reports.
+ *
+ * Returns `undefined` (— "couldn't determine") on a non-2xx response, and
+ * throws only on a transport failure (connection/timeout) — so the caller
+ * distinguishes a definitive not-a-member (`false`) from an indeterminate
+ * lookup (`undefined`) and applies its own fail-open/closed policy. The `path`
+ * differs from the parent/descendants shape, so this builds its own request.
+ */
+export async function fetchOrgMembership(orgId, userId, opts) {
+    const client = new InternalHttpClient(opts.service);
+    const path = `/organization/${encodeURIComponent(orgId)}/members/${encodeURIComponent(userId)}/exists`;
+    const headers = {
+        Authorization: getServiceAuthHeader({
+            serviceName: opts.serviceName,
+            orgId: opts.authOrgId ?? orgId,
+            role: opts.role ?? 'member',
+        }),
+        ...opts.headers,
+    };
+    const res = await client.get(path, { headers, timeout: opts.timeout });
+    if (res.statusCode >= 400)
+        return undefined;
+    const isMember = res.body?.data?.isMember;
+    return typeof isMember === 'boolean' ? isMember : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-hierarchy-http.js","sourceRoot":"","sources":["../../src/helpers/org-hierarchy-http.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Org → team hierarchy lookups over HTTP against the platform service.\n *\n * The Mongoose-based traversal in {@link ./org-hierarchy} is for services that\n * own the org table (platform, quota). Everyone else reads the hierarchy over\n * the wire from platform's authoritative `/organization/:id/*` endpoints. This\n * module centralizes the transport for those reads — URL construction, the\n * signed service-token auth header, and timeout+retry via the shared\n * {@link InternalHttpClient} — so compliance, reporting, and any future caller\n * share ONE mechanism instead of each hand-rolling a `fetch`/client with its\n * own auth and failure semantics.\n *\n * These functions deliberately do NOT swallow transport errors: a connection\n * failure/timeout propagates so each caller keeps its own fallback policy (log\n * level, degrade-to-self vs. return-undefined). A non-2xx response is treated\n * as \"no data\" (returns undefined), matching what the callers previously did.\n */\n\nimport { getServiceAuthHeader } from '../middleware/auth.js';\nimport { InternalHttpClient } from '../services/http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\n\n/** Options shared by the platform org-hierarchy HTTP lookups. */\nexport interface OrgHierarchyHttpOptions {\n  /** Platform service host/port (+ optional default timeout) for the client. */\n  service: ServiceConfig;\n  /** Service name minted into the service-auth JWT `sub` (e.g. 'compliance'). */\n  serviceName: string;\n  /**\n   * Org id embedded in the signed service token's org context. Defaults to the\n   * queried `orgId`; pass a system org id for a system-scoped lookup.\n   */\n  authOrgId?: string;\n  /** Role carried by the service token (default 'member' — least privilege). */\n  role?: 'owner' | 'admin' | 'member';\n  /** Extra request headers merged after `Authorization` (e.g. `x-org-id`). */\n  headers?: Record<string, string>;\n  /** Per-request timeout override in ms (falls back to the client default). */\n  timeout?: number;\n  /**\n   * When true, a non-2xx response THROWS instead of resolving to `undefined`.\n   * Default false (a 4xx/5xx maps to `undefined`, the fail-soft policy the\n   * message/reporting root-resolution callers rely on). A caller for whom a\n   * failed lookup must fail-CLOSED — e.g. a compliance scan, where treating a\n   * team org as parent-less would silently skip inherited blocking rules — sets\n   * this so it can distinguish \"root org\" (`undefined`) from \"lookup failed\".\n   */\n  throwOnHttpError?: boolean;\n}\n\nfunction buildRequest(\n  orgId: string,\n  suffix: 'parent' | 'descendants',\n  opts: OrgHierarchyHttpOptions,\n): { client: InternalHttpClient; path: string; headers: Record<string, string> } {\n  const client = new InternalHttpClient(opts.service);\n  const path = `/organization/${encodeURIComponent(orgId)}/${suffix}`;\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      orgId: opts.authOrgId ?? orgId,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  return { client, path, headers };\n}\n\n/**\n * Resolve an org's direct parent id via platform's\n * `GET /organization/:id/parent`. Returns `undefined` for a root org. A non-2xx\n * response resolves to `undefined` by default, or THROWS when\n * `throwOnHttpError` is set. Always throws on a transport failure\n * (connection/timeout) so the caller can apply its own fallback.\n */\nexport async function fetchParentOrgId(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'parent', opts);\n  const res = await client.get<{ data?: { parentOrgId?: string | null } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) {\n    if (opts.throwOnHttpError) {\n      throw new Error(`parent-org lookup failed for ${orgId}: HTTP ${res.statusCode}`);\n    }\n    return undefined;\n  }\n  return res.body?.data?.parentOrgId ?? undefined;\n}\n\n/**\n * Resolve `[self, ...descendantOrgIds]` for an org via platform's\n * `GET /organization/:id/descendants`. Returns the id list only when it is\n * larger than the org itself (a real subtree), else `undefined`; also\n * `undefined` on a non-2xx response. Throws on a transport failure so the\n * caller can apply its own fallback.\n *\n * This is a trust boundary: the response is validated element-by-element rather\n * than cast — every entry must be a string, and any non-string is dropped — so\n * a malformed payload can never smuggle a non-string into the returned\n * `string[]`.\n */\nexport async function fetchOrgDescendants(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string[] | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'descendants', opts);\n  const res = await client.get<{ data?: { orgIds?: unknown } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  const ids = res.body?.data?.orgIds;\n  if (!Array.isArray(ids)) return undefined;\n  const orgIds = ids.filter((id): id is string => typeof id === 'string');\n  // Only meaningful when the (validated) subtree is larger than the org itself.\n  return orgIds.length > 1 ? orgIds : undefined;\n}\n\n/**\n * Check whether `userId` is an ACTIVE member of `orgId` via platform's\n * `GET /organization/:id/members/:userId/exists`. Returns the boolean the\n * platform reports.\n *\n * Returns `undefined` (— \"couldn't determine\") on a non-2xx response, and\n * throws only on a transport failure (connection/timeout) — so the caller\n * distinguishes a definitive not-a-member (`false`) from an indeterminate\n * lookup (`undefined`) and applies its own fail-open/closed policy. The `path`\n * differs from the parent/descendants shape, so this builds its own request.\n */\nexport async function fetchOrgMembership(\n  orgId: string,\n  userId: string,\n  opts: OrgHierarchyHttpOptions,\n): Promise<boolean | undefined> {\n  const client = new InternalHttpClient(opts.service);\n  const path = `/organization/${encodeURIComponent(orgId)}/members/${encodeURIComponent(userId)}/exists`;\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      orgId: opts.authOrgId ?? orgId,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  const res = await client.get<{ data?: { isMember?: unknown } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  const isMember = res.body?.data?.isMember;\n  return typeof isMember === 'boolean' ? isMember : undefined;\n}\n"]}

package/lib/helpers/sse-helpers.d.ts

@@ -1,4 +1,11 @@
 import type { Request, Response } from 'express';
+/**
+ * Set the four standard SSE response headers (does NOT flush — the caller flushes
+ * after any additional per-endpoint setup like `res.setTimeout`). The single
+ * source of truth for the `text/event-stream` + no-cache + keep-alive +
+ * `X-Accel-Buffering: no` (disable nginx buffering) block.
+ */
+export declare function writeSseHeaders(res: Response): void;
 /**
  * Set SSE response headers and flush.
  * Returns an `aborted()` function to check if the client disconnected.

package/lib/helpers/sse-helpers.js

@@ -2,14 +2,23 @@
 // SPDX-License-Identifier: Apache-2.0
 import { sendBadRequest, sendInternalError } from '../utils/response.js';
 /**
- * Set SSE response headers and flush.
- * Returns an `aborted()` function to check if the client disconnected.
+ * Set the four standard SSE response headers (does NOT flush — the caller flushes
+ * after any additional per-endpoint setup like `res.setTimeout`). The single
+ * source of truth for the `text/event-stream` + no-cache + keep-alive +
+ * `X-Accel-Buffering: no` (disable nginx buffering) block.
  */
-export function initSSEStream(req, res, timeoutMs) {
+export function writeSseHeaders(res) {
     res.setHeader('Content-Type', 'text/event-stream');
     res.setHeader('Cache-Control', 'no-cache');
     res.setHeader('Connection', 'keep-alive');
     res.setHeader('X-Accel-Buffering', 'no');
+}
+/**
+ * Set SSE response headers and flush.
+ * Returns an `aborted()` function to check if the client disconnected.
+ */
+export function initSSEStream(req, res, timeoutMs) {
+    writeSseHeaders(res);
     res.setTimeout(timeoutMs);
     res.flushHeaders();
     let _aborted = false;
@@ -33,4 +42,4 @@ export function handleAIError(res, message, fallbackMessage) {
     res.write(`data: ${JSON.stringify({ type: 'error', message })}\n\n`);
     res.end();
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/middleware/step-up.js

@@ -1,6 +1,7 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import jwt from 'jsonwebtoken';
+import { isServicePrincipal } from './auth.js';
 import { createEnvRedisClient } from '../services/env-redis.js';
 import { getHeaderString } from '../utils/headers.js';
 import { createLogger } from '../utils/logger.js';
@@ -87,6 +88,18 @@ export async function consumeStepUpJti(jti, expEpochSeconds) {
  * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).
  */
 export async function requireStepUp(req, res, next) {
+    // Verified internal service principals are EXEMPT: step-up is a re-verify-the-
+    // HUMAN gate (they replay a password-reverify token), which a service token
+    // structurally cannot produce. Services already bypass `requirePermission` on
+    // the same trust basis (a signed service JWT), and internal callers of a
+    // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`
+    // or the billing→quota entitlement sync — would otherwise be hard-blocked.
+    // Safe: a service token can only be minted with `JWT_SECRET`, so this can't be
+    // spoofed by an external client to skip step-up.
+    if (isServicePrincipal(req)) {
+        next();
+        return;
+    }
     const callerSub = req.user?.sub;
     if (!callerSub) {
         sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');
@@ -122,4 +135,4 @@ export async function requireStepUp(req, res, next) {
     }
     next();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the\n * stateless api services, mirroring the platform middleware of the same name.\n *\n * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user's\n * password; platform mints a short-lived (60s) `step-up` JWT signed with the\n * SAME `JWT_SECRET` these services already verify access tokens with. The UI\n * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;\n * this middleware verifies it, binds it to the caller (`sub` match), and\n * consumes its `jti` once (Redis-backed cross-instance when configured, else a\n * bounded process-local set) so a replay inside the TTL is rejected.\n *\n * WHY here: restore endpoints on the api services (pipeline/plugin/...) are\n * step-up-gated, but step-up previously lived only in `platform`. This ports the\n * verify + single-use jti into api-core so any service can require it.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { createEnvRedisClient } from '../services/env-redis.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('step-up');\nconst HEADER = 'x-step-up-token';\n\n/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */\nexport interface StepUpTokenPayload {\n  type: 'step-up';\n  sub: string;\n  jti: string;\n  iat: number;\n  exp: number;\n}\n\nfunction jwtAlgorithm(): jwt.Algorithm {\n  return (process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm;\n}\n\n/**\n * Verify a step-up token: valid signature (primary `JWT_SECRET`, or\n * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, AND the\n * `type: 'step-up'` + `jti` claims — a plain access token shares the secret and\n * `sub`, so without asserting the step-up shape it would bypass the gate.\n * Throws on any failure. Does NOT bind to a caller — `requireStepUp` does the\n * `sub` match and single-use consume.\n */\nexport function verifyStepUpToken(token: string): StepUpTokenPayload {\n  const secret = process.env.JWT_SECRET;\n  if (!secret) throw new Error('JWT_SECRET environment variable is required');\n  const opts: jwt.VerifyOptions = { algorithms: [jwtAlgorithm()] };\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = jwt.verify(token, secret, opts) as StepUpTokenPayload;\n  } catch (primaryErr) {\n    const previous = process.env.JWT_SECRET_PREVIOUS;\n    if (!previous) throw primaryErr;\n    payload = jwt.verify(token, previous, opts) as StepUpTokenPayload;\n  }\n\n  if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {\n    throw new Error('INVALID_STEP_UP_TOKEN');\n  }\n  return payload;\n}\n\n// -- Single-use jti store -----------------------------------------------------\n// Redis SET NX EX when Redis is configured (cross-instance single-use); else a\n// bounded process-local map with TTL sweep (per-process). A step-up token is\n// 60s-lived. When Redis IS configured it's the authoritative store: a Redis\n// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than\n// degrading to the per-instance mem guard, which would accept a cross-instance\n// replay during the outage. The mem guard is used ONLY when Redis is absent.\n\nlet _redis: { set: (...args: unknown[]) => Promise<unknown> } | null | undefined;\nfunction redis(): { set: (...args: unknown[]) => Promise<unknown> } | null {\n  if (_redis === undefined) {\n    _redis = createEnvRedisClient<{ set: (...args: unknown[]) => Promise<unknown> }>('step-up-jti');\n  }\n  return _redis;\n}\n\nconst memJti = new Map<string, number>(); // jti -> expiry epoch ms\nconst memSweep = setInterval(() => {\n  const now = Date.now();\n  for (const [jti, exp] of memJti) if (exp <= now) memJti.delete(jti);\n}, 30_000);\nmemSweep.unref?.();\n\n/**\n * Consume a step-up `jti` exactly once. Returns true if this call claimed it\n * (first use), false if it was already consumed (replay). `expEpochSeconds` is\n * the token's `exp`, so the marker auto-expires with the token.\n */\nexport async function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean> {\n  const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));\n  const client = redis();\n  if (client) {\n    // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'\n    // when newly set, null when already consumed. A thrown Redis error is NOT\n    // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)\n    // instead of silently degrading to the per-instance mem guard.\n    const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n    return res === 'OK';\n  }\n  // No Redis ⇒ single-instance deployment; the process-local map IS the store.\n  if (memJti.has(jti)) return false;\n  memJti.set(jti, Date.now() + ttlSeconds * 1000);\n  return true;\n}\n\n/**\n * Express middleware: require a valid, caller-bound, single-use step-up token in\n * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).\n */\nexport async function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void> {\n  const callerSub = (req as Request & { user?: { sub?: string } }).user?.sub;\n  if (!callerSub) {\n    sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');\n    return;\n  }\n\n  const token = getHeaderString(req.headers[HEADER]);\n  if (!token) {\n    sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');\n    return;\n  }\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = verifyStepUpToken(token);\n  } catch {\n    sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');\n    return;\n  }\n\n  if (payload.sub !== callerSub) {\n    sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');\n    return;\n  }\n\n  try {\n    if (!(await consumeStepUpJti(payload.jti, payload.exp))) {\n      sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');\n      return;\n    }\n  } catch (err) {\n    logger.error('Step-up jti consume errored', { error: String(err) });\n    sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');\n    return;\n  }\n\n  next();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the\n * stateless api services, mirroring the platform middleware of the same name.\n *\n * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user's\n * password; platform mints a short-lived (60s) `step-up` JWT signed with the\n * SAME `JWT_SECRET` these services already verify access tokens with. The UI\n * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;\n * this middleware verifies it, binds it to the caller (`sub` match), and\n * consumes its `jti` once (Redis-backed cross-instance when configured, else a\n * bounded process-local set) so a replay inside the TTL is rejected.\n *\n * WHY here: restore endpoints on the api services (pipeline/plugin/...) are\n * step-up-gated, but step-up previously lived only in `platform`. This ports the\n * verify + single-use jti into api-core so any service can require it.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { isServicePrincipal } from './auth.js';\nimport { createEnvRedisClient } from '../services/env-redis.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('step-up');\nconst HEADER = 'x-step-up-token';\n\n/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */\nexport interface StepUpTokenPayload {\n  type: 'step-up';\n  sub: string;\n  jti: string;\n  iat: number;\n  exp: number;\n}\n\nfunction jwtAlgorithm(): jwt.Algorithm {\n  return (process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm;\n}\n\n/**\n * Verify a step-up token: valid signature (primary `JWT_SECRET`, or\n * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, AND the\n * `type: 'step-up'` + `jti` claims — a plain access token shares the secret and\n * `sub`, so without asserting the step-up shape it would bypass the gate.\n * Throws on any failure. Does NOT bind to a caller — `requireStepUp` does the\n * `sub` match and single-use consume.\n */\nexport function verifyStepUpToken(token: string): StepUpTokenPayload {\n  const secret = process.env.JWT_SECRET;\n  if (!secret) throw new Error('JWT_SECRET environment variable is required');\n  const opts: jwt.VerifyOptions = { algorithms: [jwtAlgorithm()] };\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = jwt.verify(token, secret, opts) as StepUpTokenPayload;\n  } catch (primaryErr) {\n    const previous = process.env.JWT_SECRET_PREVIOUS;\n    if (!previous) throw primaryErr;\n    payload = jwt.verify(token, previous, opts) as StepUpTokenPayload;\n  }\n\n  if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {\n    throw new Error('INVALID_STEP_UP_TOKEN');\n  }\n  return payload;\n}\n\n// -- Single-use jti store -----------------------------------------------------\n// Redis SET NX EX when Redis is configured (cross-instance single-use); else a\n// bounded process-local map with TTL sweep (per-process). A step-up token is\n// 60s-lived. When Redis IS configured it's the authoritative store: a Redis\n// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than\n// degrading to the per-instance mem guard, which would accept a cross-instance\n// replay during the outage. The mem guard is used ONLY when Redis is absent.\n\nlet _redis: { set: (...args: unknown[]) => Promise<unknown> } | null | undefined;\nfunction redis(): { set: (...args: unknown[]) => Promise<unknown> } | null {\n  if (_redis === undefined) {\n    _redis = createEnvRedisClient<{ set: (...args: unknown[]) => Promise<unknown> }>('step-up-jti');\n  }\n  return _redis;\n}\n\nconst memJti = new Map<string, number>(); // jti -> expiry epoch ms\nconst memSweep = setInterval(() => {\n  const now = Date.now();\n  for (const [jti, exp] of memJti) if (exp <= now) memJti.delete(jti);\n}, 30_000);\nmemSweep.unref?.();\n\n/**\n * Consume a step-up `jti` exactly once. Returns true if this call claimed it\n * (first use), false if it was already consumed (replay). `expEpochSeconds` is\n * the token's `exp`, so the marker auto-expires with the token.\n */\nexport async function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean> {\n  const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));\n  const client = redis();\n  if (client) {\n    // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'\n    // when newly set, null when already consumed. A thrown Redis error is NOT\n    // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)\n    // instead of silently degrading to the per-instance mem guard.\n    const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n    return res === 'OK';\n  }\n  // No Redis ⇒ single-instance deployment; the process-local map IS the store.\n  if (memJti.has(jti)) return false;\n  memJti.set(jti, Date.now() + ttlSeconds * 1000);\n  return true;\n}\n\n/**\n * Express middleware: require a valid, caller-bound, single-use step-up token in\n * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).\n */\nexport async function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void> {\n  // Verified internal service principals are EXEMPT: step-up is a re-verify-the-\n  // HUMAN gate (they replay a password-reverify token), which a service token\n  // structurally cannot produce. Services already bypass `requirePermission` on\n  // the same trust basis (a signed service JWT), and internal callers of a\n  // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`\n  // or the billing→quota entitlement sync — would otherwise be hard-blocked.\n  // Safe: a service token can only be minted with `JWT_SECRET`, so this can't be\n  // spoofed by an external client to skip step-up.\n  if (isServicePrincipal(req)) {\n    next();\n    return;\n  }\n\n  const callerSub = (req as Request & { user?: { sub?: string } }).user?.sub;\n  if (!callerSub) {\n    sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');\n    return;\n  }\n\n  const token = getHeaderString(req.headers[HEADER]);\n  if (!token) {\n    sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');\n    return;\n  }\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = verifyStepUpToken(token);\n  } catch {\n    sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');\n    return;\n  }\n\n  if (payload.sub !== callerSub) {\n    sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');\n    return;\n  }\n\n  try {\n    if (!(await consumeStepUpJti(payload.jti, payload.exp))) {\n      sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');\n      return;\n    }\n  } catch (err) {\n    logger.error('Step-up jti consume errored', { error: String(err) });\n    sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');\n    return;\n  }\n\n  next();\n}\n"]}

package/lib/services/compliance-client.js

@@ -95,51 +95,34 @@ export function createComplianceClient(config) {
         }
         return response.body.data;
     }
+    // Shared body for all four validate/dry-run calls: POST → unwrap, and on a
+    // transport/HTTP failure either return a fail-open bypass result (when
+    // COMPLIANCE_BYPASS) or rethrow. The four methods differ ONLY in path, request
+    // body, op label, and bypass context.
+    async function runValidation(orgId, authHeader, path, body, op, bypassCtx) {
+        try {
+            const response = await client.post(path, body, validateOptions(orgId, authHeader));
+            return unwrap(response, op);
+        }
+        catch (error) {
+            if (COMPLIANCE_BYPASS)
+                return bypassResult(bypassCtx);
+            throw error;
+        }
+    }
     return {
-        async validatePlugin(orgId, attributes, authHeader, entityId, entityName, action) {
-            try {
-                const response = await client.post('/compliance/validate/plugin', { attributes, entityId, entityName, action: action ?? 'upload' }, validateOptions(orgId, authHeader));
-                return unwrap(response, 'validatePlugin');
-            }
-            catch (error) {
-                if (COMPLIANCE_BYPASS)
-                    return bypassResult({ orgId, entityType: 'plugin', entityId, entityName });
-                throw error;
-            }
+        validatePlugin(orgId, attributes, authHeader, entityId, entityName, action) {
+            return runValidation(orgId, authHeader, '/compliance/validate/plugin', { attributes, entityId, entityName, action: action ?? 'upload' }, 'validatePlugin', { orgId, entityType: 'plugin', entityId, entityName });
         },
-        async validatePipeline(orgId, attributes, authHeader, entityId, entityName, action) {
-            try {
-                const response = await client.post('/compliance/validate/pipeline', { attributes, entityId, entityName, action: action ?? 'create' }, validateOptions(orgId, authHeader));
-                return unwrap(response, 'validatePipeline');
-            }
-            catch (error) {
-                if (COMPLIANCE_BYPASS)
-                    return bypassResult({ orgId, entityType: 'pipeline', entityId, entityName });
-                throw error;
-            }
+        validatePipeline(orgId, attributes, authHeader, entityId, entityName, action) {
+            return runValidation(orgId, authHeader, '/compliance/validate/pipeline', { attributes, entityId, entityName, action: action ?? 'create' }, 'validatePipeline', { orgId, entityType: 'pipeline', entityId, entityName });
         },
-        async dryRunPlugin(orgId, attributes, authHeader) {
-            try {
-                const response = await client.post('/compliance/validate/plugin/dry-run', { attributes }, validateOptions(orgId, authHeader));
-                return unwrap(response, 'dryRunPlugin');
-            }
-            catch (error) {
-                if (COMPLIANCE_BYPASS)
-                    return bypassResult({ orgId, entityType: 'plugin', dryRun: true });
-                throw error;
-            }
+        dryRunPlugin(orgId, attributes, authHeader) {
+            return runValidation(orgId, authHeader, '/compliance/validate/plugin/dry-run', { attributes }, 'dryRunPlugin', { orgId, entityType: 'plugin', dryRun: true });
         },
-        async dryRunPipeline(orgId, attributes, authHeader) {
-            try {
-                const response = await client.post('/compliance/validate/pipeline/dry-run', { attributes }, validateOptions(orgId, authHeader));
-                return unwrap(response, 'dryRunPipeline');
-            }
-            catch (error) {
-                if (COMPLIANCE_BYPASS)
-                    return bypassResult({ orgId, entityType: 'pipeline', dryRun: true });
-                throw error;
-            }
+        dryRunPipeline(orgId, attributes, authHeader) {
+            return runValidation(orgId, authHeader, '/compliance/validate/pipeline/dry-run', { attributes }, 'dryRunPipeline', { orgId, entityType: 'pipeline', dryRun: true });
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compliance-client.js","sourceRoot":"","sources":["../../src/services/compliance-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { InternalHttpClient, type RequestOptions } from './http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('compliance-client');\n\n/**\n * When true, compliance checks are bypassed if the service is unavailable\n * (fail-open). Default is fail-closed (errors propagate and block the operation).\n */\nconst COMPLIANCE_BYPASS = process.env.COMPLIANCE_BYPASS === 'true';\n\n/**\n * Per-attempt timeout for a validation POST (env: `COMPLIANCE_VALIDATE_TIMEOUT_MS`).\n * Deliberately TIGHTER than the 5s client default so the enforced retries (below)\n * fit inside a bounded total budget rather than stacking three 5s stalls onto a\n * single interactive request.\n */\nconst VALIDATE_TIMEOUT_MS = parseInt(process.env.COMPLIANCE_VALIDATE_TIMEOUT_MS ?? '4000', 10);\n\n/**\n * Result of a compliance validation check.\n */\nexport interface ComplianceCheckResult {\n  passed: boolean;\n  violations: ComplianceViolation[];\n  warnings: ComplianceViolation[];\n  blocked: boolean;\n  rulesEvaluated: number;\n  rulesSkipped: number;\n  exemptionsApplied: string[];\n}\n\nexport interface ComplianceViolation {\n  ruleId: string;\n  ruleName: string;\n  policyId?: string | null;\n  field: string;\n  operator: string;\n  expectedValue: unknown;\n  actualValue: unknown;\n  severity: string;\n  message: string;\n}\n\n/**\n * Compliance service client interface.\n * Uses fail-closed design: errors propagate to block the operation.\n */\nexport interface ComplianceClient {\n  /** Validate plugin attributes against org rules. Throws on service error (fail-closed). */\n  validatePlugin(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Validate pipeline attributes against org rules. Throws on service error (fail-closed). */\n  validatePipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for plugin (no audit, no notification). */\n  dryRunPlugin(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for pipeline (no audit, no notification). */\n  dryRunPipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n}\n\n/**\n * Return a pass-through result when COMPLIANCE_BYPASS is enabled and the\n * compliance service is unreachable.\n */\nfunction bypassResult(context: Record<string, unknown>): ComplianceCheckResult {\n  logger.warn('COMPLIANCE_BYPASS: Service unavailable, allowing request', context);\n  return {\n    passed: true,\n    blocked: false,\n    violations: [],\n    warnings: [{ ruleId: '', ruleName: '', field: '', operator: '', expectedValue: null, actualValue: null, severity: 'warning', message: 'Compliance check skipped (service unavailable)' }],\n    rulesEvaluated: 0,\n    rulesSkipped: 0,\n    exemptionsApplied: [],\n  };\n}\n\n/**\n * Build common request headers for compliance calls.\n */\nfunction buildHeaders(orgId: string, authHeader: string): Record<string, string> {\n  const headers: Record<string, string> = {\n    'x-org-id': orgId,\n  };\n  // NOTE: the old `x-internal-service: true` header was removed — it is trusted\n  // by nothing (it was spoofable); compliance routes authenticate the caller via\n  // the `Authorization` service JWT (`requireServicePrincipal`).\n  if (authHeader) headers.Authorization = authHeader;\n  return headers;\n}\n\n/**\n * Request options for a compliance validation POST.\n *\n * These calls are side-effect-free (they evaluate rules and return a verdict;\n * any audit/notification the compliance service writes is derived, not a mutation\n * the caller depends on being once-only), so they are marked `idempotent: true`.\n * That lets the HTTP client auto-retry a transient 503 / connection reset /\n * timeout instead of surfacing it as a hard failure — which, under the\n * fail-closed default, would wrongly REJECT a legitimate plugin upload / pipeline\n * create just because compliance briefly stalled. Paired with the tighter\n * per-attempt timeout so the retries stay within a bounded total budget.\n */\nfunction validateOptions(orgId: string, authHeader: string): RequestOptions {\n  return {\n    headers: buildHeaders(orgId, authHeader),\n    idempotent: true,\n    timeout: VALIDATE_TIMEOUT_MS,\n  };\n}\n\n/**\n * Create a compliance client.\n *\n * IMPORTANT: This client is fail-closed — if the compliance service is\n * unreachable or returns an error, the error propagates and the calling\n * operation (plugin upload, pipeline create) is rejected.\n */\nexport function createComplianceClient(config?: Partial<ServiceConfig>): ComplianceClient {\n  const serviceConfig: ServiceConfig = {\n    host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',\n    port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),\n  };\n\n  const client = new InternalHttpClient(serviceConfig);\n\n  /**\n   * Validate response shape + status. The HTTP client doesn't throw on non-2xx\n   * (it just returns the body), so without this an auth failure / route miss\n   * silently produced `response.body.data === undefined` and the caller\n   * crashed on `.blocked`. Now non-2xx surfaces as a thrown error that the\n   * outer try/catch can turn into either fail-closed (default) or\n   * COMPLIANCE_BYPASS (fail-open).\n   */\n  function unwrap(\n    response: { statusCode: number; body: { success?: boolean; data?: ComplianceCheckResult; message?: string } },\n    op: string,\n  ): ComplianceCheckResult {\n    if (response.statusCode < 200 || response.statusCode >= 300) {\n      const msg = response.body?.message ?? `HTTP ${response.statusCode}`;\n      throw new Error(`compliance ${op} failed: ${msg}`);\n    }\n    if (!response.body?.data) {\n      throw new Error(`compliance ${op} returned no data (status ${response.statusCode})`);\n    }\n    return response.body.data;\n  }\n\n  return {\n    async validatePlugin(orgId, attributes, authHeader, entityId, entityName, action) {\n      try {\n        const response = await client.post<{ success: boolean; data: ComplianceCheckResult; message?: string }>(\n          '/compliance/validate/plugin',\n          { attributes, entityId, entityName, action: action ?? 'upload' },\n          validateOptions(orgId, authHeader),\n        );\n        return unwrap(response, 'validatePlugin');\n      } catch (error) {\n        if (COMPLIANCE_BYPASS) return bypassResult({ orgId, entityType: 'plugin', entityId, entityName });\n        throw error;\n      }\n    },\n\n    async validatePipeline(orgId, attributes, authHeader, entityId, entityName, action) {\n      try {\n        const response = await client.post<{ success: boolean; data: ComplianceCheckResult; message?: string }>(\n          '/compliance/validate/pipeline',\n          { attributes, entityId, entityName, action: action ?? 'create' },\n          validateOptions(orgId, authHeader),\n        );\n        return unwrap(response, 'validatePipeline');\n      } catch (error) {\n        if (COMPLIANCE_BYPASS) return bypassResult({ orgId, entityType: 'pipeline', entityId, entityName });\n        throw error;\n      }\n    },\n\n    async dryRunPlugin(orgId, attributes, authHeader) {\n      try {\n        const response = await client.post<{ success: boolean; data: ComplianceCheckResult; message?: string }>(\n          '/compliance/validate/plugin/dry-run',\n          { attributes },\n          validateOptions(orgId, authHeader),\n        );\n        return unwrap(response, 'dryRunPlugin');\n      } catch (error) {\n        if (COMPLIANCE_BYPASS) return bypassResult({ orgId, entityType: 'plugin', dryRun: true });\n        throw error;\n      }\n    },\n\n    async dryRunPipeline(orgId, attributes, authHeader) {\n      try {\n        const response = await client.post<{ success: boolean; data: ComplianceCheckResult; message?: string }>(\n          '/compliance/validate/pipeline/dry-run',\n          { attributes },\n          validateOptions(orgId, authHeader),\n        );\n        return unwrap(response, 'dryRunPipeline');\n      } catch (error) {\n        if (COMPLIANCE_BYPASS) return bypassResult({ orgId, entityType: 'pipeline', dryRun: true });\n        throw error;\n      }\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compliance-client.js","sourceRoot":"","sources":["../../src/services/compliance-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { InternalHttpClient, type RequestOptions } from './http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('compliance-client');\n\n/**\n * When true, compliance checks are bypassed if the service is unavailable\n * (fail-open). Default is fail-closed (errors propagate and block the operation).\n */\nconst COMPLIANCE_BYPASS = process.env.COMPLIANCE_BYPASS === 'true';\n\n/**\n * Per-attempt timeout for a validation POST (env: `COMPLIANCE_VALIDATE_TIMEOUT_MS`).\n * Deliberately TIGHTER than the 5s client default so the enforced retries (below)\n * fit inside a bounded total budget rather than stacking three 5s stalls onto a\n * single interactive request.\n */\nconst VALIDATE_TIMEOUT_MS = parseInt(process.env.COMPLIANCE_VALIDATE_TIMEOUT_MS ?? '4000', 10);\n\n/**\n * Result of a compliance validation check.\n */\nexport interface ComplianceCheckResult {\n  passed: boolean;\n  violations: ComplianceViolation[];\n  warnings: ComplianceViolation[];\n  blocked: boolean;\n  rulesEvaluated: number;\n  rulesSkipped: number;\n  exemptionsApplied: string[];\n}\n\nexport interface ComplianceViolation {\n  ruleId: string;\n  ruleName: string;\n  policyId?: string | null;\n  field: string;\n  operator: string;\n  expectedValue: unknown;\n  actualValue: unknown;\n  severity: string;\n  message: string;\n}\n\n/**\n * Compliance service client interface.\n * Uses fail-closed design: errors propagate to block the operation.\n */\nexport interface ComplianceClient {\n  /** Validate plugin attributes against org rules. Throws on service error (fail-closed). */\n  validatePlugin(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Validate pipeline attributes against org rules. Throws on service error (fail-closed). */\n  validatePipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for plugin (no audit, no notification). */\n  dryRunPlugin(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for pipeline (no audit, no notification). */\n  dryRunPipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n}\n\n/**\n * Return a pass-through result when COMPLIANCE_BYPASS is enabled and the\n * compliance service is unreachable.\n */\nfunction bypassResult(context: Record<string, unknown>): ComplianceCheckResult {\n  logger.warn('COMPLIANCE_BYPASS: Service unavailable, allowing request', context);\n  return {\n    passed: true,\n    blocked: false,\n    violations: [],\n    warnings: [{ ruleId: '', ruleName: '', field: '', operator: '', expectedValue: null, actualValue: null, severity: 'warning', message: 'Compliance check skipped (service unavailable)' }],\n    rulesEvaluated: 0,\n    rulesSkipped: 0,\n    exemptionsApplied: [],\n  };\n}\n\n/**\n * Build common request headers for compliance calls.\n */\nfunction buildHeaders(orgId: string, authHeader: string): Record<string, string> {\n  const headers: Record<string, string> = {\n    'x-org-id': orgId,\n  };\n  // NOTE: the old `x-internal-service: true` header was removed — it is trusted\n  // by nothing (it was spoofable); compliance routes authenticate the caller via\n  // the `Authorization` service JWT (`requireServicePrincipal`).\n  if (authHeader) headers.Authorization = authHeader;\n  return headers;\n}\n\n/**\n * Request options for a compliance validation POST.\n *\n * These calls are side-effect-free (they evaluate rules and return a verdict;\n * any audit/notification the compliance service writes is derived, not a mutation\n * the caller depends on being once-only), so they are marked `idempotent: true`.\n * That lets the HTTP client auto-retry a transient 503 / connection reset /\n * timeout instead of surfacing it as a hard failure — which, under the\n * fail-closed default, would wrongly REJECT a legitimate plugin upload / pipeline\n * create just because compliance briefly stalled. Paired with the tighter\n * per-attempt timeout so the retries stay within a bounded total budget.\n */\nfunction validateOptions(orgId: string, authHeader: string): RequestOptions {\n  return {\n    headers: buildHeaders(orgId, authHeader),\n    idempotent: true,\n    timeout: VALIDATE_TIMEOUT_MS,\n  };\n}\n\n/**\n * Create a compliance client.\n *\n * IMPORTANT: This client is fail-closed — if the compliance service is\n * unreachable or returns an error, the error propagates and the calling\n * operation (plugin upload, pipeline create) is rejected.\n */\nexport function createComplianceClient(config?: Partial<ServiceConfig>): ComplianceClient {\n  const serviceConfig: ServiceConfig = {\n    host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',\n    port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),\n  };\n\n  const client = new InternalHttpClient(serviceConfig);\n\n  /**\n   * Validate response shape + status. The HTTP client doesn't throw on non-2xx\n   * (it just returns the body), so without this an auth failure / route miss\n   * silently produced `response.body.data === undefined` and the caller\n   * crashed on `.blocked`. Now non-2xx surfaces as a thrown error that the\n   * outer try/catch can turn into either fail-closed (default) or\n   * COMPLIANCE_BYPASS (fail-open).\n   */\n  function unwrap(\n    response: { statusCode: number; body: { success?: boolean; data?: ComplianceCheckResult; message?: string } },\n    op: string,\n  ): ComplianceCheckResult {\n    if (response.statusCode < 200 || response.statusCode >= 300) {\n      const msg = response.body?.message ?? `HTTP ${response.statusCode}`;\n      throw new Error(`compliance ${op} failed: ${msg}`);\n    }\n    if (!response.body?.data) {\n      throw new Error(`compliance ${op} returned no data (status ${response.statusCode})`);\n    }\n    return response.body.data;\n  }\n\n  // Shared body for all four validate/dry-run calls: POST → unwrap, and on a\n  // transport/HTTP failure either return a fail-open bypass result (when\n  // COMPLIANCE_BYPASS) or rethrow. The four methods differ ONLY in path, request\n  // body, op label, and bypass context.\n  async function runValidation(\n    orgId: string,\n    authHeader: string,\n    path: string,\n    body: Record<string, unknown>,\n    op: string,\n    bypassCtx: Record<string, unknown>,\n  ): Promise<ComplianceCheckResult> {\n    try {\n      const response = await client.post<{ success: boolean; data: ComplianceCheckResult; message?: string }>(\n        path, body, validateOptions(orgId, authHeader),\n      );\n      return unwrap(response, op);\n    } catch (error) {\n      if (COMPLIANCE_BYPASS) return bypassResult(bypassCtx);\n      throw error;\n    }\n  }\n\n  return {\n    validatePlugin(orgId, attributes, authHeader, entityId, entityName, action) {\n      return runValidation(orgId, authHeader, '/compliance/validate/plugin',\n        { attributes, entityId, entityName, action: action ?? 'upload' }, 'validatePlugin',\n        { orgId, entityType: 'plugin', entityId, entityName });\n    },\n\n    validatePipeline(orgId, attributes, authHeader, entityId, entityName, action) {\n      return runValidation(orgId, authHeader, '/compliance/validate/pipeline',\n        { attributes, entityId, entityName, action: action ?? 'create' }, 'validatePipeline',\n        { orgId, entityType: 'pipeline', entityId, entityName });\n    },\n\n    dryRunPlugin(orgId, attributes, authHeader) {\n      return runValidation(orgId, authHeader, '/compliance/validate/plugin/dry-run',\n        { attributes }, 'dryRunPlugin', { orgId, entityType: 'plugin', dryRun: true });\n    },\n\n    dryRunPipeline(orgId, attributes, authHeader) {\n      return runValidation(orgId, authHeader, '/compliance/validate/pipeline/dry-run',\n        { attributes }, 'dryRunPipeline', { orgId, entityType: 'pipeline', dryRun: true });\n    },\n  };\n}\n"]}

package/lib/services/env-redis.d.ts

@@ -1,11 +1,32 @@
+/**
+ * Parse `REDIS_SENTINELS` (comma-separated `host:port` list) into the ioredis
+ * `{ host, port }[]` sentinel array. Blank/garbage entries are skipped; a
+ * missing port defaults to the Sentinel default 26379. Returns an empty array
+ * when the env is unset/empty (→ non-sentinel mode).
+ */
+export declare function parseSentinels(raw: string | undefined): Array<{
+    host: string;
+    port: number;
+}>;
 /**
  * Construct an ioredis client from the standard `REDIS_URL` or
- * `REDIS_HOST`/`REDIS_PORT` env — the shared construction previously duplicated
- * across the leader-lock, audit-spool, and token-revocation env factories.
+ * `REDIS_HOST`/`REDIS_PORT` env — OR, for HA, from Redis Sentinel via
+ * `REDIS_SENTINELS` + `REDIS_SENTINEL_MASTER`. The shared construction was
+ * previously duplicated across the leader-lock, audit-spool, and
+ * token-revocation env factories.
+ *
+ * Connection modes (first that matches wins):
+ * 1. SENTINEL — `REDIS_SENTINELS` set (comma-separated `host:port`): ioredis
+ *    resolves the current master from the sentinels (`name` = `REDIS_SENTINEL_MASTER`,
+ *    default `mymaster`) and transparently reconnects to the new master after a
+ *    failover. This is how the app gets HA against a single-node Redis loss —
+ *    also the shape a managed ElastiCache (cluster-mode-disabled) speaks.
+ * 2. URL — `REDIS_URL`.
+ * 3. HOST/PORT — `REDIS_HOST`(+`REDIS_PORT`).
  *
  * Semantics every caller relies on (kept identical across the consolidation):
- * - Returns `null` when neither `REDIS_URL` nor `REDIS_HOST` is set, so a caller
- *   degrades to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).
+ * - Returns `null` when NONE of sentinels/url/host is set, so a caller degrades
+ *   to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).
  * - FAIL-SAFE: any ioredis load or construction error is swallowed and returns
  *   `null` — Redis being unavailable must never crash the importing service.
  * - `ioredis` is a runtime-only optional dep loaded via `createRequire`, so this
@@ -15,6 +36,9 @@
  * - An `error` listener is attached (ioredis auto-reconnects) so a dropped
  *   connection can't surface as an unhandled `'error'` event that crashes Node.
  *
+ * Optional auth: `REDIS_PASSWORD` (data-node AUTH) and `REDIS_SENTINEL_PASSWORD`
+ * (sentinel AUTH, sentinel mode only) are threaded through when set.
+ *
  * @param label short human name for this client, used in the two warn logs.
  */
 export declare function createEnvRedisClient<T = unknown>(label: string): T | null;

package/lib/services/env-redis.js

@@ -3,14 +3,39 @@
 import { createRequire } from 'module';
 import { createLogger } from '../utils/logger.js';
 const logger = createLogger('env-redis');
+/**
+ * Parse `REDIS_SENTINELS` (comma-separated `host:port` list) into the ioredis
+ * `{ host, port }[]` sentinel array. Blank/garbage entries are skipped; a
+ * missing port defaults to the Sentinel default 26379. Returns an empty array
+ * when the env is unset/empty (→ non-sentinel mode).
+ */
+export function parseSentinels(raw) {
+    if (!raw)
+        return [];
+    return raw.split(',').map((s) => s.trim()).filter(Boolean).map((entry) => {
+        const [host, port] = entry.split(':');
+        return { host, port: parseInt(port ?? '26379', 10) || 26379 };
+    }).filter((s) => !!s.host);
+}
 /**
  * Construct an ioredis client from the standard `REDIS_URL` or
- * `REDIS_HOST`/`REDIS_PORT` env — the shared construction previously duplicated
- * across the leader-lock, audit-spool, and token-revocation env factories.
+ * `REDIS_HOST`/`REDIS_PORT` env — OR, for HA, from Redis Sentinel via
+ * `REDIS_SENTINELS` + `REDIS_SENTINEL_MASTER`. The shared construction was
+ * previously duplicated across the leader-lock, audit-spool, and
+ * token-revocation env factories.
+ *
+ * Connection modes (first that matches wins):
+ * 1. SENTINEL — `REDIS_SENTINELS` set (comma-separated `host:port`): ioredis
+ *    resolves the current master from the sentinels (`name` = `REDIS_SENTINEL_MASTER`,
+ *    default `mymaster`) and transparently reconnects to the new master after a
+ *    failover. This is how the app gets HA against a single-node Redis loss —
+ *    also the shape a managed ElastiCache (cluster-mode-disabled) speaks.
+ * 2. URL — `REDIS_URL`.
+ * 3. HOST/PORT — `REDIS_HOST`(+`REDIS_PORT`).
  *
  * Semantics every caller relies on (kept identical across the consolidation):
- * - Returns `null` when neither `REDIS_URL` nor `REDIS_HOST` is set, so a caller
- *   degrades to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).
+ * - Returns `null` when NONE of sentinels/url/host is set, so a caller degrades
+ *   to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).
  * - FAIL-SAFE: any ioredis load or construction error is swallowed and returns
  *   `null` — Redis being unavailable must never crash the importing service.
  * - `ioredis` is a runtime-only optional dep loaded via `createRequire`, so this
@@ -20,21 +45,43 @@ const logger = createLogger('env-redis');
  * - An `error` listener is attached (ioredis auto-reconnects) so a dropped
  *   connection can't surface as an unhandled `'error'` event that crashes Node.
  *
+ * Optional auth: `REDIS_PASSWORD` (data-node AUTH) and `REDIS_SENTINEL_PASSWORD`
+ * (sentinel AUTH, sentinel mode only) are threaded through when set.
+ *
  * @param label short human name for this client, used in the two warn logs.
  */
 export function createEnvRedisClient(label) {
     try {
+        const sentinels = parseSentinels(process.env.REDIS_SENTINELS);
         const url = process.env.REDIS_URL;
         const host = process.env.REDIS_HOST;
-        if (!url && !host)
+        if (sentinels.length === 0 && !url && !host)
             return null;
         const req = createRequire(import.meta.url);
         const mod = req('ioredis');
         const RedisCtor = (mod.Redis ?? mod.default ?? mod);
         const redisOpts = { maxRetriesPerRequest: 1, enableOfflineQueue: false };
-        const inst = url
-            ? new RedisCtor(url, redisOpts)
-            : new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...redisOpts });
+        if (process.env.REDIS_PASSWORD)
+            redisOpts.password = process.env.REDIS_PASSWORD;
+        let inst;
+        if (sentinels.length > 0) {
+            // Sentinel mode: ioredis tracks the master via the sentinels + auto-fails-over.
+            const sentinelOpts = {
+                sentinels,
+                name: process.env.REDIS_SENTINEL_MASTER || 'mymaster',
+                ...redisOpts,
+            };
+            if (process.env.REDIS_SENTINEL_PASSWORD)
+                sentinelOpts.sentinelPassword = process.env.REDIS_SENTINEL_PASSWORD;
+            inst = new RedisCtor(sentinelOpts);
+            logger.info(`Redis ${label}: Sentinel mode`, { master: sentinelOpts.name, sentinels: sentinels.length });
+        }
+        else if (url) {
+            inst = new RedisCtor(url, redisOpts);
+        }
+        else {
+            inst = new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...redisOpts });
+        }
         inst
             .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));
         return inst;
@@ -44,4 +91,4 @@ export function createEnvRedisClient(label) {
         return null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env-redis.js","sourceRoot":"","sources":["../../src/services/env-redis.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createRequire } from 'module';\n\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('env-redis');\n\n/**\n * Parse `REDIS_SENTINELS` (comma-separated `host:port` list) into the ioredis\n * `{ host, port }[]` sentinel array. Blank/garbage entries are skipped; a\n * missing port defaults to the Sentinel default 26379. Returns an empty array\n * when the env is unset/empty (→ non-sentinel mode).\n */\nexport function parseSentinels(raw: string | undefined): Array<{ host: string; port: number }> {\n  if (!raw) return [];\n  return raw.split(',').map((s) => s.trim()).filter(Boolean).map((entry) => {\n    const [host, port] = entry.split(':');\n    return { host, port: parseInt(port ?? '26379', 10) || 26379 };\n  }).filter((s) => !!s.host);\n}\n\n/**\n * Construct an ioredis client from the standard `REDIS_URL` or\n * `REDIS_HOST`/`REDIS_PORT` env — OR, for HA, from Redis Sentinel via\n * `REDIS_SENTINELS` + `REDIS_SENTINEL_MASTER`. The shared construction was\n * previously duplicated across the leader-lock, audit-spool, and\n * token-revocation env factories.\n *\n * Connection modes (first that matches wins):\n * 1. SENTINEL — `REDIS_SENTINELS` set (comma-separated `host:port`): ioredis\n *    resolves the current master from the sentinels (`name` = `REDIS_SENTINEL_MASTER`,\n *    default `mymaster`) and transparently reconnects to the new master after a\n *    failover. This is how the app gets HA against a single-node Redis loss —\n *    also the shape a managed ElastiCache (cluster-mode-disabled) speaks.\n * 2. URL — `REDIS_URL`.\n * 3. HOST/PORT — `REDIS_HOST`(+`REDIS_PORT`).\n *\n * Semantics every caller relies on (kept identical across the consolidation):\n * - Returns `null` when NONE of sentinels/url/host is set, so a caller degrades\n *   to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).\n * - FAIL-SAFE: any ioredis load or construction error is swallowed and returns\n *   `null` — Redis being unavailable must never crash the importing service.\n * - `ioredis` is a runtime-only optional dep loaded via `createRequire`, so this\n *   module stays importable in CJS bundles and where Redis isn't installed.\n * - `maxRetriesPerRequest: 1` + `enableOfflineQueue: false`: commands fail fast\n *   rather than queueing during an outage (callers are fail-open/best-effort).\n * - An `error` listener is attached (ioredis auto-reconnects) so a dropped\n *   connection can't surface as an unhandled `'error'` event that crashes Node.\n *\n * Optional auth: `REDIS_PASSWORD` (data-node AUTH) and `REDIS_SENTINEL_PASSWORD`\n * (sentinel AUTH, sentinel mode only) are threaded through when set.\n *\n * @param label short human name for this client, used in the two warn logs.\n */\nexport function createEnvRedisClient<T = unknown>(label: string): T | null {\n  try {\n    const sentinels = parseSentinels(process.env.REDIS_SENTINELS);\n    const url = process.env.REDIS_URL;\n    const host = process.env.REDIS_HOST;\n    if (sentinels.length === 0 && !url && !host) return null;\n    const req = createRequire(import.meta.url);\n    const mod = req('ioredis') as {\n      Redis?: new (...args: unknown[]) => unknown;\n      default?: new (...args: unknown[]) => unknown;\n    };\n    const RedisCtor = (mod.Redis ?? mod.default ?? mod) as new (...args: unknown[]) => T;\n    const redisOpts: Record<string, unknown> = { maxRetriesPerRequest: 1, enableOfflineQueue: false };\n    if (process.env.REDIS_PASSWORD) redisOpts.password = process.env.REDIS_PASSWORD;\n\n    let inst: T;\n    if (sentinels.length > 0) {\n      // Sentinel mode: ioredis tracks the master via the sentinels + auto-fails-over.\n      const sentinelOpts: Record<string, unknown> = {\n        sentinels,\n        name: process.env.REDIS_SENTINEL_MASTER || 'mymaster',\n        ...redisOpts,\n      };\n      if (process.env.REDIS_SENTINEL_PASSWORD) sentinelOpts.sentinelPassword = process.env.REDIS_SENTINEL_PASSWORD;\n      inst = new RedisCtor(sentinelOpts);\n      logger.info(`Redis ${label}: Sentinel mode`, { master: sentinelOpts.name, sentinels: sentinels.length });\n    } else if (url) {\n      inst = new RedisCtor(url, redisOpts);\n    } else {\n      inst = new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...redisOpts });\n    }\n    (inst as unknown as { on: (evt: string, cb: (e: unknown) => void) => void })\n      .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));\n    return inst;\n  } catch (err) {\n    logger.warn(`Redis unavailable for ${label}`, { error: err instanceof Error ? err.message : String(err) });\n    return null;\n  }\n}\n"]}

package/lib/services/index.d.ts

@@ -5,10 +5,12 @@ export * from './compliance-client.js';
 export * from './compliance-event-subscriber.js';
 export * from './entity-events.js';
 export * from './http-client.js';
-export { DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY_MS, DEFAULT_MAX_RATE_LIMIT_RETRIES, calculateBackoff, isTransientStatusCode, isRateLimited, getRetryDecision, getErrorRetryDecision, } from './retry-strategy.js';
+export { DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY_MS, DEFAULT_MAX_RATE_LIMIT_RETRIES, calculateBackoff, getRetryDecision, getErrorRetryDecision, } from './retry-strategy.js';
 export type { RetryConfig, RetryDecision } from './retry-strategy.js';
 export * from './quota.js';
 export * from './remote-audit-client.js';
 export * from './audit-spool.js';
 export * from './env-redis.js';
 export * from './token-revocation.js';
+export * from './sse-ticket-store.js';
+export * from './service-boot.js';