@goodandready/dsh-clinebot 0.3.11 → 0.3.13

package/lib/cline-client.js

@@ -553,132 +553,5 @@ export async function resolveKeyValue(ctx, apiKeyEnv) {
   return { envName: refName, value: '', source: 'none' }
 }
 
-/**
- * Resolve all accounts in pool with their status and keys.
- */
-export async function resolveAccountPool(ctx, cfg) {
-  const apiKeyEnv = cfg?.apiKeyEnv || DEFAULT_API_KEY_ENV
-  const defaultSlot = {
-    id: 'default',
-    label: 'Default',
-    apiKeyEnv,
-  }
-  const accounts = Array.isArray(cfg?.accounts) ? cfg.accounts : []
-  const allSlots = [defaultSlot, ...accounts]
-  const activeAccount = String(cfg?.activeAccount || '')
-  const resolved = []
-
-  for (let i = 0; i < allSlots.length; i++) {
-    const slot = allSlots[i]
-    const envName = slot.apiKeyEnv || (i === 0 ? 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: activeAccount ? activeAccount === envName : i === 0,
-    })
-  }
-
-  return resolved
-}
-
-/**
- * Check if a cached quota entry is currently exhausted.
- * Checks 5-hour rolling limit and verifies if resetsAt timestamp has already elapsed.
- */
-export function isAccountQuotaExhausted(usage) {
-  if (!usage?.windows?.fiveHour) return false
-  const fiveHour = usage.windows.fiveHour
-  if (typeof fiveHour.percentUsed !== 'number' || fiveHour.percentUsed < 95) {
-    return false
-  }
-  // Auto-recovery: if resetsAt is present and in the past, the account is recovered
-  if (fiveHour.resetsAt) {
-    const resetTime = new Date(fiveHour.resetsAt).getTime()
-    if (!Number.isNaN(resetTime) && Date.now() >= resetTime) {
-      return false
-    }
-  }
-  return true
-}
-
-/**
- * Smart Quota-Aware Failover: rotates active account upon 429 or quota exhaustion.
- * Prioritizes accounts with lowest percentUsed and respects resetsAt recovery.
- */
-export async function rotateToNextAccount(ctx, cfg, reason = 'rate_limit', settingsApi = null) {
-  const pool = await resolveAccountPool(ctx, cfg)
-  const configured = pool.filter((acc) => acc.present && acc.value)
-  if (configured.length <= 1) {
-    return { rotated: false, reason, message: 'Pool has only 1 configured account' }
-  }
-
-  const active = String(cfg?.activeAccount || configured[0].apiKeyEnv)
-  const currentIndex = configured.findIndex((acc) => acc.apiKeyEnv === active)
-
-  // Candidate pool excluding current account if possible
-  const candidates = configured.filter((acc) => acc.apiKeyEnv !== active)
-  if (!candidates.length) {
-    return { rotated: false, reason, message: 'No alternative accounts configured' }
-  }
 
-  // Assess quota for candidates if cached in memory
-  let bestCandidate = null
-  let lowestUsagePct = Infinity
-
-  for (const cand of candidates) {
-    const cacheKey = `cline:usage:${cand.value.slice(-8)}`
-    const cached = usageCache.get(cacheKey)?.data
-    const isExhausted = isAccountQuotaExhausted(cached)
-
-    if (!isExhausted) {
-      const pct = cached?.windows?.fiveHour?.percentUsed ?? 50
-      if (pct < lowestUsagePct) {
-        lowestUsagePct = pct
-        bestCandidate = cand
-      }
-    }
-  }
-
-  // Fallback if all candidates are either exhausted or uncached: pick next in round-robin
-  const nextAcc = bestCandidate || candidates[currentIndex % candidates.length] || candidates[0]
-
-  let updated = false
-  if (settingsApi?.replace) {
-    try {
-      const next = { ...cfg, activeAccount: nextAcc.apiKeyEnv }
-      await settingsApi.replace(next)
-      updated = true
-    } catch (err) {
-      ctx?.logger?.warn?.('[dsh-clinebot] Failed to persist rotated activeAccount via settingsApi: ' + (err?.message || err))
-    }
-  } else {
-    const settings = (ctx?.get && ctx.get('settings')) || ctx?.settings
-    if (settings?.mutate) {
-      try {
-        await settings.mutate('dsh-clinebot', [
-          { op: 'set', path: ['activeAccount'], value: nextAcc.apiKeyEnv },
-        ])
-        updated = true
-      } catch (err) {
-        ctx?.logger?.warn?.('[dsh-clinebot] Failed to persist rotated activeAccount via settings.mutate: ' + (err?.message || err))
-      }
-    }
-  }
-
-  // Reset cached quota and host probes so new account immediately revalidates
-  clearUsageCache()
-  clearProbeCache()
-
-  return {
-    rotated: true,
-    previousAccount: active,
-    activeAccount: nextAcc.apiKeyEnv,
-    reason,
-    updatedSettings: updated,
-  }
-}
+export { resolveAccountPool, isAccountQuotaExhausted, rotateToNextAccount } from './account-pool.js'

package/lib/config.js

@@ -0,0 +1,84 @@
+import z from '@deepseek-ai/schemastery'
+import {
+  DEFAULT_BASE_URL,
+  DEFAULT_API_KEY_ENV,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_SMOKE_TIMEOUT_MS,
+  normalizeBaseUrl,
+} from './cline-client.js'
+import {
+  DEFAULT_MODEL_ID,
+  getAllModels,
+  getActiveModelIds,
+} from './models.js'
+
+export const NS = 'dsh-clinebot'
+export const LLM_PI_AI_NS = 'llm-pi-ai'
+
+export const Config = z.object({
+  enabled: z.boolean().default(true)
+    .description('When true, ClineBot is registered as a model provider in DSH.'),
+  baseUrl: z.string().default(DEFAULT_BASE_URL)
+    .description('Base API URL (default: https://api.cline.bot/api/v1).'),
+  apiKeyEnv: z.string().default(DEFAULT_API_KEY_ENV)
+    .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.'),
+  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(),
+    description: z.string().default(''),
+    contextLength: z.number().default(200000),
+    maxTokens: z.number().default(8192),
+    input: z.array(z.string()).default(['text']),
+    category: z.string().default('general'),
+    isCustom: z.boolean().default(false),
+  })).default([])
+    .description('Models automatically discovered from the official ClinePass subscription plan.'),
+  timeoutMs: z.number().default(DEFAULT_TIMEOUT_MS)
+    .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.'),
+})
+
+export function publicConfig(cfg) {
+  const dynamic = Array.isArray(cfg?.dynamicModels) ? cfg.dynamicModels : []
+  const allModels = getAllModels(dynamic)
+  const allDefaultIds = allModels.map((m) => m.id)
+
+  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,
+    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 || ''),
+  }
+}