@goodandready/dsh-key-rotation 0.7.26 → 0.7.27

package/lib/cascade.js

@@ -1,39 +1,39 @@
-// cascade.js — cross-provider failover cascade (issue #194).
-// ponytail: minimal — pick fallback provider from a RegionMap-like config.
-
-export const CASCADE_MAX_DEPTH = 1;
-
-export function pickCascadeFallback(provider, cfg, pools) {
-  const list = Array.isArray(cfg && cfg.cascade) ? cfg.cascade : [];
-  for (const entry of list) {
-    const fb = typeof entry === 'string' ? { provider: entry } : entry;
-    if (!fb || !fb.provider || fb.provider === provider) continue;
-    const pool = pools instanceof Map ? pools.get(fb.provider) : (pools ? pools[fb.provider] : null);
-    if (!pool) continue;
-    const now = Date.now();
-    let healthy = 0;
-    for (const ref of pool.refs) {
-      const failedUntil = (pool.state && pool.state.failedUntil && pool.state.failedUntil.get(ref)) || 0;
-      if (failedUntil > now) continue;
-      const exp = pool.expiresAt ? pool.expiresAt[ref] : undefined;
-      if (exp !== undefined && now >= exp) continue;
-      healthy += 1;
-    }
-    if (healthy === 0) continue;
-    return { provider: fb.provider, pool, model: fb.model || null };
-  }
-  return null;
-}
-
-export function hasHealthyKey(pool, now) {
-  now = now || Date.now();
-  if (!pool || !Array.isArray(pool.refs)) return false;
-  for (const ref of pool.refs) {
-    const failedUntil = (pool.state && pool.state.failedUntil && pool.state.failedUntil.get(ref)) || 0;
-    if (failedUntil > now) continue;
-    const exp = pool.expiresAt ? pool.expiresAt[ref] : undefined;
-    if (exp !== undefined && now >= exp) continue;
-    return true;
-  }
-  return false;
-}
+// cascade.js — cross-provider failover cascade (issue #194).
+// ponytail: minimal — pick fallback provider from a RegionMap-like config.
+
+export const CASCADE_MAX_DEPTH = 1;
+
+export function pickCascadeFallback(provider, cfg, pools) {
+  const list = Array.isArray(cfg && cfg.cascade) ? cfg.cascade : [];
+  for (const entry of list) {
+    const fb = typeof entry === 'string' ? { provider: entry } : entry;
+    if (!fb || !fb.provider || fb.provider === provider) continue;
+    const pool = pools instanceof Map ? pools.get(fb.provider) : (pools ? pools[fb.provider] : null);
+    if (!pool) continue;
+    const now = Date.now();
+    let healthy = 0;
+    for (const ref of pool.refs) {
+      const failedUntil = (pool.state && pool.state.failedUntil && pool.state.failedUntil.get(ref)) || 0;
+      if (failedUntil > now) continue;
+      const exp = pool.expiresAt ? pool.expiresAt[ref] : undefined;
+      if (exp !== undefined && now >= exp) continue;
+      healthy += 1;
+    }
+    if (healthy === 0) continue;
+    return { provider: fb.provider, pool, model: fb.model || null };
+  }
+  return null;
+}
+
+export function hasHealthyKey(pool, now) {
+  now = now || Date.now();
+  if (!pool || !Array.isArray(pool.refs)) return false;
+  for (const ref of pool.refs) {
+    const failedUntil = (pool.state && pool.state.failedUntil && pool.state.failedUntil.get(ref)) || 0;
+    if (failedUntil > now) continue;
+    const exp = pool.expiresAt ? pool.expiresAt[ref] : undefined;
+    if (exp !== undefined && now >= exp) continue;
+    return true;
+  }
+  return false;
+}

package/lib/client-helpers.js

@@ -1,21 +1,21 @@
-export function formatAgo(t, at) {
-  if (!at) return '';
-  const sec = Math.max(0, Math.round((Date.now() - at) / 1000));
-  if (sec < 60) return t('justNow');
-  if (sec < 3600) return t('minutesAgo').replace('{n}', String(Math.round(sec / 60)));
-  return t('hoursAgo').replace('{n}', String(Math.round(sec / 3600)));
-}
-
-export function nextKeyRef(providerId, existingKeys, allRefs) {
-  const fromExisting = (existingKeys || []).find((k) => typeof k === 'string' && k.length > 0);
-  const base = fromExisting
-    ? fromExisting.replace(/_\d+$/, '')
-    : String(providerId || 'provider').toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '') + '_API_KEY';
-  const taken = new Set(allRefs);
-  if (!taken.has(base)) return base;
-  for (let n = 2; n < 1000; n++) {
-    const candidate = base + '_' + n;
-    if (!taken.has(candidate)) return candidate;
-  }
-  return base + '_' + Date.now();
-}
+export function formatAgo(t, at) {
+  if (!at) return '';
+  const sec = Math.max(0, Math.round((Date.now() - at) / 1000));
+  if (sec < 60) return t('justNow');
+  if (sec < 3600) return t('minutesAgo').replace('{n}', String(Math.round(sec / 60)));
+  return t('hoursAgo').replace('{n}', String(Math.round(sec / 3600)));
+}
+
+export function nextKeyRef(providerId, existingKeys, allRefs) {
+  const fromExisting = (existingKeys || []).find((k) => typeof k === 'string' && k.length > 0);
+  const base = fromExisting
+    ? fromExisting.replace(/_\d+$/, '')
+    : String(providerId || 'provider').toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '') + '_API_KEY';
+  const taken = new Set(allRefs);
+  if (!taken.has(base)) return base;
+  for (let n = 2; n < 1000; n++) {
+    const candidate = base + '_' + n;
+    if (!taken.has(candidate)) return candidate;
+  }
+  return base + '_' + Date.now();
+}

