refactor: simplify desktop runtime build and cleanup flow

Author: zouyonghe

astrbot/core/updator.py

@@ -8,7 +8,7 @@
 from astrbot.core.config.default import VERSION
 from astrbot.core.utils.astrbot_path import get_astrbot_path
 from astrbot.core.utils.io import download_file
-from astrbot.core.utils.runtime_env import is_packaged_electron_runtime
+from astrbot.core.utils.update_guard import ensure_packaged_update_allowed
 
 from .zip_updator import ReleaseInfo, RepoZipUpdator
 
@@ -90,10 +90,7 @@ async def get_releases(self) -> list:
     async def update(self, reboot=False, latest=True, version=None, proxy="") -> None:
         if os.environ.get("ASTRBOT_CLI") or os.environ.get("ASTRBOT_LAUNCHER"):
             raise Exception("不支持更新此方式启动的AstrBot")  # 避免版本管理混乱
-        if is_packaged_electron_runtime():
-            raise Exception(
-                "桌面打包版不支持在线更新，请下载最新安装包并替换当前应用。"
-            )
+        ensure_packaged_update_allowed()
 
         update_data = await self.fetch_release_info(self.ASTRBOT_RELEASE_API, latest)
         file_url = None

astrbot/core/utils/update_guard.py

@@ -0,0 +1,18 @@
+from astrbot.core.utils.runtime_env import is_packaged_electron_runtime
+
+DESKTOP_PACKAGED_UPDATE_BLOCK_MESSAGE = (
+    "桌面打包版不支持在线更新。请下载最新安装包并替换当前应用。"
+)
+
+
+def should_block_packaged_update() -> bool:
+    return is_packaged_electron_runtime()
+
+
+def get_packaged_update_block_message() -> str:
+    return DESKTOP_PACKAGED_UPDATE_BLOCK_MESSAGE
+
+
+def ensure_packaged_update_allowed() -> None:
+    if should_block_packaged_update():
+        raise RuntimeError(get_packaged_update_block_message())

astrbot/dashboard/routes/update.py

@@ -8,14 +8,14 @@
 from astrbot.core.db.migration.helper import check_migration_needed_v4, do_migration_v4
 from astrbot.core.updator import AstrBotUpdator
 from astrbot.core.utils.io import download_dashboard, get_dashboard_version
-from astrbot.core.utils.runtime_env import is_packaged_electron_runtime
+from astrbot.core.utils.update_guard import (
+    get_packaged_update_block_message,
+    should_block_packaged_update,
+)
 
 from .route import Response, Route, RouteContext
 
 CLEAR_SITE_DATA_HEADERS = {"Clear-Site-Data": '"cache"'}
-DESKTOP_PACKAGED_UPDATE_BLOCK_MESSAGE = (
-    "桌面打包版不支持在线更新。请下载最新安装包并替换当前应用。"
-)
 
 
 class UpdateRoute(Route):
@@ -90,8 +90,8 @@ async def get_releases(self):
             return Response().error(e.__str__()).__dict__
 
     async def update_project(self):
-        if is_packaged_electron_runtime():
-            return Response().error(DESKTOP_PACKAGED_UPDATE_BLOCK_MESSAGE).__dict__
+        if should_block_packaged_update():
+            return Response().error(get_packaged_update_block_message()).__dict__
 
         data = await request.json
         version = data.get("version", "")
@@ -144,8 +144,8 @@ async def update_project(self):
             return Response().error(e.__str__()).__dict__
 
     async def update_dashboard(self):
-        if is_packaged_electron_runtime():
-            return Response().error(DESKTOP_PACKAGED_UPDATE_BLOCK_MESSAGE).__dict__
+        if should_block_packaged_update():
+            return Response().error(get_packaged_update_block_message()).__dict__
 
         try:
             try:

desktop/lib/backend-manager.js

@@ -162,41 +162,56 @@ class BackendManager {
     };
   }
 
