@goodandready/dsh-clinebot 0.3.8 → 0.3.9

package/lib/index.js

@@ -1,6 +1,7 @@
 import z from '@deepseek-ai/schemastery'
 import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { writeJson, readBody, isTrustedSettingsRequest } from './http.js'
+import { registerPluginUpdater } from './updater.js'
 import {
   CLINE_MODELS,
   DEFAULT_MODEL_ID,
@@ -21,6 +22,9 @@ import {
   DEFAULT_SMOKE_TIMEOUT_MS,
   normalizeBaseUrl,
   resolveApiKey,
+  resolveKeyValue,
+  resolveAccountPool,
+  rotateToNextAccount,
   saveCredentialKey,
   fetchUsageLimits,
   probeHealth,
@@ -29,6 +33,7 @@ import {
   sessionStats,
   recordSessionRequest,
   resetSessionStats,
+  usageCache,
 } from './cline-client.js'
 
 export const name = '@goodandready/dsh-clinebot'
@@ -37,7 +42,7 @@ export const inject = ['settings', 'webServer', 'credentials']
 export const NS = 'dsh-clinebot'
 export const LLM_PI_AI_NS = 'llm-pi-ai'
 
-export { sessionStats, recordSessionRequest, resetSessionStats }
+export { sessionStats, recordSessionRequest, resetSessionStats, rotateToNextAccount }
 
 export const Config = z.object({
   enabled: z.boolean().default(true)
@@ -120,80 +125,6 @@ function resolvePathWithHome(p) {
   return p
 }
 
-async function resolveKeyValue(ctx, apiKeyEnv) {
-  const refName = String(apiKeyEnv || DEFAULT_API_KEY_ENV).trim() || DEFAULT_API_KEY_ENV
-  const creds = (ctx?.get && ctx.get('credentials')) || ctx?.credentials
-  if (creds && typeof creds.resolve === 'function') {
-    try {
-      const hit = await creds.resolve(credentialRef(refName))
-      if (hit?.value) {
-        return { envName: refName, value: hit.value, source: 'credentials' }
-      }
-    } catch {
-      /* credentials service miss, fall through */
-    }
-  }
-
-  const fromEnv = resolveApiKey(refName)
-  if (fromEnv.value) {
-    return { ...fromEnv, source: 'env' }
-  }
-
-  return { envName: refName, value: '', source: 'none' }
-}
-
-/**
- * Resolve all accounts in pool with their status and quota.
- */
-async function resolveAccountPool(ctx, cfg) {
-  const pub = publicConfig(cfg)
-  const defaultSlot = {
-    id: 'default',
-    label: 'Default',
-    apiKeyEnv: pub.apiKeyEnv,
-  }
-  const allSlots = [defaultSlot, ...(Array.isArray(pub.accounts) ? pub.accounts : [])]
-  const resolved = []
-
-  for (let i = 0; i < allSlots.length; i++) {
-    const slot = allSlots[i]
-    const envName = slot.apiKeyEnv || (i === 0 ? pub.apiKeyEnv : `CLINEBOT_API_KEY_${i + 1}`)
-    const keyInfo = await resolveKeyValue(ctx, envName)
-    resolved.push({
-      id: slot.id || (i === 0 ? 'default' : `account-${i + 1}`),
-      label: slot.label || (i === 0 ? 'Default' : `Account ${i + 1}`),
-      apiKeyEnv: envName,
-      present: Boolean(keyInfo.value),
-      source: keyInfo.source,
-      value: keyInfo.value,
-      isPinned: pub.activeAccount ? pub.activeAccount === envName : i === 0,
-    })
-  }
-
-  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
@@ -205,48 +136,18 @@ async function checkRegisteredInPiAi(ctx) {
   }
 }
 
-/**
- * Rotate active account to next available configured account upon rate-limiting (429) or quota exhaustion.
- */
-export async function rotateToNextAccount(ctx, cfg, reason = 'rate_limit', settingsApi = null) {
+async function resolveActiveAccountKey(ctx, cfg) {
   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' }
+  if (!configured.length) {
+    return { envName: publicConfig(cfg).apiKeyEnv, value: '', source: 'none', id: 'default' }
   }
-
   const pub = publicConfig(cfg)
-  const currentEnv = pub.activeAccount || configured[0].apiKeyEnv
-  const currentIndex = configured.findIndex((acc) => acc.apiKeyEnv === currentEnv)
-  const nextIndex = (currentIndex + 1) % configured.length
-  const nextAcc = configured[nextIndex]
-
-  let updated = false
-  if (settingsApi?.replace) {
-    try {
-      const next = Config({ ...cfg, activeAccount: nextAcc.apiKeyEnv })
-      await settingsApi.replace(next)
-      updated = true
-    } catch {}
-  } else {
-    const settings = (ctx?.get && ctx.get('settings')) || ctx?.settings
-    if (settings?.mutate) {
-      try {
-        await settings.mutate(NS, [
-          { op: 'set', path: ['activeAccount'], value: nextAcc.apiKeyEnv },
-        ])
-        updated = true
-      } catch {}
-    }
-  }
-
-  return {
-    rotated: true,
-    previousAccount: currentEnv,
-    activeAccount: nextAcc.apiKeyEnv,
-    reason,
-    updatedSettings: updated,
+  if (pub.activeAccount) {
+    const pinned = configured.find((acc) => acc.apiKeyEnv === pub.activeAccount || acc.id === pub.activeAccount)
+    if (pinned) return pinned
   }
+  return configured[0]
 }
 
 async function buildStatus(ctx, cfg) {
@@ -278,13 +179,13 @@ async function buildStatus(ctx, cfg) {
     if (pct >= 95) {
       quotaWarning = {
         level: 'exhausted',
-        message: `5-часовой лимит почти полностью исчерпан (${pct}%). Новые запросы могут отклоняться провайдером до сброса.`,
+        message: `5-hour rolling limit is almost exhausted (${pct}%). New requests may be rejected until quota reset.`,
         resetsAt: usage.windows.fiveHour.resetsAt,
       }
     } else if (pct >= 80) {
       quotaWarning = {
         level: 'warning',
-        message: `Внимание: израсходовано ${pct}% 5-часового скользящего лимита.`,
+        message: `Notice: ${pct}% of the 5-hour rolling limit has been consumed.`,
         resetsAt: usage.windows.fiveHour.resetsAt,
       }
     }
@@ -474,6 +375,16 @@ export function apply(ctx, config) {
 
   // Web server HTTP route handlers
   if (ctx.webServer?.register) {
+    // 0. GET & POST /dsh-clinebot/update — host one-click updater
+    const unregisterUpdater = registerPluginUpdater(ctx, {
+      endpoint: '/dsh-clinebot/update',
+      packageName: name,
+      manifestUrl: new URL('../package.json', import.meta.url),
+    })
+    if (typeof ctx.effect === 'function') {
+      ctx.effect(() => () => unregisterUpdater?.(), 'dsh-clinebot: updater')
+    }
+
     // 1. GET /dsh-clinebot/status
     ctx.effect(() => ctx.webServer.register({
       kind: 'exact',
@@ -887,56 +798,59 @@ export function apply(ctx, config) {
           const pool = await resolveAccountPool(ctx, live())
           const lines = [
             '### 🔑 ClinePass Accounts Pool',
-            `* **Активный аккаунт**: \`${pub.activeAccount || pub.apiKeyEnv}\``,
+            `* **Active Account**: \`${pub.activeAccount || pub.apiKeyEnv}\``,
             '',
           ]
           for (const acc of pool) {
             const pinBadge = acc.isPinned ? '📌 [Pinned]' : ''
-            const statusBadge = acc.present ? '✅ Configured' : '⚠️ Missing'
-            lines.push(`* **${acc.label}** (\`${acc.apiKeyEnv}\`): ${statusBadge} ${pinBadge}`)
+            const statusBadge = acc.present ? '✅ Configured' : '⚠️ Missing Key'
+            const cacheKey = `cline:usage:${(acc.value || '').slice(-8)}`
+            const cached = usageCache.get(cacheKey)?.data
+            const usageInfo = cached?.windows?.fiveHour ? ` · ⏱ ${cached.windows.fiveHour.percentUsed}% used` : ''
+            lines.push(`* **${acc.label}** (\`${acc.apiKeyEnv}\`): ${statusBadge} ${pinBadge}${usageInfo}`)
           }
-          lines.push('', 'Переключить активный аккаунт: `/cline switch <имя_переменной>`')
+          lines.push('', 'Switch active account: `/cline switch <env_variable_name>`')
           return lines.join('\n')
         }
 
         // 3. Subcommand /cline switch <account>
         if (subcmd === 'switch') {
           if (!param) {
-            return '⚠️ Укажите аккаунт: `/cline switch <CLINEBOT_API_KEY_2>`'
+            return '⚠️ Please specify account: `/cline switch <CLINEBOT_API_KEY_2>`'
           }
           if (settingsApi?.replace) {
             const next = Config({ ...live(), activeAccount: param })
             await settingsApi.replace(next)
             await syncProviderState(next)
-            return `✅ Активный аккаунт переключен на \`${param}\``
+            return `✅ Active account switched to \`${param}\``
           }
-          return `⚠️ Не удалось применить настройку (сервис настроек недоступен).`
+          return `⚠️ Could not apply setting (settings service unavailable).`
         }
 
-        // 4. Subcommand /cline rotate (auto-failover next)
+        // 4. Subcommand /cline rotate (smart failover next)
         if (subcmd === 'rotate') {
           const res = await rotateToNextAccount(ctx, live(), 'slash_command', settingsApi)
           if (res.rotated) {
             await syncProviderState(live())
-            return `🔄 **Ротация аккаунта**: переключено с \`${res.previousAccount}\` на \`${res.activeAccount}\`. Провайдер DSH обновлён!`
+            return `🔄 **Account Rotated**: switched from \`${res.previousAccount}\` to \`${res.activeAccount}\`. DSH provider updated!`
           }
-          return `⚠️ Ротация не выполнена: ${res.message || 'нет доступных альтернативных аккаунтов в пуле'}.`
+          return `⚠️ Rotation skipped: ${res.message || 'no alternative configured accounts in pool'}.`
         }
 
         // 5. Subcommand /cline ping (fresh host reachability probe)
         if (subcmd === 'ping') {
           const health = await probeHealth(pub.baseUrl, { bypassCache: true, timeoutMs: 5000 })
           if (health.ok) {
-            return `🏓 **Cline API Pong**: \`${pub.baseUrl}\` доступен (задержка: **${health.latencyMs} мс**, HTTP ${health.status})`
+            return `🏓 **Cline API Pong**: \`${pub.baseUrl}\` is reachable (latency: **${health.latencyMs} ms**, HTTP ${health.status})`
           }
-          return `❌ **Cline API Ping Failed**: ${health.error || 'Хост недоступен'}`
+          return `❌ **Cline API Ping Failed**: ${health.error || 'Host unreachable'}`
         }
 
-        // 6. Subcommand /cline test [model]
+        // 6. Subcommand /cline test [model] / smoke
         if (subcmd === 'test' || subcmd === 'smoke') {
           const activeKey = await resolveActiveAccountKey(ctx, live())
           if (!activeKey.value) {
-            return '⚠️ **ClineBot**: API-ключ не настроен. Откройте **Настройки → ClineBot**.'
+            return '⚠️ **ClineBot**: API key is not configured. Open **Settings → Plugins → ClineBot**.'
           }
           const modelToTest = param || pub.defaultModel || DEFAULT_MODEL_ID
           const outcome = await smokeChat(pub.baseUrl, activeKey.value, {
@@ -956,26 +870,25 @@ export function apply(ctx, config) {
             const failover = await rotateToNextAccount(ctx, live(), 'smoke_429', settingsApi)
             if (failover.rotated) {
               await syncProviderState(live())
-              failoverNotice = `
-🔄 **Auto-failover**: Обнаружен HTTP 429! Активный аккаунт автоматически переключен на \`${failover.activeAccount}\`.`
+              failoverNotice = `\n🔄 **Auto-failover**: HTTP 429 detected! Active account automatically rotated to \`${failover.activeAccount}\`.`
             }
           }
 
           if (outcome.ok) {
             return [
-              `### 🟢 Smoke Test Успешен: \`${outcome.model}\``,
-              `* **Задержка**: ${outcome.latencyMs} мс`,
-              `* **Токены**: prompt: ${outcome.promptTokens}, completion: ${outcome.completionTokens} (всего: ${outcome.totalTokens})`,
-              `* **Превью**: _"${outcome.preview}"_`,
+              `### 🟢 Smoke Test Passed: \`${outcome.model}\``,
+              `* **Latency**: ${outcome.latencyMs} ms`,
+              `* **Tokens**: prompt: ${outcome.promptTokens}, completion: ${outcome.completionTokens} (total: ${outcome.totalTokens})`,
+              `* **Preview**: _"${outcome.preview}"_`,
             ].join('\n')
           }
-          return `❌ **Smoke Test Ошибка**: ${outcome.error} (HTTP ${outcome.status || 'timeout'})${failoverNotice}`
+          return `❌ **Smoke Test Failed**: ${outcome.error} (HTTP ${outcome.status || 'timeout'})${failoverNotice}`
         }
 
-        // 4. Default /cline quota
+        // 7. Subcommand /cline quota or /cline balance
         const activeKey = await resolveActiveAccountKey(ctx, live())
         if (!activeKey.value) {
-          return '⚠️ **ClineBot**: API-ключ не настроен. Откройте **Настройки → ClineBot** и сохраните ключ.'
+          return '⚠️ **ClineBot**: API key is not configured. Open **Settings → Plugins → ClineBot**.'
         }
 
         const [health, usage] = await Promise.all([
@@ -985,31 +898,31 @@ export function apply(ctx, config) {
 
         const fiveHour = usage?.windows?.fiveHour
         const weekly = usage?.windows?.weekly
-        const reset5h = fiveHour?.resetsAt ? new Date(fiveHour.resetsAt).toLocaleTimeString() : 'н/д'
-        const resetWk = weekly?.resetsAt ? new Date(weekly.resetsAt).toLocaleDateString() : 'н/д'
+        const reset5h = fiveHour?.resetsAt ? new Date(fiveHour.resetsAt).toLocaleTimeString() : 'N/A'
+        const resetWk = weekly?.resetsAt ? new Date(weekly.resetsAt).toLocaleDateString() : 'N/A'
 
         const lines = [
           `### 🤖 ClinePass Status (${usage?.plan || 'ClinePass'})`,
-          `* **Пинг хоста**: ${health.ok ? `✅ ${health.latencyMs} мс` : '❌ Недоступен'}`,
-          `* **Активный ключ**: \`${activeKey.envName}\` (${activeKey.source})`,
-          `* **Модель по умолчанию**: \`${pub.defaultModel}\``,
+          `* **Host Ping**: ${health.ok ? `✅ ${health.latencyMs} ms` : '❌ Unreachable'}`,
+          `* **Active Key**: \`${activeKey.envName}\` (${activeKey.source})`,
+          `* **Default Model**: \`${pub.defaultModel}\``,
           '',
-          `**⏱ 5-часовое окно**: ${formatProgressBar(fiveHour?.percentUsed)} (сброс: ${reset5h})`,
-          `**📅 Недельное окно**: ${formatProgressBar(weekly?.percentUsed)} (сброс: ${resetWk})`,
+          `**⏱ 5-Hour Rolling Limit**: ${formatProgressBar(fiveHour?.percentUsed)} (reset: ${reset5h})`,
+          `**📅 Weekly Window**: ${formatProgressBar(weekly?.percentUsed)} (reset: ${resetWk})`,
         ]
 
         if (fiveHour?.percentUsed >= 95) {
-          lines.push('', '🚨 **КРИТИЧЕСКИЙ ЛИМИТ**: 5-часовая квота израсходована на 95%+. Запросы могут быть заблокированы до сброса!')
+          lines.push('', '🚨 **CRITICAL LIMIT**: 5-hour quota is 95%+ consumed! New requests may be throttled until reset.')
         } else if (fiveHour?.percentUsed >= 80) {
-          lines.push('', '⚠️ **Внимание**: 5-часовая квота израсходована на ' + fiveHour.percentUsed + '%.')
+          lines.push('', `⚠️ **Warning**: 5-hour quota is ${fiveHour.percentUsed}% consumed.`)
         }
 
         if (sessionStats.totalRequests > 0) {
-          lines.push('', `**📊 Сессия DSH**: ${sessionStats.successfulRequests}/${sessionStats.totalRequests} успешных запросов, ~${sessionStats.totalTokensEst} токенов`)
+          lines.push('', `**📊 Session Telemetry**: ${sessionStats.successfulRequests}/${sessionStats.totalRequests} successful requests, ~${sessionStats.totalTokensEst} total tokens`)
         }
 
         if (usage?.user?.email) {
-          lines.push(`* **Аккаунт**: \`${usage.user.email}\``)
+          lines.push(`* **Account**: \`${usage.user.email}\``)
         }
 
         return lines.join('\n')

package/lib/updater.js

@@ -0,0 +1,245 @@
+/**
+ * Host-side one-click updater for @goodandready/dsh-clinebot.
+ * Conforms to the DSH authoring reference implementation.
+ */
+
+import { spawn } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { basename, dirname, isAbsolute, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const UPDATE_HEADER = 'x-dsh-plugin-update'
+const UPDATE_TIMEOUT_MS = 10 * 60_000
+const VERSION_CACHE_MS = 5 * 60_000
+let latestCache = undefined
+
+function header(request, name) {
+  const value = request?.headers?.[name]
+  return Array.isArray(value) ? value[0] : value
+}
+
+function isLoopback(value) {
+  const address = value?.toLowerCase().replace(/^\[|\]$/g, '')
+  return address === 'localhost' || address === 'localhost.' || address === '::1'
+    || address?.startsWith('127.') === true
+    || address?.startsWith('::ffff:127.') === true
+}
+
+export function isTrustedUpdateRequest(request) {
+  if (header(request, UPDATE_HEADER) !== '1') return false
+  if (!isLoopback(request?.socket?.remoteAddress)) return false
+  const site = header(request, 'sec-fetch-site')
+  if (site !== undefined && site !== 'same-origin') return false
+  const origin = header(request, 'origin')
+  const host = header(request, 'host')
+  if (origin === undefined || host === undefined) return false
+  try {
+    const url = new URL(origin)
+    return (url.protocol === 'http:' || url.protocol === 'https:')
+      && isLoopback(url.hostname) && url.host === host
+  } catch {
+    return false
+  }
+}
+
+function validProfileName(value) {
+  return typeof value === 'string' && value !== '' && value !== '.' && value !== '..'
+    && !value.includes('/') && !value.includes('\\') && !/[\0-\x1f\x7f]/.test(value)
+}
+
+function profileNameFromArgv(argv) {
+  if (!Array.isArray(argv)) return undefined
+  for (let index = 2; index < argv.length; index += 1) {
+    if (argv[index] === '--profile') return argv[index + 1]
+    if (argv[index]?.startsWith('--profile=')) return argv[index].slice('--profile='.length)
+  }
+  return argv[2] === 'web' ? 'web' : undefined
+}
+
+function findDshCliEntry() {
+  const value = process.argv[1]
+  if (value === undefined || value === '') return undefined
+  const entry = value.startsWith('file:') ? fileURLToPath(value) : resolve(process.cwd(), value)
+  if (!existsSync(entry)) return undefined
+  for (let directory = dirname(entry); ; directory = dirname(directory)) {
+    const manifestPath = resolve(directory, 'package.json')
+    if (existsSync(manifestPath)) {
+      try {
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
+        const bin = typeof manifest.bin === 'string'
+          ? manifest.bin
+          : typeof manifest.bin === 'object' && manifest.bin !== null
+            ? manifest.bin.dsh
+            : undefined
+        if (manifest.name === '@deepseek-ai/dsh' && typeof bin === 'string'
+          && !isAbsolute(bin) && resolve(directory, bin) === resolve(entry)) return entry
+      } catch {
+        /* continue */
+      }
+    }
+    const parent = dirname(directory)
+    if (parent === directory) return undefined
+  }
+}
+
+function detectRuntime() {
+  const profileDir = resolve(process.env.DSH_PROFILE_DIR
+    ?? resolve(homedir(), '.dsh', 'profiles', 'web'))
+  const selected = profileNameFromArgv(process.argv)
+  const profileName = validProfileName(selected)
+    ? selected
+    : validProfileName(basename(profileDir)) ? basename(profileDir) : 'web'
+  const cliEntry = findDshCliEntry()
+  return cliEntry === undefined ? { profileName, profileDir } : { profileName, profileDir, cliEntry }
+}
+
+function parseSemver(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(String(value || ''))
+  if (match === null) return undefined
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4]?.split('.') ?? [],
+  }
+}
+
+export function isNewerVersion(currentValue, candidateValue) {
+  const current = parseSemver(currentValue)
+  const candidate = parseSemver(candidateValue)
+  if (current === undefined || candidate === undefined) return false
+  for (let index = 0; index < 3; index += 1) {
+    if (candidate.core[index] !== current.core[index]) return candidate.core[index] > current.core[index]
+  }
+  return false
+}
+
+async function fetchLatestVersion(packageName, registry) {
+  if (latestCache?.packageName === packageName && latestCache.registry === registry && Date.now() < latestCache.expiresAt) {
+    return latestCache.version
+  }
+  try {
+    const reg = registry.replace(/\/+$/, '')
+    const response = await fetch(`${reg}/${encodeURIComponent(packageName)}/latest`, {
+      signal: AbortSignal.timeout(6000),
+    })
+    if (!response.ok) return undefined
+    const value = await response.json()
+    if (typeof value?.version !== 'string' || !value.version) return undefined
+    latestCache = { packageName, registry, version: value.version, expiresAt: Date.now() + VERSION_CACHE_MS }
+    return value.version
+  } catch {
+    return undefined
+  }
+}
+
+async function readCurrentVersion(manifestUrl) {
+  const value = JSON.parse(await readFile(manifestUrl, 'utf8'))
+  if (typeof value?.version !== 'string' || !value.version) throw new Error('Cannot read current plugin version.')
+  return value.version
+}
+
+export async function checkUpdateStatus(options, target = detectRuntime()) {
+  const current = await readCurrentVersion(options.manifestUrl)
+  const latest = await fetchLatestVersion(options.packageName, options.registry || 'https://registry.npmjs.org')
+  return {
+    packageName: options.packageName,
+    currentVersion: current,
+    ...(latest === undefined ? {} : { latestVersion: latest }),
+    latestCheckFailed: latest === undefined,
+    updateAvailable: latest !== undefined && isNewerVersion(current, latest),
+    profileName: target.profileName,
+    canAutoUpdate: target.cliEntry !== undefined,
+  }
+}
+
+async function installExact(target, packageSpec, options) {
+  if (target.cliEntry === undefined) throw new Error('Automatic update is unavailable in this runtime.')
+  await new Promise((resolvePromise, reject) => {
+    const child = spawn(process.execPath, [
+      target.cliEntry, 'plugin', '--profile', target.profileName, 'add',
+      '--config.minimumReleaseAge=0', packageSpec,
+      `--registry=${options.registry || 'https://registry.npmjs.org/'}`,
+    ], {
+      cwd: target.profileDir,
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, NO_COLOR: '1' },
+    })
+    let detail = ''
+    child.stdout?.on('data', (chunk) => { detail = (detail + String(chunk)).slice(-4000) })
+    child.stderr?.on('data', (chunk) => { detail = (detail + String(chunk)).slice(-4000) })
+    const timer = setTimeout(() => {
+      child.kill()
+      reject(new Error('Update timed out.'))
+    }, UPDATE_TIMEOUT_MS)
+    child.once('error', (error) => { clearTimeout(timer); reject(error) })
+    child.once('exit', (code) => {
+      clearTimeout(timer)
+      if (code === 0) resolvePromise()
+      else reject(new Error(detail.trim() || `Update exited with code ${String(code)}.`))
+    })
+  })
+}
+
+function writeResponseJson(response, statusCode, value) {
+  response.writeHead(statusCode, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+  })
+  response.end(JSON.stringify(value))
+}
+
+export function registerPluginUpdater(ctx, options) {
+  if (!ctx?.webServer?.register) return () => {}
+  let installing = false
+  return ctx.webServer.register({
+    kind: 'exact',
+    path: options.endpoint,
+    handler: async (request, response) => {
+      try {
+        const target = detectRuntime()
+        if (request.method === 'GET' || request.method === 'HEAD') {
+          const payload = await checkUpdateStatus(options, target)
+          writeResponseJson(response, 200, payload)
+          return
+        }
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'GET, HEAD, POST' })
+          response.end()
+          return
+        }
+        if (!isTrustedUpdateRequest(request)) {
+          writeResponseJson(response, 403, { ok: false, error: 'Rejected non-local or cross-origin update request.' })
+          return
+        }
+        if (installing) {
+          writeResponseJson(response, 409, { ok: false, error: 'This plugin is already updating.' })
+          return
+        }
+        installing = true
+        try {
+          const before = await checkUpdateStatus(options, target)
+          if (before.latestVersion === undefined) {
+            writeResponseJson(response, 503, { ok: false, error: 'The latest version is temporarily unavailable.' })
+            return
+          }
+          if (!before.updateAvailable) {
+            writeResponseJson(response, 200, before)
+            return
+          }
+          await installExact(target, `${options.packageName}@${before.latestVersion}`, options)
+          writeResponseJson(response, 200, {
+            ...before,
+            updatedVersion: before.latestVersion,
+            restartRequired: true,
+          })
+        } finally {
+          installing = false
+        }
+      } catch (error) {
+        writeResponseJson(response, 500, { ok: false, error: String(error?.message || error) })
+      }
+    },
+  })
+}

package/package.json

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