@goodandready/dsh-clinebot 0.3.11 → 0.3.12

package/lib/provider-sync.js

@@ -0,0 +1,216 @@
+import os from 'node:os'
+import path from 'node:path'
+import { publicConfig, Config, LLM_PI_AI_NS } from './config.js'
+import {
+  PROVIDER_ID,
+  PROVIDER_DISPLAY_NAME,
+  getAllModels,
+  loadModelsDiskCache,
+  saveModelsDiskCache,
+} from './models.js'
+import {
+  resolveKeyValue,
+  resolveAccountPool,
+  probeHealth,
+  fetchUsageLimits,
+  buildPiAiProvider,
+  sessionStats,
+} from './cline-client.js'
+
+export function resolvePathWithHome(p) {
+  if (!p || typeof p !== 'string') return ''
+  if (p === '~') return os.homedir()
+  if (p.startsWith('~/') || p.startsWith('~\\')) {
+    return path.join(os.homedir(), p.slice(2))
+  }
+  return p
+}
+
+export async function checkRegisteredInPiAi(ctx) {
+  const settings = ctx?.get?.('settings')
+  if (!settings?.get) return false
+  try {
+    const piAi = settings.get(LLM_PI_AI_NS)
+    return !!piAi?.providers?.[PROVIDER_ID]
+  } catch {
+    return false
+  }
+}
+
+export 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' }
+  }
+  const pub = publicConfig(cfg)
+  if (pub.activeAccount) {
+    const pinned = configured.find((acc) => acc.apiKeyEnv === pub.activeAccount || acc.id === pub.activeAccount)
+    if (pinned) return pinned
+  }
+  return configured[0]
+}
+
+export async function buildStatus(ctx, cfg) {
+  const pub = publicConfig(cfg)
+  const probeTimeout = Math.min(2500, pub.timeoutMs || 2500)
+
+  const [key, pool, isRegistered, health] = await Promise.all([
+    resolveKeyValue(ctx, pub.apiKeyEnv),
+    resolveAccountPool(ctx, cfg),
+    checkRegisteredInPiAi(ctx),
+    probeHealth(pub.baseUrl, { timeoutMs: probeTimeout }),
+  ])
+
+  const activeAcc = await resolveActiveAccountKey(ctx, cfg)
+  const allModels = getAllModels(pub.dynamicModels)
+
+  let usage = null
+  const keyToUse = activeAcc.value || key.value
+  if (keyToUse) {
+    usage = await fetchUsageLimits(pub.baseUrl, keyToUse, { timeoutMs: probeTimeout }).catch(() => null)
+  }
+
+  let quotaWarning = null
+  if (usage?.windows?.fiveHour) {
+    const pct = usage.windows.fiveHour.percentUsed
+    if (pct >= 95) {
+      quotaWarning = {
+        level: 'exhausted',
+        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: `Notice: ${pct}% of the 5-hour rolling limit has been consumed.`,
+        resetsAt: usage.windows.fiveHour.resetsAt,
+      }
+    }
+  }
+
+  return {
+    ok: true,
+    providerId: PROVIDER_ID,
+    displayName: PROVIDER_DISPLAY_NAME,
+    config: pub,
+    key: {
+      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,
+    sessionStats: { ...sessionStats },
+    isRegistered,
+    availableModels: allModels,
+  }
+}
+
+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)
+  const allowedSet = new Set(activeModelIds || pub.enabledModels)
+  const modelsToRegister = allModels.filter((m) => allowedSet.has(m.id))
+
+  const providerObj = buildPiAiProvider({
+    baseUrl: pub.baseUrl,
+    apiKeyEnv: pub.apiKeyEnv,
+    models: modelsToRegister.length ? modelsToRegister : allModels,
+    customModels: pub.dynamicModels,
+    displayName: PROVIDER_DISPLAY_NAME,
+  })
+
+  await settings.mutate(LLM_PI_AI_NS, [
+    {
+      op: 'set',
+      path: ['providers', PROVIDER_ID],
+      value: providerObj,
+    },
+  ])
+
+  return providerObj
+}
+
+export async function removePiAiProvider(ctx) {
+  const settings = ctx?.get?.('settings')
+  if (!settings?.mutate) {
+    throw new Error('DSH settings service unavailable')
+  }
+
+  await settings.mutate(LLM_PI_AI_NS, [
+    {
+      op: 'remove',
+      path: ['providers', PROVIDER_ID],
+    },
+  ])
+  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)
+  const empty = Math.max(0, totalWidth - filled)
+  return `[${'█'.repeat(filled)}${'░'.repeat(empty)}] ${clamped}%`
+}
+
+export async function autoDiscoverPlanModels(ctx, { live, getSettingsApi, syncProviderState }) {
+  try {
+    const cfg = live()
+    const pub = publicConfig(cfg)
+    const cacheFile = resolvePathWithHome(pub.modelsCachePath)
+    const settingsApi = getSettingsApi()
+
+    if ((!pub.dynamicModels || !pub.dynamicModels.length) && cacheFile) {
+      const fromDisk = await loadModelsDiskCache(cacheFile)
+      if (Array.isArray(fromDisk) && fromDisk.length && settingsApi?.replace) {
+        const next = Config({ ...live(), 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({
+          ...live(),
+          dynamicModels: usageData.dynamicModels,
+        })
+        await settingsApi.replace(next)
+        await syncProviderState(next)
+        if (cacheFile) {
+          await saveModelsDiskCache(cacheFile, usageData.dynamicModels)
+        }
+      }
+    }
+  } catch {
+    /* best-effort discovery */
+  }
+}

package/lib/routes/accounts.js

@@ -0,0 +1,79 @@
+import { writeJson, readBody } from '../http.js'
+import { isTrustedSettingsRequest } from '../access.js'
+import { publicConfig, Config } from '../config.js'
+import { upsertPiAiProvider, removePiAiProvider } from '../provider-sync.js'
+import { clearUsageCache, clearProbeCache } from '../cline-client.js'
+
+export function registerAccountsRoutes(ctx, { live, getSettingsApi, syncProviderState }) {
+  // 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()
+
+        clearUsageCache()
+        clearProbeCache()
+        const settingsApi = getSettingsApi()
+        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')
+
+  // 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 (!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 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 (!isTrustedSettingsRequest(req)) {
+        return writeJson(res, 403, { ok: false, error: 'Forbidden' })
+      }
+      try {
+        await removePiAiProvider(ctx)
+        writeJson(res, 200, { ok: true })
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+      }
+    },
+  }), 'dsh-clinebot: /unregister')
+}

