@pipeline-builder/api-core 4.1.2 → 4.1.4

package/lib/services/quota.js

@@ -1,24 +1,72 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { createSafeClient } from './http-client.js';
+import { getServiceAuthHeader } from '../middleware/auth.js';
+import { ErrorCode } from '../types/error-codes.js';
 import { DEFAULT_TIER, isValidTier } from '../types/quota-tiers.js';
 import { createLogger } from '../utils/logger.js';
 import { emitCounter } from '../utils/metric-emitter.js';
-/** Retry options for quota calls  fail fast since quota is fail-open. */
+import { sendError, sendQuotaExceeded } from '../utils/response.js';
+/**
+ * Retry options for quota calls — fail fast (a slow quota service must not stall the request).
+ *
+ * NEVER retry a 429. The quota service answers an over-limit org with 429
+ * QUOTA_EXCEEDED and `Retry-After` = seconds until the period resets; the HTTP
+ * client honors that (capped at 60s), so a single rate-limit retry stalled the
+ * request well past the handler timeout, which then answered 503 and the real
+ * 429 was lost. A 429 is a final answer here.
+ */
 const QUOTA_REQUEST_OPTIONS = {
-    maxRateLimitRetries: 1,
+    maxRateLimitRetries: 0,
     maxRetries: 1,
 };
 const logger = createLogger('quota');
-// `reserve` gates EXPENSIVE resources (plugin builds, pipelines). When the
-// quota service is reachable but returns an error (often an OVERLOADED service),
-// failing open would pile unmetered expensive work onto it and bypass quota
-// entirely — the textbook fail-open blow-up. So `reserve` fails CLOSED on an
-// errored response by default. Operators who prefer availability over
-// enforcement can opt back into fail-open with QUOTA_RESERVE_FAIL_OPEN=true.
-// (A genuinely UNREACHABLE service still fails open — that's a confirmed outage,
-// not an overload signal.)
+// RESERVE FAIL MODE — explicit, single policy.
+//
+// `reserve` gates EXPENSIVE, billable resources (pipelines, plugin builds, AI
+// calls, platform feature slots). Every quota type is a per-period FLOW counter
+// with no after-the-fact reconciliation: a unit consumed while the reservation
+// could not be confirmed is never counted, so fail-open lets an org consume
+// unbounded unmetered units for the whole length of an incident — and an
+// unconfirmed reserve (timeout, open circuit) may even have landed server-side.
+// So `reserve` fails CLOSED whenever the quota service did not CONFIRM the slot:
+//   - unreachable / timed out / circuit breaker open (no response),
+//   - a reachable-but-errored response (5xx, 4xx, malformed body),
+//   - a 429 that is NOT a genuine QUOTA_EXCEEDED (gateway / rate limiter).
+// Operators who prefer availability over enforcement opt the WHOLE set into
+// fail-open with QUOTA_RESERVE_FAIL_OPEN=true. Both outcomes emit a counter
+// (`quota_fail_closed_total` / `quota_fail_open_total`) tagged with the reason.
+// `check` (a cheap read gate) stays fail-open; `increment` is fire-and-forget.
 const QUOTA_RESERVE_FAIL_OPEN = process.env.QUOTA_RESERVE_FAIL_OPEN === 'true';
+/**
+ * Service-principal `Authorization` header for a quota call made on behalf of
+ * `orgId` by the CURRENT service (`SERVICE_NAME`, the same identity the health
+ * router reports).
+ *
+ * The quota service's mutation endpoints (`/:orgId/increment`, `/decrement`)
+ * reject anything but a signed service principal or a system admin, so
+ * forwarding the end user's bearer token there is always a 403. Service tokens
+ * are also exempt from the quota service's per-IP rate limiter, so hot-path
+ * quota traffic from a busy pod can't exhaust that pod IP's bucket and silently
+ * turn enforcement off. Scoped to the target org with the lowest role (member).
+ */
+export function getQuotaServiceAuthHeader(orgId) {
+    return getServiceAuthHeader({ serviceName: process.env.SERVICE_NAME || 'api', orgId, role: 'member' });
+}
+/**
+ * Apply the explicit reserve fail-mode policy to a reservation the quota service
+ * did NOT confirm (see QUOTA_RESERVE_FAIL_OPEN above). Default: deny.
+ */
+function unconfirmedReserve(orgId, quotaType, reason, statusCode) {
+    if (QUOTA_RESERVE_FAIL_OPEN) {
+        logger.warn('QUOTA_FAIL_OPEN: quota reserve not confirmed, allowing request', { orgId, quotaType, reason, statusCode });
+        emitCounter('quota_fail_open_total', { operation: 'reserve', reason, quotaType });
+        return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };
+    }
+    logger.warn('QUOTA_FAIL_CLOSED: quota reserve not confirmed, denying request', { orgId, quotaType, reason, statusCode });
+    emitCounter('quota_fail_closed_total', { operation: 'reserve', reason, quotaType });
+    return { exceeded: true, unavailable: true, quota: { type: quotaType, limit: 0, used: 0, remaining: 0 } };
+}
 /**
  * Create a fail-open quota result (allows the request).
  */
