dsh-miloco-bridge 0.1.0 → 0.1.2

package/lib/settings-api.js

@@ -21,7 +21,8 @@
  */
 
 import { access } from 'node:fs/promises'
-import { join } from 'node:path'
+import { dirname, join } from 'node:path'
+import { fetchLatestRelease, inferDeployKind, isNewerRelease, normalizeReleaseVersion } from './github-release.js'
 import { MilocoError, readMilocoConfig } from './miloco-client.js'
 import { normalizePerceptionLevel, PERCEPTION_LEVELS } from './perception.js'
 import { AGENT_MODES, describeMode, readSessions } from './state.js'
@@ -212,6 +213,8 @@ export function registerSettingsApi(options) {
   const { ctx, config, client, overlay } = options
   const log = options.logger ?? ctx.logger
   const disposers = []
+  /** @type {null | {at: number, source: string, has_update: boolean, current: string, latest: string}} */
+  let lastUpgradeCheck = null
 
   /**
    * Register one exact route.
@@ -470,6 +473,172 @@ export function registerSettingsApi(options) {
     })
   })
 
+  route(`${SETTINGS_PREFIX}/version`, async (req, res) => {
+    if (req.method !== 'GET') {
+      sendJson(res, 405, { ok: false, error: 'method not allowed' })
+      return
+    }
+    const force = new URL(req.url, 'http://127.0.0.1').searchParams.get('refresh') === '1'
+    const endpoint = await client.endpoint()
+    const fileConfig = await readMilocoConfig(endpoint.home)
+    const pythonBin = String(fileConfig?.server?.python_bin ?? '')
+    // server.python_bin = <source>/backend/.venv/bin/python
+    const sourceRoot = pythonBin
+      ? dirname(dirname(dirname(dirname(pythonBin))))
+      : (config.deploy?.sourceDir || '')
+
+    try {
+      const [version, backendUpgrade, upgradeStatus] = await Promise.all([
+        client.get('/api/admin/version', { signal: AbortSignal.timeout(8_000) }),
+        client.get('/api/admin/upgrade/check', {
+          query: { force: force ? 'true' : 'false' },
+          signal: AbortSignal.timeout(15_000),
+        }).catch(() => null),
+        client.get('/api/admin/upgrade/status', { signal: AbortSignal.timeout(8_000) }).catch(() => null),
+      ])
+      let upgrade = backendUpgrade
+      if (!upgrade || upgrade.reachable === false) {
+        const current = String(upgrade?.current || version?.version || '')
+        const deployKind = upgrade?.deploy_kind || inferDeployKind(current)
+        try {
+          const latest = await fetchLatestRelease({
+            repo: config.deploy?.repo,
+            apiBase: config.deploy?.githubApi,
+            mirrors: config.deploy?.githubMirrors,
+            timeoutMs: 6_000,
+          })
+          upgrade = {
+            current,
+            latest: normalizeReleaseVersion(latest.tag),
+            has_update: Boolean(current) && deployKind === 'release'
+              && isNewerRelease(current, latest.tag),
+            deploy_kind: deployKind,
+            release_url: latest.release_url || latest.html_url,
+            reachable: true,
+            source: latest.source,
+            mirror: latest.mirror || null,
+            checked_at: Math.floor(Date.now() / 1000),
+          }
+        } catch (fallbackError) {
+          const message = fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
+          upgrade = {
+            ...(upgrade ?? {}),
+            current,
+            latest: null,
+            has_update: false,
+            deploy_kind: deployKind,
+            release_url: null,
+            reachable: false,
+            source: 'none',
+            error: message,
+          }
+        }
+      } else {
+        upgrade = { ...upgrade, source: upgrade.source || 'backend' }
+      }
+      if (upgrade) {
+        lastUpgradeCheck = {
+          at: Date.now(),
+          source: upgrade.source || 'backend',
+          has_update: Boolean(upgrade.has_update),
+          current: String(upgrade.current || ''),
+          latest: String(upgrade.latest || ''),
+        }
+      }
+      sendJson(res, 200, {
+        ok: true,
+        reachable: true,
+        sourceRoot,
+        version,
+        upgrade,
+        upgradeStatus,
+      })
+    } catch (error) {
+      sendJson(res, 200, {
+        ok: true,
+        reachable: false,
+        sourceRoot,
+        error: error instanceof MilocoError ? error.message : String(error),
+        version: null,
+        upgrade: null,
+        upgradeStatus: null,
+      })
+    }
+  })
+
+  route(`${SETTINGS_PREFIX}/upgrade`, async (req, res) => {
+    if (req.method !== 'POST') {
+      sendJson(res, 405, { ok: false, error: 'method not allowed' })
+      return
+    }
+    const body = await mutateBody(req, res)
+    if (body === null) return
+    const recent = lastUpgradeCheck && Date.now() - lastUpgradeCheck.at < 10 * 60_000
+    const pluginUpgrade = recent
+      && lastUpgradeCheck.source !== 'backend'
+      && lastUpgradeCheck.has_update
+      && typeof options.deploy?.startUpgrade === 'function'
+    if (pluginUpgrade) {
+      const proto = String(req.headers['x-forwarded-proto'] || 'http').split(',')[0].trim()
+      const origin = typeof req.headers.origin === 'string' && req.headers.origin
+        ? req.headers.origin
+        : `${proto}://${req.headers.host ?? '127.0.0.1:3080'}`
+      const outcome = await options.deploy.startUpgrade({ origin })
+      if (!outcome.started) {
+        sendJson(res, 409, { ok: false, error: outcome.reason || '升级未启动', ...outcome })
+        return
+      }
+      sendJson(res, 200, { ok: true, source: 'plugin', ...outcome })
+      return
+    }
+    // Upstream only allows /upgrade/run for release deployments. It performs
+    // its own has_update check; surface its 400 reason verbatim.
+    try {
+      const data = await client.post('/api/admin/upgrade/run', undefined, {
+        signal: AbortSignal.timeout(30_000),
+      })
+      sendJson(res, 200, { ok: true, data })
+    } catch (error) {
+      sendJson(res, 400, {
+        ok: false,
+        error: error instanceof MilocoError ? error.message : String(error),
+      })
+    }
+  })
+
+  route(`${SETTINGS_PREFIX}/upgrade/status`, async (req, res) => {
+    if (req.method !== 'GET') {
+      sendJson(res, 405, { ok: false, error: 'method not allowed' })
+      return
+    }
+    const pluginState = options.deploy?.upgradeState?.()
+    if (pluginState && pluginState.step !== 'idle') {
+      const phaseMap = {
+        'downloading-installer': 'downloading',
+        'starting-service': 'restarting',
+        wiring: 'installing',
+      }
+      sendJson(res, 200, {
+        ok: true,
+        source: 'plugin',
+        status: { ...pluginState, phase: phaseMap[pluginState.step] || pluginState.step },
+      })
+      return
+    }
+    try {
+      const status = await client.get('/api/admin/upgrade/status', {
+        signal: AbortSignal.timeout(8_000),
+      })
+      sendJson(res, 200, { ok: true, status })
+    } catch (error) {
+      sendJson(res, 200, {
+        ok: true,
+        status: null,
+        error: error instanceof MilocoError ? error.message : String(error),
+      })
+    }
+  })
+
   route(`${SETTINGS_PREFIX}/deploy`, async (req, res) => {
     if (!options.deploy) {
       sendJson(res, 503, { ok: false, error: '部署功能未启用' })