package/lib/routes/auth.js

@@ -0,0 +1,102 @@
+import { writeJson, readBody } from '../http.js'
+import { isTrustedSettingsRequest } from '../access.js'
+import { publicConfig } from '../config.js'
+import { resolveActiveAccountKey } from '../provider-sync.js'
+import { smokeChat, recordSessionRequest, rotateToNextAccount, DEFAULT_MODEL_ID } from '../cline-client.js'
+
+export function registerAuthRoutes(ctx, { live, getSettingsApi, syncProviderState }) {
+  let authSession = null
+
+  // POST /dsh-clinebot/auth/begin — start loopback auth listener
+  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')
+
+  // 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')
+
+  // POST /dsh-clinebot/smoke — live ping test
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-clinebot/smoke',
+    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 pub = publicConfig(live())
+        const activeKey = await resolveActiveAccountKey(ctx, live())
+        if (!activeKey.value) {
+          return writeJson(res, 400, {
+            ok: false,
+            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, activeKey.value, {
+          model: modelToTest,
+          timeoutMs: pub.smokeTimeoutMs,
+        })
+        recordSessionRequest({
+          latencyMs: outcome.latencyMs,
+          ok: outcome.ok,
+          error: outcome.error,
+          promptTokens: outcome.promptTokens || 5,
+          completionTokens: outcome.completionTokens || 10,
+        })
+
+        let failover = null
+        if (outcome.status === 429) {
+          failover = await rotateToNextAccount(ctx, live(), 'smoke_429', getSettingsApi())
+          if (failover.rotated) {
+            await syncProviderState(live())
+          }
+        }
+
+        writeJson(res, outcome.ok ? 200 : 502, { ...outcome, failover })
+      } catch (err) {
+        recordSessionRequest({ ok: false, error: String(err?.message || err) })
+        writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+      }
+    },
+  }), 'dsh-clinebot: /smoke')
+}

package/lib/routes/models.js

