@pipeline-builder/api-core 4.1.2 → 4.1.3

package/lib/services/leader-lock.d.ts

@@ -30,12 +30,15 @@ export declare function closeLeaderLock(redis: LockRedis | null | undefined): Pr
  * released on completion, but only if we still own it — a slower predecessor
  * never deletes a successor's lock. `ttlMs` should comfortably exceed one run.
  *
- * @returns true if we held the lock and ran `fn`; false if another holder did.
+ * If Redis can't be reached the run is skipped (returns false) rather than
+ * rejecting — callers are timers, and a Redis blip must not crash the process.
+ *
+ * @returns true if we held the lock and ran `fn`; false if another holder did or
+ *   the lock couldn't be taken.
  */
 export declare function withLeaderLock(redis: LockRedis, key: string, ttlMs: number, fn: () => Promise<void>): Promise<boolean>;
 /**
- * A `LockRedis` backed by an env-configured ioredis client (`REDIS_URL` or
- * `REDIS_HOST`) — the leader-lock counterpart to `createEnvRedisAuditSpool` /
+ * A `LockRedis` backed by the shared env Redis client (see env-redis.ts) — the leader-lock counterpart to `createEnvRedisAuditSpool` /
  * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to
  * borrow. Returns `null` when Redis isn't configured, so a caller can degrade to
  * running on every pod (the atomic guards it wraps must still make that safe).

package/lib/services/leader-lock.js

@@ -38,11 +38,27 @@ const RELEASE_IF_OWNER = 'if redis.call("get", KEYS[1]) == ARGV[1] then return r
  * released on completion, but only if we still own it — a slower predecessor
  * never deletes a successor's lock. `ttlMs` should comfortably exceed one run.
  *
- * @returns true if we held the lock and ran `fn`; false if another holder did.
+ * If Redis can't be reached the run is skipped (returns false) rather than
+ * rejecting — callers are timers, and a Redis blip must not crash the process.
+ *
+ * @returns true if we held the lock and ran `fn`; false if another holder did or
+ *   the lock couldn't be taken.
  */
 export async function withLeaderLock(redis, key, ttlMs, fn) {
     const token = randomUUID();
-    const acquired = await redis.set(key, token, 'PX', ttlMs, 'NX');
+    let acquired;
+    try {
+        acquired = await redis.set(key, token, 'PX', ttlMs, 'NX');
+    }
+    catch (err) {
+        // Redis unreachable (including before the first connection completes): no
+        // pod can prove it's the leader, so nobody runs this window. Skipping is
+        // the safe side — running here could duplicate destructive work across pods.
+        lockLogger.warn('Leader lock unavailable; skipping this run', {
+            key, error: err instanceof Error ? err.message : String(err),
+        });
+        return false;
+    }
     if (acquired !== 'OK')
         return false;
     try {
@@ -68,8 +84,7 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
     return true;
 }
 /**
- * A `LockRedis` backed by an env-configured ioredis client (`REDIS_URL` or
- * `REDIS_HOST`) — the leader-lock counterpart to `createEnvRedisAuditSpool` /
+ * A `LockRedis` backed by the shared env Redis client (see env-redis.ts) — the leader-lock counterpart to `createEnvRedisAuditSpool` /
  * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to
  * borrow. Returns `null` when Redis isn't configured, so a caller can degrade to
  * running on every pod (the atomic guards it wraps must still make that safe).
@@ -82,4 +97,4 @@ export function createEnvRedisLock() {
         lockLogger.info('Redis leader-lock client initialized');
     return inst;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVhZGVyLWxvY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvbGVhZGVyLWxvY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVsRCxNQUFNLFVBQVUsR0FBRyxZQUFZLENBQUMsYUFBYSxDQUFDLENBQUM7QUFvQi9DOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGVBQWUsQ0FBQyxLQUFtQztJQUN2RSxJQUFJLENBQUMsS0FBSztRQUFFLE9BQU87SUFDbkIsSUFBSSxDQUFDO1FBQ0gsSUFBSSxPQUFPLEtBQUssQ0FBQyxJQUFJLEtBQUssVUFBVSxFQUFFLENBQUM7WUFBQyxNQUFNLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUFDLE9BQU87UUFBQyxDQUFDO0lBQ3ZFLENBQUM7SUFBQyxNQUFNLENBQUM7UUFDUCw2QkFBNkI7SUFDL0IsQ0FBQztJQUNELElBQUksQ0FBQztRQUFDLEtBQUssQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDO0lBQUMsQ0FBQztJQUFDLE1BQU0sQ0FBQyxDQUFDLGlCQUFpQixDQUFDLENBQUM7QUFDM0QsQ0FBQztBQUVEO2lFQUNpRTtBQUNqRSxNQUFNLGdCQUFnQixHQUNwQixtR0FBbUcsQ0FBQztBQUV0Rzs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxjQUFjLENBQ2xDLEtBQWdCLEVBQ2hCLEdBQVcsRUFDWCxLQUFhLEVBQ2IsRUFBdUI7SUFFdkIsTUFBTSxLQUFLLEdBQUcsVUFBVSxFQUFFLENBQUM7SUFDM0IsTUFBTSxRQUFRLEdBQUcsTUFBTSxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQztJQUNoRSxJQUFJLFFBQVEsS0FBSyxJQUFJO1FBQUUsT0FBTyxLQUFLLENBQUM7SUFFcEMsSUFBSSxDQUFDO1FBQ0gsTUFBTSxFQUFFLEVBQUUsQ0FBQztJQUNiLENBQUM7WUFBUyxDQUFDO1FBQ1QsMEVBQTBFO1FBQzFFLHdFQUF3RTtRQUN4RSw0RUFBNEU7UUFDNUUscURBQXFEO1FBQ3JELElBQUksQ0FBQztZQUNILElBQUksT0FBTyxLQUFLLENBQUMsSUFBSSxLQUFLLFVBQVUsRUFBRSxDQUFDO2dCQUNyQyxNQUFNLEtBQUssQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxFQUFFLEdBQUcsRUFBRSxLQUFLLENBQUMsQ0FBQztZQUNwRCxDQUFDO2lCQUFNLElBQUksQ0FBQyxNQUFNLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsS0FBSyxLQUFLLEVBQUUsQ0FBQztnQkFDNUMsTUFBTSxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3ZCLENBQUM7UUFDSCxDQUFDO1FBQUMsTUFBTSxDQUFDO1lBQ1Asb0RBQW9EO1FBQ3RELENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQ7Ozs7Ozs7O0dBUUc7QUFDSCxNQUFNLFVBQVUsa0JBQWtCO0lBQ2hDLE1BQU0sSUFBSSxHQUFHLG9CQUFvQixDQUFZLGFBQWEsQ0FBQyxDQUFDO0lBQzVELElBQUksSUFBSTtRQUFFLFVBQVUsQ0FBQyxJQUFJLENBQUMsc0NBQXNDLENBQUMsQ0FBQztJQUNsRSxPQUFPLElBQUksQ0FBQztBQUNkLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuaW1wb3J0IHsgcmFuZG9tVVVJRCB9IGZyb20gJ2NyeXB0byc7XG5pbXBvcnQgeyBjcmVhdGVFbnZSZWRpc0NsaWVudCB9IGZyb20gJy4vZW52LXJlZGlzLmpzJztcbmltcG9ydCB7IGNyZWF0ZUxvZ2dlciB9IGZyb20gJy4uL3V0aWxzL2xvZ2dlci5qcyc7XG5cbmNvbnN0IGxvY2tMb2dnZXIgPSBjcmVhdGVMb2dnZXIoJ2xlYWRlci1sb2NrJyk7XG5cbi8qKlxuICogTWluaW1hbCBSZWRpcyBjbGllbnQgc3VyZmFjZSBuZWVkZWQgZm9yIGEgbGVhZGVyIGxvY2sgKGEgc3Vic2V0IG9mIGlvcmVkaXMpLlxuICogYHNldGAgaXMgdmFyaWFkaWMgc28gY2FsbGVycyBjYW4gcGFzcyBgJ1BYJywgdHRsLCAnTlgnYC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBMb2NrUmVkaXMge1xuICBzZXQoa2V5OiBzdHJpbmcsIHZhbHVlOiBzdHJpbmcsIC4uLmFyZ3M6IHVua25vd25bXSk6IFByb21pc2U8dW5rbm93bj47XG4gIGdldChrZXk6IHN0cmluZyk6IFByb21pc2U8c3RyaW5nIHwgbnVsbD47XG4gIGRlbCguLi5rZXlzOiBzdHJpbmdbXSk6IFByb21pc2U8bnVtYmVyPjtcbiAgLyoqIE9wdGlvbmFsIEx1YSBldmFsIChpb3JlZGlzIGhhcyBpdCkuIFdoZW4gcHJlc2VudCwgcmVsZWFzZSB1c2VzIGFuIGF0b21pY1xuICAgKiAgY29tcGFyZS1hbmQtZGVsZXRlIHNvIGEgbGFwc2VkIGhvbGRlciBjYW4ndCBmcmVlIGEgc3VjY2Vzc29yJ3MgbG9jay4gKi9cbiAgZXZhbD8oc2NyaXB0OiBzdHJpbmcsIG51bUtleXM6IG51bWJlciwgLi4uYXJnczogdW5rbm93bltdKTogUHJvbWlzZTx1bmtub3duPjtcbiAgLyoqIEdyYWNlZnVsIGNsb3NlIChpb3JlZGlzIGBxdWl0YCkg4oCUIGNhbGxlZCBvbiBzaHV0ZG93biBzbyB0aGUgY29ubmVjdGlvblxuICAgKiAgZG9lc24ndCBrZWVwIHRoZSBldmVudCBsb29wIGFsaXZlLiAqL1xuICBxdWl0PygpOiBQcm9taXNlPHVua25vd24+O1xuICAvKiogSW1tZWRpYXRlIGNsb3NlIChpb3JlZGlzIGBkaXNjb25uZWN0YCkg4oCUIHRoZSBmYWxsYmFjayBpZiBgcXVpdGAgZmFpbHMuICovXG4gIGRpc2Nvbm5lY3Q/KCk6IHZvaWQ7XG59XG5cbi8qKlxuICogQmVzdC1lZmZvcnQgY2xvc2Ugb2YgYSBsZWFkZXItbG9jayBSZWRpcyBjbGllbnQgb24gc2h1dGRvd24uIFByZWZlcnMgZ3JhY2VmdWxcbiAqIGBxdWl0YDsgZmFsbHMgYmFjayB0byBgZGlzY29ubmVjdGAuIE5vLW9wIGZvciBhIG51bGwgY2xpZW50IC8gb25lIHdpdGhvdXRcbiAqIGVpdGhlciBtZXRob2QuIE5ldmVyIHRocm93cy5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGNsb3NlTGVhZGVyTG9jayhyZWRpczogTG9ja1JlZGlzIHwgbnVsbCB8IHVuZGVmaW5lZCk6IFByb21pc2U8dm9pZD4ge1xuICBpZiAoIXJlZGlzKSByZXR1cm47XG4gIHRyeSB7XG4gICAgaWYgKHR5cGVvZiByZWRpcy5xdWl0ID09PSAnZnVuY3Rpb24nKSB7IGF3YWl0IHJlZGlzLnF1aXQoKTsgcmV0dXJuOyB9XG4gIH0gY2F0Y2gge1xuICAgIC8vIGZhbGwgdGhyb3VnaCB0byBkaXNjb25uZWN0XG4gIH1cbiAgdHJ5IHsgcmVkaXMuZGlzY29ubmVjdD8uKCk7IH0gY2F0Y2ggeyAvKiBiZXN0LWVmZm9ydCAqLyB9XG59XG5cbi8qKiBBdG9taWMgXCJkZWxldGUgb25seSBpZiBJIHN0aWxsIG93biBpdFwiIOKAlCBjbG9zZXMgdGhlIGdldC10aGVuLWRlbCByYWNlIHdoZXJlXG4gKiAgdGhlIGxvY2sgZXhwaXJlcyBhbmQgaXMgcmUtYWNxdWlyZWQgYmV0d2VlbiB0aGUgdHdvIGNhbGxzLiAqL1xuY29uc3QgUkVMRUFTRV9JRl9PV05FUiA9XG4gICdpZiByZWRpcy5jYWxsKFwiZ2V0XCIsIEtFWVNbMV0pID09IEFSR1ZbMV0gdGhlbiByZXR1cm4gcmVkaXMuY2FsbChcImRlbFwiLCBLRVlTWzFdKSBlbHNlIHJldHVybiAwIGVuZCc7XG5cbi8qKlxuICogUnVuIGBmbmAgb25seSBpZiB0aGlzIHByb2Nlc3Mgd2lucyBhIHNob3J0LWxpdmVkIGRpc3RyaWJ1dGVkIGxvY2sg4oCUIHRoZVxuICogYWNyb3NzLXBvZHMgXCJzaW5nbGUgcnVubmVyXCIgZ3VhcmQgZm9yIHBlcmlvZGljIGpvYnMgKGRpZ2VzdCBmbHVzaGVzLCBldGMuKS5cbiAqXG4gKiBVc2VzIGBTRVQga2V5IHRva2VuIE5YIFBYIHR0bGAsIHNvIGV4YWN0bHkgb25lIGhvbGRlciBydW5zIHBlciB3aW5kb3cgYW5kIHRoZVxuICogbG9jayBhdXRvLWV4cGlyZXMgaWYgdGhhdCBob2xkZXIgZGllcyBtaWQtcnVuIChubyBzdHVjayBsb2NrKS4gVGhlIGxvY2sgaXNcbiAqIHJlbGVhc2VkIG9uIGNvbXBsZXRpb24sIGJ1dCBvbmx5IGlmIHdlIHN0aWxsIG93biBpdCDigJQgYSBzbG93ZXIgcHJlZGVjZXNzb3JcbiAqIG5ldmVyIGRlbGV0ZXMgYSBzdWNjZXNzb3IncyBsb2NrLiBgdHRsTXNgIHNob3VsZCBjb21mb3J0YWJseSBleGNlZWQgb25lIHJ1bi5cbiAqXG4gKiBAcmV0dXJucyB0cnVlIGlmIHdlIGhlbGQgdGhlIGxvY2sgYW5kIHJhbiBgZm5gOyBmYWxzZSBpZiBhbm90aGVyIGhvbGRlciBkaWQuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB3aXRoTGVhZGVyTG9jayhcbiAgcmVkaXM6IExvY2tSZWRpcyxcbiAga2V5OiBzdHJpbmcsXG4gIHR0bE1zOiBudW1iZXIsXG4gIGZuOiAoKSA9PiBQcm9taXNlPHZvaWQ+LFxuKTogUHJvbWlzZTxib29sZWFuPiB7XG4gIGNvbnN0IHRva2VuID0gcmFuZG9tVVVJRCgpO1xuICBjb25zdCBhY3F1aXJlZCA9IGF3YWl0IHJlZGlzLnNldChrZXksIHRva2VuLCAnUFgnLCB0dGxNcywgJ05YJyk7XG4gIGlmIChhY3F1aXJlZCAhPT0gJ09LJykgcmV0dXJuIGZhbHNlO1xuXG4gIHRyeSB7XG4gICAgYXdhaXQgZm4oKTtcbiAgfSBmaW5hbGx5IHtcbiAgICAvLyBSZWxlYXNlIG9ubHkgaWYgdGhlIGxvY2sgaXMgc3RpbGwgb3VycyDigJQgaWYgb3VyIHJ1biBvdmVycmFuIHRoZSBUVEwgYW5kXG4gICAgLy8gYW5vdGhlciBob2xkZXIgdG9vayBvdmVyLCByZWxlYXNpbmcgaGVyZSB3b3VsZCBmcmVlIHRoZWlyIGxvY2sgZWFybHkuXG4gICAgLy8gUHJlZmVyIGFuIGF0b21pYyBDQVMgKEx1YSk7IGZhbGwgYmFjayB0byBnZXQtdGhlbi1kZWwgZm9yIGNsaWVudHMgd2l0aG91dFxuICAgIC8vIGV2YWwgKHRoZSBzbWFsbCBub24tYXRvbWljIHdpbmRvdyBpcyBUVEwtYm91bmRlZCkuXG4gICAgdHJ5IHtcbiAgICAgIGlmICh0eXBlb2YgcmVkaXMuZXZhbCA9PT0gJ2Z1bmN0aW9uJykge1xuICAgICAgICBhd2FpdCByZWRpcy5ldmFsKFJFTEVBU0VfSUZfT1dORVIsIDEsIGtleSwgdG9rZW4pO1xuICAgICAgfSBlbHNlIGlmICgoYXdhaXQgcmVkaXMuZ2V0KGtleSkpID09PSB0b2tlbikge1xuICAgICAgICBhd2FpdCByZWRpcy5kZWwoa2V5KTtcbiAgICAgIH1cbiAgICB9IGNhdGNoIHtcbiAgICAgIC8vIEJlc3QtZWZmb3J0OiB0aGUgVFRMIGV4cGlyZXMgdGhlIGxvY2sgcmVnYXJkbGVzcy5cbiAgICB9XG4gIH1cbiAgcmV0dXJuIHRydWU7XG59XG5cbi8qKlxuICogQSBgTG9ja1JlZGlzYCBiYWNrZWQgYnkgYW4gZW52LWNvbmZpZ3VyZWQgaW9yZWRpcyBjbGllbnQgKGBSRURJU19VUkxgIG9yXG4gKiBgUkVESVNfSE9TVGApIOKAlCB0aGUgbGVhZGVyLWxvY2sgY291bnRlcnBhcnQgdG8gYGNyZWF0ZUVudlJlZGlzQXVkaXRTcG9vbGAgL1xuICogYGNyZWF0ZUVudlJlZGlzVG9rZW5SZXZvY2F0aW9uU3RvcmVgLCBmb3IgYSBzZXJ2aWNlIHRoYXQgaGFzIG5vIEJ1bGxNUSBjbGllbnQgdG9cbiAqIGJvcnJvdy4gUmV0dXJucyBgbnVsbGAgd2hlbiBSZWRpcyBpc24ndCBjb25maWd1cmVkLCBzbyBhIGNhbGxlciBjYW4gZGVncmFkZSB0b1xuICogcnVubmluZyBvbiBldmVyeSBwb2QgKHRoZSBhdG9taWMgZ3VhcmRzIGl0IHdyYXBzIG11c3Qgc3RpbGwgbWFrZSB0aGF0IHNhZmUpLlxuICogVGhlIGNsaWVudCBpcyBhIHJlYWwgaW9yZWRpcyBpbnN0YW5jZTsgaW9yZWRpcyBleHBvc2VzIGBzZXRgL2BnZXRgL2BkZWxgL2BldmFsYCxcbiAqIHNhdGlzZnlpbmcgYExvY2tSZWRpc2AgaW5jbHVkaW5nIHRoZSBhdG9taWMgQ0FTIHJlbGVhc2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVFbnZSZWRpc0xvY2soKTogTG9ja1JlZGlzIHwgbnVsbCB7XG4gIGNvbnN0IGluc3QgPSBjcmVhdGVFbnZSZWRpc0NsaWVudDxMb2NrUmVkaXM+KCdsZWFkZXItbG9jaycpO1xuICBpZiAoaW5zdCkgbG9ja0xvZ2dlci5pbmZvKCdSZWRpcyBsZWFkZXItbG9jayBjbGllbnQgaW5pdGlhbGl6ZWQnKTtcbiAgcmV0dXJuIGluc3Q7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leader-lock.js","sourceRoot":"","sources":["../../src/services/leader-lock.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,UAAU,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;AAoB/C;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,KAAmC;IACvE,IAAI,CAAC,KAAK;QAAE,OAAO;IACnB,IAAI,CAAC;QACH,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAAC,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC;YAAC,OAAO;QAAC,CAAC;IACvE,CAAC;IAAC,MAAM,CAAC;QACP,6BAA6B;IAC/B,CAAC;IACD,IAAI,CAAC;QAAC,KAAK,CAAC,UAAU,EAAE,EAAE,CAAC;IAAC,CAAC;IAAC,MAAM,CAAC,CAAC,iBAAiB,CAAC,CAAC;AAC3D,CAAC;AAED;iEACiE;AACjE,MAAM,gBAAgB,GACpB,mGAAmG,CAAC;AAEtG;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,KAAgB,EAChB,GAAW,EACX,KAAa,EACb,EAAuB;IAEvB,MAAM,KAAK,GAAG,UAAU,EAAE,CAAC;IAC3B,IAAI,QAAiB,CAAC;IACtB,IAAI,CAAC;QACH,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IAC5D,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,0EAA0E;QAC1E,yEAAyE;QACzE,6EAA6E;QAC7E,UAAU,CAAC,IAAI,CAAC,4CAA4C,EAAE;YAC5D,GAAG,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;SAC7D,CAAC,CAAC;QACH,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,QAAQ,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAEpC,IAAI,CAAC;QACH,MAAM,EAAE,EAAE,CAAC;IACb,CAAC;YAAS,CAAC;QACT,0EAA0E;QAC1E,wEAAwE;QACxE,4EAA4E;QAC5E,qDAAqD;QACrD,IAAI,CAAC;YACH,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;gBACrC,MAAM,KAAK,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YACpD,CAAC;iBAAM,IAAI,CAAC,MAAM,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC;gBAC5C,MAAM,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,oDAAoD;QACtD,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB;IAChC,MAAM,IAAI,GAAG,oBAAoB,CAAY,aAAa,CAAC,CAAC;IAC5D,IAAI,IAAI;QAAE,UAAU,CAAC,IAAI,CAAC,sCAAsC,CAAC,CAAC;IAClE,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport { createEnvRedisClient } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst lockLogger = createLogger('leader-lock');\n\n/**\n * Minimal Redis client surface needed for a leader lock (a subset of ioredis).\n * `set` is variadic so callers can pass `'PX', ttl, 'NX'`.\n */\nexport interface LockRedis {\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  get(key: string): Promise<string | null>;\n  del(...keys: string[]): Promise<number>;\n  /** Optional Lua eval (ioredis has it). When present, release uses an atomic\n   *  compare-and-delete so a lapsed holder can't free a successor's lock. */\n  eval?(script: string, numKeys: number, ...args: unknown[]): Promise<unknown>;\n  /** Graceful close (ioredis `quit`) — called on shutdown so the connection\n   *  doesn't keep the event loop alive. */\n  quit?(): Promise<unknown>;\n  /** Immediate close (ioredis `disconnect`) — the fallback if `quit` fails. */\n  disconnect?(): void;\n}\n\n/**\n * Best-effort close of a leader-lock Redis client on shutdown. Prefers graceful\n * `quit`; falls back to `disconnect`. No-op for a null client / one without\n * either method. Never throws.\n */\nexport async function closeLeaderLock(redis: LockRedis | null | undefined): Promise<void> {\n  if (!redis) return;\n  try {\n    if (typeof redis.quit === 'function') { await redis.quit(); return; }\n  } catch {\n    // fall through to disconnect\n  }\n  try { redis.disconnect?.(); } catch { /* best-effort */ }\n}\n\n/** Atomic \"delete only if I still own it\" — closes the get-then-del race where\n *  the lock expires and is re-acquired between the two calls. */\nconst RELEASE_IF_OWNER =\n  'if redis.call(\"get\", KEYS[1]) == ARGV[1] then return redis.call(\"del\", KEYS[1]) else return 0 end';\n\n/**\n * Run `fn` only if this process wins a short-lived distributed lock — the\n * across-pods \"single runner\" guard for periodic jobs (digest flushes, etc.).\n *\n * Uses `SET key token NX PX ttl`, so exactly one holder runs per window and the\n * lock auto-expires if that holder dies mid-run (no stuck lock). The lock is\n * released on completion, but only if we still own it — a slower predecessor\n * never deletes a successor's lock. `ttlMs` should comfortably exceed one run.\n *\n * If Redis can't be reached the run is skipped (returns false) rather than\n * rejecting — callers are timers, and a Redis blip must not crash the process.\n *\n * @returns true if we held the lock and ran `fn`; false if another holder did or\n *   the lock couldn't be taken.\n */\nexport async function withLeaderLock(\n  redis: LockRedis,\n  key: string,\n  ttlMs: number,\n  fn: () => Promise<void>,\n): Promise<boolean> {\n  const token = randomUUID();\n  let acquired: unknown;\n  try {\n    acquired = await redis.set(key, token, 'PX', ttlMs, 'NX');\n  } catch (err) {\n    // Redis unreachable (including before the first connection completes): no\n    // pod can prove it's the leader, so nobody runs this window. Skipping is\n    // the safe side — running here could duplicate destructive work across pods.\n    lockLogger.warn('Leader lock unavailable; skipping this run', {\n      key, error: err instanceof Error ? err.message : String(err),\n    });\n    return false;\n  }\n  if (acquired !== 'OK') return false;\n\n  try {\n    await fn();\n  } finally {\n    // Release only if the lock is still ours — if our run overran the TTL and\n    // another holder took over, releasing here would free their lock early.\n    // Prefer an atomic CAS (Lua); fall back to get-then-del for clients without\n    // eval (the small non-atomic window is TTL-bounded).\n    try {\n      if (typeof redis.eval === 'function') {\n        await redis.eval(RELEASE_IF_OWNER, 1, key, token);\n      } else if ((await redis.get(key)) === token) {\n        await redis.del(key);\n      }\n    } catch {\n      // Best-effort: the TTL expires the lock regardless.\n    }\n  }\n  return true;\n}\n\n/**\n * A `LockRedis` backed by the shared env Redis client (see env-redis.ts) — the leader-lock counterpart to `createEnvRedisAuditSpool` /\n * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to\n * borrow. Returns `null` when Redis isn't configured, so a caller can degrade to\n * running on every pod (the atomic guards it wraps must still make that safe).\n * The client is a real ioredis instance; ioredis exposes `set`/`get`/`del`/`eval`,\n * satisfying `LockRedis` including the atomic CAS release.\n */\nexport function createEnvRedisLock(): LockRedis | null {\n  const inst = createEnvRedisClient<LockRedis>('leader-lock');\n  if (inst) lockLogger.info('Redis leader-lock client initialized');\n  return inst;\n}\n"]}

package/lib/services/quota.d.ts

@@ -1,12 +1,35 @@
+import type { Response } from 'express';
 import type { QuotaType, QuotaCheckResult } from '../types/common.js';
 import { type QuotaTier } from '../types/quota-tiers.js';
+/**
+ * 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 declare function getQuotaServiceAuthHeader(orgId: string): string;
 /**
  * Result of a synchronous quota reservation  the atomic check+increment
  * variant. `exceeded: true` means the operation was rejected at the DB
  * level; the caller should return 429 without running the gated action.
  */
 export interface QuotaReserveResult {
+    /** True when the slot was NOT reserved — the gated action must not run. */
     exceeded: boolean;
+    /**
+     * Set (true) by the quota CLIENT when the reservation was denied because the
+     * quota service could not CONFIRM it (unreachable / timeout / circuit open /
+     * errored) — not because the org is over its limit. Always paired with
+     * `exceeded: true`. Answer with {@link sendQuotaReserveDenied}, which maps it to
+     * 503 instead of a misleading 429 "quota exceeded".
+     */
+    unavailable?: boolean;
     quota: {
         type: QuotaType;
         limit: number;
@@ -29,9 +52,9 @@ export interface QuotaService {
      * reserved. Use this for expensive resources where the post-hoc fire-
      * and-forget pattern allows concurrent over-spend.
      *
-     * Fail-open semantics on transport errors: returns `exceeded: false` so
-     * the caller can proceed and the request isn't blocked by quota-service
-     * outages (matches `check()`).
+     * Fails CLOSED (`exceeded: true`) whenever the slot is not confirmed —
+     * unreachable, timeout, open circuit, non-ok, or a non-quota 429 — unless
+     * `QUOTA_RESERVE_FAIL_OPEN=true` (see the policy note at the top of this file).
      */
     reserve(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<QuotaReserveResult>;
     /**
@@ -88,18 +111,20 @@ export interface QuotaServiceConfig {
  */
 export declare function createQuotaService(config?: QuotaServiceConfig): QuotaService;
 /**
- * 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 declare function incrementQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, authHeader: string, logWarn: (message: string, data?: unknown) => void): void;
+export declare function incrementQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, logWarn: (message: string, data?: unknown) => void): void;
 /**
  * Atomic reserve helper for the "reserve + commit / rollback" pattern.
  * Use for expensive resources (pipelines, plugins, AI calls) where the
@@ -111,7 +136,7 @@ export declare function incrementQuota(quotaService: QuotaService, orgId: string
  * @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) {
@@ -122,6 +147,15 @@ export declare function incrementQuota(quotaService: QuotaService, orgId: string
  * ```
  */
 export declare function reserveQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<QuotaReserveResult>;
+/**
+ * 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 declare function sendQuotaReserveDenied(res: Response, quotaType: QuotaType, reservation: QuotaReserveResult): void;
 /**
  * Fire-and-forget rollback for a previously reserved quota slot.
  * Logs on failure but never throws  the action that needed the rollback

package/lib/services/quota.js

@@ -1,24 +1,64 @@
 // 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). */
 const QUOTA_REQUEST_OPTIONS = {
     maxRateLimitRetries: 1,
     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 +149,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).
+                // 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.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 +230,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 +257,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 +270,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 +297,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/** Retry options for quota calls — fail fast (a slow quota service must not stall the request). */\nconst QUOTA_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 1,\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        errorCode?: 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.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/sse-ticket-store.d.ts

@@ -43,7 +43,7 @@ export interface SseTicketStoreConfig {
 }
 /**
  * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or
- * `REDIS_HOST`/`REDIS_PORT`). Uses the Redis backend when configured
+ * `REDIS_SENTINELS`). Uses the Redis backend when configured
  * (multi-replica safe), otherwise falls back to the in-memory single-process
  * backend. A service opts in with one boot line:
  *   `const tickets = createEnvSseTicketStore({ ttlMs, maxTotal, maxPerOrg });`