fix: scope css selector normalization and simplify backend launch flow

Author: zouyonghe

dashboard/vite.config.ts

@@ -5,11 +5,24 @@ import vuetify from 'vite-plugin-vuetify';
 
 const normalizeNestedTypeSelectorPlugin = {
   postcssPlugin: 'normalize-nested-type-selector',
-  Rule(rule: { parent?: { type?: string }; selector?: string }) {
+  Rule(rule: {
+    parent?: { type?: string; parent?: unknown; selector?: string };
+    selector?: string;
+    source?: { input?: { file?: string; from?: string } };
+  }) {
     if (rule.parent?.type !== 'rule' || typeof rule.selector !== 'string') {
       return;
     }
 
+    const sourceFile = String(rule.source?.input?.file || rule.source?.input?.from || '')
+      .replace(/\\/g, '/')
+      .toLowerCase();
+    const isProjectSource = sourceFile.includes('/dashboard/src/');
+    const isMonacoVendor = sourceFile.includes('/node_modules/monaco-editor/');
+    if (!isProjectSource && !isMonacoVendor) {
+      return;
+    }
+
     const segments = rule.selector
       .split(',')
       .map((segment) => segment.trim())

desktop/lib/backend-manager.js

@@ -132,24 +132,19 @@ class BackendManager {
     return fs.existsSync(indexPath) ? candidate : null;
   }
 
-  loadPackagedBackendState() {
+  getPackagedBackendState() {
     if (!this.app.isPackaged) {
       return null;
     }
-    if (this.packagedBackendState) {
-      return this.packagedBackendState;
+    if (!this.packagedBackendState) {
+      this.packagedBackendState = resolvePackagedBackendState(
+        process.resourcesPath,
+        (message) => this.log(message),
+      );
     }
-    this.packagedBackendState = resolvePackagedBackendState(
-      process.resourcesPath,
-      (message) => this.log(message),
-    );
     return this.packagedBackendState;
   }
 
-  getPackagedBackendState() {
-    return this.loadPackagedBackendState();
-  }
-
   buildDefaultBackendLaunch(webuiDir) {
     const args = ['run', 'main.py'];
     if (webuiDir) {
@@ -162,46 +157,42 @@ class BackendManager {
     };
   }
 
-  resolveLaunchCommand(webuiDir) {
-    const customCmd = process.env.ASTRBOT_BACKEND_CMD;
-    if (customCmd) {
-      return {
-        launch: {
-          cmd: customCmd,
-          args: [],
-          shell: true,
-        },
-        failureReason: null,
-      };
-    }
-
-    if (this.app.isPackaged) {
-      const packagedBackendState = this.getPackagedBackendState();
-      if (packagedBackendState?.ok && packagedBackendState.config) {
-        return {
-          launch: {
-            cmd: packagedBackendState.config.runtimePythonPath,
-            args: [packagedBackendState.config.launchScriptPath, ...(webuiDir ? ['--webui-dir', webuiDir] : [])],
-            shell: false,
-          },
-          failureReason: null,
-        };
-      }
+  buildLaunchForPackagedBackend(packagedBackendState, webuiDir) {
+    if (!packagedBackendState?.ok || !packagedBackendState.config) {
       return {
         launch: null,
-        failureReason: packagedBackendState?.failureReason || 'Backend command is not configured.',
+        failureReason:
+          packagedBackendState?.failureReason || 'Backend command is not configured.',
       };
     }
 
+    const { runtimePythonPath, launchScriptPath } = packagedBackendState.config;
+    const args = [launchScriptPath];
+    if (webuiDir) {
+      args.push('--webui-dir', webuiDir);
+    }
     return {
-      launch: this.buildDefaultBackendLaunch(webuiDir),
+      launch: { cmd: runtimePythonPath, args, shell: false },
       failureReason: null,
     };
   }
 
   resolveBackendConfig() {
     const webuiDir = this.resolveWebuiDir();
-    const { launch, failureReason } = this.resolveLaunchCommand(webuiDir);
+    let launch = null;
+    let failureReason = null;
+
+    const customCmd = process.env.ASTRBOT_BACKEND_CMD;
+    if (customCmd) {
+      launch = { cmd: customCmd, args: [], shell: true };
+    } else if (this.app.isPackaged) {
+      ({ launch, failureReason } = this.buildLaunchForPackagedBackend(
+        this.getPackagedBackendState(),
+        webuiDir,
+      ));
+    } else {
+      launch = this.buildDefaultBackendLaunch(webuiDir);
+    }
 
     const cwd = process.env.ASTRBOT_BACKEND_CWD || this.resolveBackendCwd();
     const rootDir = process.env.ASTRBOT_ROOT || this.resolveBackendRoot();
@@ -656,25 +647,6 @@ 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;
@@ -718,11 +690,15 @@ class BackendManager {
         this.log(`Skip unmanaged cleanup for pid=${pid}: unable to resolve process info.`);
         continue;
       }
-      const shouldKill = this.shouldKillUnmanagedProcess({
+      const shouldKill = shouldKillUnmanagedBackendProcess({
         pid,
         processInfo,
         backendConfig,
+        allowImageOnlyMatch: !hasBackendConfig,
         commandLineCache,
+        spawnSync,
+        log: (message) => this.log(message),
+        fallbackCmdRaw: process.env.ASTRBOT_BACKEND_CMD || 'python.exe',
       });
       if (!shouldKill) {
         continue;

desktop/scripts/runtime-layout-utils.mjs

@@ -44,10 +44,13 @@ export const resolveAndValidateRuntimeSource = ({ rootDir, outputDir, runtimeSou
 
   const runtimeNorm = normalizeForCompare(runtimeSourceReal);
   const outputNorm = normalizeForCompare(outputDir);
+  const projectRootNorm = normalizeForCompare(rootDir);
   const runtimeIsOutputOrSub =
     runtimeNorm === outputNorm || runtimeNorm.startsWith(`${outputNorm}${path.sep}`);
   const outputIsRuntimeOrSub =
     outputNorm === runtimeNorm || outputNorm.startsWith(`${runtimeNorm}${path.sep}`);
+  const runtimeContainsProjectRoot =
+    runtimeNorm === projectRootNorm || projectRootNorm.startsWith(`${runtimeNorm}${path.sep}`);
 
   if (runtimeIsOutputOrSub || outputIsRuntimeOrSub) {
     throw new Error(
@@ -56,6 +59,14 @@ export const resolveAndValidateRuntimeSource = ({ rootDir, outputDir, runtimeSou
         'Please set ASTRBOT_DESKTOP_CPYTHON_HOME to a separate runtime directory.',
     );
   }
+  if (runtimeContainsProjectRoot) {
+    throw new Error(
+      `CPython runtime source is too broad and contains the project root. ` +
+        `runtime=${runtimeSourceReal}, projectRoot=${path.resolve(rootDir)}. ` +
+        'Please point ASTRBOT_DESKTOP_CPYTHON_HOME (or ASTRBOT_DESKTOP_BACKEND_RUNTIME) ' +
+        'to a dedicated CPython runtime directory instead of the repository root or its parent.',
+    );
+  }
 
   return runtimeSourceReal;
 };