@@ -109,48 +157,23 @@ export function createQuotaService(config = {}) {
             // 200 carries `data.quota`; 429 (QUOTA_EXCEEDED) carries `details.quota`.
             // Both shapes are normalized into QuotaReserveResult.
             const response = await client.post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
-            if (!response) {
-                logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable on reserve, allowing request', { orgId, quotaType });
-                emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'unreachable', quotaType });
-                return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };
-            }
+            if (!response)
+                return unconfirmedReserve(orgId, quotaType, 'unreachable');
             if (response.statusCode === 429) {
                 const q = response.body.details?.quota;
                 // Only a GENUINE quota-exceeded 429 means "over quota". A generic 429 —
-                // the quota service's OWN rate limiter (RATE_LIMIT_EXCEEDED) or an
-                // intervening gateway during a spike — must NOT be surfaced as
-                // quota-exceeded: that would falsely block legitimate work behind a
-                // transient rate limit. Require the QUOTA_EXCEEDED error code (or the
-                // quota payload) and otherwise fall through to the non-ok
-                // fail-open/closed policy below (the right handling for a transient 429).
-                if (response.body.errorCode === 'QUOTA_EXCEEDED' || q) {
+                // an intervening gateway or rate limiter — did not confirm anything, so
+                // it goes through the same unconfirmed-reservation policy as an outage.
+                if (response.body.code === ErrorCode.QUOTA_EXCEEDED || q) {
                     return {
                         exceeded: true,
                         quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },
                     };
                 }
-                // A non-QUOTA_EXCEEDED 429 is a TRANSIENT signal (the quota service's own
-                // rate limiter, or a gateway during a spike) — the tenant is NOT over quota,
-                // so fail OPEN (as for an unreachable service) rather than falsely blocking
-                // legitimate work. Do not fall through to the fail-closed non-ok default.
-                logger.warn('QUOTA_FAIL_OPEN: transient 429 on reserve (not quota-exceeded), allowing request', { orgId, quotaType });
-                emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'transient-429', quotaType });
-                return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };
+                return unconfirmedReserve(orgId, quotaType, 'transient-429', response.statusCode);
             }
             if (response.statusCode !== 200 || !response.body.success) {
-                if (QUOTA_RESERVE_FAIL_OPEN) {
-                    logger.warn('QUOTA_FAIL_OPEN: Quota reserve returned non-ok, allowing request', {
-                        orgId, quotaType, statusCode: response.statusCode,
-                    });
-                    emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'non-ok', quotaType });
-                    return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };
-                }
-                // Service reachable but didn't confirm the reservation → fail CLOSED.
-                logger.warn('QUOTA_FAIL_CLOSED: Quota reserve returned non-ok, denying request', {
-                    orgId, quotaType, statusCode: response.statusCode,
-                });
-                emitCounter('quota_fail_closed_total', { operation: 'reserve', reason: 'non-ok', quotaType });
-                return { exceeded: true, quota: { type: quotaType, limit: 0, used: 0, remaining: 0 } };
+                return unconfirmedReserve(orgId, quotaType, 'non-ok', response.statusCode);
             }
             const q = response.body.data?.quota;
             return {
@@ -215,19 +238,21 @@ export function createQuotaService(config = {}) {
     };
 }
 /**
- * Fire-and-forget quota increment with standardized error logging.
+ * Fire-and-forget quota METERING increment with standardized error logging.
  *
- * Wraps `quotaService.increment()` with a `.catch()` that logs a warning.
- * Eliminates the identical one-liner repeated across every read route.
+ * Authenticates as the calling SERVICE ({@link getQuotaServiceAuthHeader}), never
+ * with the end user's token: `/quotas/:orgId/increment` is service-principal /
+ * system-admin only, so a forwarded user JWT was always rejected (403) and the
+ * metered quota (e.g. `apiCalls`, and the `api_pack` bundle raising it) never
+ * moved.
  *
  * @param quotaService - Quota service client
- * @param orgId - Organization ID
+ * @param orgId - Organization ID whose counter is incremented
  * @param quotaType - Quota type to increment
- * @param authHeader - Authorization header value
  * @param logWarn - Logging function for warnings
  */
