@goodandready/dsh-key-rotation 0.8.42 → 0.8.43

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.8.43 - 2026-10-01
+
+### Fixed
+- **Sanitized GitHub mirror and provenance workflow documentation (#425)**:
+  - Updated `docs/deployment/github-npm-provenance.md` to accurately document the Gitea-first development workflow and sanitized GitHub mirror export (`./scripts/publish-github.sh --push <tag>`), eliminating contradictions regarding direct GitHub PRs and external CI triggers.
+- **LatencyHistogram configuration from latencyWindow setting (#426)**:
+  - Implemented dynamic `reconfigure({ window })` on `LatencyHistogram` (`lib/histogram.js`) and wired `cfg.latencyWindow` from configuration into `buildRuntime()` (`lib/index.js`), ensuring the configured latency sampling window is respected at runtime.
+- **Auto-unbreak quarantine separation and safety checks (#427)**:
+  - Updated `lib/rotate.js` to place keys into a recoverable 30-minute quarantine (`brokenUntil`) after 3 consecutive non-auth failures while protecting rate-limited/quota-exhausted keys from quarantine pollution.
+  - Updated `lib/heal.js` to strictly skip permanently revoked (`revokedRefs`) and paused (`pausedRefs`) credentials during auto-unbreak background probing, preventing probing or accidental reactivation of revoked credentials.
+- **Webhook Alert Digest pipeline integration (#428)**:
+  - Wired `AlertDebouncer` into the production notification pipeline in `lib/index.js`, batching rapid alert bursts into consolidated digest payloads before webhook dispatch as documented.
+
 ## 0.8.42 - 2026-10-01
 
 ### Fixed

package/lib/heal.js

@@ -54,6 +54,7 @@ export async function autoUnbreakBrokenKeys(pools, probeFn, now = Date.now(), {
     if (!bu || bu.size === 0) continue;
     const brokenRefs = [];
     for (const [ref, until] of bu.entries()) {
+      if (pool.state.revokedRefs?.has(ref) || pool.state.pausedRefs?.has(ref)) continue;
       if (Number.isFinite(until) && until > now) {
         brokenRefs.push(ref);
       }

package/lib/histogram.js

@@ -4,11 +4,43 @@
 export const LATENCY_DEFAULT_WINDOW = 200;
 
 export class LatencyHistogram {
-  constructor({ window = LATENCY_DEFAULT_WINDOW } = {}) {
+  constructor(opts = {}) {
+    const windowVal = typeof opts === 'number' ? opts : opts?.window;
+    this.reconfigure({ window: windowVal });
+  }
+
+  get window() {
+    return this._window;
+  }
+
+  reconfigure({ window = LATENCY_DEFAULT_WINDOW } = {}) {
     const w = Number.isFinite(window) && window > 0 ? Math.floor(window) : LATENCY_DEFAULT_WINDOW;
+    if (this._window === w && this._buffers) return;
+
+    if (!this._buffers) {
+      this._window = w;
+      this._buffers = new Map(); // ref -> { buf, head, count }
+      this._lastAt = new Map();  // ref -> epochMs
+      return;
+    }
+
+    // Resize existing ring buffers to new length w
+    for (const [ref, entry] of this._buffers.entries()) {
+      const samples = [];
+      const start = entry.count < entry.buf.length ? 0 : entry.head;
+      for (let i = 0; i < entry.count; i++) {
+        samples.push(entry.buf[(start + i) % entry.buf.length]);
+      }
+      const newSamples = samples.slice(-w);
+      const newBuf = new Float64Array(w);
+      for (let i = 0; i < newSamples.length; i++) {
+        newBuf[i] = newSamples[i];
+      }
+      entry.buf = newBuf;
+      entry.head = newSamples.length % w;
+      entry.count = newSamples.length;
+    }
     this._window = w;
-    this._buffers = new Map(); // ref -> Float64Array of size w, plus index/count
-    this._lastAt = new Map();  // ref -> epochMs of last sample
   }
 
   record(ref, ms) {

package/lib/index.js

@@ -20,7 +20,7 @@ import {
 import { LatencyHistogram } from './histogram.js';
 import { ConcurrencyTracker } from './concurrency.js';
 import { QuotaStore } from './quota.js';
-import { WebhookSender } from './webhook.js';
+import { WebhookSender, AlertDebouncer } from './webhook.js';
 import { compactUsage } from './usage-report.js';
 import { json, handleConfigBridge } from './http-bridge.js';
 import { createRotate } from './rotate.js';
@@ -80,7 +80,8 @@ const concurrencyTracker = new ConcurrencyTracker();
 
 let moduleBreaker = new CircuitBreaker({ threshold: 5, openMs: 30000, halfOpenProbes: 1, now: nowMono });
 const webhookSender = new WebhookSender({ fetchImpl: globalThis.fetch });
-let moduleNotifyQueue = new NotifyQueue({ send: (url, payload) => webhookSender.send(url, payload) });
+const alertDebouncer = new AlertDebouncer({ sender: webhookSender, debounceMs: 2000 });
+let moduleNotifyQueue = new NotifyQueue({ send: (url, payload) => alertDebouncer.enqueue(url, payload) });
 
 let getConfig = () => null;
 function verboseLoggingOn() {
@@ -270,6 +271,9 @@ export function apply(ctx, config = {}) {
       openMs: cfg.circuitBreakerOpenMs ?? 30000,
       halfOpenProbes: cfg.circuitBreakerHalfOpenProbes ?? 1,
     });
+    if (cfg.latencyWindow && latencyHistogram.window !== cfg.latencyWindow) {
+      latencyHistogram.reconfigure({ window: cfg.latencyWindow });
+    }
     const switchCodes = cfg.switchCodes ?? DEFAULT_SWITCH_CODES;
     const cooldownMs = cfg.cooldownMs ?? 60000;
     const maxCooldownMs = cfg.maxCooldownMs;

package/lib/rotate.js

@@ -26,6 +26,8 @@ import {
   formatModelQuotaExhaustion,
 } from './model-quota.js';
 
+import { LOCAL_POOL_EXHAUSTED_CODE } from './resolver.js';
+
 export const LOCAL_QUOTA_CODE = 'LOCAL_MODEL_QUOTA_EXHAUSTED';
 
 export async function* preserveDispatchContext(iterable, storage, store) {
@@ -186,6 +188,16 @@ export function createRotate(deps) {
           logWarn(`[dsh-key-rotation] ${options.provider}: key ${targetRef} permanently REVOKED on auth failure`);
         } else {
           pool.state.authFailCounts.delete(targetRef);
+          if (!isQuota) {
+            const _fc = (pool.state.failCounts.get(targetRef) ?? 0) + 1;
+            pool.state.failCounts.set(targetRef, _fc);
+            if (_fc >= 3 && !pool.state.brokenUntil.has(targetRef)) {
+              const quarantineMs = 1800000;
+              pool.state.brokenUntil.set(targetRef, Date.now() + quarantineMs);
+              pushEvent(pool, targetRef, 'KEY_QUARANTINED', quarantineMs);
+              logWarn(`[dsh-key-rotation] ${options.provider}: key ${targetRef} put in recoverable quarantine after ${_fc} failures`);
+            }
+          }
         }
       };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-key-rotation",
-  "version": "0.8.42",
+  "version": "0.8.43",
   "packageManager": "pnpm@10.33.2",
   "description": "Per-provider API key rotation for DeepSeek Harness: a key pool per provider, auto-created clone routes, and switching to the next key on quota/rate-limit errors. Includes a Settings section (Key Rotation) to edit the key pools, cooldown and switch codes.",
   "keywords": [