@goodandready/dsh-key-rotation 0.8.10 → 0.8.12

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

package/lib/plugin-updater.js

@@ -0,0 +1,277 @@
+import { spawn } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { basename, dirname, isAbsolute, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * Host-side one-click updater for a DSH Web plugin.
+ *
+ * Mount from apply():
+ *
+ * registerPluginUpdater(ctx, {
+ *   endpoint: '/dsh-key-rotation/update',
+ *   packageName: '@goodandready/dsh-key-rotation',
+ *   manifestUrl: new URL('../package.json', import.meta.url),
+ * })
+ *
+ * GET returns status. POST is accepted only from the local same-origin UI and
+ * installs the exact registry version through the normal DSH CLI.
+ */
+
+const UPDATE_HEADER = 'x-dsh-plugin-update'
+const UPDATE_TIMEOUT_MS = 10 * 60_000
+const VERSION_CACHE_MS = 5 * 60_000
+let latestCache
+
+function header(request, name) {
+  const value = request.headers?.[name]
+  return Array.isArray(value) ? value[0] : value
+}
+
+function isLoopback(value) {
+  const address = value?.toLowerCase().replace(/^\[|\]$/g, '')
+  return address === 'localhost' || address === 'localhost.' || address === '::1'
+    || address?.startsWith('127.') === true
+    || address?.startsWith('::ffff:127.') === true
+}
+
+export function isTrustedUpdateRequest(request) {
+  if (header(request, UPDATE_HEADER) !== '1') return false
+  if (!isLoopback(request.socket?.remoteAddress)) return false
+  const site = header(request, 'sec-fetch-site')
+  if (site !== undefined && site !== 'same-origin') return false
+  const origin = header(request, 'origin')
+  const host = header(request, 'host')
+  if (origin === undefined || host === undefined) return false
+  try {
+    const url = new URL(origin)
+    return (url.protocol === 'http:' || url.protocol === 'https:')
+      && isLoopback(url.hostname) && url.host === host
+  } catch {
+    return false
+  }
+}
+
+function validProfileName(value) {
+  return typeof value === 'string' && value !== '' && value !== '.' && value !== '..'
+    && !value.includes('/') && !value.includes('\\') && !/[\0-\x1f\x7f]/.test(value)
+}
+
+function profileNameFromArgv(argv) {
+  for (let index = 2; index < argv.length; index += 1) {
+    if (argv[index] === '--profile') return argv[index + 1]
+    if (argv[index]?.startsWith('--profile=')) return argv[index].slice('--profile='.length)
+  }
+  return argv[2] === 'web' ? 'web' : undefined
+}
+
+function findDshCliEntry() {
+  const value = process.argv[1]
+  if (value === undefined || value === '') return undefined
+  const entry = value.startsWith('file:') ? fileURLToPath(value) : resolve(process.cwd(), value)
+  if (!existsSync(entry)) return undefined
+  for (let directory = dirname(entry); ; directory = dirname(directory)) {
+    const manifestPath = resolve(directory, 'package.json')
+    if (existsSync(manifestPath)) {
+      try {
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
+        const bin = typeof manifest.bin === 'string'
+          ? manifest.bin
+          : typeof manifest.bin === 'object' && manifest.bin !== null
+            ? manifest.bin.dsh
+            : undefined
+        if (manifest.name === '@deepseek-ai/dsh' && typeof bin === 'string'
+          && !isAbsolute(bin) && resolve(directory, bin) === resolve(entry)) return entry
+      } catch {
+        // Continue searching parent package directories.
+      }
+    }
+    const parent = dirname(directory)
+    if (parent === directory) return undefined
+  }
+}
+
+function runtime() {
+  const profileDir = resolve(process.env.DSH_PROFILE_DIR
+    ?? resolve(homedir(), '.dsh', 'profiles', 'web'))
+  const selected = profileNameFromArgv(process.argv)
+  const profileName = validProfileName(selected)
+    ? selected
+    : validProfileName(basename(profileDir)) ? basename(profileDir) : 'web'
+  const cliEntry = findDshCliEntry()
+  return cliEntry === undefined ? { profileName, profileDir } : { profileName, profileDir, cliEntry }
+}
+
+function parseSemver(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value)
+  if (match === null) return undefined
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4]?.split('.') ?? [],
+  }
+}
+
+function comparePrerelease(left, right) {
+  if (left.length === 0 || right.length === 0) return left.length === right.length ? 0 : left.length === 0 ? 1 : -1
+  const length = Math.max(left.length, right.length)
+  for (let index = 0; index < length; index += 1) {
+    const a = left[index]
+    const b = right[index]
+    if (a === undefined || b === undefined) return a === b ? 0 : a === undefined ? -1 : 1
+    if (a === b) continue
+    const aNumeric = /^\d+$/.test(a)
+    const bNumeric = /^\d+$/.test(b)
+    if (aNumeric && bNumeric) {
+      const aNumber = BigInt(a)
+      const bNumber = BigInt(b)
+      if (aNumber !== bNumber) return aNumber > bNumber ? 1 : -1
+      continue
+    }
+    if (aNumeric !== bNumeric) return aNumeric ? -1 : 1
+    return a > b ? 1 : -1
+  }
+  return 0
+}
+
+export function isNewerVersion(currentValue, candidateValue) {
+  const current = parseSemver(currentValue)
+  const candidate = parseSemver(candidateValue)
+  if (current === undefined || candidate === undefined) return false
+  for (let index = 0; index < 3; index += 1) {
+    if (candidate.core[index] !== current.core[index]) return candidate.core[index] > current.core[index]
+  }
+  return comparePrerelease(candidate.prerelease, current.prerelease) > 0
+}
+
+async function latestVersion(packageName, registry) {
+  if (latestCache?.packageName === packageName && latestCache.registry === registry && Date.now() < latestCache.expiresAt) return latestCache.version
+  try {
+    const response = await fetch(`${registry.replace(/\/$/, '')}/${encodeURIComponent(packageName)}/latest`, {
+      signal: AbortSignal.timeout(8_000),
+    })
+    if (!response.ok) return undefined
+    const value = await response.json()
+    if (typeof value.version !== 'string' || value.version === '') return undefined
+    latestCache = { packageName, registry, version: value.version, expiresAt: Date.now() + VERSION_CACHE_MS }
+    return value.version
+  } catch {
+    return undefined
+  }
+}
+
+async function currentVersion(manifestUrl) {
+  const value = JSON.parse(await readFile(manifestUrl, 'utf8'))
+  if (typeof value.version !== 'string' || value.version === '') throw new Error('Cannot read current plugin version.')
+  return value.version
+}
+
+async function status(options, target) {
+  const current = await currentVersion(options.manifestUrl)
+  const latest = await latestVersion(options.packageName, options.registry ?? 'https://registry.npmjs.org')
+  return {
+    packageName: options.packageName,
+    currentVersion: current,
+    ...(latest === undefined ? {} : { latestVersion: latest }),
+    latestCheckFailed: latest === undefined,
+    updateAvailable: latest !== undefined && isNewerVersion(current, latest),
+    profileName: target.profileName,
+    canAutoUpdate: target.cliEntry !== undefined,
+  }
+}
+
+async function installExact(target, packageSpec, options) {
+  if (target.cliEntry === undefined) throw new Error('Automatic update is unavailable in this runtime.')
+  await new Promise((resolvePromise, reject) => {
+    const child = spawn(process.execPath, [
+      target.cliEntry, 'plugin', '--profile', target.profileName, 'add',
+      '--config.minimumReleaseAge=0', packageSpec,
+      `--registry=${options.registry ?? 'https://registry.npmjs.org/'}`,
+    ], {
+      cwd: target.profileDir,
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, NO_COLOR: '1' },
+    })
+    let detail = ''
+    child.stdout?.on('data', chunk => { detail = (detail + String(chunk)).slice(-4_000) })
+    child.stderr?.on('data', chunk => { detail = (detail + String(chunk)).slice(-4_000) })
+    const timer = setTimeout(() => {
+      child.kill()
+      reject(new Error('Update timed out; use the normal DSH update flow.'))
+    }, UPDATE_TIMEOUT_MS)
+    child.once('error', error => { clearTimeout(timer); reject(error) })
+    child.once('exit', code => {
+      clearTimeout(timer)
+      if (code === 0) resolvePromise()
+      else reject(new Error(detail.trim() || `Update exited with code ${String(code)}.`))
+    })
+  })
+}
+
+function json(response, statusCode, value) {
+  response.writeHead(statusCode, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+  })
+  response.end(JSON.stringify(value))
+}
+
+export function registerPluginUpdater(ctx, options) {
+  let installing = false
+  return ctx.webServer.register({
+    kind: 'exact',
+    path: options.endpoint,
+    handler: async (request, response) => {
+      try {
+        const target = runtime()
+        if (request.method === 'GET' || request.method === 'HEAD') {
+          const payload = await status(options, target)
+          response.writeHead(200, {
+            'content-type': 'application/json; charset=utf-8',
+            'cache-control': 'no-store',
+          })
+          response.end(request.method === 'HEAD' ? undefined : JSON.stringify(payload))
+          return
+        }
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'GET, HEAD, POST' })
+          response.end()
+          return
+        }
+        if (!isTrustedUpdateRequest(request)) {
+          json(response, 403, { error: 'Rejected non-local or cross-origin update request.' })
+          return
+        }
+        if (installing) {
+          json(response, 409, { error: 'This plugin is already updating.' })
+          return
+        }
+        installing = true
+        try {
+          const before = await status(options, target)
+          if (before.latestVersion === undefined) {
+            json(response, 503, { error: 'The latest version is temporarily unavailable.' })
+            return
+          }
+          if (!before.updateAvailable) {
+            json(response, 200, before)
+            return
+          }
+          await installExact(target, `${options.packageName}@${before.latestVersion}`, options)
+          json(response, 200, {
+            ...before,
+            updatedVersion: before.latestVersion,
+            restartRequired: true,
+          })
+        } finally {
+          installing = false
+        }
+      } catch (error) {
+        ctx.logger?.warn?.(`plugin updater failed: ${String(error)}`)
+        json(response, 503, { error: 'Plugin update failed; see server logs.' })
+      }
+    },
+  })
+}

