@pipeline-builder/api-core 3.4.35 → 3.4.37

package/lib/services/quota.js

@@ -4,9 +4,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createQuotaService = createQuotaService;
 exports.incrementQuota = incrementQuota;
+exports.reserveQuota = reserveQuota;
+exports.decrementQuota = decrementQuota;
 const http_client_1 = require("./http-client");
+const quota_tiers_1 = require("../types/quota-tiers");
 const logger_1 = require("../utils/logger");
-/** Retry options for quota calls — fail fast since quota is fail-open. */
+const metric_emitter_1 = require("../utils/metric-emitter");
+/** Retry options for quota calls  fail fast since quota is fail-open. */
 const QUOTA_REQUEST_OPTIONS = {
     maxRateLimitRetries: 1,
     maxRetries: 1,
@@ -49,7 +53,7 @@ function buildHeaders(orgId, authHeader, requestId) {
  * // Check quota before processing
  * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);
  * if (!quota.allowed) {
- *   return res.status(429).json({ error: 'Quota exceeded' });
+ * return res.status(429).json({ error: 'Quota exceeded' });
  * }
  *
  * // Increment quota after success
@@ -69,12 +73,14 @@ function createQuotaService(config = {}) {
             const response = await client.get(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
             if (!response) {
                 logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable, allowing request', { orgId, quotaType });
+                (0, metric_emitter_1.emitCounter)('quota_fail_open_total', { operation: 'check', reason: 'unreachable', quotaType });
                 return createFailOpenResult();
             }
             if (response.statusCode !== 200 || !response.body.success || !response.body.data?.status) {
                 logger.warn('QUOTA_FAIL_OPEN: Quota check returned non-ok, allowing request', {
                     orgId, quotaType, statusCode: response.statusCode, message: response.body.message,
                 });
+                (0, metric_emitter_1.emitCounter)('quota_fail_open_total', { operation: 'check', reason: 'non-ok', quotaType });
                 return createFailOpenResult();
             }
             return response.body.data.status;
@@ -92,6 +98,52 @@ function createQuotaService(config = {}) {
                 logger.debug('Quota incremented', { orgId, quotaType, amount });
             }
         },
+        async reserve(orgId, quotaType, authHeader, amount = 1, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}/increment`;
+            // 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 });
+                (0, metric_emitter_1.emitCounter)('quota_fail_open_total', { operation: 'reserve', reason: 'unreachable', quotaType });
+                return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };
+            }
+            if (response.statusCode === 429) {
+                const q = response.body.details?.quota;
+                return {
+                    exceeded: true,
+                    quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },
+                };
+            }
+            if (response.statusCode !== 200 || !response.body.success) {
+                logger.warn('QUOTA_FAIL_OPEN: Quota reserve returned non-ok, allowing request', {
+                    orgId, quotaType, statusCode: response.statusCode,
+                });
+                (0, metric_emitter_1.emitCounter)('quota_fail_open_total', { operation: 'reserve', reason: 'non-ok', quotaType });
+                return { exceeded: false, quota: { type: quotaType, limit: -1, used: 0, remaining: -1 } };
+            }
+            const q = response.body.data?.quota;
+            return {
+                exceeded: false,
+                quota: q ?? { type: quotaType, limit: -1, used: 0, remaining: -1 },
+            };
+        },
+        async decrement(orgId, quotaType, authHeader, amount = 1, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}/decrement`;
+            const response = await client
+                .post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+            if (!response || response.statusCode !== 200) {
+                // Rollback failure is logged but never propagated  the action's own
+                // failure has already been surfaced to the caller; a stuck counter
+                // resolves on the next period reset.
+                logger.warn('Failed to decrement quota (slot will reset on next period)', {
+                    orgId, quotaType, amount, statusCode: response?.statusCode,
+                });
+            }
+            else {
+                logger.debug('Quota decremented', { orgId, quotaType, amount });
+            }
+        },
         async updateLimits(orgId, limits, authHeader, requestId) {
             const path = `/quotas/${encodeURIComponent(orgId)}`;
             const response = await client.put(path, limits, { headers: buildHeaders(orgId, authHeader, requestId) });
@@ -104,6 +156,19 @@ function createQuotaService(config = {}) {
             logger.info('Quota limits updated', { orgId, limits });
             return true;
         },
+        async getTier(orgId, authHeader, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}`;
+            const response = await client.get(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+            if (!response || response.statusCode !== 200 || !response.body.success) {
+                logger.warn('QUOTA_FAIL_OPEN: tier lookup failed, defaulting to developer tier', {
+                    orgId, statusCode: response?.statusCode,
+                });
+                (0, metric_emitter_1.emitCounter)('quota_fail_open_total', { operation: 'tier', reason: response ? 'non-ok' : 'unreachable', quotaType: 'tier' });
+                return quota_tiers_1.DEFAULT_TIER;
+            }
+            const tier = response.body.data?.quota?.tier;
+            return tier && (0, quota_tiers_1.isValidTier)(tier) ? tier : quota_tiers_1.DEFAULT_TIER;
+        },
         async reset(orgId, quotaType, authHeader, requestId) {
             const path = `/quotas/${encodeURIComponent(orgId)}/reset`;
             const body = quotaType ? { quotaType } : {};
@@ -134,4 +199,35 @@ function createQuotaService(config = {}) {
 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) }));
 }
-//# 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, RequestOptions } from './http-client';\nimport { QuotaType, QuotaCheckResult, ServiceConfig } from '../types/common';\nimport { createLogger } from '../utils/logger';\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/**\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  /** 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\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  };\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        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        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 updateLimits(\n      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 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(\n  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"]}
+/**
+ * Atomic reserve helper for the "reserve + commit / rollback" pattern.
+ * Use for expensive resources (pipelines, plugins, AI calls) where the
+ * fire-and-forget post-hoc `incrementQuota` allows concurrent over-spend.
+ *
+ * Returns the structured result so the caller can decide whether to run
+ * the gated action or 429 the client.
+ *
+ * @example
+ * ```typescript
+ * const reservation = await reserveQuota(quotaService, orgId, 'pipelines', authHeader);
+ * if (reservation.exceeded) return sendQuotaExceeded(res, 'pipelines', reservation.quota);
+ * try {
+ * await doExpensiveThing();
+ * } catch (err) {
+ * await decrementQuota(quotaService, orgId, 'pipelines', authHeader);
+ * throw err;
+ * }
+ * ```
+ */
+function reserveQuota(quotaService, orgId, quotaType, authHeader, amount = 1, requestId) {
+    return quotaService.reserve(orgId, quotaType, authHeader, amount, requestId);
+}
+/**
+ * Fire-and-forget rollback for a previously reserved quota slot.
+ * Logs on failure but never throws  the action that needed the rollback
+ * has already failed, no point compounding the error.
+ */
+function decrementQuota(quotaService, orgId, quotaType, authHeader, logWarn, amount = 1) {
+    quotaService.decrement(orgId, quotaType, authHeader, amount).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, RequestOptions } from './http-client';\nimport { QuotaType, QuotaCheckResult, ServiceConfig } from '../types/common';\nimport { DEFAULT_TIER, isValidTier, QuotaTier } from '../types/quota-tiers';\nimport { createLogger } from '../utils/logger';\nimport { emitCounter } from '../utils/metric-emitter';\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/**\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  /** Roll back a previously reserved slot. Fire-and-forget  never throws. */\n  decrement(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, 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 tier ('developer' | 'pro' | 'unlimited'). Used by\n   * the plugin-build queue partitioning to route a build to the\n   * right per-tier queue. Fail-open returns DEFAULT_TIER ('developer')\n   * a misclassified pro/unlimited org will land in the developer queue\n   * and still build, just without the 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  };\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        return {\n          exceeded: true,\n          quota: q ?? { type: quotaType, limit: 0, used: 0, remaining: 0 },\n        };\n      }\n\n      if (response.statusCode !== 200 || !response.body.success) {\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\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, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/decrement`;\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        // 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 developer tier', {\n          orgId, statusCode: response?.statusCode,\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 * await decrementQuota(quotaService, orgId, 'pipelines', authHeader);\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): void {\n  quotaService.decrement(orgId, quotaType, authHeader, amount).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

@@ -0,0 +1,63 @@
+/**
+ * Subset of platform's AuditAction enum that non-platform services emit.
+ * Kept in sync manually with platform/src/models/audit-event.ts; mismatched
+ * actions are rejected by the platform ingest endpoint (400) so a drift is
+ * visible in logs rather than silently dropped.
+ */
+export type RemoteAuditAction = 'plugin.build.completed' | 'plugin.build.failed' | 'plugin.build.timeout';
+export interface RemoteAuditEvent {
+    action: RemoteAuditAction;
+    actorId: string;
+    actorEmail?: string;
+    orgId?: string;
+    affectedOrgId?: string;
+    targetType?: string;
+    targetId?: string;
+    details?: Record<string, unknown>;
+}
+/**
+ * Client for POSTing audit events to the platform's `/audit-events` ingest
+ * endpoint. Mints a fresh service token per call (5 min TTL)  there's no
+ * meaningful caching benefit when emissions are sparse.
+ */
+export interface RemoteAuditClient {
+    /**
+     * Fire-and-forget audit emission. Failures are logged at warn level but
+     * never thrown  the originating action (e.g. a plugin build) has its
+     * own success/failure path that shouldn't get polluted by a flaky audit
+     * downstream.
+     */
+    record(event: RemoteAuditEvent, serviceName: string): void;
+}
+/**
+ * Configuration for the remote audit client.
+ */
+export interface RemoteAuditClientConfig {
+    /** Platform service host (default: env PLATFORM_SERVICE_HOST or 'platform') */
+    host?: string;
+    /** Platform service port (default: env PLATFORM_SERVICE_PORT or 3000) */
+    port?: number;
+    /** Request timeout ms (default 3000  audit shouldn't block the worker). */
+    timeout?: number;
+}
+/**
+ * Construct a remote-audit client targeted at the platform service.
+ *
+ * Used by api/plugin's build worker to push `plugin.build.*` events into
+ * the platform's MongoDB `audit_events` collection. Other services
+ * with worker-style emitters can use the same client.
+ *
+ * @example
+ * ```typescript
+ * const auditClient = createRemoteAuditClient();
+ * auditClient.record({
+ * action: 'plugin.build.completed',
+ * actorId: 'user-123',
+ * orgId: 'org-acme',
+ * targetType: 'plugin',
+ * targetId: 'plugin-abc',
+ * details: { name: 'my-plugin', version: '1.0.0' },
+ * }, 'plugin');
+ * ```
+ */
+export declare function createRemoteAuditClient(config?: RemoteAuditClientConfig): RemoteAuditClient;

package/lib/services/remote-audit-client.js

@@ -0,0 +1,67 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRemoteAuditClient = createRemoteAuditClient;
+const http_client_1 = require("./http-client");
+const auth_1 = require("../middleware/auth");
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.createLogger)('remote-audit');
+/** Tight retries  audit ingest is best-effort, never block the caller. */
+const AUDIT_REQUEST_OPTIONS = {
+    maxRateLimitRetries: 0,
+    maxRetries: 1,
+};
+/**
+ * Construct a remote-audit client targeted at the platform service.
+ *
+ * Used by api/plugin's build worker to push `plugin.build.*` events into
+ * the platform's MongoDB `audit_events` collection. Other services
+ * with worker-style emitters can use the same client.
+ *
+ * @example
+ * ```typescript
+ * const auditClient = createRemoteAuditClient();
+ * auditClient.record({
+ * action: 'plugin.build.completed',
+ * actorId: 'user-123',
+ * orgId: 'org-acme',
+ * targetType: 'plugin',
+ * targetId: 'plugin-abc',
+ * details: { name: 'my-plugin', version: '1.0.0' },
+ * }, 'plugin');
+ * ```
+ */
+function createRemoteAuditClient(config = {}) {
+    const serviceConfig = {
+        host: config.host ?? process.env.PLATFORM_SERVICE_HOST ?? 'platform',
+        port: config.port ?? parseInt(process.env.PLATFORM_SERVICE_PORT ?? '3000', 10),
+        timeout: config.timeout ?? 3000,
+    };
+    const client = (0, http_client_1.createSafeClient)(serviceConfig);
+    return {
+        record(event, serviceName) {
+            const authHeader = (0, auth_1.getServiceAuthHeader)({ serviceName, orgId: event.orgId });
+            // Strip the `Bearer ` prefix for InternalHttpClient  it sets the
+            // Authorization header itself; the value here is raw.
+            const headers = { Authorization: authHeader };
+            // Path is /audit/events  the platform mounts the audit router under
+            // /audit, and the internal ingest endpoint lives at /events under that.
+            client.post('/audit/events', event, { headers, ...AUDIT_REQUEST_OPTIONS })
+                .then((response) => {
+                if (!response || response.statusCode !== 200) {
+                    logger.warn('Remote audit ingest non-ok', {
+                        action: event.action, statusCode: response?.statusCode,
+                    });
+                }
+            })
+                .catch((err) => {
+                logger.warn('Remote audit ingest threw', {
+                    action: event.action,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            });
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/common.d.ts

@@ -5,12 +5,25 @@
  * - `apiCalls` — generic API call count (read-heavy paths)
  * - `aiCalls` — AI provider invocations (counted separately because each call
  *   has external dollar cost; sized smaller than apiCalls per tier)
+ * - `storageBytes` — registry storage budget per org. Unlike the others
+ *   (which count discrete events), this is a measured total recomputed
+ *   on demand. Incremented by the image-registry's push-gate before
+ *   issuing a token whose scope includes `push`; the GC scheduler
+ *   eventually frees the bytes, then the next push-gate check reads
+ *   the lower value. NOT a counter-style quota in the sense of
+ *   `incrementUsage` — the registry pushes the measured total via
+ *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.
+ * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —
+ *   resource-count quotas added to close per-org DoS surfaces in the
+ *   user-editable feature tables. Without these caps a single org could
+ *   spam thousands of dashboards / rules and bloat the shared Postgres /
+ *   Mongo working sets. Counted at create time; decremented on delete.
  */
-export type QuotaType = 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls';
+export type QuotaType = 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls' | 'storageBytes' | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';
 /**
  * Valid quota type values.
  */
-export declare const VALID_QUOTA_TYPES: readonly ["plugins", "pipelines", "apiCalls", "aiCalls"];
+export declare const VALID_QUOTA_TYPES: readonly ["plugins", "pipelines", "apiCalls", "aiCalls", "storageBytes", "dashboards", "alertRules", "alertDestinations", "idpConfigs"];
 /**
  * Type guard to check if a value is a valid QuotaType.
  *
@@ -117,6 +130,16 @@ export interface JwtPayload {
     role: 'owner' | 'admin' | 'member';
     /** Derived: true when role is 'admin' or 'owner' in the active organization */
     isAdmin?: boolean;
+    /**
+     * Global super-admin flag (cross-org). When `true`, the user is treated
+     * as a system administrator regardless of which org they're currently
+     * acting under. This is the canonical signal for sysadmin authority —
+     * previously the only path was membership in the well-known "system" org
+     * with role admin/owner, which conflated "Pipeline Builder operator" with
+     * "real customer tenant" in the data model. Either path still works
+     * during the rollout; new users should be granted via `isSuperAdmin`.
+     */
+    isSuperAdmin?: boolean;
     /** Organization's quota tier ('developer' | 'pro' | 'unlimited') */
     tier?: string;
     /** Resolved feature flags for this user/org */
@@ -125,6 +148,18 @@ export interface JwtPayload {
     organizationId?: string;
     /** Active organization name */
     organizationName?: string;
+    /**
+     * Set on tokens issued by the sysadmin impersonation flow
+     * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's
+     * user id so audit events still attribute actions correctly.
+     */
+    impersonatorId?: string;
+    /**
+     * When true, the token is read-only — any non-GET request is rejected
+     * upstream by the platform's read-only impersonation gate. Lets
+     * sysadmins "view as user X" without risking a destructive action.
+     */
+    impersonationReadOnly?: boolean;
     /** Token type */
     type: 'access' | 'refresh';
     /** Issued at timestamp */

package/lib/types/common.js

@@ -8,7 +8,10 @@ exports.validateQuotaType = validateQuotaType;
 /**
  * Valid quota type values.
  */
-exports.VALID_QUOTA_TYPES = ['plugins', 'pipelines', 'apiCalls', 'aiCalls'];
+exports.VALID_QUOTA_TYPES = [
+    'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',
+    'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',
+];
 /**
  * Type guard to check if a value is a valid QuotaType.
  *
@@ -50,4 +53,4 @@ function validateQuotaType(value, fieldName = 'quotaType') {
     }
     return value;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,sCAAsC;;;AAgDtC,4CAEC;AAqBD,8CAOC;AAnDD;;GAEG;AACU,QAAA,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc;IAC7D,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;CACrD,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,SAAgB,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,yBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,iBAAiB,CAAC,KAAc,EAAE,SAAS,GAAG,WAAW;IACvE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,WAAW,SAAS,MAAM,KAAK,sBAAsB,yBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACpF,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths)\n * - `aiCalls` — AI provider invocations (counted separately because each call\n *   has external dollar cost; sized smaller than apiCalls per tier)\n * - `storageBytes` — registry storage budget per org. Unlike the others\n *   (which count discrete events), this is a measured total recomputed\n *   on demand. Incremented by the image-registry's push-gate before\n *   issuing a token whose scope includes `push`; the GC scheduler\n *   eventually frees the bytes, then the next push-gate check reads\n *   the lower value. NOT a counter-style quota in the sense of\n *   `incrementUsage` — the registry pushes the measured total via\n *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.\n * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —\n *   resource-count quotas added to close per-org DoS surfaces in the\n *   user-editable feature tables. Without these caps a single org could\n *   spam thousands of dashboards / rules and bloat the shared Postgres /\n *   Mongo working sets. Counted at create time; decremented on delete.\n */\nexport type QuotaType =\n  | 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls' | 'storageBytes'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n] as const;\n\n/**\n * Type guard to check if a value is a valid QuotaType.\n *\n * @param value - Value to check\n * @returns True if value is a valid QuotaType\n *\n * @example\n * ```typescript\n * if (isValidQuotaType(req.body.quotaType)) {\n *   // quotaType is guaranteed to be QuotaType\n * }\n * ```\n */\nexport function isValidQuotaType(value: unknown): value is QuotaType {\n  return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value as QuotaType);\n}\n\n/**\n * Validate and assert that a value is a valid QuotaType.\n * Throws an error if validation fails.\n *\n * @param value - Value to validate\n * @param fieldName - Name of the field being validated (for error messages)\n * @returns The validated QuotaType\n * @throws Error if value is not a valid QuotaType\n *\n * @example\n * ```typescript\n * try {\n *   const quotaType = validateQuotaType(req.body.quotaType, 'quotaType');\n *   // Use quotaType safely\n * } catch (err) {\n *   return sendError(res, 400, err.message);\n * }\n * ```\n */\nexport function validateQuotaType(value: unknown, fieldName = 'quotaType'): QuotaType {\n  if (!isValidQuotaType(value)) {\n    throw new Error(\n      `Invalid ${fieldName}: \"${value}\". Must be one of: ${VALID_QUOTA_TYPES.join(', ')}`,\n    );\n  }\n  return value;\n}\n\n/**\n * Result from quota check operation.\n */\nexport interface QuotaCheckResult {\n  /** Whether the request is allowed */\n  allowed: boolean;\n  /** Maximum quota limit (-1 for unlimited) */\n  limit: number;\n  /** Current usage count */\n  used: number;\n  /** Remaining quota (-1 for unlimited) */\n  remaining: number;\n  /** ISO timestamp when quota resets */\n  resetAt: string;\n  /** Whether quota is unlimited */\n  unlimited: boolean;\n}\n\n/**\n * Quota information for error responses.\n */\nexport interface QuotaInfo {\n  type: QuotaType;\n  limit: number;\n  used: number;\n  remaining: number;\n}\n\n/**\n * Standard API success response.\n */\nexport interface ApiSuccessResponse<T = unknown> {\n  success: true;\n  statusCode: number;\n  data?: T;\n  message?: string;\n}\n\n/**\n * Standard API error response.\n */\nexport interface ApiErrorResponse {\n  success: false;\n  statusCode: number;\n  message: string;\n  code?: string;\n  details?: unknown;\n  quota?: QuotaInfo;\n}\n\n/**\n * Combined API response type.\n */\nexport type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n/**\n * JWT payload from access tokens.\n *\n * Users can belong to multiple organizations. The token is scoped to one\n * active organization at a time. The `role` field is the user's per-org\n * role in that organization (from the UserOrganization junction collection),\n * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.\n *\n * Use `POST /auth/switch-org` to change the active organization, which\n * re-issues tokens with the new org's role and context.\n */\nexport interface JwtPayload {\n  /** User ID (subject) */\n  sub: string;\n  /** Username */\n  username: string;\n  /** User email */\n  email: string;\n  /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */\n  role: 'owner' | 'admin' | 'member';\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Global super-admin flag (cross-org). When `true`, the user is treated\n   * as a system administrator regardless of which org they're currently\n   * acting under. This is the canonical signal for sysadmin authority —\n   * previously the only path was membership in the well-known \"system\" org\n   * with role admin/owner, which conflated \"Pipeline Builder operator\" with\n   * \"real customer tenant\" in the data model. Either path still works\n   * during the rollout; new users should be granted via `isSuperAdmin`.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier ('developer' | 'pro' | 'unlimited') */\n  tier?: string;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /** Active organization ID (from UserOrganization membership) */\n  organizationId?: string;\n  /** Active organization name */\n  organizationName?: string;\n  /**\n   * Set on tokens issued by the sysadmin impersonation flow\n   * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's\n   * user id so audit events still attribute actions correctly.\n   */\n  impersonatorId?: string;\n  /**\n   * When true, the token is read-only — any non-GET request is rejected\n   * upstream by the platform's read-only impersonation gate. Lets\n   * sysadmins \"view as user X\" without risking a destructive action.\n   */\n  impersonationReadOnly?: boolean;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * Extended Express Request with user property.\n */\ndeclare global {\n  namespace Express {\n    interface Request {\n      user?: JwtPayload;\n    }\n  }\n}\n\n/**\n * Service configuration for internal HTTP client.\n */\nexport interface ServiceConfig {\n  /** Service hostname */\n  host: string;\n  /** Service port */\n  port: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Health check response.\n */\nexport interface HealthCheckResponse {\n  status: 'healthy' | 'unhealthy';\n  service: string;\n  timestamp: string;\n  uptime: number;\n  version?: string;\n  dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;\n}\n"]}

package/lib/types/feature-flags.d.ts

@@ -15,24 +15,24 @@ export declare const FEATURE_METADATA: Record<FeatureFlag, {
 /**
  * Resolve a user's effective feature set.
  *
- * 1. System org users always get ALL features.
+ * 1. Sysadmins (isSuperAdmin) always get ALL features.
  * 2. Start with the tier's default features.
  * 3. Apply per-user overrides: `true` adds a feature, `false` removes it.
  * 4. Invalid override keys are silently ignored.
  *
  * @param tier - The organization's quota tier
  * @param featureOverrides - Per-user overrides (key = feature flag, value = enabled)
- * @param isSystemOrg - Whether the user belongs to the system organization
+ * @param isSuperAdmin - Whether the user has the global super-admin flag
  * @returns Sorted array of enabled feature flags
  */
-export declare function resolveUserFeatures(tier: QuotaTier, featureOverrides?: Record<string, boolean> | null, isSystemOrg?: boolean): FeatureFlag[];
+export declare function resolveUserFeatures(tier: QuotaTier, featureOverrides?: Record<string, boolean> | null, isSuperAdmin?: boolean): FeatureFlag[];
 /**
  * Check if a specific feature is enabled for a user.
  *
  * @param tier - The organization's quota tier
  * @param feature - The feature flag to check
  * @param featureOverrides - Per-user overrides
- * @param isSystemOrg - Whether the user belongs to the system organization
+ * @param isSuperAdmin - Whether the user has the global super-admin flag
  * @returns true if the feature is enabled
  */
-export declare function hasFeature(tier: QuotaTier, feature: FeatureFlag, featureOverrides?: Record<string, boolean> | null, isSystemOrg?: boolean): boolean;
+export declare function hasFeature(tier: QuotaTier, feature: FeatureFlag, featureOverrides?: Record<string, boolean> | null, isSuperAdmin?: boolean): boolean;