-export function incrementQuota(quotaService, orgId, quotaType, authHeader, logWarn) {
-    quotaService.increment(orgId, quotaType, authHeader).catch((err) => logWarn('Quota increment failed', { error: err instanceof Error ? err.message : String(err) }));
+export function incrementQuota(quotaService, orgId, quotaType, logWarn) {
+    quotaService.increment(orgId, quotaType, getQuotaServiceAuthHeader(orgId)).catch((err) => logWarn('Quota increment failed', { error: err instanceof Error ? err.message : String(err) }));
 }
 /**
  * Atomic reserve helper for the "reserve + commit / rollback" pattern.
@@ -240,7 +265,7 @@ export function incrementQuota(quotaService, orgId, quotaType, authHeader, logWa
  * @example
  * ```typescript
  * const reservation = await reserveQuota(quotaService, orgId, 'pipelines', authHeader);
- * if (reservation.exceeded) return sendQuotaExceeded(res, 'pipelines', reservation.quota);
+ * if (reservation.exceeded) return sendQuotaReserveDenied(res, 'pipelines', reservation);
  * try {
  * await doExpensiveThing();
  * } catch (err) {
@@ -253,6 +278,25 @@ export function incrementQuota(quotaService, orgId, quotaType, authHeader, logWa
 export function reserveQuota(quotaService, orgId, quotaType, authHeader, amount = 1, requestId) {
     return quotaService.reserve(orgId, quotaType, authHeader, amount, requestId);
 }
+/** Seconds a client should wait before retrying when quota couldn't be confirmed. */
+const QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS = 5;
+/**
+ * Answer a DENIED reservation (`reservation.exceeded === true`).
+ *
+ * - `unavailable` (the quota service couldn't confirm the slot) → **503**
+ *   `SERVICE_UNAVAILABLE` with a short `Retry-After`: the org is not over its
+ *   limit, so a 429 "quota exceeded" would send users to upgrade for an outage.
+ * - otherwise → the standard 429 `QUOTA_EXCEEDED` with the X-Quota-* headers.
+ */
+export function sendQuotaReserveDenied(res, quotaType, reservation) {
+    if (reservation.unavailable) {
+        if (!res.headersSent)
+            res.setHeader('Retry-After', QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS);
+        sendError(res, 503, `Unable to confirm ${quotaType} quota right now. Please try again shortly.`, ErrorCode.SERVICE_UNAVAILABLE);
+        return;
+    }
+    sendQuotaExceeded(res, quotaType, reservation.quota, reservation.quota.resetAt);
+}
 /**
  * Fire-and-forget rollback for a previously reserved quota slot.
  * Logs on failure but never throws  the action that needed the rollback
@@ -261,4 +305,4 @@ export function reserveQuota(quotaService, orgId, quotaType, authHeader, amount
 export function decrementQuota(quotaService, orgId, quotaType, authHeader, logWarn, amount = 1, resetAtSnapshot) {
     quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot).catch((err) => logWarn('Quota rollback failed', { error: err instanceof Error ? err.message : String(err) }));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota.js","sourceRoot":"","sources":["../../src/services/quota.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport type { QuotaType, QuotaCheckResult, ServiceConfig } from '../types/common.js';\nimport { DEFAULT_TIER, isValidTier, type QuotaTier } from '../types/quota-tiers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\n/** Retry options for quota calls  fail fast since quota is fail-open. */\nconst QUOTA_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 1,\n  maxRetries: 1,\n};\n\nconst logger = createLogger('quota');\n\n// `reserve` gates EXPENSIVE resources (plugin builds, pipelines). When the\n// quota service is reachable but returns an error (often an OVERLOADED service),\n// failing open would pile unmetered expensive work onto it and bypass quota\n// entirely — the textbook fail-open blow-up. So `reserve` fails CLOSED on an\n// errored response by default. Operators who prefer availability over\n// enforcement can opt back into fail-open with QUOTA_RESERVE_FAIL_OPEN=true.\n// (A genuinely UNREACHABLE service still fails open — that's a confirmed outage,\n// not an overload signal.)\nconst QUOTA_RESERVE_FAIL_OPEN = process.env.QUOTA_RESERVE_FAIL_OPEN === 'true';\n\n/**\n * Result of a synchronous quota reservation  the atomic check+increment\n * variant. `exceeded: true` means the operation was rejected at the DB\n * level; the caller should return 429 without running the gated action.\n */\nexport interface QuotaReserveResult {\n  exceeded: boolean;\n  quota: {\n    type: QuotaType;\n    limit: number;\n    used: number;\n    remaining: number;\n    resetAt?: string;\n  };\n}\n\n/**\n * Quota service client interface.\n */\nexport interface QuotaService {\n  /** Check if quota is available (fail-open on error). */\n  check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult>;\n  /** Increment quota usage. Returns a promise so callers can optionally handle errors. */\n  increment(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<void>;\n  /**\n   * Atomic reserve  the same atomic check+increment as `increment`, but\n   * parses the response so callers can see whether the slot was actually\n   * reserved. Use this for expensive resources where the post-hoc fire-\n   * and-forget pattern allows concurrent over-spend.\n   *\n   * Fail-open semantics on transport errors: returns `exceeded: false` so\n   * the caller can proceed and the request isn't blocked by quota-service\n   * outages (matches `check()`).\n   */\n  reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<QuotaReserveResult>;\n  /**\n   * Roll back a previously reserved slot. Fire-and-forget — never throws.\n   * Pass `resetAtSnapshot` (the `quota.resetAt` observed when the slot was\n   * reserved) to make the rollback conditional: if the period rolled over\n   * between reserve and rollback, the server skips the decrement so it doesn't\n   * steal capacity from the new period.\n   */\n  decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, resetAtSnapshot?: string, requestId?: string): Promise<void>;\n  /** Update quota limits. Returns true on success. */\n  updateLimits(orgId: string, limits: Partial<Record<QuotaType, number>>, authHeader: string, requestId?: string): Promise<boolean>;\n  /** Reset quota usage. Returns true on success. */\n  reset(orgId: string, quotaType?: QuotaType, authHeader?: string, requestId?: string): Promise<boolean>;\n  /**\n   * Get the org's quota `QuotaTier`. Used by the plugin-build queue partitioning\n   * to route a build to the right per-tier queue. Fail-open returns `DEFAULT_TIER`\n   * (`developer` when billing is enabled, `unlimited` when it's disabled); a\n   * misclassified org still builds on the default queue, just without the\n   * tier-scoped scheduling boost.\n   */\n  getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier>;\n}\n\n/**\n * Configuration for quota service client.\n */\nexport interface QuotaServiceConfig {\n  /** Quota service host (default: env QUOTA_SERVICE_HOST or 'quota') */\n  host?: string;\n  /** Quota service port (default: env QUOTA_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout in milliseconds (default: 5000) */\n  timeout?: number;\n}\n\n/**\n * Create a fail-open quota result (allows the request).\n */\nfunction createFailOpenResult(): QuotaCheckResult {\n  return {\n    allowed: true,\n    limit: -1,\n    used: 0,\n    remaining: -1,\n    resetAt: new Date().toISOString(),\n    unlimited: true,\n    // Tag the sentinel so fail-closed callers can tell an outage apart from a\n    // real unlimited (-1) reading. Real quota results never set this.\n    failOpen: true,\n  };\n}\n\n/**\n * Build common request headers with optional request ID for distributed tracing.\n */\nfunction buildHeaders(orgId: string, authHeader?: string, requestId?: string): Record<string, string> {\n  const headers: Record<string, string> = { 'x-org-id': orgId };\n  if (authHeader) headers.Authorization = authHeader;\n  if (requestId) headers['X-Request-Id'] = requestId;\n  return headers;\n}\n\n/**\n * Create a quota service client.\n *\n * @param config - Optional service configuration\n * @returns Quota service client\n *\n * @example\n * ```typescript\n * const quotaService = createQuotaService();\n *\n * // Check quota before processing\n * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);\n * if (!quota.allowed) {\n * return res.status(429).json({ error: 'Quota exceeded' });\n * }\n *\n * // Increment quota after success\n * quotaService.increment(orgId, 'apiCalls', authHeader).catch(err => logger.warn('Quota increment failed', { error: err }));\n * ```\n */\nexport function createQuotaService(config: QuotaServiceConfig = {}): QuotaService {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? process.env.QUOTA_SERVICE_HOST ?? 'quota',\n    port: config.port ?? parseInt(process.env.QUOTA_SERVICE_PORT ?? '3000', 10),\n    timeout: config.timeout ?? 5000,\n  };\n\n  const client = createSafeClient(serviceConfig);\n\n  return {\n    async check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/${encodeURIComponent(quotaType)}`;\n\n      const response = await client.get<{\n        success: boolean;\n        data?: { quotaType: string; status: QuotaCheckResult };\n        message?: string;\n      }>(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable, allowing request', { orgId, quotaType });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'unreachable', quotaType });\n        return createFailOpenResult();\n      }\n\n      if (response.statusCode !== 200 || !response.body.success || !response.body.data?.status) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota check returned non-ok, allowing request', {\n          orgId, quotaType, statusCode: response.statusCode, message: response.body.message,\n        });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'non-ok', quotaType });\n        return createFailOpenResult();\n      }\n\n      return response.body.data.status;\n    },\n\n    async increment(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n\n      const response = await client\n        .post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to increment quota', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota incremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, requestId?: string): Promise<QuotaReserveResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n\n      // 200 carries `data.quota`; 429 (QUOTA_EXCEEDED) carries `details.quota`.\n      // Both shapes are normalized into QuotaReserveResult.\n      const response = await client.post<{\n        success: boolean;\n        data?: { quota?: QuotaReserveResult['quota'] };\n        details?: { quota?: QuotaReserveResult['quota'] };\n        errorCode?: string;\n      }>(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable on reserve, allowing request', { orgId, quotaType });\n        emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'unreachable', quotaType });\n        return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };\n      }\n\n      if (response.statusCode === 429) {\n        const q = response.body.details?.quota;\n        // Only a GENUINE quota-exceeded 429 means \"over quota\". A generic 429 —\n        // the quota service's OWN rate limiter (RATE_LIMIT_EXCEEDED) or an\n        // intervening gateway during a spike — must NOT be surfaced as\n        // quota-exceeded: that would falsely block legitimate work behind a\n        // transient rate limit. Require the QUOTA_EXCEEDED error code (or the\n        // quota payload) and otherwise fall through to the non-ok\n        // fail-open/closed policy below (the right handling for a transient 429).\n        if (response.body.errorCode === 'QUOTA_EXCEEDED' || q) {\n          return {\n            exceeded: true,\n            quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },\n          };\n        }\n        // A non-QUOTA_EXCEEDED 429 is a TRANSIENT signal (the quota service's own\n        // rate limiter, or a gateway during a spike) — the tenant is NOT over quota,\n        // so fail OPEN (as for an unreachable service) rather than falsely blocking\n        // legitimate work. Do not fall through to the fail-closed non-ok default.\n        logger.warn('QUOTA_FAIL_OPEN: transient 429 on reserve (not quota-exceeded), allowing request', { orgId, quotaType });\n        emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'transient-429', quotaType });\n        return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };\n      }\n\n      if (response.statusCode !== 200 || !response.body.success) {\n        if (QUOTA_RESERVE_FAIL_OPEN) {\n          logger.warn('QUOTA_FAIL_OPEN: Quota reserve returned non-ok, allowing request', {\n            orgId, quotaType, statusCode: response.statusCode,\n          });\n          emitCounter('quota_fail_open_total', { operation: 'reserve', reason: 'non-ok', quotaType });\n          return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };\n        }\n        // Service reachable but didn't confirm the reservation → fail CLOSED.\n        logger.warn('QUOTA_FAIL_CLOSED: Quota reserve returned non-ok, denying request', {\n          orgId, quotaType, statusCode: response.statusCode,\n        });\n        emitCounter('quota_fail_closed_total', { operation: 'reserve', reason: 'non-ok', quotaType });\n        return { exceeded: true, quota: { type: quotaType, limit: 0, used: 0, remaining: 0 } };\n      }\n\n      const q = response.body.data?.quota;\n      return {\n        exceeded: false,\n        quota: q ?? { type: quotaType, limit: -1, used: 0, remaining: -1 },\n      };\n    },\n\n    async decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, resetAtSnapshot?: string, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/decrement`;\n      const response = await client\n        .post(path, { quotaType, amount, ...(resetAtSnapshot && { resetAtSnapshot }) }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        // Rollback failure is logged but never propagated  the action's own\n        // failure has already been surfaced to the caller; a stuck counter\n        // resolves on the next period reset.\n        logger.warn('Failed to decrement quota (slot will reset on next period)', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota decremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async updateLimits( orgId: string,\n      limits: Partial<Record<QuotaType, number>>,\n      authHeader: string,\n      requestId?: string,\n    ): Promise<boolean> {\n      const path = `/quotas/${encodeURIComponent(orgId)}`;\n\n      const response = await client.put(path, limits, { headers: buildHeaders(orgId, authHeader, requestId) });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to update quota limits', {\n          orgId, limits, statusCode: response?.statusCode,\n        });\n        return false;\n      }\n\n      logger.info('Quota limits updated', { orgId, limits });\n      return true;\n    },\n\n    async getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier> {\n      const path = `/quotas/${encodeURIComponent(orgId)}`;\n\n      const response = await client.get<{\n        success: boolean;\n        data?: { quota?: { tier?: string } };\n        message?: string;\n      }>(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200 || !response.body.success) {\n        logger.warn(`QUOTA_FAIL_OPEN: tier lookup failed, defaulting to ${DEFAULT_TIER} tier`, {\n          orgId, statusCode: response?.statusCode, defaultTier: DEFAULT_TIER,\n        });\n        emitCounter('quota_fail_open_total', { operation: 'tier', reason: response ? 'non-ok' : 'unreachable', quotaType: 'tier' });\n        return DEFAULT_TIER;\n      }\n\n      const tier = response.body.data?.quota?.tier;\n      return tier && isValidTier(tier) ? tier: DEFAULT_TIER;\n    },\n\n    async reset(orgId: string, quotaType?: QuotaType, authHeader?: string, requestId?: string): Promise<boolean> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/reset`;\n\n      const body = quotaType ? { quotaType }: {};\n      const response = await client.post(path, body, { headers: buildHeaders(orgId, authHeader ?? '', requestId) });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to reset quota', {\n          orgId, quotaType, statusCode: response?.statusCode,\n        });\n        return false;\n      }\n\n      logger.info('Quota reset', { orgId, quotaType: quotaType ?? 'all' });\n      return true;\n    },\n  };\n}\n\n/**\n * Fire-and-forget quota increment with standardized error logging.\n *\n * Wraps `quotaService.increment()` with a `.catch()` that logs a warning.\n * Eliminates the identical one-liner repeated across every read route.\n *\n * @param quotaService - Quota service client\n * @param orgId - Organization ID\n * @param quotaType - Quota type to increment\n * @param authHeader - Authorization header value\n * @param logWarn - Logging function for warnings\n */\nexport function incrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  logWarn: (message: string, data?: unknown) => void,\n): void {\n  quotaService.increment(orgId, quotaType, authHeader).catch((err: unknown) =>\n    logWarn('Quota increment failed', { error: err instanceof Error ? err.message: String(err) }),\n  );\n}\n\n/**\n * Atomic reserve helper for the \"reserve + commit / rollback\" pattern.\n * Use for expensive resources (pipelines, plugins, AI calls) where the\n * fire-and-forget post-hoc `incrementQuota` allows concurrent over-spend.\n *\n * Returns the structured result so the caller can decide whether to run\n * the gated action or 429 the client.\n *\n * @example\n * ```typescript\n * const reservation = await reserveQuota(quotaService, orgId, 'pipelines', authHeader);\n * if (reservation.exceeded) return sendQuotaExceeded(res, 'pipelines', reservation.quota);\n * try {\n * await doExpensiveThing();\n * } catch (err) {\n * // Pass the reserved resetAt so a period rollover doesn't get double-charged.\n * decrementQuota(quotaService, orgId, 'pipelines', authHeader, logWarn, 1, reservation.quota.resetAt);\n * throw err;\n * }\n * ```\n */\nexport function reserveQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  amount: number = 1,\n  requestId?: string,\n): Promise<QuotaReserveResult> {\n  return quotaService.reserve(orgId, quotaType, authHeader, amount, requestId);\n}\n\n/**\n * Fire-and-forget rollback for a previously reserved quota slot.\n * Logs on failure but never throws  the action that needed the rollback\n * has already failed, no point compounding the error.\n */\nexport function decrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  logWarn: (message: string, data?: unknown) => void,\n  amount: number = 1,\n  resetAtSnapshot?: string,\n): void {\n  quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot).catch((err: unknown) =>\n    logWarn('Quota rollback failed', { error: err instanceof Error ? err.message: String(err) }),\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota.js","sourceRoot":"","sources":["../../src/services/quota.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Response } from 'express';\n\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { getServiceAuthHeader } from '../middleware/auth.js';\nimport type { QuotaType, QuotaCheckResult, ServiceConfig } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { DEFAULT_TIER, isValidTier, type QuotaTier } from '../types/quota-tiers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError, sendQuotaExceeded } from '../utils/response.js';\n\n/**\n * Retry options for quota calls — fail fast (a slow quota service must not stall the request).\n *\n * NEVER retry a 429. The quota service answers an over-limit org with 429\n * QUOTA_EXCEEDED and `Retry-After` = seconds until the period resets; the HTTP\n * client honors that (capped at 60s), so a single rate-limit retry stalled the\n * request well past the handler timeout, which then answered 503 and the real\n * 429 was lost. A 429 is a final answer here.\n */\nconst QUOTA_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 0,\n  maxRetries: 1,\n};\n\nconst logger = createLogger('quota');\n\n// RESERVE FAIL MODE — explicit, single policy.\n//\n// `reserve` gates EXPENSIVE, billable resources (pipelines, plugin builds, AI\n// calls, platform feature slots). Every quota type is a per-period FLOW counter\n// with no after-the-fact reconciliation: a unit consumed while the reservation\n// could not be confirmed is never counted, so fail-open lets an org consume\n// unbounded unmetered units for the whole length of an incident — and an\n// unconfirmed reserve (timeout, open circuit) may even have landed server-side.\n// So `reserve` fails CLOSED whenever the quota service did not CONFIRM the slot:\n//   - unreachable / timed out / circuit breaker open (no response),\n//   - a reachable-but-errored response (5xx, 4xx, malformed body),\n//   - a 429 that is NOT a genuine QUOTA_EXCEEDED (gateway / rate limiter).\n// Operators who prefer availability over enforcement opt the WHOLE set into\n// fail-open with QUOTA_RESERVE_FAIL_OPEN=true. Both outcomes emit a counter\n// (`quota_fail_closed_total` / `quota_fail_open_total`) tagged with the reason.\n// `check` (a cheap read gate) stays fail-open; `increment` is fire-and-forget.\nconst QUOTA_RESERVE_FAIL_OPEN = process.env.QUOTA_RESERVE_FAIL_OPEN === 'true';\n\n/**\n * Service-principal `Authorization` header for a quota call made on behalf of\n * `orgId` by the CURRENT service (`SERVICE_NAME`, the same identity the health\n * router reports).\n *\n * The quota service's mutation endpoints (`/:orgId/increment`, `/decrement`)\n * reject anything but a signed service principal or a system admin, so\n * forwarding the end user's bearer token there is always a 403. Service tokens\n * are also exempt from the quota service's per-IP rate limiter, so hot-path\n * quota traffic from a busy pod can't exhaust that pod IP's bucket and silently\n * turn enforcement off. Scoped to the target org with the lowest role (member).\n */\nexport function getQuotaServiceAuthHeader(orgId: string): string {\n  return getServiceAuthHeader({ serviceName: process.env.SERVICE_NAME || 'api', orgId, role: 'member' });\n}\n\n/**\n * Result of a synchronous quota reservation  the atomic check+increment\n * variant. `exceeded: true` means the operation was rejected at the DB\n * level; the caller should return 429 without running the gated action.\n */\nexport interface QuotaReserveResult {\n  /** True when the slot was NOT reserved — the gated action must not run. */\n  exceeded: boolean;\n  /**\n   * Set (true) by the quota CLIENT when the reservation was denied because the\n   * quota service could not CONFIRM it (unreachable / timeout / circuit open /\n   * errored) — not because the org is over its limit. Always paired with\n   * `exceeded: true`. Answer with {@link sendQuotaReserveDenied}, which maps it to\n   * 503 instead of a misleading 429 \"quota exceeded\".\n   */\n  unavailable?: boolean;\n  quota: {\n    type: QuotaType;\n    limit: number;\n    used: number;\n    remaining: number;\n    resetAt?: string;\n  };\n}\n\n/**\n * Quota service client interface.\n */\nexport interface QuotaService {\n  /** Check if quota is available (fail-open on error). */\n  check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult>;\n  /** Increment quota usage. Returns a promise so callers can optionally handle errors. */\n  increment(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<void>;\n  /**\n   * Atomic reserve  the same atomic check+increment as `increment`, but\n   * parses the response so callers can see whether the slot was actually\n   * reserved. Use this for expensive resources where the post-hoc fire-\n   * and-forget pattern allows concurrent over-spend.\n   *\n   * Fails CLOSED (`exceeded: true`) whenever the slot is not confirmed —\n   * unreachable, timeout, open circuit, non-ok, or a non-quota 429 — unless\n   * `QUOTA_RESERVE_FAIL_OPEN=true` (see the policy note at the top of this file).\n   */\n  reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<QuotaReserveResult>;\n  /**\n   * Roll back a previously reserved slot. Fire-and-forget — never throws.\n   * Pass `resetAtSnapshot` (the `quota.resetAt` observed when the slot was\n   * reserved) to make the rollback conditional: if the period rolled over\n   * between reserve and rollback, the server skips the decrement so it doesn't\n   * steal capacity from the new period.\n   */\n  decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, resetAtSnapshot?: string, requestId?: string): Promise<void>;\n  /** Update quota limits. Returns true on success. */\n  updateLimits(orgId: string, limits: Partial<Record<QuotaType, number>>, authHeader: string, requestId?: string): Promise<boolean>;\n  /** Reset quota usage. Returns true on success. */\n  reset(orgId: string, quotaType?: QuotaType, authHeader?: string, requestId?: string): Promise<boolean>;\n  /**\n   * Get the org's quota `QuotaTier`. Used by the plugin-build queue partitioning\n   * to route a build to the right per-tier queue. Fail-open returns `DEFAULT_TIER`\n   * (`developer` when billing is enabled, `unlimited` when it's disabled); a\n   * misclassified org still builds on the default queue, just without the\n   * tier-scoped scheduling boost.\n   */\n  getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier>;\n}\n\n/**\n * Configuration for quota service client.\n */\nexport interface QuotaServiceConfig {\n  /** Quota service host (default: env QUOTA_SERVICE_HOST or 'quota') */\n  host?: string;\n  /** Quota service port (default: env QUOTA_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout in milliseconds (default: 5000) */\n  timeout?: number;\n}\n\n/**\n * Apply the explicit reserve fail-mode policy to a reservation the quota service\n * did NOT confirm (see QUOTA_RESERVE_FAIL_OPEN above). Default: deny.\n */\nfunction unconfirmedReserve(\n  orgId: string,\n  quotaType: QuotaType,\n  reason: 'unreachable' | 'transient-429' | 'non-ok',\n  statusCode?: number,\n): QuotaReserveResult {\n  if (QUOTA_RESERVE_FAIL_OPEN) {\n    logger.warn('QUOTA_FAIL_OPEN: quota reserve not confirmed, allowing request', { orgId, quotaType, reason, statusCode });\n    emitCounter('quota_fail_open_total', { operation: 'reserve', reason, quotaType });\n    return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };\n  }\n  logger.warn('QUOTA_FAIL_CLOSED: quota reserve not confirmed, denying request', { orgId, quotaType, reason, statusCode });\n  emitCounter('quota_fail_closed_total', { operation: 'reserve', reason, quotaType });\n  return { exceeded: true, unavailable: true, quota: { type: quotaType, limit: 0, used: 0, remaining: 0 } };\n}\n\n/**\n * Create a fail-open quota result (allows the request).\n */\nfunction createFailOpenResult(): QuotaCheckResult {\n  return {\n    allowed: true,\n    limit: -1,\n    used: 0,\n    remaining: -1,\n    resetAt: new Date().toISOString(),\n    unlimited: true,\n    // Tag the sentinel so fail-closed callers can tell an outage apart from a\n    // real unlimited (-1) reading. Real quota results never set this.\n    failOpen: true,\n  };\n}\n\n/**\n * Build common request headers with optional request ID for distributed tracing.\n */\nfunction buildHeaders(orgId: string, authHeader?: string, requestId?: string): Record<string, string> {\n  const headers: Record<string, string> = { 'x-org-id': orgId };\n  if (authHeader) headers.Authorization = authHeader;\n  if (requestId) headers['X-Request-Id'] = requestId;\n  return headers;\n}\n\n/**\n * Create a quota service client.\n *\n * @param config - Optional service configuration\n * @returns Quota service client\n *\n * @example\n * ```typescript\n * const quotaService = createQuotaService();\n *\n * // Check quota before processing\n * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);\n * if (!quota.allowed) {\n * return res.status(429).json({ error: 'Quota exceeded' });\n * }\n *\n * // Increment quota after success\n * quotaService.increment(orgId, 'apiCalls', authHeader).catch(err => logger.warn('Quota increment failed', { error: err }));\n * ```\n */\nexport function createQuotaService(config: QuotaServiceConfig = {}): QuotaService {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? process.env.QUOTA_SERVICE_HOST ?? 'quota',\n    port: config.port ?? parseInt(process.env.QUOTA_SERVICE_PORT ?? '3000', 10),\n    timeout: config.timeout ?? 5000,\n  };\n\n  const client = createSafeClient(serviceConfig);\n\n  return {\n    async check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/${encodeURIComponent(quotaType)}`;\n\n      const response = await client.get<{\n        success: boolean;\n        data?: { quotaType: string; status: QuotaCheckResult };\n        message?: string;\n      }>(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable, allowing request', { orgId, quotaType });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'unreachable', quotaType });\n        return createFailOpenResult();\n      }\n\n      if (response.statusCode !== 200 || !response.body.success || !response.body.data?.status) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota check returned non-ok, allowing request', {\n          orgId, quotaType, statusCode: response.statusCode, message: response.body.message,\n        });\n        emitCounter('quota_fail_open_total', { operation: 'check', reason: 'non-ok', quotaType });\n        return createFailOpenResult();\n      }\n\n      return response.body.data.status;\n    },\n\n    async increment(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n\n      const response = await client\n        .post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to increment quota', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota incremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, requestId?: string): Promise<QuotaReserveResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n\n      // 200 carries `data.quota`; 429 (QUOTA_EXCEEDED) carries `details.quota`.\n      // Both shapes are normalized into QuotaReserveResult.\n      const response = await client.post<{\n        success: boolean;\n        data?: { quota?: QuotaReserveResult['quota'] };\n        details?: { quota?: QuotaReserveResult['quota'] };\n        /** `sendError`'s error-code field. */\n        code?: string;\n      }>(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) return unconfirmedReserve(orgId, quotaType, 'unreachable');\n\n      if (response.statusCode === 429) {\n        const q = response.body.details?.quota;\n        // Only a GENUINE quota-exceeded 429 means \"over quota\". A generic 429 —\n        // an intervening gateway or rate limiter — did not confirm anything, so\n        // it goes through the same unconfirmed-reservation policy as an outage.\n        if (response.body.code === ErrorCode.QUOTA_EXCEEDED || q) {\n          return {\n            exceeded: true,\n            quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },\n          };\n        }\n        return unconfirmedReserve(orgId, quotaType, 'transient-429', response.statusCode);\n      }\n\n      if (response.statusCode !== 200 || !response.body.success) {\n        return unconfirmedReserve(orgId, quotaType, 'non-ok', response.statusCode);\n      }\n\n      const q = response.body.data?.quota;\n      return {\n        exceeded: false,\n        quota: q ?? { type: quotaType, limit: -1, used: 0, remaining: -1 },\n      };\n    },\n\n    async decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, resetAtSnapshot?: string, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/decrement`;\n      const response = await client\n        .post(path, { quotaType, amount, ...(resetAtSnapshot && { resetAtSnapshot }) }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        // Rollback failure is logged but never propagated  the action's own\n        // failure has already been surfaced to the caller; a stuck counter\n        // resolves on the next period reset.\n        logger.warn('Failed to decrement quota (slot will reset on next period)', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota decremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async updateLimits( orgId: string,\n      limits: Partial<Record<QuotaType, number>>,\n      authHeader: string,\n      requestId?: string,\n    ): Promise<boolean> {\n      const path = `/quotas/${encodeURIComponent(orgId)}`;\n\n      const response = await client.put(path, limits, { headers: buildHeaders(orgId, authHeader, requestId) });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to update quota limits', {\n          orgId, limits, statusCode: response?.statusCode,\n        });\n        return false;\n      }\n\n      logger.info('Quota limits updated', { orgId, limits });\n      return true;\n    },\n\n    async getTier(orgId: string, authHeader: string, requestId?: string): Promise<QuotaTier> {\n      const path = `/quotas/${encodeURIComponent(orgId)}`;\n\n      const response = await client.get<{\n        success: boolean;\n        data?: { quota?: { tier?: string } };\n        message?: string;\n      }>(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200 || !response.body.success) {\n        logger.warn(`QUOTA_FAIL_OPEN: tier lookup failed, defaulting to ${DEFAULT_TIER} tier`, {\n          orgId, statusCode: response?.statusCode, defaultTier: DEFAULT_TIER,\n        });\n        emitCounter('quota_fail_open_total', { operation: 'tier', reason: response ? 'non-ok' : 'unreachable', quotaType: 'tier' });\n        return DEFAULT_TIER;\n      }\n\n      const tier = response.body.data?.quota?.tier;\n      return tier && isValidTier(tier) ? tier: DEFAULT_TIER;\n    },\n\n    async reset(orgId: string, quotaType?: QuotaType, authHeader?: string, requestId?: string): Promise<boolean> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/reset`;\n\n      const body = quotaType ? { quotaType }: {};\n      const response = await client.post(path, body, { headers: buildHeaders(orgId, authHeader ?? '', requestId) });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to reset quota', {\n          orgId, quotaType, statusCode: response?.statusCode,\n        });\n        return false;\n      }\n\n      logger.info('Quota reset', { orgId, quotaType: quotaType ?? 'all' });\n      return true;\n    },\n  };\n}\n\n/**\n * Fire-and-forget quota METERING increment with standardized error logging.\n *\n * Authenticates as the calling SERVICE ({@link getQuotaServiceAuthHeader}), never\n * with the end user's token: `/quotas/:orgId/increment` is service-principal /\n * system-admin only, so a forwarded user JWT was always rejected (403) and the\n * metered quota (e.g. `apiCalls`, and the `api_pack` bundle raising it) never\n * moved.\n *\n * @param quotaService - Quota service client\n * @param orgId - Organization ID whose counter is incremented\n * @param quotaType - Quota type to increment\n * @param logWarn - Logging function for warnings\n */\nexport function incrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  logWarn: (message: string, data?: unknown) => void,\n): void {\n  quotaService.increment(orgId, quotaType, getQuotaServiceAuthHeader(orgId)).catch((err: unknown) =>\n    logWarn('Quota increment failed', { error: err instanceof Error ? err.message: String(err) }),\n  );\n}\n\n/**\n * Atomic reserve helper for the \"reserve + commit / rollback\" pattern.\n * Use for expensive resources (pipelines, plugins, AI calls) where the\n * fire-and-forget post-hoc `incrementQuota` allows concurrent over-spend.\n *\n * Returns the structured result so the caller can decide whether to run\n * the gated action or 429 the client.\n *\n * @example\n * ```typescript\n * const reservation = await reserveQuota(quotaService, orgId, 'pipelines', authHeader);\n * if (reservation.exceeded) return sendQuotaReserveDenied(res, 'pipelines', reservation);\n * try {\n * await doExpensiveThing();\n * } catch (err) {\n * // Pass the reserved resetAt so a period rollover doesn't get double-charged.\n * decrementQuota(quotaService, orgId, 'pipelines', authHeader, logWarn, 1, reservation.quota.resetAt);\n * throw err;\n * }\n * ```\n */\nexport function reserveQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  amount: number = 1,\n  requestId?: string,\n): Promise<QuotaReserveResult> {\n  return quotaService.reserve(orgId, quotaType, authHeader, amount, requestId);\n}\n\n/** Seconds a client should wait before retrying when quota couldn't be confirmed. */\nconst QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS = 5;\n\n/**\n * Answer a DENIED reservation (`reservation.exceeded === true`).\n *\n * - `unavailable` (the quota service couldn't confirm the slot) → **503**\n *   `SERVICE_UNAVAILABLE` with a short `Retry-After`: the org is not over its\n *   limit, so a 429 \"quota exceeded\" would send users to upgrade for an outage.\n * - otherwise → the standard 429 `QUOTA_EXCEEDED` with the X-Quota-* headers.\n */\nexport function sendQuotaReserveDenied(res: Response, quotaType: QuotaType, reservation: QuotaReserveResult): void {\n  if (reservation.unavailable) {\n    if (!res.headersSent) res.setHeader('Retry-After', QUOTA_UNAVAILABLE_RETRY_AFTER_SECONDS);\n    sendError(\n      res,\n      503,\n      `Unable to confirm ${quotaType} quota right now. Please try again shortly.`,\n      ErrorCode.SERVICE_UNAVAILABLE,\n    );\n    return;\n  }\n  sendQuotaExceeded(res, quotaType, reservation.quota, reservation.quota.resetAt);\n}\n\n/**\n * Fire-and-forget rollback for a previously reserved quota slot.\n * Logs on failure but never throws  the action that needed the rollback\n * has already failed, no point compounding the error.\n */\nexport function decrementQuota( quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  logWarn: (message: string, data?: unknown) => void,\n  amount: number = 1,\n  resetAtSnapshot?: string,\n): void {\n  quotaService.decrement(orgId, quotaType, authHeader, amount, resetAtSnapshot).catch((err: unknown) =>\n    logWarn('Quota rollback failed', { error: err instanceof Error ? err.message: String(err) }),\n  );\n}\n"]}