package/lib/pool.js

@@ -1,3 +1,4 @@
+import { bestEffort } from './best-effort.js';
 // lib/pool.js — pure pool arithmetic and selection logic for dsh-key-rotation.
 // Isolated from cordis/dsh runtime so unit tests run in vanilla Node.js.
 
@@ -71,11 +72,6 @@ export const SOFT_FAILURE_CODES = new Set([
 ]);
 
 /** True if failure code or message represents a soft/transient drop. */
-export function isSoftFailure(code, message = '') {
-  if (code && SOFT_FAILURE_CODES.has(String(code).toUpperCase())) return true;
-  if (/502|503|504|timeout|econnreset|econnrefused|socket hang up/i.test(message)) return true;
-  return false;
-}
 
 /** Ref name validator. Same rule lib/index.js enforces in PUT/DELETE /key. */
 const REF_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -469,7 +465,7 @@ export function budgetVerdict(spend, budget) {
 /** Safely reset a provider's circuit breaker to closed state. */
 export function resetCircuitForProvider(circuitBreaker, provider) {
   if (!circuitBreaker || !provider) return false;
-  try {
+  const ok = bestEffort('resetCircuitForProvider', () => {
     if (typeof circuitBreaker.reset === 'function') {
       circuitBreaker.reset(provider);
       return true;
@@ -478,6 +474,7 @@ export function resetCircuitForProvider(circuitBreaker, provider) {
       circuitBreaker.onSuccess(provider);
       return true;
     }
-  } catch (_) {}
-  return false;
+    return false;
+  });
+  return ok === true;
 }