Skip to content

A team of long-lived bots for DeepSeek Harness, with main bots, bot-to-bot messages and group chats.

7.9 KB
Raw Blame
// DSH updates: a released DS Bot may name the DSH release it was verified
// against (`dsBot.verifiedDsh` in package.json); a release that names none
// offers nothing. The newest released bot wins: offering that version and
// nothing newer keeps the update path away from DSH releases we have not
// checked. A DSH installed from npm swaps with `npm i -g`; a packaged app's
// runtime lives inside its bundle and only its own updater moves it, to the
// newest release it finds, so the client offers it only when that release is
// the verified one.
import { spawn } from 'node:child_process'
import { readFileSync } from 'node:fs'
import { dirname, join } from 'node:path'

import {
  CHECK_TTL_MS, cleanVersion, encodeName, fetchJson, installSpecOf,
  newer, registryPlan, repoSlug, sourceOf,
} from './update.js'

const PKG = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'))
const APP_BOOT = '@deepseek-ai/dsh-app-boot'
const DSH_PACKAGE = '@deepseek-ai/dsh'

export function install(rt) {
  const { ctx, config } = rt
  const enabled = config.updateCheck !== false

  const status = {
    current: null, verified: null, kind: 'npm', blockedBy: null,
    checkedAt: 0, phase: 'idle', installed: null, error: null,
  }
  let target = null
  let checking = null
  let running = null

  // A newer `minBot` than the running bot gates the offer: the bot goes first.
  const blocked = () => status.blockedBy !== null && newer(status.blockedBy, PKG.version)

  const view = () => ({
    current: status.current, verified: status.verified, kind: status.kind, blockedBy: status.blockedBy,
    checkedAt: status.checkedAt, phase: status.phase, installed: status.installed, error: status.error,
    // Nothing is offered without a current version to compare against.
    available: status.phase !== 'installed' && target !== null && status.current !== null
      && status.verified !== null && status.verified !== status.current && !blocked(),
  })

  // The version of the DSH that is running us: the app-boot export, or — where
  // that import cannot see it — the nearest @deepseek-ai package.json above the
  // entry script.
  async function currentDsh() {
    try {
      const loader = ctx.get?.('loader')
      const loaded = await loader?.import?.(APP_BOOT)
      const appBoot = loader?.unwrapExports?.(loaded) ?? loaded?.default ?? loaded
      const version = cleanVersion(appBoot?.getDshRuntimeVersion?.())
      if (version) return version
    } catch { /* the export is not visible here: read the install instead */ }
    let dir = dirname(String(process.argv[1] ?? ''))
    for (let depth = 0; depth < 12; depth += 1) {
      try {
        const manifest = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'))
        if (manifest?.name?.startsWith?.('@deepseek-ai/')) {
          const version = cleanVersion(manifest.version)
          if (version) return version
        }
      } catch { /* not a package directory */ }
      const parent = dirname(dir)
      if (parent === dir) break
      dir = parent
    }
    return null
  }

  // A bundled package manager means the runtime came with the app and only the
  // app's own updater can move it.
  const installKind = () =>
    typeof ctx.get?.('profileContext')?.packageManager?.command === 'string' ? 'app' : 'npm'

  // The newest released DS Bot's `dsBot` block, through the same channel the bot
  // itself updates from: its registry, or the public repo's latest release.
  async function releasedDeclaration(source) {
    if (source.kind === 'registry') {
      for (const registry of await registryPlan(config, ctx.get?.('pluginManager'))) {
        try {
          const manifest = await fetchJson(`${registry}${encodeName(PKG.name)}/latest`)
          if (manifest?.dsBot?.verifiedDsh) return manifest.dsBot
        } catch { /* unreachable or not published there: ask the next one */ }
      }
      return null
    }
    const repo = repoSlug()
    if (!repo) return null
    try {
      const release = await fetchJson(`https://api.github.com/repos/${repo}/releases/latest`, { 'user-agent': `${PKG.name}/${PKG.version}` })
      const tag = cleanVersion(release?.tag_name)
      if (!tag) return null
      const manifest = await fetchJson(`https://raw.githubusercontent.com/${repo}/${release.tag_name}/ds-bot/package.json`, { 'user-agent': `${PKG.name}/${PKG.version}` })
      return manifest?.dsBot?.verifiedDsh ? manifest.dsBot : null
    } catch { return null }
  }

  async function runCheck() {
    try {
      status.current = await currentDsh()
      status.kind = installKind()
      // The desktop app pins its DSH and updates it as a whole, so it has nothing to offer.
      const inApp = process.env.DS_BOT_APP === '1'
      // The release the running package itself verified stays the floor: a bot
      // older than its own declaration has nothing newer to offer.
      const declared = inApp ? [] : [{ verifiedDsh: PKG.dsBot?.verifiedDsh }]
      const released = inApp ? null : await releasedDeclaration(sourceOf(await installSpecOf(ctx)))
      if (released) declared.push(released)
      const newestDeclared = declared
        .filter(entry => cleanVersion(entry.verifiedDsh))
        .sort((a, b) => (newer(cleanVersion(a.verifiedDsh), cleanVersion(b.verifiedDsh)) ? -1 : 1))[0]
      status.verified = cleanVersion(newestDeclared?.verifiedDsh)
      // A release may gate the DSH update on a newer bot: offer nothing until
      // the bot itself is at least `minBot`.
      status.blockedBy = cleanVersion(newestDeclared?.minBot)
      target = status.current !== null && status.verified !== null && status.verified !== status.current
        ? { version: status.verified }
        : null
      status.error = null
    } catch (error) {
      rt.warn('ds-bot: dsh update check failed: %s', error?.message ?? error)
      status.verified = null
      status.blockedBy = null
      target = null
    }
    status.checkedAt = Date.now()
  }

  /** Read current and verified DSH versions; a fresh check ignores the last answer. */
  async function check({ fresh = false } = {}) {
    if (!enabled) return view()
    if (checking) return checking
    if (!fresh && Date.now() - status.checkedAt < CHECK_TTL_MS) return view()
    checking = runCheck().finally(() => { checking = null })
    await checking
    return view()
  }

  /** Swap an npm-installed DSH for the verified version; the answer comes back through `check`. */
  function start() {
    if (status.phase === 'installing') return view()
    if (target === null || blocked()) throw new Error('No DSH update is available')
    if (status.kind !== 'npm') throw new Error('This DSH updates with its app')
    const chosen = target
    Object.assign(status, { phase: 'installing', error: null })
    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm'
    const args = ['install', '-g', `${DSH_PACKAGE}@${chosen.version}`]
    const runner = rt.dshSpawn ?? ((command, argv, options) => spawn(command, argv, options))
    running = runner(npm, args, { windowsHide: true })
    let output = ''
    running.stdout?.on?.('data', chunk => { output = `${output}${chunk}`.slice(-4000) })
    running.stderr?.on?.('data', chunk => { output = `${output}${chunk}`.slice(-4000) })
    const done = new Promise((resolve, reject) => {
      running.once?.('error', reject)
      running.once?.('close', code => (code === 0 ? resolve() : reject(new Error(`npm exited ${code}`))))
    })
    void done
      .then(() => Object.assign(status, { phase: 'installed', installed: chosen.version }))
      .catch((error) => {
        rt.warn('ds-bot: dsh update to %s failed: %s', chosen.version, error?.message ?? error)
        Object.assign(status, { phase: 'failed', error: `${error?.message ?? error}${output ? ` — ${output.trim().slice(-400)}` : ''}`.slice(0, 600) })
      })
    return view()
  }

  // Whatever npm is still running when the plugin unloads dies with it.
  ctx.effect(() => () => running?.kill?.(), 'ds-bot: dsh update install')

  Object.assign(rt, { dshUpdateCheck: check, dshUpdateStart: start, dshUpdateView: view })
}