@goodandready/dsh-key-rotation 0.7.30 → 0.7.32

package/lib/concurrency.js

@@ -1,72 +1,73 @@
-// concurrency.js — per-key in-flight counter + least-connections picking (issue #193).
-
-export const CONCURRENCY_DEFAULT_LIMIT = 0;
-export const CONCURRENCY_STALE_LOCK_MS = 5 * 60 * 1000;
-
-export class ConcurrencyTracker {
-  constructor(opts) {
-    opts = opts || {};
-    const limit = opts.limit !== undefined ? opts.limit : CONCURRENCY_DEFAULT_LIMIT;
-    this._limit = (Number.isFinite(limit) && limit >= 0) ? Math.floor(limit) : 0;
-    this._staleMs = opts.staleMs || CONCURRENCY_STALE_LOCK_MS;
-    this._inFlight = new Map();
-  }
-
-  isEnabled() { return this._limit > 0; }
-  get limit() { return this._limit; }
-
-  acquire(ref, now) {
-    now = now || Date.now();
-    if (!this.isEnabled()) return true;
-    let e = this._inFlight.get(ref);
-    if (!e) {
-      e = { count: 0, lastAcquired: now };
-      this._inFlight.set(ref, e);
-    }
-    if (now - e.lastAcquired > this._staleMs) {
-      e.count = 0;
-    }
-    if (e.count >= this._limit) return false;
-    e.count += 1;
-    e.lastAcquired = now;
-    return true;
-  }
-
-  release(ref, now) {
-    now = now || Date.now();
-    const e = this._inFlight.get(ref);
-    if (!e) return;
-    e.count = Math.max(0, e.count - 1);
-    e.lastAcquired = now;
-  }
-
-  snapshot() {
-    const out = {};
-    for (const [k, v] of this._inFlight) out[k] = { count: v.count };
-    return out;
-  }
-
-  pickLeastLoaded(candidates, now) {
-    now = now || Date.now();
-    if (!Array.isArray(candidates) || candidates.length === 0) return null;
-    let best = null;
-    let bestCount = Infinity;
-    for (const ref of candidates) {
-      const e = this._inFlight.get(ref);
-      const count = e ? e.count : 0;
-      if (this.isEnabled() && count >= this._limit) continue;
-      if (count < bestCount) {
-        best = ref;
-        bestCount = count;
-      }
-    }
-    return best;
-  }
-
-  clear(ref) {
-    if (ref) this._inFlight.delete(ref);
-    else this._inFlight.clear();
-  }
-
-  get size() { return this._inFlight.size; }
-}
+// concurrency.js — per-key in-flight counter + least-connections picking (issue #193).
+
+export const CONCURRENCY_DEFAULT_LIMIT = 0;
+export const CONCURRENCY_STALE_LOCK_MS = 5 * 60 * 1000;
+
+export class ConcurrencyTracker {
+  constructor(opts) {
+    opts = opts || {};
+    const limit = opts.limit !== undefined ? opts.limit : CONCURRENCY_DEFAULT_LIMIT;
+    this._limit = (Number.isFinite(limit) && limit >= 0) ? Math.floor(limit) : 0;
+    this._staleMs = opts.staleMs || CONCURRENCY_STALE_LOCK_MS;
+    this._inFlight = new Map();
+  }
+
+  isEnabled() { return this._limit > 0; }
+  get limit() { return this._limit; }
+
+  acquire(ref, now) {
+    now = now || Date.now();
+    if (!this.isEnabled()) return true;
+    let e = this._inFlight.get(ref);
+    if (!e) {
+      e = { count: 0, lastAcquired: now };
+      this._inFlight.set(ref, e);
+    }
+    if (now - e.lastAcquired > this._staleMs) {
+      e.count = 0;
+    }
+    if (e.count >= this._limit) return false;
+    e.count += 1;
+    e.lastAcquired = now;
+    return true;
+  }
+
+  release(ref, now) {
+    now = now || Date.now();
+    const e = this._inFlight.get(ref);
+    if (!e) return;
+    e.count = Math.max(0, e.count - 1);
+    e.lastAcquired = now;
+  }
+
+  snapshot() {
+    const out = {};
+    for (const [k, v] of this._inFlight) out[k] = { count: v.count };
+    return out;
+  }
+
+  pickLeastLoaded(candidates, now) {
+    now = now || Date.now();
+    if (!Array.isArray(candidates) || candidates.length === 0) return null;
+    let best = null;
+    let bestCount = Infinity;
+    for (const ref of candidates) {
+      const e = this._inFlight.get(ref);
+      let count = e ? e.count : 0;
+      if (e && now - e.lastAcquired > this._staleMs) count = 0;
+      if (this.isEnabled() && count >= this._limit) continue;
+      if (count < bestCount) {
+        best = ref;
+        bestCount = count;
+      }
+    }
+    return best;
+  }
+
+  clear(ref) {
+    if (ref) this._inFlight.delete(ref);
+    else this._inFlight.clear();
+  }
+
+  get size() { return this._inFlight.size; }
+}

