fix: install env path issue (#773)

Author: Wendong-Fan

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -12,7 +12,7 @@ body:
     id: version
     attributes:
       label: What version of eigent are you using?
-      placeholder: E.g., 0.0.72
+      placeholder: E.g., 0.0.73
     validations:
       required: true
 

backend/pyproject.toml

@@ -3,9 +3,9 @@ name = "backend"
 version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
-requires-python = "==3.10.16"
+requires-python = ">=3.10,<3.11"
 dependencies = [
-    "camel-ai[eigent]==0.2.80a3",
+    "camel-ai[eigent]==0.2.80",
     "fastapi>=0.115.12",
     "fastapi-babel>=1.0.0",
     "uvicorn[standard]>=0.34.2",

backend/uv.lock

@@ -1,4 +1,4 @@
-import { getBackendPath, getBinaryPath, getCachePath, getVenvPath, isBinaryExists, runInstallScript } from "./utils/process";
+import { getBackendPath, getBinaryPath, getCachePath, getVenvPath, getUvEnv, isBinaryExists, runInstallScript, killProcessByName } from "./utils/process";
 import { spawn, exec } from 'child_process'
 import log from 'electron-log'
 import fs from 'fs'
@@ -21,16 +21,16 @@ export function getMainWindow(): BrowserWindow | null {
 export async function checkToolInstalled() {
     return new Promise<PromiseReturnType>(async (resolve, reject) => {
         if (!(await isBinaryExists('uv'))) {
-            resolve({success: false, message: "uv doesn't exist"})
+            resolve({ success: false, message: "uv doesn't exist" })
             return
         }
 
         if (!(await isBinaryExists('bun'))) {
-            resolve({success: false, message: "Bun doesn't exist"})
+            resolve({ success: false, message: "Bun doesn't exist" })
             return
         }
 
-        resolve({success: true, message: "Tools exist already"})
+        resolve({ success: true, message: "Tools exist already" })
     })
 
 }
@@ -159,12 +159,13 @@ export async function startBackend(setPort?: (port: number) => void): Promise<an
         fs.mkdirSync(npmCacheDir, { recursive: true });
     }
 
+    const uvEnv = getUvEnv(currentVersion);
     const env = {
         ...process.env,
+        ...uvEnv,
         SERVER_URL: "https://dev.eigent.ai/api",
         PYTHONIOENCODING: 'utf-8',
         PYTHONUNBUFFERED: '1',
-        UV_PROJECT_ENVIRONMENT: venvPath,
         npm_config_cache: npmCacheDir,
     }
 
@@ -202,10 +203,79 @@ export async function startBackend(setPort?: (port: number) => void): Promise<an
                 { cwd: backendPath, env: env }
             );
             log.info(`Python test output: ${pythonTest.trim()}`);
-        } catch (testErr) {
-            log.error(`Pre-flight check failed: ${testErr}`);
-            reject(new Error(`Backend environment check failed: ${testErr}`));
-            return;
+        } catch (testErr: any) {
+            log.warn(`Pre-flight check failed, attempting repair: ${testErr}`);
+
+            try {
+                // Attempt to repair the environment
+                log.info("Attempting to repair environment...");
+
+                // Cleanup stale processes and locks
+                log.info("Cleaning up stale processes and locks...");
+                await killProcessByName('uv');
+                await killProcessByName('python');
+
+                // Try to remove the lock file explicitly if it exists
+                try {
+                    const lockFile = path.join(getCachePath('uv_python'), '.lock');
+                    if (fs.existsSync(lockFile)) {
+                        fs.unlinkSync(lockFile);
+                    }
+                } catch (e) {
+                    log.warn(`Failed to remove lock file: ${e}`);
+                }
+
+                // Cleanup corrupted python cache
+                try {
+                    const pythonCacheDir = getCachePath('uv_python');
+                    if (fs.existsSync(pythonCacheDir)) {
+                        log.info(`Removing potentially corrupted Python cache: ${pythonCacheDir}`);
+                        fs.rmSync(pythonCacheDir, { recursive: true, force: true });
+                    }
+                } catch (e) {
+                    log.warn(`Failed to remove Python cache: ${e}`);
+                }
+
+                // Cleanup corrupted venv (pyvenv.cfg may reference non-existent Python version)
+                try {
+                    if (fs.existsSync(venvPath)) {
+                        log.info(`Removing potentially corrupted venv: ${venvPath}`);
+                        fs.rmSync(venvPath, { recursive: true, force: true });
+                    }
+                } catch (e) {
+                    log.warn(`Failed to remove venv: ${e}`);
+                }
+
+                // Use proxy if in China (simple check based on timezone)
+                // Add official PyPI as fallback for packages not available on mirror
+                const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+                const proxyArgs = timezone === 'Asia/Shanghai'
+                    ? [
+                        '--default-index', 'https://mirrors.aliyun.com/pypi/simple/',
+                        '--index', 'https://pypi.org/simple/'
+                    ]
+                    : [];
+
+                // Step 1: Ensure Python is installed (fixes corrupted/missing Python)
+                log.info("Step 1: Ensuring Python is installed...");
+                await execAsync(`${uv_path} python install 3.10`, { cwd: backendPath, env: env });
+
+                // Step 2: Sync dependencies
+                log.info("Step 2: Syncing dependencies...");
+                const syncArgs = ['sync', '--no-dev', ...proxyArgs];
+                await execAsync(`${uv_path} ${syncArgs.join(' ')}`, { cwd: backendPath, env: env });
+
+                // Retry the check
+                const { stdout: pythonTest } = await execAsync(
+                    `${uv_path} run python -c "print('Python OK')"`,
+                    { cwd: backendPath, env: env }
+                );
+                log.info(`Python test output after repair: ${pythonTest.trim()}`);
+            } catch (repairErr) {
+                log.error(`Repair failed: ${repairErr}`);
+                reject(new Error(`Backend environment check failed: ${testErr}\nRepair failed: ${repairErr}`));
+                return;
+            }
         }
 
         const node_process = spawn(
@@ -265,7 +335,7 @@ export async function startBackend(setPort?: (port: number) => void): Promise<an
                         setTimeout(() => {
                             try {
                                 process.kill(-proc.pid, 'SIGKILL');
-                            } catch (e) {}
+                            } catch (e) { }
                         }, 1000);
                     } catch (e) {
                         log.error(`Failed to kill process group: ${e}`);

electron/main/init.ts

@@ -3,7 +3,7 @@ import path from 'node:path'
 import log from 'electron-log'
 import { getMainWindow } from './init'
 import fs from 'node:fs'
-import { getBackendPath, getBinaryPath, getCachePath, getVenvPath, cleanupOldVenvs, isBinaryExists, runInstallScript } from './utils/process'
+import { getBackendPath, getBinaryPath, getCachePath, getVenvPath, getUvEnv, cleanupOldVenvs, isBinaryExists, runInstallScript } from './utils/process'
 import { spawn } from 'child_process'
 import { safeMainWindowSend } from './utils/safeWebContentsSend'
 import os from 'node:os'
@@ -242,7 +242,6 @@ class InstallLogs {
 
   constructor(extraArgs:string[], version: string) {
     console.log('start install dependencies', extraArgs, 'version:', version)
-    const venvPath = getVenvPath(version);
     this.version = version;
 
     this.node_process = spawn(uv_path, [
@@ -253,10 +252,7 @@ class InstallLogs {
         cwd: backendPath,
         env: {
             ...process.env,
-            UV_TOOL_DIR: getCachePath('uv_tool'),
-            UV_PYTHON_INSTALL_DIR: getCachePath('uv_python'),
-            UV_PROJECT_ENVIRONMENT: venvPath,
-            UV_HTTP_TIMEOUT: '180', // 3 minutes timeout
+            ...getUvEnv(version),
         }
     })
   }

electron/main/install-deps.ts

@@ -142,3 +142,49 @@ export async function isBinaryExists(name: string): Promise<boolean> {
 
   return await fs.existsSync(cmd)
 }
+
+/**
+ * Get unified UV environment variables for consistent Python environment management.
+ * This ensures both installation and runtime use the same paths.
+ * @param version - The app version for venv path
+ * @returns Environment variables for UV commands
+ */
+export function getUvEnv(version: string): Record<string, string> {
+  return {
+    UV_PYTHON_INSTALL_DIR: getCachePath('uv_python'),
+    UV_TOOL_DIR: getCachePath('uv_tool'),
+    UV_PROJECT_ENVIRONMENT: getVenvPath(version),
+    UV_HTTP_TIMEOUT: '180',
+  }
+}
+
+export async function killProcessByName(name: string): Promise<void> {
+  const platform = process.platform
+  try {
+    if (platform === 'win32') {
+      await new Promise<void>((resolve, reject) => {
+        // /F = force, /IM = image name
+        const cmd = spawn('taskkill', ['/F', '/IM', `${name}.exe`])
+        cmd.on('close', (code) => {
+          // code 0 = success, code 128 = process not found (which is fine)
+          if (code === 0 || code === 128) resolve()
+          else reject(new Error(`taskkill exited with code ${code}`))
+        })
+        cmd.on('error', reject)
+      })
+    } else {
+      await new Promise<void>((resolve, reject) => {
+        const cmd = spawn('pkill', ['-9', name])
+        cmd.on('close', (code) => {
+          // code 0 = success, code 1 = no process found (which is fine)
+          if (code === 0 || code === 1) resolve()
+          else reject(new Error(`pkill exited with code ${code}`))
+        })
+        cmd.on('error', reject)
+      })
+    }
+  } catch (err) {
+    // Ignore errors, just best effort
+    log.warn(`Failed to kill process ${name}:`, err)
+  }
+}

electron/main/utils/process.ts

@@ -1,6 +1,6 @@
 {
   "name": "eigent",
-  "version": "0.0.72",
+  "version": "0.0.73",
   "main": "dist-electron/main/index.js",
   "description": "Eigent",
   "author": "Eigent.AI",