@goodandready/dsh-clinebot 0.5.8 → 0.5.10

package/lib/models.js

@@ -510,14 +510,20 @@ export function isVisionModel(id, dynamicModels = [], modelContextOverrides = []
 /**
  * Disk caching for discovered models.
  */
-export async function saveModelsDiskCache(cachePath, models = [], planSyncedAt = Date.now()) {
-  if (!cachePath || !Array.isArray(models) || !models.length) return false
+export async function saveModelsDiskCache(cachePath, models = [], planSyncedAt = Date.now(), options = {}) {
+  if (!cachePath || !Array.isArray(models)) return false
   try {
     const fs = await import('node:fs/promises')
     const path = await import('node:path')
     const dir = path.dirname(cachePath)
     await fs.mkdir(dir, { recursive: true })
-    const payload = JSON.stringify({ savedAt: Date.now(), planSyncedAt, models }, null, 2)
+    const payload = JSON.stringify({
+      savedAt: Date.now(),
+      planSyncedAt,
+      endpoint: options.endpoint || options.baseUrl || '',
+      accountRef: options.accountRef || options.accountId || options.apiKeyEnv || '',
+      models,
+    }, null, 2)
     await fs.writeFile(cachePath, payload, 'utf8')
     return true
   } catch {
@@ -525,7 +531,7 @@ export async function saveModelsDiskCache(cachePath, models = [], planSyncedAt =
   }
 }
 
-export async function loadModelsDiskCache(cachePath) {
+export async function loadModelsDiskCache(cachePath, options = {}) {
   if (!cachePath) return null
   try {
     const fs = await import('node:fs/promises')
@@ -533,6 +539,19 @@ export async function loadModelsDiskCache(cachePath) {
     const parsed = JSON.parse(raw)
     const rawList = Array.isArray(parsed?.models) ? parsed.models : (Array.isArray(parsed) ? parsed : null)
     if (!rawList) return null
+
+    const expectedEndpoint = options.endpoint || options.baseUrl
+    const expectedAccount = options.accountRef || options.accountId || options.apiKeyEnv
+    if (expectedEndpoint && parsed?.endpoint && parsed.endpoint !== expectedEndpoint) {
+      return null
+    }
+    if (expectedAccount && parsed?.accountRef && parsed.accountRef !== expectedAccount) {
+      return null
+    }
+    if ((expectedEndpoint || expectedAccount) && (!parsed?.endpoint || !parsed?.accountRef)) {
+      return null
+    }
+
     let hasObsolete = false
     const list = rawList.map((m) => {
       const migrated = migrateModelEntry(m)
@@ -540,8 +559,10 @@ export async function loadModelsDiskCache(cachePath) {
       return migrated
     })
     list.planSyncedAt = typeof parsed?.planSyncedAt === 'number' ? parsed.planSyncedAt : (typeof parsed?.savedAt === 'number' ? parsed.savedAt : 0)
+    list.endpoint = parsed?.endpoint
+    list.accountRef = parsed?.accountRef
     if (hasObsolete) {
-      saveModelsDiskCache(cachePath, list, list.planSyncedAt).catch(() => {})
+      saveModelsDiskCache(cachePath, list, list.planSyncedAt, options).catch(() => {})
     }
     return list
   } catch {

package/lib/provider-sync.js

@@ -123,12 +123,16 @@ export async function buildStatus(ctx, cfg) {
       if (fiveHour.percentUsed >= 95) {
         quotaWarning = {
           level: 'exhausted',
+          code: 'quota.exhausted_5h',
+          params: { percentUsed: fiveHour.percentUsed },
           message: `5-hour rolling limit is almost exhausted (${fiveHour.percentUsed}%). New requests may be rejected until quota reset.`,
           resetsAt: fiveHour.resetsAt,
         }
       } else if (fiveHour.percentUsed >= 90) {
         quotaWarning = {
           level: 'warning',
+          code: 'quota.warning_5h',
+          params: { percentUsed: fiveHour.percentUsed },
           message: `Low quota warning: ${fiveHour.percentUsed}% of 5-hour limit consumed (<10% remaining).`,
           resetsAt: fiveHour.resetsAt,
         }
@@ -136,17 +140,23 @@ export async function buildStatus(ctx, cfg) {
     }
 
     if (!quotaWarning && weekly && typeof weekly.percentUsed === 'number' && weekly.percentUsed >= 90) {
+      const remainingPercent = weekly.remainingPercent ?? (100 - weekly.percentUsed)
       quotaWarning = {
         level: weekly.percentUsed >= 99 ? 'exhausted' : 'warning',
-        message: `Low weekly quota warning: ${weekly.percentUsed}% consumed (${weekly.remainingPercent ?? (100 - weekly.percentUsed)}% remaining).`,
+        code: 'quota.warning_weekly',
+        params: { percentUsed: weekly.percentUsed, remainingPercent },
+        message: `Low weekly quota warning: ${weekly.percentUsed}% consumed (${remainingPercent}% remaining).`,
         resetsAt: weekly.resetsAt,
       }
     }
 
     if (!quotaWarning && monthly && typeof monthly.percentUsed === 'number' && monthly.percentUsed >= 90) {
+      const remainingPercent = monthly.remainingPercent ?? (100 - monthly.percentUsed)
       quotaWarning = {
         level: monthly.percentUsed >= 99 ? 'exhausted' : 'warning',
-        message: `Low monthly quota warning: ${monthly.percentUsed}% consumed (${monthly.remainingPercent ?? (100 - monthly.percentUsed)}% remaining).`,
+        code: 'quota.warning_monthly',
+        params: { percentUsed: monthly.percentUsed, remainingPercent },
+        message: `Low monthly quota warning: ${monthly.percentUsed}% consumed (${remainingPercent}% remaining).`,
         resetsAt: monthly.resetsAt,
       }
     }
@@ -283,34 +293,30 @@ export async function autoDiscoverPlanModels(ctx, { live, getSettingsApi, syncPr
       await syncProviderState(next)
     }
 
-    if ((!pub.dynamicModels || !pub.dynamicModels.length) && cacheFile) {
-      const fromDisk = await loadModelsDiskCache(cacheFile)
-      if (Array.isArray(fromDisk) && fromDisk.length && settingsApi?.replace) {
-        const migratedDisk = fromDisk.map(migrateModelEntry)
-        const next = plainConfig(Config({
-          ...plainConfig(live()),
-          dynamicModels: migratedDisk,
-          planSyncedAt: fromDisk.planSyncedAt || Date.now(),
-        }))
-        await settingsApi.replace(next)
-        await syncProviderState(next)
-      }
-    }
-
     const activeAcc = await resolveActiveAccountKey(ctx, cfg)
     if (!activeAcc.value) return
 
-    const usageData = await fetchUsageLimits(pub.baseUrl, activeAcc.value, {
-      timeoutMs: Math.min(pub.timeoutMs, 5000),
-      bypassCache: true,
-    })
+    const cacheIdentity = {
+      endpoint: pub.baseUrl,
+      accountRef: activeAcc.envName || activeAcc.id || pub.apiKeyEnv,
+    }
+
+    let usageData = null
+    try {
+      usageData = await fetchUsageLimits(pub.baseUrl, activeAcc.value, {
+        timeoutMs: Math.min(pub.timeoutMs, 5000),
+        bypassCache: true,
+      })
+    } catch {
+      usageData = null
+    }
 
     if (usageData?.ok && Array.isArray(usageData.dynamicModels)) {
       const existingDynamic = pub.dynamicModels || []
       const isDifferent = isCatalogDifferent(existingDynamic, usageData.dynamicModels)
+      const now = Date.now()
 
       if (isDifferent && settingsApi?.replace) {
-        const now = Date.now()
         const next = plainConfig(Config({
           ...plainConfig(live()),
           dynamicModels: usageData.dynamicModels,
@@ -318,9 +324,24 @@ export async function autoDiscoverPlanModels(ctx, { live, getSettingsApi, syncPr
         }))
         await settingsApi.replace(next)
         await syncProviderState(next)
-        if (cacheFile) {
-          await saveModelsDiskCache(cacheFile, usageData.dynamicModels, now)
-        }
+      }
+      if (cacheFile) {
+        await saveModelsDiskCache(cacheFile, usageData.dynamicModels, now, cacheIdentity)
+      }
+      return
+    }
+
+    if ((!pub.dynamicModels || !pub.dynamicModels.length) && cacheFile) {
+      const fromDisk = await loadModelsDiskCache(cacheFile, cacheIdentity)
+      if (Array.isArray(fromDisk) && fromDisk.length && settingsApi?.replace) {
+        const migratedDisk = fromDisk.map(migrateModelEntry)
+        const next = plainConfig(Config({
+          ...plainConfig(live()),
+          dynamicModels: migratedDisk,
+          planSyncedAt: 0,
+        }))
+        await settingsApi.replace(next)
+        await syncProviderState(next)
       }
     }
   } catch {

package/lib/routes/accounts.js

@@ -161,26 +161,38 @@ export function registerAccountsRoutes(ctx, { live, getSettingsApi, syncProvider
         })
       }
 
-      if (body.deleteSecret) {
-        const delRes = await deleteCredentialKey(ctx, targetEnv)
-        if (!delRes || !delRes.ok) {
-          return writeJson(res, 500, {
-            ok: false,
-            error: `Failed to delete secret for account "${targetEnv}" from credentials store`,
-          })
-        }
-      }
-
       const nextAccounts = existingAccounts.filter((a) => a && a.apiKeyEnv !== targetEnv)
       let activeAccount = curr.activeAccount
       if (activeAccount === targetEnv) {
         activeAccount = ''
       }
 
+      // Persist settings changes first before unsetting credentials (#184)
       const next = plainConfig(Config({ ...curr, accounts: nextAccounts, activeAccount }))
       await settingsApi.replace(next)
       await syncProviderState(next)
 
+      if (body.deleteSecret) {
+        let delRes = null
+        try {
+          delRes = await deleteCredentialKey(ctx, targetEnv)
+        } catch {
+          delRes = null
+        }
+        if (!delRes || !delRes.ok) {
+          try {
+            await settingsApi.replace(curr)
+            await syncProviderState(curr)
+          } catch {
+            /* ignore rollback error */
+          }
+          return writeJson(res, 500, {
+            ok: false,
+            error: `Failed to delete secret for account "${targetEnv}" from credentials store`,
+          })
+        }
+      }
+
       clearUsageCache()
       clearProbeCache()
 

package/lib/routes/proxy.js

@@ -192,13 +192,15 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
         const streamIdleTimeoutMs = Math.max(50, Number(pub.streamIdleTimeoutMs || pub.idleTimeoutMs) || 30000)
 
         const connectAbortCtrl = new AbortController()
+        const bodyAbortCtrl = new AbortController()
         let connectTimedOut = false
+        let bodyTimedOut = false
         const connectTimer = setTimeout(() => {
           connectTimedOut = true
           connectAbortCtrl.abort(new Error(`Upstream connect timeout after ${connectTimeoutMs}ms`))
         }, connectTimeoutMs)
 
-        const fetchSignal = AbortSignal.any([clientAbortCtrl.signal, connectAbortCtrl.signal])
+        const fetchSignal = AbortSignal.any([clientAbortCtrl.signal, connectAbortCtrl.signal, bodyAbortCtrl.signal])
 
         let upstreamRes
         try {
@@ -404,8 +406,57 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
           return
         }
 
-        // Non-streaming JSON response
-        const resText = await upstreamRes.text().catch(() => '{}')
+        // Non-streaming JSON response with deadline and fail-closed error handling (#185)
+        const idleTimeoutMs = streamIdleTimeoutMs
+        let bodyTimer = null
+        const bodyTimeoutPromise = new Promise((_, reject) => {
+          bodyTimer = setTimeout(() => {
+            bodyTimedOut = true
+            bodyAbortCtrl.abort(new Error(`Upstream body read timed out after ${idleTimeoutMs}ms`))
+            reject(new Error(`Upstream body read timed out after ${idleTimeoutMs}ms`))
+          }, idleTimeoutMs)
+        })
+
+        let resText = ''
+        let readError = null
+        try {
+          resText = await Promise.race([
+            upstreamRes.text(),
+            bodyTimeoutPromise,
+          ])
+        } catch (err) {
+          readError = err
+        } finally {
+          clearTimeout(bodyTimer)
+        }
+
+        cleanupClientListeners()
+
+        if (clientAbortCtrl.signal.aborted || clientClosed) {
+          return
+        }
+
+        if (bodyTimedOut || readError) {
+          const isTimeout = bodyTimedOut || bodyAbortCtrl.signal.aborted
+          recordUsage({
+            model: body.model,
+            accountId: targetAccount.id || targetAccount.label,
+            isError: true,
+            statsPath: pub.statsPath
+          })
+          const statusCode = isTimeout ? 504 : 502
+          const errMessage = isTimeout
+            ? `Gateway Timeout: upstream body read timed out after ${idleTimeoutMs}ms`
+            : `Bad Gateway: upstream response body read error: ${readError?.message || readError}`
+          return writeJson(res, statusCode, {
+            error: {
+              message: errMessage,
+              type: isTimeout ? 'gateway_timeout' : 'bad_gateway',
+              code: isTimeout ? 'body_read_timeout' : 'body_read_error'
+            }
+          })
+        }
+
         let resJson = null
         try {
           resJson = JSON.parse(resText)
@@ -413,7 +464,6 @@ export function registerProxyRoutes(ctx, { live, getSettingsApi, syncProviderSta
           resJson = null
         }
 
-        cleanupClientListeners()
         recordUsage({
           model: body.model,
           accountId: targetAccount.id || targetAccount.label,

package/lib/session-router.js

@@ -205,6 +205,11 @@ export function resolveSessionAccount(sessionId, accounts = [], defaultActiveId
     }
   }
 
+  // Prune if needed before allocating a new session entry (#183)
+  if (!existing && sessions.size >= MAX_SESSIONS) {
+    pruneSessions(now, MAX_SESSIONS - 1, SESSION_TTL_MS)
+  }
+
   // If manual pin is configured and available:
   if (pinnedAvailable) {
     const reassigned = Boolean(existing && !matchesAccount(pinnedAvailable, existing.accountId))
@@ -230,11 +235,6 @@ export function resolveSessionAccount(sessionId, accounts = [], defaultActiveId
     // Otherwise, failover is needed
   }
 
-  // Prune if needed
-  if (!existing && sessions.size >= MAX_SESSIONS) {
-    pruneSessions(now, MAX_SESSIONS - 1, SESSION_TTL_MS)
-  }
-
   // Pick least-used available account
   const chosen = selectLeastUsedAccount(safeAccounts) || safeAccounts[0]
   if (chosen) {

package/lib/updater.js

@@ -219,10 +219,32 @@ export async function checkUpdateStatus(options, target = detectRuntime()) {
   }
 }
 
-async function installExact(target, packageSpec, options) {
+export function cleanStaleLock(profileDir) {
+  if (!profileDir) return false
+  const lockFile = resolve(profileDir, 'package.json.lock')
+  if (existsSync(lockFile)) {
+    try {
+      const pid = parseInt(readFileSync(lockFile, 'utf8').trim(), 10)
+      if (!isPidAlive(pid)) {
+        unlinkSync(lockFile)
+        return true
+      }
+    } catch (err) {
+      /* best-effort stale lock unlink */
+    }
+  }
+  return false
+}
+
+export async function installExact(target, packageSpec, options = {}) {
   if (target.cliEntry === undefined) throw new Error('Automatic update is unavailable in this runtime.')
+  const timeoutMs = typeof options.timeoutMs === 'number' ? options.timeoutMs : UPDATE_TIMEOUT_MS
+  const sigtermGraceMs = typeof options.sigtermGraceMs === 'number' ? options.sigtermGraceMs : 500
+  const sigkillGraceMs = typeof options.sigkillGraceMs === 'number' ? options.sigkillGraceMs : 500
+  const spawnFn = typeof options.spawn === 'function' ? options.spawn : spawn
+
   await new Promise((resolvePromise, reject) => {
-    const child = spawn(process.execPath, [
+    const child = spawnFn(process.execPath, [
       target.cliEntry, 'plugin', '--profile', target.profileName, 'add',
       packageSpec,
       `--registry=${options.registry || 'https://registry.npmjs.org/'}`,
@@ -231,44 +253,84 @@ async function installExact(target, packageSpec, options) {
       windowsHide: true,
       stdio: ['ignore', 'pipe', 'pipe'],
       env: { ...process.env, NO_COLOR: '1' },
+      detached: options.detached !== undefined ? options.detached : process.platform !== 'win32',
     })
     let detail = ''
     child.stdout?.on('data', (chunk) => { detail = (detail + String(chunk)).slice(-4000) })
     child.stderr?.on('data', (chunk) => { detail = (detail + String(chunk)).slice(-4000) })
-    const timer = setTimeout(() => {
-      child.kill('SIGTERM')
-      setTimeout(() => {
-        if (!child.killed) {
-          try {
-            child.kill('SIGKILL')
-          } catch (err) {
-            /* ignore if process already terminated */
-          }
+
+    let exited = false
+    let isTimedOut = false
+    let sigtermTimer = null
+    let sigkillTimer = null
+
+    function cleanupTimers() {
+      clearTimeout(mainTimer)
+      if (sigtermTimer) clearTimeout(sigtermTimer)
+      if (sigkillTimer) clearTimeout(sigkillTimer)
+    }
+
+    function onProcessExit(code, signal) {
+      if (exited) return
+      exited = true
+      cleanupTimers()
+
+      if (isTimedOut) {
+        cleanStaleLock(target.profileDir)
+        reject(new Error('Update timed out.'))
+      } else if (code === 0) {
+        resolvePromise()
+      } else {
+        reject(new Error(detail.trim() || `Update exited with code ${String(code)}.`))
+      }
+    }
+
+    child.once('error', (error) => {
+      cleanupTimers()
+      reject(error)
+    })
+
+    child.once('exit', onProcessExit)
+    child.once('close', onProcessExit)
+
+    function killProcessTree(sig) {
+      if (!child) return
+      if (typeof child.pid === 'number' && child.pid > 0 && process.platform !== 'win32') {
+        try {
+          process.kill(-child.pid, sig)
+        } catch {
+          /* process group might not exist or already terminated */
         }
-        setTimeout(() => {
-          if (target.profileDir) {
-            const lockFile = resolve(target.profileDir, 'package.json.lock')
-            if (existsSync(lockFile)) {
-              try {
-                const pid = parseInt(readFileSync(lockFile, 'utf8').trim(), 10)
-                if (!isPidAlive(pid)) {
-                  unlinkSync(lockFile)
-                }
-              } catch (err) {
-                /* best-effort stale lock unlink */
-              }
+      }
+      try {
+        child.kill(sig)
+      } catch {
+        /* ignore if already dead */
+      }
+    }
+
+    const mainTimer = setTimeout(() => {
+      isTimedOut = true
+      // Step 1: Send SIGTERM
+      killProcessTree('SIGTERM')
+
+      // Step 2: Wait for grace period, if process has not exited escalate to SIGKILL (#172)
+      sigtermTimer = setTimeout(() => {
+        const hasExited = exited || (child.exitCode !== null && child.exitCode !== undefined) || (child.signalCode !== null && child.signalCode !== undefined)
+        if (!hasExited) {
+          killProcessTree('SIGKILL')
+
+          // Step 3: Hard deadline for exit notification
+          sigkillTimer = setTimeout(() => {
+            if (!exited) {
+              exited = true
+              cleanStaleLock(target.profileDir)
+              reject(new Error('Update timed out.'))
             }
-          }
-        }, 100)
-      }, 500)
-      reject(new Error('Update timed out.'))
-    }, 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)}.`))
-    })
+          }, sigkillGraceMs)
+        }
+      }, sigtermGraceMs)
+    }, timeoutMs)
   })
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-clinebot",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "DeepSeek Harness companion for ClineBot / ClinePass: dynamic subscription models sync, quota exhaustion warnings, session metrics, dedicated settings page, live usage limits, and /cline slash-command.",
   "license": "MIT",
   "type": "module",