@@ -0,0 +1,126 @@
+import { writeJson, readBody } from '../http.js'
+import { isTrustedSettingsRequest } from '../access.js'
+import { publicConfig, Config } from '../config.js'
+import { resolveActiveAccountKey, resolvePathWithHome } from '../provider-sync.js'
+import { getAllModels, saveModelsDiskCache } from '../models.js'
+import { fetchUsageLimits } from '../cline-client.js'
+
+export function registerModelsRoutes(ctx, { live, getSettingsApi, syncProviderState }) {
+  // POST /dsh-clinebot/models/sync — dynamically load models from plan
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-clinebot/models/sync',
+    handler: async (req, res) => {
+      if (!isTrustedSettingsRequest(req)) {
+        return writeJson(res, 403, { ok: false, error: 'Forbidden' })
+      }
+      if (req.method !== 'POST') {
+        return writeJson(res, 405, { ok: false, error: 'POST only' })
+      }
+      try {
+        const pub = publicConfig(live())
+        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, activeKey.value, {
+          timeoutMs: pub.timeoutMs,
+          bypassCache: true,
+        })
+
+        if (!usageData.ok) {
+          return writeJson(res, 502, { ok: false, error: usageData.error || 'Failed to fetch plan models' })
+        }
+
+        const dynamicModels = Array.isArray(usageData.dynamicModels) ? usageData.dynamicModels : []
+        const allModels = getAllModels(dynamicModels)
+        const settingsApi = getSettingsApi()
+
+        if (settingsApi?.replace) {
+          const next = Config({
+            ...live(),
+            dynamicModels,
+          })
+          await settingsApi.replace(next)
+          await syncProviderState(next)
+          const cacheFile = resolvePathWithHome(pub.modelsCachePath)
+          if (cacheFile) {
+            await saveModelsDiskCache(cacheFile, dynamicModels)
+          }
+        }
+
+        return writeJson(res, 200, {
+          ok: true,
+          plan: usageData.plan,
+          discoveredCount: dynamicModels.length,
+          totalModelsCount: allModels.length,
+          models: allModels,
+        })
+      } catch (err) {
+        return writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+      }
+    },
+  }), 'dsh-clinebot: /models/sync')
+
+  // POST /dsh-clinebot/models/toggle — toggle disabled/enabled status in picker
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-clinebot/models/toggle',
+    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 settingsApi = getSettingsApi()
+        if (settingsApi?.replace) {
+          const patch = {}
+          if (Array.isArray(body.disabledModels)) {
+            patch.disabledModels = body.disabledModels
+          } else if (Array.isArray(body.enabledModels)) {
+            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)
+          await syncProviderState(next)
+          writeJson(res, 200, { ok: true, disabledModels: next.disabledModels, enabledModels: publicConfig(next).enabledModels })
+        } else {
+          writeJson(res, 200, { ok: true })
+        }
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+      }
+    },
+  }), 'dsh-clinebot: /models/toggle')
+
+  // GET /dsh-clinebot/usage — direct fresh usage limit query
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-clinebot/usage',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' })
+      try {
+        const pub = publicConfig(live())
+        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, activeKey.value, {
+          timeoutMs: pub.timeoutMs,
+          bypassCache: true,
+        })
+        writeJson(res, usageData.ok ? 200 : 502, usageData)
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+      }
+    },
+  }), 'dsh-clinebot: /usage')
+}

package/lib/routes/settings.js

@@ -0,0 +1,102 @@
+import { writeJson, readBody } from '../http.js'
+import { isTrustedSettingsRequest } from '../access.js'
+import { publicConfig, Config } from '../config.js'
+import { buildStatus } from '../provider-sync.js'
+import { saveCredentialKey, smokeChat, DEFAULT_API_KEY_ENV } from '../cline-client.js'
+
+export function registerSettingsRoutes(ctx, { live, getSettingsApi, syncProviderState, triggerAutoDiscover }) {
+  // 1. GET /dsh-clinebot/status
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-clinebot/status',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' })
+      try {
+        const st = await buildStatus(ctx, live())
+        writeJson(res, 200, st)
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+      }
+    },
+  }), 'dsh-clinebot: /status')
+
+  // 2. GET & PUT /dsh-clinebot/config
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-clinebot/config',
+    handler: async (req, res) => {
+      if (req.method === 'GET') {
+        return writeJson(res, 200, { ok: true, config: publicConfig(live()) })
+      }
+      if (req.method !== 'PUT') {
+        return writeJson(res, 405, { ok: false, error: 'GET or PUT' })
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        return writeJson(res, 403, { ok: false, error: 'same-origin only' })
+      }
+      const settingsApi = getSettingsApi()
+      if (!settingsApi) {
+        return writeJson(res, 503, { ok: false, error: 'settings not ready' })
+      }
+      let payload
+      try {
+        payload = JSON.parse((await readBody(req)).toString('utf8') || '{}')
+      } catch {
+        return writeJson(res, 400, { ok: false, error: 'invalid json' })
+      }
+      if (payload && typeof payload.config === 'object') payload = payload.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) })
+      }
+    },
+  }), 'dsh-clinebot: /config')
+
+  // 3. POST /dsh-clinebot/save-key — direct saving into DSH credentials service
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-clinebot/save-key',
+    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 apiKey = String(body.apiKey || '').trim()
+        if (!apiKey) {
+          return writeJson(res, 400, { ok: false, error: 'API key cannot be empty' })
+        }
+
+        const pub = publicConfig(live())
+        const targetEnvName = String(body.apiKeyEnv || pub.apiKeyEnv || DEFAULT_API_KEY_ENV).trim()
+        await saveCredentialKey(ctx, targetEnvName, apiKey)
+
+        await syncProviderState(live())
+        triggerAutoDiscover()
+
+        const validation = await smokeChat(pub.baseUrl, apiKey, {
+          model: pub.defaultModel,
+          timeoutMs: 15000,
+        })
+
+        writeJson(res, 200, {
+          ok: true,
+          envName: targetEnvName,
+          validated: validation.ok,
+          latencyMs: validation.latencyMs,
+          validationError: validation.ok ? null : validation.error,
+        })
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+      }
+    },
+  }), 'dsh-clinebot: /save-key')
+}