@goodandready/dsh-key-rotation 0.8.11 → 0.8.12

package/lib/ops-test.js

@@ -0,0 +1,106 @@
+// lib/ops-test.js — sandbox test + sandbox cache routes (#312 split from routes-ops.js).
+import {
+  json,
+  readJson,
+} from './http-bridge.js';
+import {
+  isTrustedBridgeRequest,
+  isValidRef,
+  keyTail,
+  envValue,
+} from './pool.js';
+import { bestEffort } from './best-effort.js';
+import {
+  TEST_PATH,
+  SANDBOX_CACHE_PATH,
+} from './ops-paths.js';
+
+/**
+ * @param {object} ctx cordis context
+ * @param {object} deps live dependencies from apply()
+ */
+export function registerTestRoutes(ctx, deps) {
+  const {
+    lastTestCache,
+    ensureSandboxRunner,
+    poolState,
+  } = deps;
+
+// ── test route: dry-run a single key without rotation ──
+ctx.effect(() => ctx.webServer.register({
+  kind: 'exact',
+  path: TEST_PATH,
+  handler: async (req, res) => {
+    if (req.method !== 'POST') { json(res, 405, { error: { code: 'method', message: 'POST only' } }); return; }
+    if (!isTrustedBridgeRequest(req)) { json(res, 403, { error: { code: 'forbidden', message: 'dsh-key-rotation: test is local-only' } }); return; }
+    let body; try { body = await readJson(req); } catch (e) { json(res, 400, { error: { code: 'bad-request', message: String(e?.message ?? e) } }); return; }
+    const ref = typeof body?.ref === 'string' ? body.ref.trim() : '';
+    if (!isValidRef(ref)) { json(res, 400, { error: { code: 'bad-ref', message: 'dsh-key-rotation: ref must be an environment variable name' } }); return; }
+    // Optional value for pre-save validation (issue #118)
+    const testValue = typeof body?.value === 'string' && body.value.length > 0 ? body.value : undefined;
+    const probe = body?.probe === 'models' || body?.probe === 'chat' ? body.probe : undefined;
+    const base = ctx.get('credentials');
+    try {
+      let hit = await (base?.__dshKeyRotationOriginalResolve ?? base?.resolve)?.call(base, ref);
+      let present = Boolean(hit && typeof hit.value === 'string' && hit.value.length > 0);
+      const effectiveValue = testValue || hit?.value;
+      const valid = present ? Boolean(effectiveValue && typeof effectiveValue === 'string' && effectiveValue.length > 0) : Boolean(testValue);
+      const tail = valid ? keyTail(effectiveValue) : '';
+      let source = null;
+      await bestEffort('credentials.describe', async () => { const d = await base?.describe?.(ref); source = d?.source ?? null; }, ctx.logger);
+      if (!present && !testValue) { json(res, 200, { ok: false, ref, code: 'no-credential', message: 'no such credential' }); return; }
+      if (!present && testValue) { source = 'pre-save'; }
+      else if (!present) {
+        const ev = envValue(ref);
+        if (ev !== undefined) { present = true; json(res, 200, { ok: true, ref, tail: keyTail(ev), source: 'env' }); return; }
+      }
+      // sandbox probe (models is free; chat is hook-only, see sandbox.js)
+      if (probe) {
+        const keyForProbe = effectiveValue;
+        const runner = ensureSandboxRunner(ctx);
+        const result = probe === 'chat' ? await runner.probeChat(ref, keyForProbe) : await runner.probeModels(ref, keyForProbe);
+        const cached = { ...result, at: Date.now() };
+        lastTestCache.set(ref, cached);
+        if (cached.ok) {
+          for (const st of poolState.values()) {
+            if (st.failedUntil?.has(ref) || st.failCounts?.has(ref) || st.brokenUntil?.has(ref)) {
+              st.failedUntil?.delete(ref);
+              st.failCounts?.delete(ref);
+              st.authFailCounts?.delete(ref);
+              st.brokenUntil?.delete(ref);
+            }
+          }
+        }
+        json(res, 200, { ok: cached.ok, ref, tail, source, probe, code: cached.code, latencyMs: cached.latencyMs, modelsCount: cached.modelsCount });
+        return;
+      }
+      json(res, 200, { ok: true, ref, tail, source });
+    } catch (e) {
+      json(res, 200, { ok: false, ref, code: 'error', message: String(e?.message ?? e) });
+    }
+  },
+}), 'dsh-key-rotation: test route');
+
+// Intercept the llm/stream waterfall: rotate any request whose provider maps
+// to a configured key pool; pass everything else (and internal dispatches)
+// straight through.
+// Read-only cache snapshot for clients (badge polling).
+
+ctx.effect(() => ctx.webServer.register({
+  kind: 'exact',
+  path: SANDBOX_CACHE_PATH,
+  handler: (req, res) => {
+    if (!isTrustedBridgeRequest(req)) { json(res, 403, { error: { code: 'forbidden', message: 'dsh-key-rotation: cache is local-only' } }); return; }
+    const cacheSnap = typeof lastTestCache?.snapshot === 'function'
+      ? lastTestCache.snapshot()
+      : (lastTestCache instanceof Map ? Object.fromEntries(lastTestCache) : (lastTestCache ?? {}));
+    json(res, 200, cacheSnap);
+  },
+}), 'dsh-key-rotation: sandbox cache');
+
+
+
+// #199 webhook-action: interactive webhook buttons call back here.
+// Auth: bearer token from Config (external services like Telegram/Discord
+// cannot be same-origin, so a shared secret is the gate).
+}

