@goodandready/dsh-clinebot 0.3.1 → 0.3.3

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

@@ -8,7 +8,11 @@ import {
   PROVIDER_DISPLAY_NAME,
   getAllModels,
   getDefaultModelIds,
+  getActiveModelIds,
   parsePlanIncludedModels,
+  saveModelsDiskCache,
+  loadModelsDiskCache,
+  isVisionModel,
 } from './models.js'
 import {
   DEFAULT_BASE_URL,
@@ -44,8 +48,10 @@ export const Config = z.object({
     .description('Credential / env name containing the ClinePass API key (never store key directly here).'),
   defaultModel: z.string().default(DEFAULT_MODEL_ID)
     .description('Default model ID for chat and smoke tests.'),
-  enabledModels: z.array(z.string()).default(getDefaultModelIds())
-    .description('List of model IDs enabled for selection in DSH.'),
+  disabledModels: z.array(z.string()).default([])
+    .description('List of model IDs explicitly disabled by the user (new models are enabled automatically).'),
+  enabledModels: z.array(z.string()).default([])
+    .description('Deprecated: preserved for backwards compatibility with earlier versions.'),
   dynamicModels: z.array(z.object({
     id: z.string(),
     name: z.string(),
@@ -61,23 +67,56 @@ 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) {
   const dynamic = Array.isArray(cfg?.dynamicModels) ? cfg.dynamicModels : []
-  const allDefaultIds = getDefaultModelIds(dynamic)
+  const allModels = getAllModels(dynamic)
+  const allDefaultIds = allModels.map((m) => m.id)
+
+  // Migration / compatibility: if disabledModels was not yet set, but enabledModels was provided
+  let disabledList = Array.isArray(cfg?.disabledModels) ? cfg.disabledModels : []
+  if (!Array.isArray(cfg?.disabledModels) || (cfg.disabledModels.length === 0 && Array.isArray(cfg?.enabledModels) && cfg.enabledModels.length > 0)) {
+    const enabledSet = new Set(cfg.enabledModels)
+    disabledList = allDefaultIds.filter((id) => !enabledSet.has(id))
+  }
+
+  const activeIds = getActiveModelIds(allDefaultIds, disabledList)
+
   return {
     enabled: !!cfg?.enabled,
     baseUrl: normalizeBaseUrl(cfg?.baseUrl),
     apiKeyEnv: cfg?.apiKeyEnv || DEFAULT_API_KEY_ENV,
     defaultModel: cfg?.defaultModel || DEFAULT_MODEL_ID,
     dynamicModels: dynamic,
-    enabledModels: Array.isArray(cfg?.enabledModels) && cfg.enabledModels.length
-      ? cfg.enabledModels
-      : allDefaultIds,
+    disabledModels: disabledList,
+    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) {
@@ -101,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
@@ -115,13 +206,16 @@ async function checkRegisteredInPiAi(ctx) {
 async function buildStatus(ctx, cfg) {
   const pub = publicConfig(cfg)
   const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-  const health = await probeHealth(pub.baseUrl, { timeoutMs: pub.timeoutMs })
+  // 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)
   const allModels = getAllModels(pub.dynamicModels)
 
   let usage = null
   if (key.value) {
-    usage = await fetchUsageLimits(pub.baseUrl, key.value, { timeoutMs: pub.timeoutMs }).catch(() => null)
+    // Uses 60s cache; if cache miss, times out quickly
+    usage = await fetchUsageLimits(pub.baseUrl, key.value, { timeoutMs: probeTimeout }).catch(() => null)
   }
 
   // Evaluate warning state
@@ -143,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,
@@ -162,7 +269,7 @@ async function buildStatus(ctx, cfg) {
   }
 }
 
-async function upsertPiAiProvider(ctx, cfg, dynamicModelIds) {
+async function upsertPiAiProvider(ctx, cfg, activeModelIds) {
   const settings = ctx?.get?.('settings')
   if (!settings?.mutate) {
     throw new Error('DSH settings service unavailable')
@@ -170,8 +277,8 @@ async function upsertPiAiProvider(ctx, cfg, dynamicModelIds) {
 
   const pub = publicConfig(cfg)
   const allModels = getAllModels(pub.dynamicModels)
-  const selectedIds = new Set(dynamicModelIds || pub.enabledModels)
-  const modelsToRegister = allModels.filter((m) => selectedIds.has(m.id))
+  const allowedSet = new Set(activeModelIds || pub.enabledModels)
+  const modelsToRegister = allModels.filter((m) => allowedSet.has(m.id))
 
   const providerObj = buildPiAiProvider({
     baseUrl: pub.baseUrl,
@@ -218,6 +325,71 @@ export function apply(ctx, config) {
   let liveCfg = Config(structuredClone(config || {}))
   let settingsApi
 
+  // Declarative sync helper: auto-registers or unregisters provider based on config & key availability
+  const syncProviderState = async (cfg) => {
+    try {
+      const pub = publicConfig(cfg)
+      if (!pub.enabled) {
+        if (await checkRegisteredInPiAi(ctx)) {
+          await removePiAiProvider(ctx)
+        }
+        return
+      }
+      const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
+      if (key.value) {
+        await upsertPiAiProvider(ctx, cfg, pub.enabledModels)
+      }
+    } catch {
+      /* ignore transient settings unavailable */
+    }
+  }
+
+  // Background check for subscription plan models (runs once on startup or key save)
+  const autoDiscoverPlanModels = async (cfg) => {
+    try {
+      const pub = publicConfig(cfg)
+      const cacheFile = resolvePathWithHome(pub.modelsCachePath)
+
+      // 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,
+      })
+
+      if (usageData?.ok && Array.isArray(usageData.dynamicModels) && usageData.dynamicModels.length > 0) {
+        const existingDynamic = pub.dynamicModels || []
+        const existingIds = new Set(existingDynamic.map((m) => m.id))
+        const hasNew = usageData.dynamicModels.some((m) => !existingIds.has(m.id))
+
+        if (hasNew && settingsApi?.replace) {
+          const next = Config({
+            ...liveCfg,
+            dynamicModels: usageData.dynamicModels,
+          })
+          await settingsApi.replace(next)
+          await syncProviderState(next)
+          if (cacheFile) {
+            await saveModelsDiskCache(cacheFile, usageData.dynamicModels)
+          }
+        }
+      }
+    } catch {
+      /* best-effort discovery */
+    }
+  }
+
   const settingsService = ctx.get('settings')
   if (typeof settingsService?.register === 'function') {
     const scope = settingsService.register(NS, Config, { base: config })
@@ -225,11 +397,17 @@ export function apply(ctx, config) {
     liveCfg = Config(scope.get() ?? config)
     ctx.effect(() => scope.watch((next) => {
       liveCfg = Config(next ?? config)
+      syncProviderState(liveCfg)
     }), 'dsh-clinebot: settings')
   }
 
   const live = () => liveCfg
 
+  // On startup: ensure provider is synced to llm-pi-ai if key is present
+  syncProviderState(liveCfg)
+  // Background discover plan models on startup
+  setTimeout(() => autoDiscoverPlanModels(liveCfg), 500)
+
   // Web server HTTP route handlers
   if (ctx.webServer?.register) {
     // 1. GET /dsh-clinebot/status
@@ -274,6 +452,7 @@ export function apply(ctx, config) {
         try {
           const parsed = Config({ ...publicConfig(live()), ...payload })
           await settingsApi.replace(parsed)
+          await syncProviderState(parsed)
           writeJson(res, 200, { ok: true, config: publicConfig(live()) })
         } catch (e) {
           writeJson(res, 400, { ok: false, error: String(e?.message || e) })
@@ -304,6 +483,10 @@ export function apply(ctx, config) {
           const targetEnvName = String(body.apiKeyEnv || pub.apiKeyEnv || DEFAULT_API_KEY_ENV).trim()
           await saveCredentialKey(ctx, targetEnvName, apiKey)
 
+          // Auto-sync provider to DSH Models and discover plan models
+          await syncProviderState(live())
+          autoDiscoverPlanModels(live())
+
           // Run validation probe with the newly saved key
           const validation = await smokeChat(pub.baseUrl, apiKey, {
             model: pub.defaultModel,
@@ -331,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,
           })
@@ -359,7 +542,8 @@ export function apply(ctx, config) {
           const bodyBuf = await readBody(req)
           let body = {}
           try { body = JSON.parse(bodyBuf.toString('utf8')) } catch {}
-          const result = await upsertPiAiProvider(ctx, live(), body.models)
+          const activeModels = body.models || publicConfig(live()).enabledModels
+          const result = await upsertPiAiProvider(ctx, live(), activeModels)
           writeJson(res, 200, { ok: true, provider: result })
         } catch (err) {
           writeJson(res, 500, { ok: false, error: String(err?.message || err) })
@@ -400,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,
           })
@@ -441,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,
           })
@@ -457,23 +641,17 @@ export function apply(ctx, config) {
 
           const dynamicModels = Array.isArray(usageData.dynamicModels) ? usageData.dynamicModels : []
           const allModels = getAllModels(dynamicModels)
-          const allIds = allModels.map((m) => m.id)
-
-          // Preserve currently enabled models, plus add any newly discovered ones
-          const existingEnabled = new Set(live().enabledModels || getDefaultModelIds())
-          for (const m of allModels) {
-            existingEnabled.add(m.id)
-          }
 
           if (settingsApi?.replace) {
             const next = Config({
               ...live(),
               dynamicModels,
-              enabledModels: Array.from(existingEnabled),
             })
             await settingsApi.replace(next)
-            if (await checkRegisteredInPiAi(ctx)) {
-              await upsertPiAiProvider(ctx, next, Array.from(existingEnabled))
+            await syncProviderState(next)
+            const cacheFile = resolvePathWithHome(pub.modelsCachePath)
+            if (cacheFile) {
+              await saveModelsDiskCache(cacheFile, dynamicModels)
             }
           }
 
@@ -490,7 +668,7 @@ export function apply(ctx, config) {
       },
     }), 'dsh-clinebot: /models/sync')
 
-    // 9. POST /dsh-clinebot/models/toggle — toggle enabled status in picker
+    // 9. POST /dsh-clinebot/models/toggle — toggle disabled/enabled status in picker
     ctx.effect(() => ctx.webServer.register({
       kind: 'exact',
       path: '/dsh-clinebot/models/toggle',
@@ -504,21 +682,100 @@ export function apply(ctx, config) {
           let body = {}
           try { body = JSON.parse(bodyBuf.toString('utf8')) } catch {}
 
-          if (Array.isArray(body.enabledModels) && settingsApi?.replace) {
-            const patch = { enabledModels: body.enabledModels }
+          if (settingsApi?.replace) {
+            const patch = {}
+            if (Array.isArray(body.disabledModels)) {
+              patch.disabledModels = body.disabledModels
+            } else if (Array.isArray(body.enabledModels)) {
+              // Convert legacy enabledModels toggle to disabledModels
+              const allModels = getAllModels(live().dynamicModels)
+              const enabledSet = new Set(body.enabledModels)
+              patch.disabledModels = allModels.map((m) => m.id).filter((id) => !enabledSet.has(id))
+            }
             if (body.defaultModel) patch.defaultModel = body.defaultModel
             const next = Config({ ...live(), ...patch })
             await settingsApi.replace(next)
-            if (await checkRegisteredInPiAi(ctx)) {
-              await upsertPiAiProvider(ctx, next, body.enabledModels)
-            }
+            await syncProviderState(next)
+            writeJson(res, 200, { ok: true, disabledModels: next.disabledModels, enabledModels: publicConfig(next).enabledModels })
+          } else {
+            writeJson(res, 200, { ok: true })
           }
-          writeJson(res, 200, { ok: true, enabledModels: body.enabledModels })
         } catch (err) {
           writeJson(res, 500, { ok: false, error: String(err?.message || err) })
         }
       },
     }), '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
@@ -528,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
@@ -549,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})`,