@goodandready/dsh-clinebot 0.3.2 → 0.3.3

package/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to `@goodandready/dsh-clinebot` will be documented in this f
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.3] - 2026-09-08
+
+### Added
+- **Multi-Account Pool & Fast Rotation** (Issue #8): Added full account pool support (`accounts: [{ label, apiKeyEnv }]`, `activeAccount`). Users can configure multiple ClinePass keys across personal and team subscriptions, view configuration statuses in the dedicated settings card, and pin/switch active accounts instantly without restarting DSH.
+- **Web Search Integration Alignment** (Issue #9): Investigated Cline API search capabilities; confirmed search operations are natively executed via model tool-calling without requiring separate search-engine tokens or intermediate providers.
+- **Fast 1-Click Browser Login Flow** (Issue #10): Added interactive browser authorization (`POST /dsh-clinebot/auth/begin` and status polling), streamlining onboarding and credential entry directly from the web settings interface.
+- **Native Reasoning Effort Controls** (Issue #11): Configured `reasoningEfforts: ['low', 'medium', 'high', 'max']` on supported thinking models (`deepseek-v4-flash`, `deepseek-v4-pro`, `kimi-k3`, `minimax-m3`). Exposes native thinking controls in DSH model picker and UI badge `🧠 Reasoning`.
+- **Extended Slash-Command Subcommands** (Issue #12): Enhanced `/cline` with powerful subcommands:
+  - `/cline models` — Lists all available models with context length, Vision modality, and reasoning support.
+  - `/cline accounts` — Displays configured account pool, active key, and environment binding status.
+  - `/cline switch <label>` — Dynamically switches the active key across the account pool directly from chat.
+  - `/cline quota` (default) — Full rolling quota breakdown with warning indicators and session metrics.
+- **Resilient Retry Policy & Backoff** (Issue #13): Added exponential backoff retry mechanism (`retryWithBackoff`) intercepting transient 429 rate-limiting responses, `Retry-After` headers, and 5xx upstream hiccups.
+- **Informative Badges & Model Meta Tags** (Issue #14): Enriched model catalogue metadata with compact human-readable badges (`[200K · Vision · Coding · Reasoning]`), Vision detection, and category filtering.
+- **Offline Cold-Start Disk Caching** (Issue #15): Added persistent JSON disk caching (`saveModelsDiskCache`, `loadModelsDiskCache`) at `~/.dsh/clinebot-models-cache.json`. Newly discovered plan models survive offline restarts and cold boots without blocking startup.
+
 ## [0.3.2] - 2026-09-08
 
 ### Added

package/docs/design/DESIGN.md

@@ -60,6 +60,13 @@ graph LR
 * **Non-destructive actions**: Unregister cleanly removes the provider entry from DSH without touching other providers or configurations.
 
 ## 4. Security & Isolation
-* CSRF / Cross-site protection: All mutating routes (`/register`, `/unregister`, `/smoke`, `/models`) validate `isTrustedSettingsRequest(req)` (`Sec-Fetch-Site !== 'cross-site'`).
+* CSRF / Cross-site protection: All mutating routes (`/register`, `/unregister`, `/smoke`, `/models`, `/accounts/active`, `/auth/begin`) validate `isTrustedSettingsRequest(req)` (`Sec-Fetch-Site !== 'cross-site'`).
 * Body size limits: Request payloads are strictly capped at 256 KB.
 * Sensitive credential data is never returned across the HTTP API (only `{ present: boolean, source: string, envName: string }`).
+
+## 5. Multi-Account Pool & Resilient Execution (v0.3.3)
+* **Account Pool**: The plugin supports multiple accounts (`accounts: [{ label, apiKeyEnv }]`, `activeAccount`). `resolveActiveAccountKey()` automatically selects the configured active account or falls back to primary `apiKeyEnv`. Account switching (`POST /dsh-clinebot/accounts/active` and `/cline switch <label>`) triggers instant re-registration in `llm-pi-ai` without service restart.
+* **Resilient Retry Policy**: HTTP calls to ClinePass utilize `retryWithBackoff()` with exponential delays and jitter to automatically absorb transient 429 rate-limiting events and upstream 5xx errors.
+* **Reasoning Effort Support**: Models declaring `reasoningEfforts: ['low', 'medium', 'high', 'max']` expose native thinking controls within the DSH model picker, accompanied by UI badges (`🧠 Reasoning`).
+* **Offline Cold-Start Cache**: Discovered plan models are serialized locally to `modelsCachePath` (`~/.dsh/clinebot-models-cache.json`), ensuring models remain immediately available on cold boot even if the upstream network or Cline API is temporarily unavailable.
+

package/lib/client.js

@@ -32,10 +32,20 @@ window.__ModuleLoader__.load({
       'key.hide': 'Hide',
       'key.save': 'Save Key',
       'key.saving': 'Saving…',
+      'key.login_fast': '🚀 Quick Web Login',
+      'key.login_waiting': 'Waiting for authorization in browser…',
       'key.env_label': 'Credential environment name: ',
       'key.get_key': 'Get key in app.cline.bot console ↗',
       'key.saved_msg': 'Key saved to DSH Credentials. Validation: {status}',
       'key.empty_err': 'Please enter an API key before saving',
+      'accounts.title': '👥 Multi-Account Failover Pool',
+      'accounts.desc': 'Add extra accounts. When an account hits 429 rate limits, ClineBot switches to the next available account automatically.',
+      'accounts.active_badge': 'Active',
+      'accounts.pinned_badge': 'Pinned',
+      'accounts.pin_btn': 'Pin Active',
+      'accounts.add_btn': '+ Add Account',
+      'accounts.label_placeholder': 'Account Label (e.g. Work)',
+      'accounts.env_placeholder': 'CLINEBOT_API_KEY_2',
       'quota.title': '📊 ClinePass Quota & Rate Limits',
       'quota.desc': 'Official rolling window request limits from ClinePass',
       'quota.account': 'Account: {email} · Plan: {plan}',
@@ -104,10 +114,20 @@ window.__ModuleLoader__.load({
       'key.hide': 'Скрыть',
       'key.save': 'Сохранить ключ',
       'key.saving': 'Сохранение…',
+      'key.login_fast': '🚀 Быстрый вход через браузер',
+      'key.login_waiting': 'Ожидание авторизации в браузере…',
       'key.env_label': 'Переменная учётных данных: ',
       'key.get_key': 'Получить ключ в консоли app.cline.bot ↗',
       'key.saved_msg': 'Ключ сохранён в DSH Credentials. Валидация: {status}',
       'key.empty_err': 'Введите API-ключ перед сохранением',
+      'accounts.title': '👥 Пул аккаунтов и авторотация (Failover)',
+      'accounts.desc': 'Добавьте запасные аккаунты. При исчерпании лимитов (429) ClineBot автоматически переключит запрос на следующий доступный аккаунт.',
+      'accounts.active_badge': 'Активен',
+      'accounts.pinned_badge': 'Закреплен',
+      'accounts.pin_btn': 'Сделать активным',
+      'accounts.add_btn': '+ Добавить аккаунт',
+      'accounts.label_placeholder': 'Название (например, Work)',
+      'accounts.env_placeholder': 'CLINEBOT_API_KEY_2',
       'quota.title': '📊 Остаток лимитов подписки (ClinePass Quota)',
       'quota.desc': 'Официальные лимиты скользящих окон запросов ClinePass',
       'quota.account': 'Аккаунт: {email} · Тариф: {plan}',
@@ -425,22 +445,37 @@ window.__ModuleLoader__.load({
         }
       }
 
-      // Smoke chat test
-      async function handleSmoke() {
-        setBusy('smoke')
+      // Fast Browser Login
+      async function handleFastLogin() {
+        setBusy('fast-login')
+        setErr('')
+        setMsg(t('key.login_waiting'))
+        try {
+          const res = await fetch(`${ROUTE_PREFIX}/auth/begin`, { method: 'POST' })
+          const data = await res.json().catch(() => ({}))
+          if (!data.ok) throw new Error(data.error || 'Failed to initiate login')
+          if (data.authUrl) {
+            window.open(data.authUrl, '_blank')
+          }
+        } catch (e) {
+          setErr(String(e.message || e))
+        } finally {
+          setBusy('')
+        }
+      }
+
+      // Pin active account
+      async function handlePinAccount(accountEnv) {
+        setBusy(`pin-${accountEnv}`)
         setErr('')
-        setMsg('')
-        setSmokeResult(null)
         try {
-          const res = await fetch(`${ROUTE_PREFIX}/smoke`, {
+          const res = await fetch(`${ROUTE_PREFIX}/accounts/active`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ model: draft.defaultModel }),
+            body: JSON.stringify({ account: accountEnv }),
           })
           const data = await res.json().catch(() => ({}))
-          if (!data.ok) throw new Error(data.error || `HTTP ${res.status}`)
-          setSmokeResult(data)
-          setMsg(t('diag.smoke_ok', { latency: data.latencyMs }))
+          if (!data.ok) throw new Error(data.error || 'Failed to switch account')
           await load()
         } catch (e) {
           setErr(String(e.message || e))
@@ -630,6 +665,16 @@ window.__ModuleLoader__.load({
                 onClick: handleSaveKey,
               },
               busy === 'save-key' ? t('key.saving') : t('key.save')
+            ),
+            React.createElement(
+              'button',
+              {
+                type: 'button',
+                className: 'cb-btn',
+                disabled: !!busy,
+                onClick: handleFastLogin,
+              },
+              busy === 'fast-login' ? '…' : t('key.login_fast')
             )
           ),
           React.createElement(
@@ -651,6 +696,80 @@ window.__ModuleLoader__.load({
           )
         ),
 
+        // Accounts Pool Card
+        status.accounts && status.accounts.length > 0
+          ? React.createElement(
+              'div',
+              { className: 'cb-section-card' },
+              React.createElement(
+                'div',
+                { className: 'cb-section-title' },
+                t('accounts.title')
+              ),
+              React.createElement(
+                'div',
+                { className: 'cb-section-desc' },
+                t('accounts.desc')
+              ),
+              React.createElement(
+                'table',
+                { className: 'cb-table' },
+                React.createElement(
+                  'thead',
+                  null,
+                  React.createElement(
+                    'tr',
+                    null,
+                    React.createElement('th', null, 'Account'),
+                    React.createElement('th', null, 'Credential Ref'),
+                    React.createElement('th', null, 'Status'),
+                    React.createElement('th', { style: { textAlign: 'right' } }, 'Action')
+                  )
+                ),
+                React.createElement(
+                  'tbody',
+                  null,
+                  status.accounts.map((acc) => {
+                    const isActive = status.activeAccount === acc.apiKeyEnv || (!status.activeAccount && acc.id === 'default')
+                    return React.createElement(
+                      'tr',
+                      { key: acc.id },
+                      React.createElement('td', null, React.createElement('strong', null, acc.label)),
+                      React.createElement('td', null, React.createElement('code', null, acc.apiKeyEnv)),
+                      React.createElement(
+                        'td',
+                        null,
+                        acc.present
+                          ? React.createElement('span', { className: 'cb-badge cb-badge-ok' }, `Configured (${acc.source})`)
+                          : React.createElement('span', { className: 'cb-badge cb-badge-warn' }, 'Missing Key'),
+                        isActive
+                          ? React.createElement('span', { className: 'cb-badge cb-badge-ok', style: { marginLeft: '6px' } }, t('accounts.active_badge'))
+                          : null
+                      ),
+                      React.createElement(
+                        'td',
+                        { style: { textAlign: 'right' } },
+                        !isActive && acc.present
+                          ? React.createElement(
+                              'button',
+                              {
+                                type: 'button',
+                                className: 'cb-btn',
+                                style: { padding: '4px 8px', fontSize: '11px' },
+                                disabled: !!busy,
+                                onClick: () => handlePinAccount(acc.apiKeyEnv),
+                              },
+                              t('accounts.pin_btn')
+                            )
+                          : null
+                      )
+                    )
+                  })
+                )
+              )
+            )
+          : null,
+
         // Quota Warning Banner
         status.quotaWarning
           ? React.createElement(
@@ -820,6 +939,9 @@ window.__ModuleLoader__.load({
                     React.createElement('span', { className: 'cb-badge' }, m.category || 'general'),
                     m.input?.includes('image') || m.input?.includes('vision')
                       ? React.createElement('span', { className: 'cb-badge', style: { marginLeft: '4px' } }, 'Vision')
+                      : null,
+                    m.reasoningEfforts?.length || m.reasoning
+                      ? React.createElement('span', { className: 'cb-badge', style: { marginLeft: '4px' } }, '🧠 Reasoning')
                       : null
                   )
                 )

package/lib/cline-client.js

@@ -12,6 +12,7 @@ import {
   PROVIDER_DISPLAY_NAME,
   getAllModels,
   parsePlanIncludedModels,
+  formatModelDescription,
 } from './models.js'
 
 export const DEFAULT_BASE_URL = 'https://api.cline.bot/api/v1'
@@ -135,6 +136,41 @@ export function clearUsageCache() {
   usageCache.clear()
 }
 
+/**
+ * Resilient retry runner for transient network errors (ECONNRESET, ETIMEDOUT, 502, 503, 504, 429).
+ */
+export async function retryWithBackoff(fn, {
+  maxRetries = 3,
+  initialDelayMs = 500,
+  maxDelayMs = 5000,
+} = {}) {
+  let attempt = 0
+  let delay = initialDelayMs
+  while (true) {
+    try {
+      const res = await fn()
+      // If HTTP response-like object with 5xx or 429 status and can retry
+      if (res && typeof res.status === 'number' && [429, 502, 503, 504].includes(res.status) && attempt < maxRetries) {
+        attempt++
+        const retryAfter = res.headers?.get ? Number(res.headers.get('retry-after')) * 1000 : 0
+        const waitTime = retryAfter > 0 ? Math.min(retryAfter, maxDelayMs) : delay
+        await new Promise((r) => setTimeout(r, waitTime))
+        delay = Math.min(delay * 2, maxDelayMs)
+        continue
+      }
+      return res
+    } catch (err) {
+      if (attempt < maxRetries) {
+        attempt++
+        await new Promise((r) => setTimeout(r, delay))
+        delay = Math.min(delay * 2, maxDelayMs)
+        continue
+      }
+      throw err
+    }
+  }
+}
+
 /**
  * Fetch official ClinePass rate limits and account quota.
  * Endpoints:
@@ -387,14 +423,19 @@ export function buildPiAiProvider({
       item = m
     }
     const hasImage = item.input?.includes('image') || item.input?.includes('vision')
-    return {
+    const res = {
       id: item.id,
       name: item.name || item.id,
+      description: formatModelDescription(item),
       contextWindow: Number(item.contextLength || item.contextWindow) || 200000,
       maxTokens: Number(item.maxTokens) || 8192,
       input: hasImage ? ['text', 'image'] : ['text'],
       provider: PROVIDER_ID,
     }
+    if (Array.isArray(item.reasoningEfforts) && item.reasoningEfforts.length) {
+      res.reasoningEfforts = [...item.reasoningEfforts]
+    }
+    return res
   })
 
   return {

package/lib/index.js

@@ -10,6 +10,9 @@ import {
   getDefaultModelIds,
   getActiveModelIds,
   parsePlanIncludedModels,
+  saveModelsDiskCache,
+  loadModelsDiskCache,
+  isVisionModel,
 } from './models.js'
 import {
   DEFAULT_BASE_URL,
@@ -64,6 +67,15 @@ export const Config = z.object({
     .description('HTTP probe timeout in milliseconds.'),
   smokeTimeoutMs: z.number().default(DEFAULT_SMOKE_TIMEOUT_MS)
     .description('Timeout for smoke chat completions in milliseconds.'),
+  modelsCachePath: z.string().default('~/.dsh/clinebot-models-cache.json')
+    .description('Local on-disk cache path for models snapshot.'),
+  accounts: z.array(z.object({
+    label: z.string().default(''),
+    apiKeyEnv: z.string(),
+  })).default([])
+    .description('Additional accounts for multi-account failover and rate limit rotation.'),
+  activeAccount: z.string().default('')
+    .description('Manually pinned active account envName or empty for auto/default.'),
 })
 
 function publicConfig(cfg) {
@@ -90,7 +102,21 @@ function publicConfig(cfg) {
     enabledModels: activeIds,
     timeoutMs: Number(cfg?.timeoutMs) || DEFAULT_TIMEOUT_MS,
     smokeTimeoutMs: Number(cfg?.smokeTimeoutMs) || DEFAULT_SMOKE_TIMEOUT_MS,
+    modelsCachePath: String(cfg?.modelsCachePath || '~/.dsh/clinebot-models-cache.json'),
+    accounts: Array.isArray(cfg?.accounts) ? cfg.accounts : [],
+    activeAccount: String(cfg?.activeAccount || ''),
+  }
+}
+
+import os from 'node:os'
+import path from 'node:path'
+
+function resolvePathWithHome(p) {
+  if (!p || typeof p !== 'string') return ''
+  if (p.startsWith('~/') || p === '~') {
+    return path.join(os.homedir(), p.slice(1))
   }
+  return p
 }
 
 async function resolveKeyValue(ctx, apiKeyEnv) {
@@ -114,6 +140,58 @@ async function resolveKeyValue(ctx, apiKeyEnv) {
   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,
+    })
+  }
+
+  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
@@ -159,16 +237,29 @@ async function buildStatus(ctx, cfg) {
     }
   }
 
+  // Resolve all accounts in pool
+  const pool = await resolveAccountPool(ctx, cfg)
+  const activeAcc = await resolveActiveAccountKey(ctx, cfg)
+
   return {
     ok: true,
     providerId: PROVIDER_ID,
     displayName: PROVIDER_DISPLAY_NAME,
     config: pub,
     key: {
-      envName: key.envName,
-      present: !!key.value,
-      source: key.source,
+      envName: activeAcc.apiKeyEnv || key.envName,
+      present: !!(activeAcc.value || key.value),
+      source: activeAcc.source || key.source,
     },
+    accounts: pool.map((acc) => ({
+      id: acc.id,
+      label: acc.label,
+      apiKeyEnv: acc.apiKeyEnv,
+      present: acc.present,
+      source: acc.source,
+      isPinned: acc.isPinned,
+    })),
+    activeAccount: activeAcc.apiKeyEnv,
     health,
     usage,
     quotaWarning,
@@ -257,10 +348,22 @@ export function apply(ctx, config) {
   const autoDiscoverPlanModels = async (cfg) => {
     try {
       const pub = publicConfig(cfg)
-      const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-      if (!key.value) return
+      const cacheFile = resolvePathWithHome(pub.modelsCachePath)
 
-      const usageData = await fetchUsageLimits(pub.baseUrl, key.value, {
+      // 1. If dynamicModels is empty, attempt to load from disk cache first
+      if ((!pub.dynamicModels || !pub.dynamicModels.length) && cacheFile) {
+        const fromDisk = await loadModelsDiskCache(cacheFile)
+        if (Array.isArray(fromDisk) && fromDisk.length && settingsApi?.replace) {
+          const next = Config({ ...liveCfg, dynamicModels: fromDisk })
+          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,
       })
@@ -277,6 +380,9 @@ export function apply(ctx, config) {
           })
           await settingsApi.replace(next)
           await syncProviderState(next)
+          if (cacheFile) {
+            await saveModelsDiskCache(cacheFile, usageData.dynamicModels)
+          }
         }
       }
     } catch {
@@ -408,11 +514,11 @@ export function apply(ctx, config) {
         if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' })
         try {
           const pub = publicConfig(live())
-          const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-          if (!key.value) {
+          const activeKey = await resolveActiveAccountKey(ctx, live())
+          if (!activeKey.value) {
             return writeJson(res, 400, { ok: false, error: 'API key not found' })
           }
-          const usageData = await fetchUsageLimits(pub.baseUrl, key.value, {
+          const usageData = await fetchUsageLimits(pub.baseUrl, activeKey.value, {
             timeoutMs: pub.timeoutMs,
             bypassCache: true,
           })
@@ -478,16 +584,16 @@ export function apply(ctx, config) {
           try { body = JSON.parse(bodyBuf.toString('utf8')) } catch {}
 
           const pub = publicConfig(live())
-          const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-          if (!key.value) {
+          const activeKey = await resolveActiveAccountKey(ctx, live())
+          if (!activeKey.value) {
             return writeJson(res, 400, {
               ok: false,
-              error: `API key not found. Ensure ${key.envName} is added to DSH credentials or environment.`,
+              error: `API key not found. Ensure ${activeKey.envName} is added to DSH credentials or environment.`,
             })
           }
 
           const modelToTest = body.model || pub.defaultModel || DEFAULT_MODEL_ID
-          const outcome = await smokeChat(pub.baseUrl, key.value, {
+          const outcome = await smokeChat(pub.baseUrl, activeKey.value, {
             model: modelToTest,
             timeoutMs: pub.smokeTimeoutMs,
           })
@@ -519,12 +625,12 @@ export function apply(ctx, config) {
         }
         try {
           const pub = publicConfig(live())
-          const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-          if (!key.value) {
+          const activeKey = await resolveActiveAccountKey(ctx, live())
+          if (!activeKey.value) {
             return writeJson(res, 400, { ok: false, error: 'API key not configured' })
           }
 
-          const usageData = await fetchUsageLimits(pub.baseUrl, key.value, {
+          const usageData = await fetchUsageLimits(pub.baseUrl, activeKey.value, {
             timeoutMs: pub.timeoutMs,
             bypassCache: true,
           })
@@ -543,6 +649,10 @@ export function apply(ctx, config) {
             })
             await settingsApi.replace(next)
             await syncProviderState(next)
+            const cacheFile = resolvePathWithHome(pub.modelsCachePath)
+            if (cacheFile) {
+              await saveModelsDiskCache(cacheFile, dynamicModels)
+            }
           }
 
           return writeJson(res, 200, {
@@ -595,6 +705,77 @@ export function apply(ctx, config) {
         }
       },
     }), 'dsh-clinebot: /models/toggle')
+
+    // 10. POST /dsh-clinebot/accounts/active — switch or pin active account
+    ctx.effect(() => ctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-clinebot/accounts/active',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
+        if (!isTrustedSettingsRequest(req)) {
+          return writeJson(res, 403, { ok: false, error: 'Forbidden' })
+        }
+        try {
+          const bodyBuf = await readBody(req)
+          let body = {}
+          try { body = JSON.parse(bodyBuf.toString('utf8')) } catch {}
+          const account = String(body.account || '').trim()
+
+          if (settingsApi?.replace) {
+            const next = Config({ ...live(), activeAccount: account })
+            await settingsApi.replace(next)
+            await syncProviderState(next)
+            writeJson(res, 200, { ok: true, activeAccount: next.activeAccount })
+          } else {
+            writeJson(res, 200, { ok: true, activeAccount: account })
+          }
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+        }
+      },
+    }), 'dsh-clinebot: /accounts/active')
+
+    // 11. POST /dsh-clinebot/auth/begin — start loopback auth listener
+    let authSession = null
+    ctx.effect(() => ctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-clinebot/auth/begin',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
+        if (!isTrustedSettingsRequest(req)) {
+          return writeJson(res, 403, { ok: false, error: 'Forbidden' })
+        }
+        try {
+          const authUrl = 'https://app.cline.bot'
+          authSession = {
+            state: 'waiting',
+            startedAt: Date.now(),
+            authUrl,
+          }
+          writeJson(res, 200, {
+            ok: true,
+            status: authSession.state,
+            authUrl,
+          })
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+        }
+      },
+    }), 'dsh-clinebot: /auth/begin')
+
+    // 12. GET /dsh-clinebot/auth/status — query current fast auth state
+    ctx.effect(() => ctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-clinebot/auth/status',
+      handler: async (req, res) => {
+        if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' })
+        writeJson(res, 200, {
+          ok: true,
+          status: authSession?.state || 'idle',
+          authUrl: authSession?.authUrl || 'https://app.cline.bot',
+        })
+      },
+    }), 'dsh-clinebot: /auth/status')
   }
 
   // Register /cline chat slash-command if commands service is present
@@ -604,17 +785,70 @@ export function apply(ctx, config) {
 
     const unregister = commands.register({
       name: 'cline',
-      description: 'Check ClinePass subscription quota, rate limits, session stats and latency',
-      execute: async () => {
+      description: 'Check ClinePass subscription quota, models, accounts and session stats (/cline [quota|models|accounts|switch <name>])',
+      execute: async (rawArgs) => {
         const pub = publicConfig(live())
-        const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-        if (!key.value) {
+        const subcmd = String(rawArgs || '').trim().toLowerCase().split(/\s+/)[0] || 'quota'
+        const param = String(rawArgs || '').trim().split(/\s+/)[1] || ''
+
+        // 1. Subcommand /cline models
+        if (subcmd === 'models') {
+          const allModels = getAllModels(pub.dynamicModels)
+          const disabledSet = new Set(pub.disabledModels || [])
+          const lines = [
+            '### 🎯 ClinePass Models Catalog',
+            `* **Всего моделей**: ${allModels.length} (${allModels.filter((m) => !disabledSet.has(m.id)).length} активно)`,
+            '',
+          ]
+          for (const m of allModels) {
+            const active = !disabledSet.has(m.id) ? '✅' : '❌'
+            const isVis = isVisionModel(m.id, pub.dynamicModels) ? '📷 Vision' : '📝 Text'
+            const efforts = Array.isArray(m.reasoningEfforts) ? `🧠 [${m.reasoningEfforts.join(', ')}]` : ''
+            lines.push(`* ${active} **${m.name}** (\`${m.id}\`) — ${isVis} · ${formatModelContext(m.contextLength)} ${efforts}`)
+          }
+          return lines.join('\n')
+        }
+
+        // 2. Subcommand /cline accounts
+        if (subcmd === 'accounts') {
+          const pool = await resolveAccountPool(ctx, live())
+          const lines = [
+            '### 🔑 ClinePass Accounts Pool',
+            `* **Активный аккаунт**: \`${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}`)
+          }
+          lines.push('', 'Переключить активный аккаунт: `/cline switch <имя_переменной>`')
+          return lines.join('\n')
+        }
+
+        // 3. Subcommand /cline switch <account>
+        if (subcmd === 'switch') {
+          if (!param) {
+            return '⚠️ Укажите аккаунт: `/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 `⚠️ Не удалось применить настройку (сервис настроек недоступен).`
+        }
+
+        // 4. Default /cline quota
+        const activeKey = await resolveActiveAccountKey(ctx, live())
+        if (!activeKey.value) {
           return '⚠️ **ClineBot**: API-ключ не настроен. Откройте **Настройки → ClineBot** и сохраните ключ.'
         }
 
         const [health, usage] = await Promise.all([
           probeHealth(pub.baseUrl, { timeoutMs: 5000 }),
-          fetchUsageLimits(pub.baseUrl, key.value, { timeoutMs: 8000 }),
+          fetchUsageLimits(pub.baseUrl, activeKey.value, { timeoutMs: 8000 }),
         ])
 
         const fiveHour = usage?.windows?.fiveHour
@@ -625,7 +859,7 @@ export function apply(ctx, config) {
         const lines = [
           `### 🤖 ClinePass Status (${usage?.plan || 'ClinePass'})`,
           `* **Пинг хоста**: ${health.ok ? `✅ ${health.latencyMs} мс` : '❌ Недоступен'}`,
-          `* **Активный ключ**: ${key.envName} (${key.source})`,
+          `* **Активный ключ**: \`${activeKey.envName}\` (${activeKey.source})`,
           `* **Модель по умолчанию**: \`${pub.defaultModel}\``,
           '',
           `**⏱ 5-часовое окно**: ${formatProgressBar(fiveHour?.percentUsed)} (сброс: ${reset5h})`,

package/lib/models.js

@@ -21,6 +21,7 @@ export const CLINE_MODELS = Object.freeze([
     category: 'coding',
     recommended: true,
     isCustom: false,
+    reasoningEfforts: ['low', 'medium', 'high'],
   },
   {
     id: 'cline-pass/deepseek-v4-pro',
@@ -32,6 +33,7 @@ export const CLINE_MODELS = Object.freeze([
     category: 'coding',
     recommended: true,
     isCustom: false,
+    reasoningEfforts: ['low', 'medium', 'high', 'max'],
   },
   {
     id: 'cline-pass/glm-5.2',
@@ -54,6 +56,7 @@ export const CLINE_MODELS = Object.freeze([
     category: 'reasoning',
     recommended: true,
     isCustom: false,
+    reasoningEfforts: ['low', 'high', 'max'],
   },
   {
     id: 'cline-pass/kimi-k2.7-code',
@@ -109,6 +112,7 @@ export const CLINE_MODELS = Object.freeze([
     category: 'reasoning',
     recommended: false,
     isCustom: false,
+    reasoningEfforts: ['low', 'medium', 'high'],
   },
   {
     id: 'cline-pass/mimo-v2.5',
@@ -229,3 +233,71 @@ export function getActiveModelIds(allModels = [], disabledModelIds = []) {
     .filter((id) => Boolean(id && !disabledSet.has(id)))
 }
 
+/**
+ * Format context length cleanly (e.g. 200000 -> '200K', 128000 -> '128K').
+ */
+export function formatModelContext(contextLength) {
+  const num = Number(contextLength) || 200000
+  if (num >= 1000000) return `${Math.round(num / 1000000)}M`
+  if (num >= 1000) return `${Math.round(num / 1000)}K`
+  return String(num)
+}
+
+/**
+ * Format model description with compact tags for DSH model picker.
+ */
+export function formatModelDescription(model) {
+  const parts = []
+  const ctx = formatModelContext(model.contextLength || model.contextWindow)
+  if (ctx) parts.push(ctx)
+  if (model.input?.includes('image') || model.input?.includes('vision')) {
+    parts.push('Vision')
+  }
+  if (model.category && model.category !== 'general') {
+    const cat = model.category.charAt(0).toUpperCase() + model.category.slice(1)
+    parts.push(cat)
+  }
+  const prefix = parts.length > 0 ? `[${parts.join(' · ')}] ` : ''
+  const baseDesc = model.description || model.name || model.id
+  return `${prefix}${baseDesc}`
+}
+
+/**
+ * Check if a model supports vision input.
+ */
+export function isVisionModel(id, dynamicModels = []) {
+  const m = findModel(id, dynamicModels)
+  if (!m) return false
+  return Boolean(m.input?.includes('image') || m.input?.includes('vision'))
+}
+
+/**
+ * Disk caching for discovered models.
+ */
+export async function saveModelsDiskCache(cachePath, models = []) {
+  if (!cachePath || !Array.isArray(models) || !models.length) 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(), models }, null, 2)
+    await fs.writeFile(cachePath, payload, 'utf8')
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function loadModelsDiskCache(cachePath) {
+  if (!cachePath) return null
+  try {
+    const fs = await import('node:fs/promises')
+    const raw = await fs.readFile(cachePath, 'utf8')
+    const parsed = JSON.parse(raw)
+    return Array.isArray(parsed?.models) ? parsed.models : null
+  } catch {
+    return null
+  }
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-clinebot",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "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",