package/lib/client.js

@@ -63,6 +63,7 @@ window.__ModuleLoader__.load({
       keySaved: 'saved',
       keyFromEnv: 'from the environment, read-only here',
       keyWriteFailed: 'could not store the key: {msg}',
+      notSecretShape: 'saved, but the value does not look like an API key - check for a typo',
       keyHint: 'The value is stored in DSH credentials and never sent back to the browser — only its last 5 characters are shown. Names are generated for you; hover a key to see the one it uses.',
       brokenKey: 'broken (3× AUTH)',
       keyExpired: 'expired',
@@ -119,6 +120,7 @@ window.__ModuleLoader__.load({
       keySaved: 'сохранён',
       keyFromEnv: 'задан в окружении, отсюда не меняется',
       keyWriteFailed: 'не удалось сохранить ключ: {msg}',
+      notSecretShape: 'сохранено, но значение не похоже на API-ключ — проверьте опечатки',
       keyHint: 'Значение хранится в учётных данных DSH и обратно в браузер не отдаётся — показываются только последние 5 символов. Имена переменных создаются автоматически; наведите на ключ, чтобы увидеть используемое имя.',
       brokenKey: 'сломан (3× AUTH)',
       keyExpired: 'истёк',
@@ -390,6 +392,11 @@ window.__ModuleLoader__.load({
           .then((r) => r.json().then((data) => ({ ok: r.ok, data })))
           .then(({ ok, data }) => {
             if (!ok) throw new Error(data?.error?.message ?? 'unknown error');
+            // #200 leak-detector hint: stored value does not match any known
+            // API-key shape - probably a placeholder or a typo.
+            if (data?.looksLikeSecret === false) {
+              setSecretError(t('notSecretShape'));
+            }
             setSecretDraft((cur) => {
               const next = { ...cur };
               delete next[rowKey];
@@ -803,10 +810,54 @@ window.__ModuleLoader__.load({
   if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', init); else init();
 }
 
-function apply(ctx) {
+    // #201 header chip: one dot + counts for all pools. Green = all healthy,
+    // amber = some keys cooling, red = a pool fully exhausted. Click opens the
+    // same summary the floating dashboard shows.
+    function KeyRotationHeaderChip() {
+      const [snap, setSnap] = React.useState(null);
+      React.useEffect(() => {
+        let alive = true;
+        const load = () => {
+          fetch('/dsh-key-rotation/health', { headers: { accept: 'application/json' }, credentials: 'same-origin' })
+            .then((r) => (r.ok ? r.json() : null))
+            .then((d) => { if (alive) setSnap(d); })
+            .catch(() => {});
+        };
+        load();
+        const id = setInterval(load, 4000);
+        return () => { alive = false; clearInterval(id); };
+      }, []);
+      const pools = Object.values((snap && snap.pools) || {});
+      const total = pools.reduce((a, p) => a + (p.total || 0), 0);
+      const healthy = pools.reduce((a, p) => a + (p.healthy || 0), 0);
+      const anyExhausted = pools.some((p) => p.exhausted);
+      const color = !pools.length ? 'var(--dsw-alias-label-tertiary)' : anyExhausted ? '#e5484d' : healthy < total ? '#f5a623' : '#30a46c';
+      const label = pools.length ? `${healthy}/${total}` : 'rot';
+      return h('span', {
+        className: 'krot-chip',
+        title: 'Key Rotation',
+        style: { display: 'inline-flex', alignItems: 'center', gap: '5px', fontSize: '11px', color: 'var(--dsw-alias-label-secondary)', cursor: 'default' },
+      },
+        h('span', { style: { width: '8px', height: '8px', borderRadius: '50%', background: color, flex: 'none' } }),
+        label);
+    }
+
+    function apply(ctx) {
       ctx.effect(() => ctx.locale.register(NS, { en, ru }), 'dsh-key-rotation: dictionaries');
       // Dashboard widget: lives on every page, polls /health (#152).
       ctx.effect(() => mountDashboard(), 'dsh-key-rotation: dashboard widget');
+      // Header chip (#201): status dot in the session header utilities slot,
+      // same slot dsh-gitea / dsh-subscriptions use for their header widgets.
+      ctx.effect(() => {
+        if (!ctx.slots) return;
+        try {
+          ctx.slots.inject('conversation.session.header.utilities', () =>
+            ctx.slots.register(
+              { name: 'conversation.session.header.utilities', id: 'dsh-key-rotation-header-chip', order: 6 },
+              KeyRotationHeaderChip,
+            ));
+        } catch { /* slot not available in this build */ }
+      }, 'dsh-key-rotation: header chip');
       function useLocale() {
         return useActiveLocale(ctx);
       }

package/lib/concurrency.js

@@ -1,72 +1,72 @@
-// 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);
+      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; }
+}

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;
+  }
+}