package/lib/heal.js

@@ -1,35 +1,35 @@
-// heal.js — self-healing idle cooldowns.
-// ponytail: pure function, easy to test, no side effects beyond mutation of passed-in state.
-
-// Returns array of { ref, poolBase } entries that were healed in this tick.
-// Mutates `pools` (removes from failedUntil, pushes heal event into events).
-// `now` parameter is injectable for tests.
-export function healIdleCooldowns(pools, idleMs, now = Date.now()) {
-  if (!Array.isArray(pools) || pools.length === 0) return [];
-  if (!Number.isFinite(idleMs) || idleMs <= 0) return [];
-  const healed = [];
-  for (const pool of pools) {
-    if (!pool || !pool.state || !pool.base) continue;
-    const fu = pool.state.failedUntil;
-    const lu = pool.state.lastUsed;
-    if (!fu || fu.size === 0) continue;
-    const expiredRefs = [];
-    for (const [ref, until] of fu.entries()) {
-      if (!Number.isFinite(until)) continue;
-      if (until > now) continue; // cooldown still active
-      const last = lu ? lu.get(ref) : undefined;
-      if (!Number.isFinite(last)) continue; // never used → no signal, skip
-      if (now - last < idleMs) continue; // used recently → don't heal
-      expiredRefs.push(ref);
-    }
-    for (const ref of expiredRefs) {
-      fu.delete(ref);
-      if (Array.isArray(pool.state.events)) {
-        pool.state.events.push({ at: now, ref, reason: 'self-heal', cooldownMs: 0, type: 'heal' });
-        if (pool.state.events.length > 50) pool.state.events.shift();
-      }
-      healed.push({ ref, poolBase: pool.base });
-    }
-  }
-  return healed;
-}
+// heal.js — self-healing idle cooldowns.
+// ponytail: pure function, easy to test, no side effects beyond mutation of passed-in state.
+
+// Returns array of { ref, poolBase } entries that were healed in this tick.
+// Mutates `pools` (removes from failedUntil, pushes heal event into events).
+// `now` parameter is injectable for tests.
+export function healIdleCooldowns(pools, idleMs, now = Date.now()) {
+  if (!Array.isArray(pools) || pools.length === 0) return [];
+  if (!Number.isFinite(idleMs) || idleMs <= 0) return [];
+  const healed = [];
+  for (const pool of pools) {
+    if (!pool || !pool.state || !pool.base) continue;
+    const fu = pool.state.failedUntil;
+    const lu = pool.state.lastUsed;
+    if (!fu || fu.size === 0) continue;
+    const expiredRefs = [];
+    for (const [ref, until] of fu.entries()) {
+      if (!Number.isFinite(until)) continue;
+      if (until > now) continue; // cooldown still active
+      const last = lu ? lu.get(ref) : undefined;
+      if (!Number.isFinite(last)) continue; // never used → no signal, skip
+      if (now - last < idleMs) continue; // used recently → don't heal
+      expiredRefs.push(ref);
+    }
+    for (const ref of expiredRefs) {
+      fu.delete(ref);
+      if (Array.isArray(pool.state.events)) {
+        pool.state.events.push({ at: now, ref, reason: 'self-heal', cooldownMs: 0, type: 'heal' });
+        if (pool.state.events.length > 50) pool.state.events.shift();
+      }
+      healed.push({ ref, poolBase: pool.base });
+    }
+  }
+  return healed;
+}

