@goodandready/dsh-clinebot 0.6.0 → 0.6.2

package/lib/index.js

@@ -1,4 +1,4 @@
-import { Config, publicConfig, plainConfig, volatileConfig, isVolatileRef, NS, LLM_PI_AI_NS } from './config.js'
+import { Config, publicConfig, plainConfig, volatileConfig, isVolatileRef, NS } from './config.js'
 import { registerPluginUpdater } from './updater.js'
 import {
   sessionStats,
@@ -7,28 +7,20 @@ import {
   clearUsageCache,
   clearProbeCache,
 } from './cline-client.js'
-import {
-  rotateToNextAccount,
-  isQuotaExceededError,
-} from './account-pool.js'
+import { rotateToNextAccount } from './account-pool.js'
 import { PROVIDER_ID } from './models.js'
 import {
-  upsertPiAiProvider,
-  removePiAiProvider,
   autoDiscoverPlanModels,
-  resolveActiveAccountKey,
 } from './provider-sync.js'
 import { registerSettingsRoutes } from './routes/settings.js'
 import { registerAccountsRoutes } from './routes/accounts.js'
 import { registerModelsRoutes } from './routes/models.js'
 import { registerAuthRoutes } from './routes/auth.js'
-import { registerProxyRoutes } from './routes/proxy.js'
-import { startLoopbackProxyServer, stopLoopbackProxyServer } from './proxy-server.js'
 import { ClineBotAdapter } from './adapter.js'
 import { registerSlashCommand } from './slash-command.js'
 import { ClineBotSearchProvider, CLINEBOT_SEARCH_PROVIDER_ID } from './web-search.js'
 import { resolveAccountPool } from './account-pool.js'
-import { recordUsage, loadStats, flushStats, resolvePath, switchStatsStorage } from './stats-storage.js'
+import { loadStats, flushStats, resolvePath, switchStatsStorage } from './stats-storage.js'
 import { service, migrateLegacyPiAiProvider } from './services.js'
 import { applyTuiSettings } from './tui-settings.js'
 
@@ -39,7 +31,7 @@ export function configReader(config) {
   return () => config
 }
 
-export { NS, LLM_PI_AI_NS, Config, sessionStats, recordSessionRequest, resetSessionStats, rotateToNextAccount }
+export { NS, Config, sessionStats, recordSessionRequest, resetSessionStats, rotateToNextAccount }
 
 export function apply(ctx, config) {
   let currentConfig = config || {}
@@ -86,26 +78,8 @@ export function apply(ctx, config) {
   const syncProviderState = async (cfg) => {
     try {
       const pub = publicConfig(cfg)
-      if (pub.transport !== 'pi-ai') {
-        // Native ctx.llm adapter: the route set follows `enabled`; no
-        // llm-pi-ai mutation and no loopback proxy are involved.
-        if (adapterRegistration) {
-          adapterRegistration.replace(pub.enabled ? [PROVIDER_ID] : [])
-        }
-        return
-      }
-      if (!pub.enabled) {
-        await removePiAiProvider(ctx)
-        return
-      }
-      if (pub.proxyMode !== false && (service(ctx, 'webServer') || typeof ctx?.get === 'function')) {
-        await startLoopbackProxyServer(ctx, routeEnv)
-      } else {
-        await stopLoopbackProxyServer()
-      }
-      const activeKey = await resolveActiveAccountKey(ctx, cfg)
-      if (activeKey.value) {
-        await upsertPiAiProvider(ctx, cfg, pub.enabledModels)
+      if (adapterRegistration) {
+        adapterRegistration.replace(pub.enabled ? [PROVIDER_ID] : [])
       }
     } catch {
       /* ignore transient settings unavailable */
@@ -284,7 +258,6 @@ export function apply(ctx, config) {
   }
 
   const ensureAdapter = () => {
-    if (publicConfig(live()).transport === 'pi-ai') return
     if (typeof ctx.inject !== 'function') return
     ctx.inject(['llm'], (llmCtx) => {
       const llm = llmCtx?.llm || llmCtx?.get?.('llm')
@@ -322,20 +295,12 @@ export function apply(ctx, config) {
   ensureAdapter()
   applyTuiSettings(ctx, { live })
 
-  if (typeof ctx.inject === 'function' && publicConfig(live()).transport !== 'pi-ai') {
+  if (typeof ctx.inject === 'function') {
     ctx.inject(['settings'], () => {
       void migrateLegacyPiAiProvider(ctx)
     })
   }
 
-  if (typeof ctx.effect === 'function') {
-    ctx.effect(() => {
-      return () => {
-        stopLoopbackProxyServer()
-      }
-    }, 'dsh-clinebot: loopback-proxy-server')
-  }
-
   syncProviderState(live())
   if (typeof ctx.effect === 'function') {
     ctx.effect(() => {
@@ -363,7 +328,6 @@ export function apply(ctx, config) {
     registerAccountsRoutes(webCtx, routeEnv)
     registerModelsRoutes(webCtx, routeEnv)
     registerAuthRoutes(webCtx, routeEnv)
-    registerProxyRoutes(webCtx, routeEnv)
   }
 
   if (service(ctx, 'webServer')?.register) {
@@ -380,164 +344,6 @@ export function apply(ctx, config) {
     syncProviderState,
   })
 
-  let lastFailoverAt = 0
-
-  const handleStream429 = async () => {
-    const now = Date.now()
-    if (now - lastFailoverAt < 30000) {
-      ctx?.logger?.warn?.('[dsh-clinebot] Suppressing rapid failover rotation within 30s storm window')
-      return
-    }
-    lastFailoverAt = now
-    try {
-      const failover = await rotateToNextAccount(ctx, live(), 'stream_429', settingsApi)
-      if (failover?.rotated) {
-        await syncProviderState(live())
-      }
-    } catch (err) {
-      ctx?.logger?.warn?.('[dsh-clinebot] Auto-failover rotation failed: ' + (err?.message || err))
-    }
-  }
-
-  if (typeof ctx.on === 'function' && publicConfig(live()).transport === 'pi-ai') {
-    const unlisten = ctx.on('llm/stream', (options, next) => {
-      const isCline = options?.provider === PROVIDER_ID
-      const stream = next()
-      const startTime = Date.now()
-      let promptTokens = 0
-      let completionTokens = 0
-      let finished = false
-
-      return (async function* () {
-        try {
-          for await (const chunk of stream) {
-            if (isCline && chunk?.type === 'usage' && chunk?.usage) {
-              const u = chunk.usage
-              promptTokens += (Number(u.inputTokens) || 0) + (Number(u.cacheReadTokens) || 0) + (Number(u.cacheWriteTokens) || 0)
-              completionTokens += Number(u.outputTokens) || 0
-            }
-            if (isCline && chunk?.type === 'finish' && chunk?.reason) {
-              finished = true
-              const latencyMs = Date.now() - startTime
-              const reason = chunk.reason
-              const failure = reason.failure || {}
-              const isError = reason.kind === 'error'
-              const isAborted = reason.kind === 'aborted'
-              const is429 = failure.status === 429 || failure.code === 429 || failure.code === 'rate_limit_exceeded'
-              const isExceeded = isQuotaExceededError(`${failure.message || ''} ${failure.code || ''}`)
-
-              const isProxy = publicConfig(live()).proxyMode !== false
-              if (isError) {
-                recordSessionRequest({
-                  latencyMs,
-                  ok: false,
-                  error: failure.message || 'Stream error',
-                  promptTokens,
-                  completionTokens,
-                  model: options?.model,
-                })
-                if (!isProxy) {
-                  recordUsage({
-                    model: options?.model,
-                    promptTokens,
-                    completionTokens,
-                    totalTokens: promptTokens + completionTokens,
-                    isError: true,
-                    is429,
-                    statsPath: publicConfig(live()).statsPath,
-                  })
-                }
-                if (is429 || isExceeded) {
-                  handleStream429()
-                }
-              } else if (isAborted) {
-                recordSessionRequest({
-                  latencyMs,
-                  ok: true,
-                  aborted: true,
-                  promptTokens,
-                  completionTokens,
-                  model: options?.model,
-                })
-              } else {
-                recordSessionRequest({
-                  latencyMs,
-                  ok: true,
-                  promptTokens,
-                  completionTokens,
-                  model: options?.model,
-                })
-                if (!isProxy) {
-                  recordUsage({
-                    model: options?.model,
-                    promptTokens,
-                    completionTokens,
-                    totalTokens: promptTokens + completionTokens,
-                    statsPath: publicConfig(live()).statsPath,
-                  })
-                }
-              }
-            }
-            yield chunk
-          }
-          if (isCline && !finished) {
-            recordSessionRequest({
-              latencyMs: Date.now() - startTime,
-              ok: true,
-              promptTokens,
-              completionTokens,
-              model: options?.model,
-            })
-            const isProxy = publicConfig(live()).proxyMode !== false
-            if (!isProxy) {
-              recordUsage({
-                model: options?.model,
-                promptTokens,
-                completionTokens,
-                totalTokens: promptTokens + completionTokens,
-                statsPath: publicConfig(live()).statsPath,
-              })
-            }
-          }
-        } catch (err) {
-          if (isCline) {
-            const latencyMs = Date.now() - startTime
-            const status = err?.status || err?.statusCode
-            const msg = String(err?.message || err)
-            recordSessionRequest({
-              latencyMs,
-              ok: false,
-              error: msg,
-              promptTokens,
-              completionTokens,
-              model: options?.model,
-            })
-            const isProxy = publicConfig(live()).proxyMode !== false
-            if (!isProxy) {
-              recordUsage({
-                model: options?.model,
-                promptTokens,
-                completionTokens,
-                totalTokens: promptTokens + completionTokens,
-                isError: true,
-                is429: status === 429,
-                statsPath: publicConfig(live()).statsPath,
-              })
-            }
-            if (status === 429 || isQuotaExceededError(msg)) {
-              handleStream429()
-            }
-          }
-          throw err
-        }
-      })()
-    }, { global: true, prepend: true })
-
-    if (typeof ctx.effect === 'function') {
-      ctx.effect(() => () => unlisten?.(), 'dsh-clinebot: llm/stream failover')
-    }
-  }
-
   // Native DSH WebSearchProvider over ctx.web (#233)
   if (typeof ctx.inject === 'function') {
     ctx.inject(['web'], (webCtx) => {

package/lib/provider-sync.js

@@ -15,17 +15,12 @@ import {
   probeHealth,
   fetchUsageLimits,
   sessionStats,
-  usageCache,
-  buildPiAiProvider,
   DEFAULT_API_KEY_ENV,
 } from './cline-client.js'
-import { publicConfig, plainConfig, Config, LLM_PI_AI_NS } from './config.js'
+import { publicConfig, plainConfig, Config } from './config.js'
 import { publicUsage } from './http.js'
 import { resolveKeyValue } from './credential-refs.js'
 import { resolveAccountPool, getLastRotation } from './account-pool.js'
-import { getLocalProxyToken, LOCAL_PROXY_KEY_ENV } from './proxy-token.js'
-import { saveCredentialKey } from './credential-refs.js'
-import { getProxyPort, detectHostWebServerFence } from './proxy-server.js'
 
 export function resolvePathWithHome(p) {
   let guard = 0
@@ -48,28 +43,6 @@ export function resolvePathWithHome(p) {
   return p
 }
 
-export async function checkRegisteredInPiAi(ctx) {
-  const settings = ctx?.get?.('settings')
-  try {
-    if (typeof settings?.describe === 'function') {
-      const descriptors = settings.describe()
-      const piAiDesc = Array.isArray(descriptors) ? descriptors.find((d) => d?.ns === LLM_PI_AI_NS) : null
-      if (piAiDesc?.value?.providers?.[PROVIDER_ID]) return true
-    }
-
-    const llm = ctx?.get?.('llm')
-    if (typeof llm?.listProviders === 'function') {
-      const list = await llm.listProviders()
-      if (Array.isArray(list) && list.some((p) => (p?.id || p) === PROVIDER_ID)) {
-        return true
-      }
-    }
-  } catch {
-    return false
-  }
-  return false
-}
-
 export async function checkRegisteredInLlm(ctx) {
   try {
     const llm = ctx?.get?.('llm')
@@ -110,14 +83,12 @@ export async function buildStatus(ctx, cfg) {
   const pub = publicConfig(cfg)
   const probeTimeout = Math.min(2500, pub.timeoutMs || 2500)
 
-  const [key, pool, isRegisteredInPiAi, isRegisteredInLlm, health] = await Promise.all([
+  const [key, pool, isRegistered, health] = await Promise.all([
     resolveKeyValue(ctx, pub.apiKeyEnv),
     resolveAccountPool(ctx, cfg),
-    checkRegisteredInPiAi(ctx),
     checkRegisteredInLlm(ctx),
     probeHealth(pub.baseUrl, { timeoutMs: probeTimeout }),
   ])
-  const isRegistered = isRegisteredInLlm || isRegisteredInPiAi
 
   const activeAcc = await resolveActiveAccountKey(ctx, cfg, pool)
   const allModels = getAllModels(pub.dynamicModels, pub.modelContextOverrides, pub.customModels)
@@ -210,116 +181,6 @@ export async function buildStatus(ctx, cfg) {
   }
 }
 
-export async function upsertPiAiProvider(ctx, cfg, activeModelIds) {
-  const settings = ctx?.get?.('settings')
-  if (!settings?.mutate) {
-    throw new Error('DSH settings service unavailable')
-  }
-
-  const pub = publicConfig(cfg)
-  const allModels = getAllModels(pub.dynamicModels, pub.modelContextOverrides, pub.customModels)
-  const allowedSet = new Set(activeModelIds || pub.enabledModels)
-  const modelsToRegister = allModels.filter((m) => allowedSet.has(m.id))
-
-  const activeAcc = await resolveActiveAccountKey(ctx, cfg)
-
-  let isProxy = pub.proxyMode !== false
-  let effectiveBaseUrl = pub.baseUrl
-  let proxyPort = getProxyPort()
-
-  if (isProxy) {
-    if (!proxyPort) {
-      proxyPort = ctx?.webServer?.port || ctx?.get?.('webServer')?.port || process.env.PORT || 3080
-      const isFenced = await detectHostWebServerFence(proxyPort)
-      if (isFenced) {
-        ctx?.logger?.warn?.(
-          `[dsh-clinebot] DesktopWebServer security fence detected on port ${proxyPort} and dedicated loopback proxy is not active. Falling back to direct upstream mode.`
-        )
-        isProxy = false
-      }
-    }
-  }
-
-  if (isProxy && proxyPort) {
-    effectiveBaseUrl = `http://127.0.0.1:${proxyPort}/dsh-clinebot/v1`
-  } else {
-    isProxy = false
-    effectiveBaseUrl = pub.baseUrl
-  }
-
-  const localToken = isProxy ? getLocalProxyToken() : undefined
-  if (isProxy && localToken) {
-    try {
-      await saveCredentialKey(ctx, LOCAL_PROXY_KEY_ENV, localToken)
-    } catch {
-      /* credentials service might be absent/read-only in tests; process.env is set */
-    }
-  }
-
-  let existingModels = []
-  try {
-    if (typeof settings.describe === 'function') {
-      const descriptors = settings.describe()
-      const piAiDesc = Array.isArray(descriptors) ? descriptors.find((d) => d?.ns === LLM_PI_AI_NS) : null
-      const existingProv = piAiDesc?.value?.providers?.[PROVIDER_ID]
-      if (Array.isArray(existingProv?.models)) existingModels = existingProv.models
-    } else if (typeof settings.get === 'function') {
-      const piAiVal = settings.get(LLM_PI_AI_NS)
-      const existingProv = piAiVal?.providers?.[PROVIDER_ID]
-      if (Array.isArray(existingProv?.models)) existingModels = existingProv.models
-    }
-  } catch {
-    /* ignore read error */
-  }
-
-  const providerObj = buildPiAiProvider({
-    baseUrl: effectiveBaseUrl,
-    apiKeyEnv: isProxy ? LOCAL_PROXY_KEY_ENV : (activeAcc?.apiKeyEnv || pub.apiKeyEnv),
-    models: modelsToRegister.length ? modelsToRegister : allModels,
-    dynamicModels: pub.dynamicModels,
-    modelContextOverrides: pub.modelContextOverrides,
-    customModels: pub.customModels,
-    existingModels,
-    displayName: PROVIDER_DISPLAY_NAME,
-  })
-
-  await settings.mutate(LLM_PI_AI_NS, [
-    {
-      op: 'set',
-      path: ['providers', PROVIDER_ID],
-      value: providerObj,
-    },
-  ])
-
-  ctx?.logger?.info?.(
-    `[dsh-clinebot] Synchronized llm-pi-ai provider "${PROVIDER_ID}" with ${providerObj.models.length} models.`
-  )
-
-  return providerObj
-}
-
-export async function removePiAiProvider(ctx) {
-  const settings = ctx?.get?.('settings')
-  if (!settings?.mutate) {
-    throw new Error('DSH settings service unavailable')
-  }
-
-  try {
-    await settings.mutate(LLM_PI_AI_NS, [
-      {
-        op: 'remove',
-        path: ['providers', PROVIDER_ID],
-      },
-    ])
-  } catch (err) {
-    const msg = String(err?.message || err).toLowerCase()
-    if (!msg.includes('not found') && !msg.includes('absent') && !msg.includes('enoent') && !msg.includes('does not exist')) {
-      throw err
-    }
-  }
-  return { ok: true }
-}
-
 export function formatProgressBar(pct, totalWidth = 10) {
   const clamped = Math.max(0, Math.min(100, pct || 0))
   const filled = Math.round((clamped / 100) * totalWidth)

package/lib/routes/accounts.js

@@ -2,7 +2,7 @@ import { writeJson, readBody, publicUsage } from '../http.js'
 import { discoverLocalClineKeys, consumeDiscoveredKey } from '../key-discovery.js'
 import { assertTrustedSettingsRequest } from '../access.js'
 import { publicConfig, plainConfig, Config } from '../config.js'
-import { upsertPiAiProvider, removePiAiProvider, resolveActiveAccountKey } from '../provider-sync.js'
+import { resolveActiveAccountKey } from '../provider-sync.js'
 import { resolveAccountPool } from '../account-pool.js'
 import {
   clearUsageCache,
@@ -313,42 +313,6 @@ export function registerAccountsRoutes(ctx, { live, syncProviderState, getSettin
     },
   }), 'dsh-clinebot: /accounts/active')
 
-  // POST /dsh-clinebot/register — upsert into DSH llm-pi-ai
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-clinebot/register',
-    handler: async (req, res) => {
-      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
-      if (!assertTrustedSettingsRequest(req, res, ctx)) return
-      try {
-        const bodyBuf = await readBody(req)
-        let body = {}
-        try { body = JSON.parse(bodyBuf.toString('utf8')) } catch { body = {} }
-        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) })
-      }
-    },
-  }), 'dsh-clinebot: /register')
-
-  // POST /dsh-clinebot/unregister — remove from DSH
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-clinebot/unregister',
-    handler: async (req, res) => {
-      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
-      if (!assertTrustedSettingsRequest(req, res, ctx)) return
-      try {
-        await removePiAiProvider(ctx)
-        writeJson(res, 200, { ok: true })
-      } catch (err) {
-        writeJson(res, 500, { ok: false, error: String(err?.message || err) })
-      }
-    },
-  }), 'dsh-clinebot: /unregister')
-
   // GET /dsh-clinebot/keys/discovered — scan local Cline CLI and VS Code extension keys (#232, #246)
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',

package/lib/routes/settings.js

@@ -3,7 +3,7 @@ import { assertTrustedSettingsRequest } from '../access.js'
 import { publicConfig, plainConfig, Config } from '../config.js'
 import { buildStatus } from '../provider-sync.js'
 import { saveCredentialKey, smokeChat, DEFAULT_API_KEY_ENV } from '../cline-client.js'
-import { getStatsSummary, resetStats, exportStatsAsCsv, getAnalytics } from '../stats-storage.js'
+import { getStatsSummary, getSessionStats, resetStats, exportStatsAsCsv, getAnalytics } from '../stats-storage.js'
 import { priceTable } from '../model-prices.js'
 
 export function registerSettingsRoutes(ctx, { live, getSettingsApi, syncProviderState, triggerAutoDiscover }) {
@@ -197,6 +197,24 @@ export function registerSettingsRoutes(ctx, { live, getSettingsApi, syncProvider
     },
   }), 'dsh-clinebot: /stats')
 
+  // 4b. GET /dsh-clinebot/stats/session — ClineBot-only aggregate for one DSH session
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-clinebot/stats/session',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' })
+      if (!assertTrustedSettingsRequest(req, res, ctx)) return
+      try {
+        const url = new URL(req.url || '/', 'http://localhost')
+        const sessionId = String(url.searchParams.get('sessionId') || '').trim().slice(0, 200)
+        if (!sessionId) return writeJson(res, 400, { ok: false, error: 'sessionId required' })
+        writeJson(res, 200, { ok: true, session: getSessionStats(sessionId) })
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+      }
+    },
+  }), 'dsh-clinebot: /stats/session')
+
   // 5. POST /dsh-clinebot/stats/reset — reset persistent stats (Issue #129)
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',

package/lib/stats-storage.js

@@ -336,7 +336,10 @@ export function recordUsage({
   inMemoryStats.byHourModel[hourKey][model] = Number(inMemoryStats.byHourModel[hourKey][model] || 0) + 1
   pruneHours(now)
   if (sessionId) {
-    incrementBucket(inMemoryStats.bySession, String(sessionId), entry)
+    const key = String(sessionId)
+    incrementBucket(inMemoryStats.bySession, key, entry)
+    const bucket = inMemoryStats.bySession[key]
+    if (bucket) bucket.last = { ...entry, sessionId: key }
     pruneSessions(now)
   }
   queueSaveStats(statsPath)
@@ -346,6 +349,18 @@ export function getStatsSummary() {
   return JSON.parse(JSON.stringify(inMemoryStats))
 }
 
+/**
+ * Return the ClineBot-only aggregate for one DSH session.
+ * Returns null when the session has no recorded ClineBot traffic.
+ * @param {string} sessionId
+ */
+export function getSessionStats(sessionId) {
+  const key = String(sessionId || '').trim()
+  if (!key) return null
+  const bucket = inMemoryStats.bySession?.[key]
+  return bucket ? JSON.parse(JSON.stringify(bucket)) : null
+}
+
 export function resetStats(customPath) {
   inMemoryStats = createEmptyStats()
   saveStatsSync(customPath)

package/lib/transport/cline-transport.js

@@ -9,7 +9,7 @@
 import { createRequire } from 'node:module'
 
 const require = createRequire(import.meta.url)
-let packageVersion = '0.6.0'
+let packageVersion = '0.6.2'
 try {
   packageVersion = require('../../package.json').version || packageVersion
 } catch {

package/package.json

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