-  resolveBackendConfig() {
-    const webuiDir = this.resolveWebuiDir();
+  resolveLaunchCommand(webuiDir) {
     const customCmd = process.env.ASTRBOT_BACKEND_CMD;
-    let launch = null;
-    let failureReason = null;
-
     if (customCmd) {
-      launch = {
-        cmd: customCmd,
-        args: [],
-        shell: true,
+      return {
+        launch: {
+          cmd: customCmd,
+          args: [],
+          shell: true,
+        },
+        failureReason: null,
       };
-    } else if (this.app.isPackaged) {
+    }
+
+    if (this.app.isPackaged) {
       const packagedBackendState = this.getPackagedBackendState();
       if (packagedBackendState?.ok && packagedBackendState.config) {
-        launch = {
-          cmd: packagedBackendState.config.runtimePythonPath,
-          args: [packagedBackendState.config.launchScriptPath, ...(webuiDir ? ['--webui-dir', webuiDir] : [])],
-          shell: false,
+        return {
+          launch: {
+            cmd: packagedBackendState.config.runtimePythonPath,
+            args: [packagedBackendState.config.launchScriptPath, ...(webuiDir ? ['--webui-dir', webuiDir] : [])],
+            shell: false,
+          },
+          failureReason: null,
         };
-      } else {
-        failureReason =
-          packagedBackendState?.failureReason || 'Backend command is not configured.';
-        this.log(failureReason);
       }
-    } else {
-      launch = this.buildDefaultBackendLaunch(webuiDir);
+      return {
+        launch: null,
+        failureReason: packagedBackendState?.failureReason || 'Backend command is not configured.',
+      };
     }
 
+    return {
+      launch: this.buildDefaultBackendLaunch(webuiDir),
+      failureReason: null,
+    };
+  }
+
+  resolveBackendConfig() {
+    const webuiDir = this.resolveWebuiDir();
+    const { launch, failureReason } = this.resolveLaunchCommand(webuiDir);
+
     const cwd = process.env.ASTRBOT_BACKEND_CWD || this.resolveBackendCwd();
     const rootDir = process.env.ASTRBOT_ROOT || this.resolveBackendRoot();
     ensureDir(cwd);
     if (rootDir) {
       ensureDir(rootDir);
     }
+    if (failureReason) {
+      this.log(failureReason);
+    }
     this.backendConfig = {
       cmd: launch ? launch.cmd : null,
       args: launch ? launch.args : [],
@@ -641,6 +656,25 @@ class BackendManager {
     return { imageName, pid: parsedPid };
   }
 
+  shouldKillUnmanagedProcess({
+    pid,
+    processInfo,
+    backendConfig,
+    commandLineCache,
+  }) {
+    const hasBackendConfig = backendConfig && typeof backendConfig === 'object';
+    return shouldKillUnmanagedBackendProcess({
+      pid,
+      processInfo,
+      backendConfig,
+      allowImageOnlyMatch: !hasBackendConfig,
+      commandLineCache,
+      spawnSync,
+      log: (message) => this.log(message),
+      fallbackCmdRaw: process.env.ASTRBOT_BACKEND_CMD || 'python.exe',
+    });
+  }
+
   async stopUnmanagedBackendByPort() {
     if (!this.app.isPackaged || process.platform !== 'win32') {
       return false;
@@ -684,15 +718,11 @@ class BackendManager {
         this.log(`Skip unmanaged cleanup for pid=${pid}: unable to resolve process info.`);
         continue;
       }
-      const shouldKill = shouldKillUnmanagedBackendProcess({
+      const shouldKill = this.shouldKillUnmanagedProcess({
         pid,
         processInfo,
         backendConfig,
-        allowImageOnlyMatch: !hasBackendConfig,
         commandLineCache,
-        spawnSync,
-        log: (message) => this.log(message),
-        fallbackCmdRaw: process.env.ASTRBOT_BACKEND_CMD || 'python.exe',
       });
       if (!shouldKill) {
         continue;

desktop/lib/windows-backend-cleanup.js

@@ -3,6 +3,8 @@
 const path = require('path');
 
 const WINDOWS_PROCESS_QUERY_TIMEOUT_MS = 2000;
+const COMMAND_LINE_QUERY_UNAVAILABLE_KEY = '__command_line_query_unavailable__';
+const COMMAND_LINE_FALLBACK_LOGGED_KEY = '__command_line_fallback_logged__';
 
 function normalizeWindowsPathForMatch(value) {
   return String(value || '')
@@ -15,56 +17,38 @@ function isGenericWindowsPythonImage(imageName) {
   return normalized === 'python.exe' || normalized === 'pythonw.exe' || normalized === 'py.exe';
 }
 
-function queryWindowsProcessCommandLine({ pid, shellName, spawnSync, timeoutMs }) {
-  const query = `$p = Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}"; if ($null -ne $p) { $p.CommandLine }`;
-  const args = ['-NoProfile', '-NonInteractive', '-Command', query];
-  const options = {
-    stdio: ['ignore', 'pipe', 'ignore'],
-    encoding: 'utf8',
-    windowsHide: true,
-    timeout: timeoutMs,
-  };
-  if (shellName === 'powershell') {
-    return spawnSync('powershell', args, options);
-  }
-  if (shellName === 'pwsh') {
-    return spawnSync('pwsh', args, options);
-  }
-  throw new Error(`Unsupported shell for process command line query: ${shellName}`);
-}
-
-function parseWindowsProcessCommandLine(result) {
-  if (!result || !result.stdout) {
-    return null;
-  }
-  return (
-    result.stdout
-      .split(/\r?\n/)
-      .map((item) => item.trim())
-      .find((item) => item.length > 0) || null
-  );
-}
-
 function getWindowsProcessCommandLine({ pid, commandLineCache, spawnSync, log, timeoutMs }) {
   const numericPid = Number.parseInt(`${pid}`, 10);
   if (!Number.isInteger(numericPid)) {
-    return null;
+    return { commandLine: null, commandLineQueryUnavailable: false };
+  }
+
+  if (commandLineCache && commandLineCache.get(COMMAND_LINE_QUERY_UNAVAILABLE_KEY) === true) {
+    return { commandLine: null, commandLineQueryUnavailable: true };
   }
 
   if (commandLineCache && commandLineCache.has(numericPid)) {
-    return commandLineCache.get(numericPid);
+    return {
+      commandLine: commandLineCache.get(numericPid),
+      commandLineQueryUnavailable: false,
+    };
   }
 
+  const query = `$p = Get-CimInstance Win32_Process -Filter "ProcessId = ${numericPid}"; if ($null -ne $p) { $p.CommandLine }`;
+  const args = ['-NoProfile', '-NonInteractive', '-Command', query];
+  const options = {
+    stdio: ['ignore', 'pipe', 'ignore'],
+    encoding: 'utf8',
+    windowsHide: true,
+    timeout: timeoutMs,
+  };
+
   const queryAttempts = ['powershell', 'pwsh'];
+  let hasAvailableShell = false;
   for (const shellName of queryAttempts) {
     let result = null;
     try {
-      result = queryWindowsProcessCommandLine({
-        pid: numericPid,
-        shellName,
-        spawnSync,
-        timeoutMs,
-      });
+      result = spawnSync(shellName, args, options);
     } catch (error) {
       if (error instanceof Error && error.message) {
         log(
@@ -77,41 +61,48 @@ function getWindowsProcessCommandLine({ pid, commandLineCache, spawnSync, log, t
     if (result.error && result.error.code === 'ENOENT') {
       continue;
     }
+    hasAvailableShell = true;
     if (result.error && result.error.code === 'ETIMEDOUT') {
       log(
         `Timed out (${timeoutMs}ms) querying process command line by ${shellName} for pid=${numericPid}.`,
       );
       continue;
     }
+    if (result.error) {
+      if (result.error.message) {
+        log(
+          `Failed to query process command line by ${shellName} for pid=${numericPid}: ${result.error.message}`,
+        );
+      }
+      continue;
+    }
 
     if (result.status === 0) {
-      const commandLine = parseWindowsProcessCommandLine(result);
+      const commandLine =
+        result.stdout
+          .split(/\r?\n/)
+          .map((item) => item.trim())
+          .find((item) => item.length > 0) || null;
       if (commandLineCache) {
         commandLineCache.set(numericPid, commandLine);
+        commandLineCache.set(COMMAND_LINE_QUERY_UNAVAILABLE_KEY, false);
       }
-      return commandLine;
+      return { commandLine, commandLineQueryUnavailable: false };
     }
   }
 
+  if (!hasAvailableShell) {
+    if (commandLineCache) {
+      commandLineCache.set(COMMAND_LINE_QUERY_UNAVAILABLE_KEY, true);
+    }
+    return { commandLine: null, commandLineQueryUnavailable: true };
+  }
+
   if (commandLineCache) {
     commandLineCache.set(numericPid, null);
+    commandLineCache.set(COMMAND_LINE_QUERY_UNAVAILABLE_KEY, false);
   }
-  return null;
-}
-
-function getFallbackWindowsBackendImageName(fallbackCmdRaw) {
-  const fallbackCmd = String(fallbackCmdRaw || 'python.exe')
-    .trim()
-    .split(/\s+/, 1)[0];
-  return path.basename(fallbackCmd || 'python.exe').toLowerCase();
-}
-
-function getExpectedWindowsBackendImageName(backendConfig, fallbackCmdRaw) {
-  const safeBackendConfig =
-    backendConfig && typeof backendConfig === 'object' ? backendConfig : {};
-  return path
-    .basename(safeBackendConfig.cmd || getFallbackWindowsBackendImageName(fallbackCmdRaw))
-    .toLowerCase();
+  return { commandLine: null, commandLineQueryUnavailable: false };
 }
 
 function buildBackendCommandLineMarkers(backendConfig) {
@@ -145,7 +136,14 @@ function shouldKillUnmanagedBackendProcess({
   log,
   fallbackCmdRaw,
 }) {
-  const expectedImageName = getExpectedWindowsBackendImageName(backendConfig, fallbackCmdRaw);
+  const safeBackendConfig =
+    backendConfig && typeof backendConfig === 'object' ? backendConfig : {};
+  const fallbackCmd = String(fallbackCmdRaw || 'python.exe')
+    .trim()
+    .split(/\s+/, 1)[0];
+  const expectedImageName = path
+    .basename(safeBackendConfig.cmd || fallbackCmd || 'python.exe')
+    .toLowerCase();
   const actualImageName = processInfo.imageName.toLowerCase();
   if (actualImageName !== expectedImageName) {
     log(
@@ -164,14 +162,24 @@ function shouldKillUnmanagedBackendProcess({
     return false;
   }
 
-  const commandLine = getWindowsProcessCommandLine({
+  const { commandLine, commandLineQueryUnavailable } = getWindowsProcessCommandLine({
     pid,
     commandLineCache,
     spawnSync,
     log,
     timeoutMs: WINDOWS_PROCESS_QUERY_TIMEOUT_MS,
   });
   if (!commandLine) {
+    if (commandLineQueryUnavailable) {
+      if (commandLineCache && !commandLineCache.get(COMMAND_LINE_FALLBACK_LOGGED_KEY)) {
+        commandLineCache.set(COMMAND_LINE_FALLBACK_LOGGED_KEY, true);
+        log(
+          'Neither powershell nor pwsh is available. ' +
+            'Falling back to image-name-only matching for generic Python backend cleanup.',
+        );
+      }
+      return true;
+    }
     log(`Skip unmanaged cleanup for pid=${pid}: unable to resolve process command line.`);
     return false;
   }