package/lib/histogram.js

@@ -1,66 +1,66 @@
-// histogram.js — per-ref latency ring buffer + percentile.
-// ponytail: ring buffer of fixed size, sort-on-read for percentile, no libraries.
-
-export const LATENCY_DEFAULT_WINDOW = 200;
-
-export class LatencyHistogram {
-  constructor({ window = LATENCY_DEFAULT_WINDOW } = {}) {
-    const w = Number.isFinite(window) && window > 0 ? Math.floor(window) : LATENCY_DEFAULT_WINDOW;
-    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) {
-    if (!ref || !Number.isFinite(ms) || ms < 0) return;
-    let entry = this._buffers.get(ref);
-    if (!entry) {
-      entry = { buf: new Float64Array(this._window), head: 0, count: 0 };
-      this._buffers.set(ref, entry);
-    }
-    entry.buf[entry.head] = ms;
-    entry.head = (entry.head + 1) % this._window;
-    if (entry.count < this._window) entry.count += 1;
-    this._lastAt.set(ref, Date.now());
-  }
-
-  // Returns p50/p95/p99 in milliseconds, plus count and lastAt. Sorted copy.
-  snapshot(ref) {
-    const entry = this._buffers.get(ref);
-    const lastAt = this._lastAt.get(ref);
-    if (!entry || entry.count === 0) {
-      return { count: 0, lastAt: lastAt || null };
-    }
-    const arr = entry.buf.subarray(0, entry.count);
-    const sorted = Array.from(arr).sort((a, b) => a - b);
-    const n = sorted.length;
-    return {
-      count: n,
-      lastAt: lastAt || null,
-      p50: sorted[Math.min(n - 1, Math.floor((n - 1) * 0.5))],
-      p95: sorted[Math.min(n - 1, Math.floor((n - 1) * 0.95))],
-      p99: sorted[Math.min(n - 1, Math.floor((n - 1) * 0.99))],
-    };
-  }
-
-  // Returns { [ref]: snapshot }
-  snapshotAll() {
-    const out = {};
-    for (const ref of this._buffers.keys()) out[ref] = this.snapshot(ref);
-    return out;
-  }
-
-  clear(ref) {
-    if (ref) {
-      this._buffers.delete(ref);
-      this._lastAt.delete(ref);
-    } else {
-      this._buffers.clear();
-      this._lastAt.clear();
-    }
-  }
-
-  get size() {
-    return this._buffers.size;
-  }
-}
+// histogram.js — per-ref latency ring buffer + percentile.
+// ponytail: ring buffer of fixed size, sort-on-read for percentile, no libraries.
+
+export const LATENCY_DEFAULT_WINDOW = 200;
+
+export class LatencyHistogram {
+  constructor({ window = LATENCY_DEFAULT_WINDOW } = {}) {
+    const w = Number.isFinite(window) && window > 0 ? Math.floor(window) : LATENCY_DEFAULT_WINDOW;
+    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) {
+    if (!ref || !Number.isFinite(ms) || ms < 0) return;
+    let entry = this._buffers.get(ref);
+    if (!entry) {
+      entry = { buf: new Float64Array(this._window), head: 0, count: 0 };
+      this._buffers.set(ref, entry);
+    }
+    entry.buf[entry.head] = ms;
+    entry.head = (entry.head + 1) % this._window;
+    if (entry.count < this._window) entry.count += 1;
+    this._lastAt.set(ref, Date.now());
+  }
+
+  // Returns p50/p95/p99 in milliseconds, plus count and lastAt. Sorted copy.
+  snapshot(ref) {
+    const entry = this._buffers.get(ref);
+    const lastAt = this._lastAt.get(ref);
+    if (!entry || entry.count === 0) {
+      return { count: 0, lastAt: lastAt || null };
+    }
+    const arr = entry.buf.subarray(0, entry.count);
+    const sorted = Array.from(arr).sort((a, b) => a - b);
+    const n = sorted.length;
+    return {
+      count: n,
+      lastAt: lastAt || null,
+      p50: sorted[Math.min(n - 1, Math.floor((n - 1) * 0.5))],
+      p95: sorted[Math.min(n - 1, Math.floor((n - 1) * 0.95))],
+      p99: sorted[Math.min(n - 1, Math.floor((n - 1) * 0.99))],
+    };
+  }
+
+  // Returns { [ref]: snapshot }
+  snapshotAll() {
+    const out = {};
+    for (const ref of this._buffers.keys()) out[ref] = this.snapshot(ref);
+    return out;
+  }
+
+  clear(ref) {
+    if (ref) {
+      this._buffers.delete(ref);
+      this._lastAt.delete(ref);
+    } else {
+      this._buffers.clear();
+      this._lastAt.clear();
+    }
+  }
+
+  get size() {
+    return this._buffers.size;
+  }
+}

