@goodandready/dsh-clinebot 0.3.7 → 0.3.9

package/lib/index.js

@@ -1,6 +1,7 @@
 import z from '@deepseek-ai/schemastery'
 import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { writeJson, readBody, isTrustedSettingsRequest } from './http.js'
+import { registerPluginUpdater } from './updater.js'
 import {
   CLINE_MODELS,
   DEFAULT_MODEL_ID,
@@ -21,6 +22,9 @@ import {
   DEFAULT_SMOKE_TIMEOUT_MS,
   normalizeBaseUrl,
   resolveApiKey,
+  resolveKeyValue,
+  resolveAccountPool,
+  rotateToNextAccount,
   saveCredentialKey,
   fetchUsageLimits,
   probeHealth,
@@ -29,6 +33,7 @@ import {
   sessionStats,
   recordSessionRequest,
   resetSessionStats,
+  usageCache,
 } from './cline-client.js'
 
 export const name = '@goodandready/dsh-clinebot'
@@ -37,7 +42,7 @@ export const inject = ['settings', 'webServer', 'credentials']
 export const NS = 'dsh-clinebot'
 export const LLM_PI_AI_NS = 'llm-pi-ai'
 
-export { sessionStats, recordSessionRequest, resetSessionStats }
+export { sessionStats, recordSessionRequest, resetSessionStats, rotateToNextAccount }
 
 export const Config = z.object({
   enabled: z.boolean().default(true)
@@ -120,104 +125,51 @@ function resolvePathWithHome(p) {
   return p
 }
 
-async function resolveKeyValue(ctx, apiKeyEnv) {
-  const refName = String(apiKeyEnv || DEFAULT_API_KEY_ENV).trim() || DEFAULT_API_KEY_ENV
-  const creds = (ctx?.get && ctx.get('credentials')) || ctx?.credentials
-  if (creds && typeof creds.resolve === 'function') {
-    try {
-      const hit = await creds.resolve(credentialRef(refName))
-      if (hit?.value) {
-        return { envName: refName, value: hit.value, source: 'credentials' }
-      }
-    } catch {
-      /* credentials service miss, fall through */
-    }
-  }
-
-  const fromEnv = resolveApiKey(refName)
-  if (fromEnv.value) {
-    return { ...fromEnv, source: 'env' }
-  }
-
-  return { envName: refName, value: '', source: 'none' }
-}
-
-/**
- * Resolve all accounts in pool with their status and quota.
- */
-async function resolveAccountPool(ctx, cfg) {
-  const pub = publicConfig(cfg)
-  const defaultSlot = {
-    id: 'default',
-    label: 'Default',
-    apiKeyEnv: pub.apiKeyEnv,
-  }
-  const allSlots = [defaultSlot, ...(Array.isArray(pub.accounts) ? pub.accounts : [])]
-  const resolved = []
-
-  for (let i = 0; i < allSlots.length; i++) {
-    const slot = allSlots[i]
-    const envName = slot.apiKeyEnv || (i === 0 ? pub.apiKeyEnv : `CLINEBOT_API_KEY_${i + 1}`)
-    const keyInfo = await resolveKeyValue(ctx, envName)
-    resolved.push({
-      id: slot.id || (i === 0 ? 'default' : `account-${i + 1}`),
-      label: slot.label || (i === 0 ? 'Default' : `Account ${i + 1}`),
-      apiKeyEnv: envName,
-      present: Boolean(keyInfo.value),
-      source: keyInfo.source,
-      value: keyInfo.value,
-      isPinned: pub.activeAccount ? pub.activeAccount === envName : i === 0,
-    })
+async function checkRegisteredInPiAi(ctx) {
+  const settings = ctx?.get?.('settings')
+  if (!settings?.get) return false
+  try {
+    const piAi = settings.get(LLM_PI_AI_NS)
+    return !!piAi?.providers?.[PROVIDER_ID]
+  } catch {
+    return false
   }
-
-  return resolved
 }
 
-/**
- * Resolve active key with failover support.
- */
 async function resolveActiveAccountKey(ctx, cfg) {
   const pool = await resolveAccountPool(ctx, cfg)
   const configured = pool.filter((acc) => acc.present && acc.value)
   if (!configured.length) {
     return { envName: publicConfig(cfg).apiKeyEnv, value: '', source: 'none', id: 'default' }
   }
-
-  // If user pinned a specific account and it has a key, prefer it
   const pub = publicConfig(cfg)
   if (pub.activeAccount) {
     const pinned = configured.find((acc) => acc.apiKeyEnv === pub.activeAccount || acc.id === pub.activeAccount)
     if (pinned) return pinned
   }
-
-  // Default: first available configured account
   return configured[0]
 }
 
-async function checkRegisteredInPiAi(ctx) {
-  const settings = ctx?.get?.('settings')
-  if (!settings?.get) return false
-  try {
-    const piAi = settings.get(LLM_PI_AI_NS)
-    return !!piAi?.providers?.[PROVIDER_ID]
-  } catch {
-    return false
-  }
-}
-
 async function buildStatus(ctx, cfg) {
   const pub = publicConfig(cfg)
-  const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-  // Non-blocking quick health probe with low timeout so settings page loads instantly
   const probeTimeout = Math.min(2500, pub.timeoutMs || 2500)
-  const health = await probeHealth(pub.baseUrl, { timeoutMs: probeTimeout })
-  const isRegistered = await checkRegisteredInPiAi(ctx)
+
+  // Concurrent resolution of keys, health probe (SWR cached), accounts pool and DSH registration
+  const [key, pool, isRegistered, health] = await Promise.all([
+    resolveKeyValue(ctx, pub.apiKeyEnv),
+    resolveAccountPool(ctx, cfg),
+    checkRegisteredInPiAi(ctx),
+    probeHealth(pub.baseUrl, { timeoutMs: probeTimeout }),
+  ])
+
+  const activeAcc = await resolveActiveAccountKey(ctx, cfg)
   const allModels = getAllModels(pub.dynamicModels)
 
   let usage = null
-  if (key.value) {
+  const keyToUse = activeAcc.value || key.value
+  if (keyToUse) {
     // Uses 60s cache; if cache miss, times out quickly
-    usage = await fetchUsageLimits(pub.baseUrl, key.value, { timeoutMs: probeTimeout }).catch(() => null)
+    usage = await fetchUsageLimits(pub.baseUrl, keyToUse, { timeoutMs: probeTimeout }).catch(() => null)
   }
 
   // Evaluate warning state
@@ -227,22 +179,18 @@ async function buildStatus(ctx, cfg) {
     if (pct >= 95) {
       quotaWarning = {
         level: 'exhausted',
-        message: `5-часовой лимит почти полностью исчерпан (${pct}%). Новые запросы могут отклоняться провайдером до сброса.`,
+        message: `5-hour rolling limit is almost exhausted (${pct}%). New requests may be rejected until quota reset.`,
         resetsAt: usage.windows.fiveHour.resetsAt,
       }
     } else if (pct >= 80) {
       quotaWarning = {
         level: 'warning',
-        message: `Внимание: израсходовано ${pct}% 5-часового скользящего лимита.`,
+        message: `Notice: ${pct}% of the 5-hour rolling limit has been consumed.`,
         resetsAt: usage.windows.fiveHour.resetsAt,
       }
     }
   }
 
-  // Resolve all accounts in pool
-  const pool = await resolveAccountPool(ctx, cfg)
-  const activeAcc = await resolveActiveAccountKey(ctx, cfg)
-
   return {
     ok: true,
     providerId: PROVIDER_ID,
@@ -427,6 +375,16 @@ export function apply(ctx, config) {
 
   // Web server HTTP route handlers
   if (ctx.webServer?.register) {
+    // 0. GET & POST /dsh-clinebot/update — host one-click updater
+    const unregisterUpdater = registerPluginUpdater(ctx, {
+      endpoint: '/dsh-clinebot/update',
+      packageName: name,
+      manifestUrl: new URL('../package.json', import.meta.url),
+    })
+    if (typeof ctx.effect === 'function') {
+      ctx.effect(() => () => unregisterUpdater?.(), 'dsh-clinebot: updater')
+    }
+
     // 1. GET /dsh-clinebot/status
     ctx.effect(() => ctx.webServer.register({
       kind: 'exact',
@@ -618,10 +576,19 @@ export function apply(ctx, config) {
             latencyMs: outcome.latencyMs,
             ok: outcome.ok,
             error: outcome.error,
-            promptTokens: 5,
-            completionTokens: 10,
+            promptTokens: outcome.promptTokens || 5,
+            completionTokens: outcome.completionTokens || 10,
           })
-          writeJson(res, outcome.ok ? 200 : 502, outcome)
+
+          let failover = null
+          if (outcome.status === 429) {
+            failover = await rotateToNextAccount(ctx, live(), 'smoke_429', settingsApi)
+            if (failover.rotated) {
+              await syncProviderState(live())
+            }
+          }
+
+          writeJson(res, outcome.ok ? 200 : 502, { ...outcome, failover })
         } catch (err) {
           recordSessionRequest({ ok: false, error: String(err?.message || err) })
           writeJson(res, 500, { ok: false, error: String(err?.message || err) })
@@ -802,7 +769,7 @@ export function apply(ctx, config) {
 
     const unregister = commands.register({
       name: 'cline',
-      description: 'Check ClinePass subscription quota, models, accounts and session stats (/cline [quota|models|accounts|switch <name>])',
+      description: 'Check ClinePass subscription quota, models, accounts and test connectivity (/cline [quota|models|accounts|switch <name>|test [model]|ping|rotate])',
       execute: async (rawArgs) => {
         const pub = publicConfig(live())
         const subcmd = String(rawArgs || '').trim().toLowerCase().split(/\s+/)[0] || 'quota'
@@ -831,36 +798,97 @@ export function apply(ctx, config) {
           const pool = await resolveAccountPool(ctx, live())
           const lines = [
             '### 🔑 ClinePass Accounts Pool',
-            `* **Активный аккаунт**: \`${pub.activeAccount || pub.apiKeyEnv}\``,
+            `* **Active Account**: \`${pub.activeAccount || pub.apiKeyEnv}\``,
             '',
           ]
           for (const acc of pool) {
             const pinBadge = acc.isPinned ? '📌 [Pinned]' : ''
-            const statusBadge = acc.present ? '✅ Configured' : '⚠️ Missing'
-            lines.push(`* **${acc.label}** (\`${acc.apiKeyEnv}\`): ${statusBadge} ${pinBadge}`)
+            const statusBadge = acc.present ? '✅ Configured' : '⚠️ Missing Key'
+            const cacheKey = `cline:usage:${(acc.value || '').slice(-8)}`
+            const cached = usageCache.get(cacheKey)?.data
+            const usageInfo = cached?.windows?.fiveHour ? ` · ⏱ ${cached.windows.fiveHour.percentUsed}% used` : ''
+            lines.push(`* **${acc.label}** (\`${acc.apiKeyEnv}\`): ${statusBadge} ${pinBadge}${usageInfo}`)
           }
-          lines.push('', 'Переключить активный аккаунт: `/cline switch <имя_переменной>`')
+          lines.push('', 'Switch active account: `/cline switch <env_variable_name>`')
           return lines.join('\n')
         }
 
         // 3. Subcommand /cline switch <account>
         if (subcmd === 'switch') {
           if (!param) {
-            return '⚠️ Укажите аккаунт: `/cline switch <CLINEBOT_API_KEY_2>`'
+            return '⚠️ Please specify account: `/cline switch <CLINEBOT_API_KEY_2>`'
           }
           if (settingsApi?.replace) {
             const next = Config({ ...live(), activeAccount: param })
             await settingsApi.replace(next)
             await syncProviderState(next)
-            return `✅ Активный аккаунт переключен на \`${param}\``
+            return `✅ Active account switched to \`${param}\``
           }
-          return `⚠️ Не удалось применить настройку (сервис настроек недоступен).`
+          return `⚠️ Could not apply setting (settings service unavailable).`
         }
 
-        // 4. Default /cline quota
+        // 4. Subcommand /cline rotate (smart failover next)
+        if (subcmd === 'rotate') {
+          const res = await rotateToNextAccount(ctx, live(), 'slash_command', settingsApi)
+          if (res.rotated) {
+            await syncProviderState(live())
+            return `🔄 **Account Rotated**: switched from \`${res.previousAccount}\` to \`${res.activeAccount}\`. DSH provider updated!`
+          }
+          return `⚠️ Rotation skipped: ${res.message || 'no alternative configured accounts in pool'}.`
+        }
+
+        // 5. Subcommand /cline ping (fresh host reachability probe)
+        if (subcmd === 'ping') {
+          const health = await probeHealth(pub.baseUrl, { bypassCache: true, timeoutMs: 5000 })
+          if (health.ok) {
+            return `🏓 **Cline API Pong**: \`${pub.baseUrl}\` is reachable (latency: **${health.latencyMs} ms**, HTTP ${health.status})`
+          }
+          return `❌ **Cline API Ping Failed**: ${health.error || 'Host unreachable'}`
+        }
+
+        // 6. Subcommand /cline test [model] / smoke
+        if (subcmd === 'test' || subcmd === 'smoke') {
+          const activeKey = await resolveActiveAccountKey(ctx, live())
+          if (!activeKey.value) {
+            return '⚠️ **ClineBot**: API key is not configured. Open **Settings → Plugins → ClineBot**.'
+          }
+          const modelToTest = param || pub.defaultModel || DEFAULT_MODEL_ID
+          const outcome = await smokeChat(pub.baseUrl, activeKey.value, {
+            model: modelToTest,
+            timeoutMs: pub.smokeTimeoutMs,
+          })
+          recordSessionRequest({
+            latencyMs: outcome.latencyMs,
+            ok: outcome.ok,
+            error: outcome.error,
+            promptTokens: outcome.promptTokens || 5,
+            completionTokens: outcome.completionTokens || 10,
+          })
+
+          let failoverNotice = ''
+          if (outcome.status === 429) {
+            const failover = await rotateToNextAccount(ctx, live(), 'smoke_429', settingsApi)
+            if (failover.rotated) {
+              await syncProviderState(live())
+              failoverNotice = `\n🔄 **Auto-failover**: HTTP 429 detected! Active account automatically rotated to \`${failover.activeAccount}\`.`
+            }
+          }
+
+          if (outcome.ok) {
+            return [
+              `### 🟢 Smoke Test Passed: \`${outcome.model}\``,
+              `* **Latency**: ${outcome.latencyMs} ms`,
+              `* **Tokens**: prompt: ${outcome.promptTokens}, completion: ${outcome.completionTokens} (total: ${outcome.totalTokens})`,
+              `* **Preview**: _"${outcome.preview}"_`,
+            ].join('\n')
+          }
+          return `❌ **Smoke Test Failed**: ${outcome.error} (HTTP ${outcome.status || 'timeout'})${failoverNotice}`
+        }
+
+        // 7. Subcommand /cline quota or /cline balance
         const activeKey = await resolveActiveAccountKey(ctx, live())
         if (!activeKey.value) {
-          return '⚠️ **ClineBot**: API-ключ не настроен. Откройте **Настройки → ClineBot** и сохраните ключ.'
+          return '⚠️ **ClineBot**: API key is not configured. Open **Settings → Plugins → ClineBot**.'
         }
 
         const [health, usage] = await Promise.all([
@@ -870,31 +898,31 @@ export function apply(ctx, config) {
 
         const fiveHour = usage?.windows?.fiveHour
         const weekly = usage?.windows?.weekly
-        const reset5h = fiveHour?.resetsAt ? new Date(fiveHour.resetsAt).toLocaleTimeString() : 'н/д'
-        const resetWk = weekly?.resetsAt ? new Date(weekly.resetsAt).toLocaleDateString() : 'н/д'
+        const reset5h = fiveHour?.resetsAt ? new Date(fiveHour.resetsAt).toLocaleTimeString() : 'N/A'
+        const resetWk = weekly?.resetsAt ? new Date(weekly.resetsAt).toLocaleDateString() : 'N/A'
 
         const lines = [
           `### 🤖 ClinePass Status (${usage?.plan || 'ClinePass'})`,
-          `* **Пинг хоста**: ${health.ok ? `✅ ${health.latencyMs} мс` : '❌ Недоступен'}`,
-          `* **Активный ключ**: \`${activeKey.envName}\` (${activeKey.source})`,
-          `* **Модель по умолчанию**: \`${pub.defaultModel}\``,
+          `* **Host Ping**: ${health.ok ? `✅ ${health.latencyMs} ms` : '❌ Unreachable'}`,
+          `* **Active Key**: \`${activeKey.envName}\` (${activeKey.source})`,
+          `* **Default Model**: \`${pub.defaultModel}\``,
           '',
-          `**⏱ 5-часовое окно**: ${formatProgressBar(fiveHour?.percentUsed)} (сброс: ${reset5h})`,
-          `**📅 Недельное окно**: ${formatProgressBar(weekly?.percentUsed)} (сброс: ${resetWk})`,
+          `**⏱ 5-Hour Rolling Limit**: ${formatProgressBar(fiveHour?.percentUsed)} (reset: ${reset5h})`,
+          `**📅 Weekly Window**: ${formatProgressBar(weekly?.percentUsed)} (reset: ${resetWk})`,
         ]
 
         if (fiveHour?.percentUsed >= 95) {
-          lines.push('', '🚨 **КРИТИЧЕСКИЙ ЛИМИТ**: 5-часовая квота израсходована на 95%+. Запросы могут быть заблокированы до сброса!')
+          lines.push('', '🚨 **CRITICAL LIMIT**: 5-hour quota is 95%+ consumed! New requests may be throttled until reset.')
         } else if (fiveHour?.percentUsed >= 80) {
-          lines.push('', '⚠️ **Внимание**: 5-часовая квота израсходована на ' + fiveHour.percentUsed + '%.')
+          lines.push('', `⚠️ **Warning**: 5-hour quota is ${fiveHour.percentUsed}% consumed.`)
         }
 
         if (sessionStats.totalRequests > 0) {
-          lines.push('', `**📊 Сессия DSH**: ${sessionStats.successfulRequests}/${sessionStats.totalRequests} успешных запросов, ~${sessionStats.totalTokensEst} токенов`)
+          lines.push('', `**📊 Session Telemetry**: ${sessionStats.successfulRequests}/${sessionStats.totalRequests} successful requests, ~${sessionStats.totalTokensEst} total tokens`)
         }
 
         if (usage?.user?.email) {
-          lines.push(`* **Аккаунт**: \`${usage.user.email}\``)
+          lines.push(`* **Account**: \`${usage.user.email}\``)
         }
 
         return lines.join('\n')
@@ -917,15 +945,21 @@ export function apply(ctx, config) {
     },
     runSmokeTest: async (model) => {
       const pub = publicConfig(live())
-      const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-      const res = await smokeChat(pub.baseUrl, key.value, { model: model || pub.defaultModel })
+      const activeKey = await resolveActiveAccountKey(ctx, live())
+      const res = await smokeChat(pub.baseUrl, activeKey.value, { model: model || pub.defaultModel })
       recordSessionRequest({
         latencyMs: res.latencyMs,
         ok: res.ok,
         error: res.error,
-        promptTokens: 5,
-        completionTokens: 10,
+        promptTokens: res.promptTokens || 5,
+        completionTokens: res.completionTokens || 10,
       })
+      if (res.status === 429) {
+        const failover = await rotateToNextAccount(ctx, live(), 'service_429', settingsApi)
+        if (failover.rotated) {
+          await syncProviderState(live())
+        }
+      }
       return res
     },
   }

package/lib/models.js

@@ -136,6 +136,75 @@ export const CLINE_MODELS = Object.freeze([
     recommended: false,
     isCustom: false,
   },
+  {
+    id: 'cline-pass/claude-3-7-sonnet',
+    name: 'Claude 3.7 Sonnet',
+    description: 'Hybrid reasoning and standard generation model with high coding proficiency.',
+    contextLength: 200000,
+    maxTokens: 8192,
+    input: ['text', 'image'],
+    category: 'coding',
+    recommended: true,
+    isCustom: false,
+    reasoningEfforts: ['low', 'medium', 'high'],
+  },
+  {
+    id: 'cline-pass/gpt-4.5-preview',
+    name: 'GPT-4.5 Preview',
+    description: 'Advanced flagship frontier model with deep world knowledge and intuition.',
+    contextLength: 128000,
+    maxTokens: 16384,
+    input: ['text', 'image'],
+    category: 'general',
+    recommended: true,
+    isCustom: false,
+  },
+  {
+    id: 'cline-pass/o3-mini',
+    name: 'o3-mini',
+    description: 'Fast, cost-effective reasoning model specialized for STEM and coding.',
+    contextLength: 200000,
+    maxTokens: 65536,
+    input: ['text'],
+    category: 'reasoning',
+    recommended: true,
+    isCustom: false,
+    reasoningEfforts: ['low', 'medium', 'high'],
+  },
+  {
+    id: 'cline-pass/gemini-2.5-pro',
+    name: 'Gemini 2.5 Pro',
+    description: 'State-of-the-art multimodal reasoning model with extended context.',
+    contextLength: 1000000,
+    maxTokens: 8192,
+    input: ['text', 'image'],
+    category: 'multimodal',
+    recommended: true,
+    isCustom: false,
+    reasoningEfforts: ['low', 'medium', 'high'],
+  },
+  {
+    id: 'cline-pass/gemini-2.5-flash',
+    name: 'Gemini 2.5 Flash',
+    description: 'Ultra-fast multimodal model optimized for real-time agent workflows.',
+    contextLength: 1000000,
+    maxTokens: 8192,
+    input: ['text', 'image'],
+    category: 'general',
+    recommended: false,
+    isCustom: false,
+  },
+  {
+    id: 'cline-pass/qwen-2.5-coder-32b',
+    name: 'Qwen 2.5 Coder 32B',
+    description: 'Open-weights powerhouse for code generation, refactoring and bug fixing.',
+    contextLength: 131072,
+    maxTokens: 8192,
+    input: ['text'],
+    category: 'coding',
+    recommended: false,
+    isCustom: false,
+  },
 ])
 
 /**