package/lib/services/remote-audit-client.d.ts

@@ -10,7 +10,7 @@ import { type AuditSpool } from './audit-spool.js';
  * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep
  * this list free of any platform-only action.
  */
-export declare const REMOTE_AUDIT_ACTIONS: readonly ['plugin.build.completed', 'plugin.build.failed', 'plugin.build.timeout', 'plugin.delete', 'plugin.restore', 'plugin.purge', 'plugin.update', 'plugin.upload', 'plugin.deploy', 'plugin.bulk.update', 'plugin.bulk.delete', 'plugin.dlq.purge', 'pipeline.create', 'pipeline.update', 'pipeline.delete', 'pipeline.restore', 'pipeline.purge', 'pipeline_template.create', 'pipeline_template.update', 'pipeline_template.delete', 'pipeline_template.restore', 'pipeline_template.purge', 'pipeline.execution.start', 'pipeline.execution.cancel', 'pipeline.registry.register', 'pipeline.registry.deregister', 'quota.reset', 'quota.limit.update', 'quota.delete', 'compliance.exemption.approve', 'compliance.exemption.revoke', 'compliance.rule.toggle', 'compliance.rule.create', 'compliance.rule.update', 'compliance.rule.delete', 'compliance.rule.restore', 'compliance.rule.purge', 'compliance.policy.create', 'compliance.policy.update', 'compliance.policy.delete', 'compliance.policy.restore', 'compliance.policy.purge', 'compliance.scan-schedule.create', 'compliance.scan-schedule.update', 'compliance.scan-schedule.delete', 'compliance.template.apply', 'compliance.scan.cancel', 'registry.gc', 'registry.image.delete', 'registry.image.copy', 'message.announcement.create', 'message.delete', 'message.restore', 'message.purge', 'billing.subscription.cancel', 'billing.subscription.delete', 'billing.tier.override', 'billing.addon.add', 'billing.addon.remove', 'billing.addon.prune', 'billing.discount.generate', 'billing.discount.issue', 'billing.discount.apply', 'billing.discount.remove', 'billing.discount.revoke', 'billing.promotion.create', 'billing.promotion.update', 'billing.promotion.revoke', 'billing.promotion.grant', 'billing.promotion.activate', 'billing.credit.consumed', 'billing.credit.exhausted', 'billing.combo.expired', 'authz.denied', 'ask.query', 'ask.agent.turn'];
+export declare const REMOTE_AUDIT_ACTIONS: readonly ['plugin.build.completed', 'plugin.build.failed', 'plugin.build.timeout', 'plugin.delete', 'plugin.restore', 'plugin.purge', 'plugin.update', 'plugin.upload', 'plugin.deploy', 'plugin.bulk.update', 'plugin.bulk.delete', 'plugin.dlq.purge', 'plugin.build.retry', 'plugin.dlq.replay', 'pipeline.create', 'pipeline.update', 'pipeline.delete', 'pipeline.restore', 'pipeline.purge', 'pipeline_template.create', 'pipeline_template.update', 'pipeline_template.delete', 'pipeline_template.restore', 'pipeline_template.purge', 'pipeline.execution.start', 'pipeline.execution.cancel', 'pipeline.registry.register', 'pipeline.registry.deregister', 'quota.reset', 'quota.limit.update', 'quota.delete', 'compliance.exemption.approve', 'compliance.exemption.revoke', 'compliance.rule.toggle', 'compliance.rule.create', 'compliance.rule.update', 'compliance.rule.delete', 'compliance.rule.restore', 'compliance.rule.purge', 'compliance.policy.create', 'compliance.policy.update', 'compliance.policy.delete', 'compliance.policy.restore', 'compliance.policy.purge', 'compliance.scan-schedule.create', 'compliance.scan-schedule.update', 'compliance.scan-schedule.delete', 'compliance.template.apply', 'compliance.scan.create', 'compliance.scan.cancel', 'compliance.notification-preference.update', 'registry.gc', 'registry.image.delete', 'registry.image.copy', 'message.announcement.create', 'message.delete', 'message.restore', 'message.purge', 'billing.subscription.create', 'billing.subscription.update', 'billing.subscription.reactivate', 'billing.subscription.cancel', 'billing.subscription.delete', 'billing.tier.override', 'billing.ledger.backfill', 'billing.addon.add', 'billing.addon.remove', 'billing.addon.prune', 'billing.discount.generate', 'billing.discount.issue', 'billing.discount.apply', 'billing.discount.remove', 'billing.discount.revoke', 'billing.promotion.create', 'billing.promotion.update', 'billing.promotion.revoke', 'billing.promotion.grant', 'billing.promotion.activate', 'billing.credit.consumed', 'billing.credit.exhausted', 'billing.combo.expired', 'reporting.settings.update', 'reporting.deployment.outcome', 'reporting.retention.sync', 'authz.denied', 'ask.query', 'ask.agent.turn'];
 export type RemoteAuditAction = typeof REMOTE_AUDIT_ACTIONS[number];
 /** Whether `value` is an action a remote service may emit (the ingest allow-list). */
 export declare function isRemoteAuditAction(value: string): value is RemoteAuditAction;