package/lib/ops-webhook.js

@@ -0,0 +1,115 @@
+// lib/ops-webhook.js — webhook interactive action route (#312 split from routes-ops.js).
+import {
+  json,
+  readJson,
+} from './http-bridge.js';
+import { WEBHOOK_ACTION_PATH } from './ops-paths.js';
+
+/**
+ * @param {object} ctx cordis context
+ * @param {object} deps live dependencies from apply()
+ */
+export function registerWebhookActionRoute(ctx, deps) {
+  const {
+    buildRuntime,
+    poolState,
+    setRotationDisabled,
+    circuitBreaker,
+  } = deps;
+
+ctx.effect(() => ctx.webServer.register({
+  kind: 'exact',
+  path: WEBHOOK_ACTION_PATH,
+  handler: async (req, res) => {
+    if (req.method !== 'POST') { json(res, 405, { error: { code: 'method', message: 'POST only' } }); return; }
+    const runtime = buildRuntime();
+    const expected = runtime.webhookActionToken;
+    if (!expected) { json(res, 503, { error: { code: 'no-token', message: 'dsh-key-rotation: webhookActionToken is not configured' } }); return; }
+    const auth = String(req.headers.authorization ?? '');
+    if (auth !== `Bearer ${expected}`) { json(res, 401, { error: { code: 'unauthorized', message: 'dsh-key-rotation: bad webhook action token' } }); return; }
+    let body;
+    try { body = await readJson(req); } catch (e) { json(res, 400, { error: { code: 'bad-request', message: String(e?.message ?? e) } }); return; }
+    // Accept callback payloads from formatInteractive (Telegram/Discord/Slack) or plain {action}
+    let action = typeof body?.action === 'string' ? body.action : '';
+    if (!action && typeof body?.data === 'string') {
+      try { action = String(JSON.parse(body.data)?.id ?? ''); } catch { action = ''; }
+    }
+    if (!action && typeof body?.callback_data === 'string') {
+      try { action = String(JSON.parse(body.callback_data)?.id ?? ''); } catch { action = ''; }
+    }
+    // #222: Telegram update envelope {update_id, callback_query:{data}}
+    if (!action && typeof body?.callback_query?.data === 'string') {
+      try { action = String(JSON.parse(body.callback_query.data)?.id ?? ''); } catch { action = ''; }
+    }
+    // #222: Telegram setWebhook registration helper
+    if (typeof body?.setWebhook === 'object' && body.setWebhook) {
+      const botToken = typeof body.setWebhook.botToken === 'string' ? body.setWebhook.botToken : '';
+      if (!botToken) { json(res, 400, { error: { code: 'bad-request', message: 'dsh-key-rotation: setWebhook.botToken required' } }); return; }
+      // derive the public URL from request headers; explicit URL wins
+      const url = typeof body.setWebhook.url === 'string' && body.setWebhook.url ? body.setWebhook.url : `https://${String(req.headers.host ?? '')}/dsh-key-rotation/webhook-action`;
+      try {
+        const hookRes = await fetch(`https://api.telegram.org/bot${botToken}/setWebhook`, {
+          method: 'POST', headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ url, allowed_updates: ['callback_query'] }),
+        });
+        const hookData = await hookRes.json().catch(() => ({}));
+        json(res, 200, { ok: hookRes.ok, url, telegram: hookData });
+      } catch (e) {
+        json(res, 502, { error: { code: 'telegram-failed', message: String(e?.message ?? e) } });
+      }
+      return;
+    }
+    if (!action) { json(res, 400, { error: { code: 'bad-action', message: 'dsh-key-rotation: no action in payload' } }); return; }
+    const provider = action.startsWith('pause-') || action.startsWith('reset-') ? action.replace(/^(pause|reset)-/, '') : '';
+    try {
+      if (action === 'disable-rotation') {
+        setRotationDisabled(true);
+        console.warn('[dsh-key-rotation] rotation DISABLED via webhook action');
+        json(res, 200, { ok: true, action });
+        return;
+      }
+      if (action === 'enable-rotation') {
+        setRotationDisabled(false);
+        json(res, 200, { ok: true, action });
+        return;
+      }
+      if (action.startsWith('pause-') || action.startsWith('reset-')) {
+        const st = poolState.get(provider);
+        if (!st) { json(res, 404, { error: { code: 'not-found', message: `dsh-key-rotation: no pool for '${provider}'` } }); return; }
+        if (action.startsWith('pause-')) {
+          const until = Date.now() + 3600000; // 1h pause
+          for (const ref of (st.failedUntil ? [...st.failedUntil.keys()] : [])) st.failedUntil.set(ref, Math.max(st.failedUntil.get(ref) ?? 0, until));
+          // also pause every key currently healthy
+          for (const p of buildRuntime().poolByRef.values()) {
+            if (p.base !== provider) continue;
+            for (const ref of p.refs) st.failedUntil.set(ref, Math.max(st.failedUntil.get(ref) ?? 0, until));
+          }
+          console.warn(`[dsh-key-rotation] pool ${provider} PAUSED 1h via webhook action`);
+          json(res, 200, { ok: true, action, provider, until: Date.now() + 3600000 });
+          return;
+        }
+        const cleared = st.failedUntil.size;
+        st.failedUntil.clear();
+        st.failCounts?.clear();
+        st.authFailCounts?.clear();
+        st.brokenUntil?.clear();
+        st.switches = 0;
+        st.lastReason = undefined;
+        st.lastSwitchAt = undefined;
+        let circuitReset = false;
+        const br = circuitBreaker ?? buildRuntime().breaker;
+        if (br) {
+          if (typeof br.reset === 'function') { br.reset(provider); circuitReset = true; }
+          else if (typeof br.onSuccess === 'function') { br.onSuccess(provider); circuitReset = true; }
+        }
+        console.warn(`[dsh-key-rotation] pool ${provider} RESET via webhook action (circuitReset=${circuitReset})`);
+        json(res, 200, { ok: true, action, provider, cleared, circuitReset });
+        return;
+      }
+      json(res, 400, { error: { code: 'unknown-action', message: `dsh-key-rotation: unknown action '${action}'` } });
+    } catch (e) {
+      json(res, 500, { error: { code: 'action-failed', message: String(e?.message ?? e) } });
+    }
+  },
+}), 'dsh-key-rotation: webhook-action');
+}