package/lib/incident.js

@@ -1,76 +1,76 @@
-// lib/incident.js — auto-create Gitea issue when pool exhausted > threshold.
-// ponytail: minimal — caller provides a token + base URL. No retries on rate-limit.
-
-export const INCIDENT_DEFAULT_THRESHOLD_MS = 5 * 60 * 1000; // 5 min
-export const INCIDENT_DEFAULT_COOLDOWN_MS = 30 * 60 * 1000; // 30 min between incidents per provider
-export const INCIDENT_TIMEOUT_MS = 5000;
-
-export class IncidentReporter {
-  constructor({ token, baseUrl, repo, thresholdMs = INCIDENT_DEFAULT_THRESHOLD_MS, cooldownMs = INCIDENT_DEFAULT_COOLDOWN_MS, fetchImpl } = {}) {
-    if (!token) throw new Error('incident: token required');
-    if (!baseUrl) throw new Error('incident: baseUrl required');
-    if (!repo || !repo.includes('/')) throw new Error('incident: repo (owner/name) required');
-    this._token = token;
-    this._baseUrl = baseUrl.replace(/\/+$/, '');
-    this._repo = repo;
-    this._thresholdMs = thresholdMs;
-    this._cooldownMs = cooldownMs;
-    this._lastIncidentAt = new Map(); // provider -> epochMs
-    this._fetch = fetchImpl || (typeof fetch !== 'undefined' ? fetch : () => { throw new Error('incident: no fetch available'); });
-  }
-
-  // Should we report now? Pure; does not perform I/O.
-  shouldReport(provider, exhaustedSince, now = Date.now()) {
-    if (!provider) return false;
-    if (!Number.isFinite(exhaustedSince)) return false;
-    if (now - exhaustedSince < this._thresholdMs) return false;
-    const last = this._lastIncidentAt.get(provider);
-    if (Number.isFinite(last) && now - last < this._cooldownMs) return false;
-    return true;
-  }
-
-  markReported(provider, at = Date.now()) {
-    this._lastIncidentAt.set(provider, at);
-  }
-
-  resetCooldown(provider) {
-    if (provider) this._lastIncidentAt.delete(provider);
-    else this._lastIncidentAt.clear();
-  }
-
-  // Open a Gitea issue. ponytail: minimal payload, ignore failures.
-  async open(provider, exhaustedSince, now = Date.now()) {
-    if (!this.shouldReport(provider, exhaustedSince, now)) return { reported: false };
-    const url = `${this._baseUrl}/api/v1/repos/${this._repo}/issues`;
-    const body = {
-      title: `prod-incident: pool ${provider} exhausted since ${new Date(exhaustedSince).toISOString()}`,
-      body: [
-        'Auto-generated by `dsh-key-rotation`.',
-        '',
-        `- provider: \`${provider}\``,
-        `- exhaustedSince: \`${new Date(exhaustedSince).toISOString()}\``,
-        '',
-        'All keys in the pool are in cooldown or missing. Check OpenCode provider status and rotate keys.',
-      ].join('\n'),
-      labels: ['prod-incident'],
-    };
-    const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(), INCIDENT_TIMEOUT_MS);
-    try {
-      const res = await this._fetch(url, {
-        method: 'POST',
-        headers: { authorization: `token ${this._token}`, 'content-type': 'application/json' },
-        body: JSON.stringify(body),
-        signal: ctrl.signal,
-      });
-      if (!res.ok) return { reported: false, status: res.status };
-      const data = await res.json();
-      this.markReported(provider, now);
-      return { reported: true, number: data.number, url: data.html_url };
-    } catch (_) {
-      return { reported: false };
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-}
+// lib/incident.js — auto-create Gitea issue when pool exhausted > threshold.
+// ponytail: minimal — caller provides a token + base URL. No retries on rate-limit.
+
+export const INCIDENT_DEFAULT_THRESHOLD_MS = 5 * 60 * 1000; // 5 min
+export const INCIDENT_DEFAULT_COOLDOWN_MS = 30 * 60 * 1000; // 30 min between incidents per provider
+export const INCIDENT_TIMEOUT_MS = 5000;
+
+export class IncidentReporter {
+  constructor({ token, baseUrl, repo, thresholdMs = INCIDENT_DEFAULT_THRESHOLD_MS, cooldownMs = INCIDENT_DEFAULT_COOLDOWN_MS, fetchImpl } = {}) {
+    if (!token) throw new Error('incident: token required');
+    if (!baseUrl) throw new Error('incident: baseUrl required');
+    if (!repo || !repo.includes('/')) throw new Error('incident: repo (owner/name) required');
+    this._token = token;
+    this._baseUrl = baseUrl.replace(/\/+$/, '');
+    this._repo = repo;
+    this._thresholdMs = thresholdMs;
+    this._cooldownMs = cooldownMs;
+    this._lastIncidentAt = new Map(); // provider -> epochMs
+    this._fetch = fetchImpl || (typeof fetch !== 'undefined' ? fetch : () => { throw new Error('incident: no fetch available'); });
+  }
+
+  // Should we report now? Pure; does not perform I/O.
+  shouldReport(provider, exhaustedSince, now = Date.now()) {
+    if (!provider) return false;
+    if (!Number.isFinite(exhaustedSince)) return false;
+    if (now - exhaustedSince < this._thresholdMs) return false;
+    const last = this._lastIncidentAt.get(provider);
+    if (Number.isFinite(last) && now - last < this._cooldownMs) return false;
+    return true;
+  }
+
+  markReported(provider, at = Date.now()) {
+    this._lastIncidentAt.set(provider, at);
+  }
+
+  resetCooldown(provider) {
+    if (provider) this._lastIncidentAt.delete(provider);
+    else this._lastIncidentAt.clear();
+  }
+
+  // Open a Gitea issue. ponytail: minimal payload, ignore failures.
+  async open(provider, exhaustedSince, now = Date.now()) {
+    if (!this.shouldReport(provider, exhaustedSince, now)) return { reported: false };
+    const url = `${this._baseUrl}/api/v1/repos/${this._repo}/issues`;
+    const body = {
+      title: `prod-incident: pool ${provider} exhausted since ${new Date(exhaustedSince).toISOString()}`,
+      body: [
+        'Auto-generated by `dsh-key-rotation`.',
+        '',
+        `- provider: \`${provider}\``,
+        `- exhaustedSince: \`${new Date(exhaustedSince).toISOString()}\``,
+        '',
+        'All keys in the pool are in cooldown or missing. Check OpenCode provider status and rotate keys.',
+      ].join('\n'),
+      labels: ['prod-incident'],
+    };
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), INCIDENT_TIMEOUT_MS);
+    try {
+      const res = await this._fetch(url, {
+        method: 'POST',
+        headers: { authorization: `token ${this._token}`, 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+        signal: ctrl.signal,
+      });
+      if (!res.ok) return { reported: false, status: res.status };
+      const data = await res.json();
+      this.markReported(provider, now);
+      return { reported: true, number: data.number, url: data.html_url };
+    } catch (_) {
+      return { reported: false };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}