gpu-worker 1.0.0 → 1.0.1

package/README.md

@@ -33,6 +33,23 @@ gpu-worker configure
 gpu-worker start
 ```
 
+### Using system Python / skip install
+
+If your server already has GPU dependencies installed globally, you can skip the virtual environment and auto-install:
+
+```bash
+npx gpu-worker configure --use-system-python
+npx gpu-worker start --use-system-python
+```
+
+You can also keep a venv but skip dependency installation:
+
+```bash
+npx gpu-worker configure --skip-install
+```
+
+On first run without a venv, the interactive CLI will prompt you to choose the mode.
+
 ## Requirements
 
 - **Node.js**: >= 16.0.0
@@ -41,6 +58,9 @@ gpu-worker start
 - **RAM**: 16GB+ recommended
 - **Storage**: 50GB+ for model storage
 
+CUDA note: the installer uses `nvidia-smi` to detect CUDA and selects `cu124` / `cu121` / `cu118` for PyTorch.
+CUDA 12.2/12.3 use `cu121`. Other versions fall back to CPU builds.
+
 ## Configuration
 
 The worker can be configured via:

package/bin/gpu-worker.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * GPU Worker CLI - Node.js 入口
  * 包装 Python Worker，提供简单的 npm/npx 安装体验
@@ -38,8 +38,8 @@ function findPython() {
 }
 
 // 检查虚拟环境
-function getVenvPython() {
-    const venvPath = path.join(PACKAGE_DIR, '.venv');
+function getVenvPython() {
+    const venvPath = path.join(PACKAGE_DIR, '.venv');
 
     if (process.platform === 'win32') {
         const pythonPath = path.join(venvPath, 'Scripts', 'python.exe');
@@ -48,12 +48,46 @@ function getVenvPython() {
         const pythonPath = path.join(venvPath, 'bin', 'python');
         if (fs.existsSync(pythonPath)) return pythonPath;
     }
-    return null;
-}
-
-// 创建虚拟环境
-async function createVenv(pythonCmd) {
-    const spinner = ora('Creating Python virtual environment...').start();
+    return null;
+}
+
+function detectCudaVersion() {
+    try {
+        const output = execSync('nvidia-smi', { encoding: 'utf8' });
+        const match = output.match(/CUDA Version:\\s*(\\d+)\\.(\\d+)/);
+        if (!match) return null;
+        return { major: parseInt(match[1], 10), minor: parseInt(match[2], 10) };
+    } catch (e) {
+        return null;
+    }
+}
+
+function selectTorchIndexUrl(cudaVersion) {
+    if (!cudaVersion) return null;
+    const versionValue = cudaVersion.major * 100 + cudaVersion.minor;
+    if (versionValue >= 1204) return 'https://download.pytorch.org/whl/cu124';
+    if (versionValue >= 1201) return 'https://download.pytorch.org/whl/cu121';
+    if (versionValue >= 1108) return 'https://download.pytorch.org/whl/cu118';
+    return null;
+}
+
+function createRequirementsWithoutTorch(requirementsFile) {
+    const content = fs.readFileSync(requirementsFile, 'utf8');
+    const filtered = content
+        .split(/\r?\n/)
+        .filter((line) => {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) return true;
+            return !/^torch([<>=!~].*)?$/.test(trimmed);
+        });
+    const filteredPath = path.join(PACKAGE_DIR, '.requirements.no-torch.txt');
+    fs.writeFileSync(filteredPath, filtered.join('\n'));
+    return filteredPath;
+}
+
+// 创建虚拟环境
+async function createVenv(pythonCmd) {
+    const spinner = ora('Creating Python virtual environment...').start();
     const venvPath = path.join(PACKAGE_DIR, '.venv');
 
     try {
@@ -68,24 +102,49 @@ async function createVenv(pythonCmd) {
 }
 
 // 安装 Python 依赖
-async function installDependencies() {
-    const venvPython = getVenvPython();
-    if (!venvPython) {
-        console.error(chalk.red('Virtual environment not found'));
-        return false;
-    }
-
-    const spinner = ora('Installing Python dependencies...').start();
-    const requirementsFile = path.join(PACKAGE_DIR, 'requirements.txt');
-
-    try {
-        execSync(`"${venvPython}" -m pip install -r "${requirementsFile}" -q`, {
-            stdio: 'pipe',
-            timeout: 600000  // 10分钟超时
-        });
-        spinner.succeed('Dependencies installed');
-        return true;
-    } catch (e) {
+async function installDependencies() {
+    const venvPython = getVenvPython();
+    if (!venvPython) {
+        console.error(chalk.red('Virtual environment not found'));
+        return false;
+    }
+
+    const spinner = ora('Installing Python dependencies...').start();
+    const requirementsFile = path.join(PACKAGE_DIR, 'requirements.txt');
+    const cudaVersion = detectCudaVersion();
+    const torchIndexUrl = selectTorchIndexUrl(cudaVersion);
+
+    try {
+        if (cudaVersion && !torchIndexUrl) {
+            console.log(chalk.yellow(`检测到 CUDA ${cudaVersion.major}.${cudaVersion.minor}，无匹配的 PyTorch 版本，将安装 CPU 版。`));
+        }
+        if (torchIndexUrl) {
+            execSync(`"${venvPython}" -m pip install torch --index-url "${torchIndexUrl}" --upgrade --force-reinstall -q`, {
+                stdio: 'pipe',
+                timeout: 600000  // 10分钟超时
+            });
+        } else {
+            execSync(`"${venvPython}" -m pip install "torch>=2.0.0" -q`, {
+                stdio: 'pipe',
+                timeout: 600000  // 10分钟超时
+            });
+        }
+
+        const filteredRequirements = createRequirementsWithoutTorch(requirementsFile);
+        try {
+            execSync(`"${venvPython}" -m pip install -r "${filteredRequirements}" -q`, {
+                stdio: 'pipe',
+                timeout: 600000  // 10分钟超时
+            });
+        } finally {
+            if (fs.existsSync(filteredRequirements)) {
+                fs.unlinkSync(filteredRequirements);
+            }
+        }
+
+        spinner.succeed('Dependencies installed');
+        return true;
+    } catch (e) {
         spinner.fail('Failed to install dependencies');
         console.error(chalk.red(e.message));
         return false;
@@ -93,24 +152,24 @@ async function installDependencies() {
 }
 
 // 运行 Python CLI
-function runPythonCLI(args) {
-    let pythonCmd = getVenvPython() || findPython();
-
-    if (!pythonCmd) {
-        console.error(chalk.red('Python 3.9+ not found!'));
-        console.log(chalk.yellow('Please install Python 3.9 or higher:'));
-        console.log('  - Windows: https://www.python.org/downloads/');
-        console.log('  - macOS: brew install python@3.11');
-        console.log('  - Linux: sudo apt install python3.11');
-        process.exit(1);
-    }
-
-    const cliPath = path.join(PACKAGE_DIR, 'cli.py');
-
-    const proc = spawn(pythonCmd, [cliPath, ...args], {
-        stdio: 'inherit',
-        cwd: process.cwd()
-    });
+function runPythonCLI(args, pythonCmd) {
+    const resolvedCmd = pythonCmd || getVenvPython() || findPython();
+
+    if (!resolvedCmd) {
+        console.error(chalk.red('Python 3.9+ not found!'));
+        console.log(chalk.yellow('Please install Python 3.9 or higher:'));
+        console.log('  - Windows: https://www.python.org/downloads/');
+        console.log('  - macOS: brew install python@3.11');
+        console.log('  - Linux: sudo apt install python3.11');
+        process.exit(1);
+    }
+
+    const cliPath = path.join(PACKAGE_DIR, 'cli.py');
+
+    const proc = spawn(resolvedCmd, [cliPath, ...args], {
+        stdio: 'inherit',
+        cwd: process.cwd()
+    });
 
     proc.on('close', (code) => {
         process.exit(code);
@@ -123,99 +182,195 @@ function runPythonCLI(args) {
 }
 
 // 初始化检查
-async function ensureSetup() {
-    const venvPython = getVenvPython();
-
-    if (!venvPython) {
-        console.log(chalk.cyan('First time setup detected. Setting up environment...\n'));
-
-        const pythonCmd = findPython();
-        if (!pythonCmd) {
-            console.error(chalk.red('Python 3.9+ is required but not found!'));
-            console.log(chalk.yellow('\nPlease install Python:'));
-            console.log('  - Windows: https://www.python.org/downloads/');
-            console.log('  - macOS: brew install python@3.11');
-            console.log('  - Linux: sudo apt install python3.11');
-            process.exit(1);
-        }
-
-        console.log(chalk.green(`Found Python: ${pythonCmd}`));
-
-        if (!await createVenv(pythonCmd)) {
-            process.exit(1);
-        }
-
-        if (!await installDependencies()) {
-            process.exit(1);
-        }
-
-        console.log(chalk.green('\n✓ Setup complete!\n'));
-    }
-}
 
 // 主程序
-const program = new Command();
-
-program
-    .name('gpu-worker')
-    .description('分布式GPU推理 Worker 节点')
-    .version('1.0.0');
-
-program
-    .command('install')
-    .description('安装/更新 Python 依赖')
-    .action(async () => {
-        await ensureSetup();
-        await installDependencies();
-    });
-
-program
-    .command('configure')
-    .description('交互式配置向导')
-    .action(async () => {
-        await ensureSetup();
-        runPythonCLI(['configure']);
-    });
-
-program
-    .command('start')
-    .description('启动 Worker')
-    .option('-c, --config <path>', '配置文件路径', 'config.yaml')
-    .action(async (options) => {
-        await ensureSetup();
+async function ensureSetup(options = {}) {
+    const allowPrompt = Boolean(options.allowPrompt);
+    let useSystemPython = Boolean(options.useSystemPython);
+    let skipInstall = Boolean(options.skipInstall);
+
+    if (useSystemPython) {
+        const pythonCmd = findPython();
+        if (!pythonCmd) {
+            console.error(chalk.red('Python 3.9+ is required but not found!'));
+            console.log(chalk.yellow('\nPlease install Python:'));
+            console.log('  - Windows: https://www.python.org/downloads/');
+            console.log('  - macOS: brew install python@3.11');
+            console.log('  - Linux: sudo apt install python3.11');
+            process.exit(1);
+        }
+
+        console.log(chalk.green(`Using system Python: ${pythonCmd}`));
+        return { pythonCmd, useSystemPython: true };
+    }
+
+    let venvPython = getVenvPython();
+    let createdVenv = false;
+
+    if (!venvPython) {
+        if (allowPrompt) {
+            const { mode } = await inquirer.prompt([{
+                type: 'list',
+                name: 'mode',
+                message: '未检测到虚拟环境，请选择运行方式:',
+                choices: [
+                    { name: '使用系统 Python（跳过虚拟环境与依赖安装）', value: 'system' },
+                    { name: '创建虚拟环境并安装依赖（推荐）', value: 'venv' },
+                    { name: '创建虚拟环境但跳过依赖安装', value: 'venv-skip-install' }
+                ]
+            }]);
+
+            if (mode === 'system') {
+                useSystemPython = true;
+                const pythonCmd = findPython();
+                if (!pythonCmd) {
+                    console.error(chalk.red('Python 3.9+ is required but not found!'));
+                    console.log(chalk.yellow('\nPlease install Python:'));
+                    console.log('  - Windows: https://www.python.org/downloads/');
+                    console.log('  - macOS: brew install python@3.11');
+                    console.log('  - Linux: sudo apt install python3.11');
+                    process.exit(1);
+                }
+
+                console.log(chalk.green(`Using system Python: ${pythonCmd}`));
+                return { pythonCmd, useSystemPython: true };
+            }
+
+            if (mode === 'venv-skip-install') {
+                skipInstall = true;
+            }
+        }
+
+        console.log(chalk.cyan('First time setup detected. Setting up environment...\n'));
+
+        const pythonCmd = findPython();
+        if (!pythonCmd) {
+            console.error(chalk.red('Python 3.9+ is required but not found!'));
+            console.log(chalk.yellow('\nPlease install Python:'));
+            console.log('  - Windows: https://www.python.org/downloads/');
+            console.log('  - macOS: brew install python@3.11');
+            console.log('  - Linux: sudo apt install python3.11');
+            process.exit(1);
+        }
+
+        console.log(chalk.green(`Found Python: ${pythonCmd}`));
+
+        if (!await createVenv(pythonCmd)) {
+            process.exit(1);
+        }
+
+        createdVenv = true;
+        venvPython = getVenvPython();
+    }
+
+    if (createdVenv && !skipInstall) {
+        if (!await installDependencies()) {
+            process.exit(1);
+        }
+
+        console.log(chalk.green('\nSetup complete!\n'));
+    }
+
+    return { pythonCmd: venvPython || findPython(), useSystemPython: false };
+}
+
+function addCommonOptions(command) {
+    return command
+        .option('--use-system-python', '使用系统 Python（跳过虚拟环境与依赖安装）')
+        .option('--skip-install', '跳过依赖安装，仅使用已有环境');
+}
+
+const program = new Command();
+
+program
+    .name('gpu-worker')
+    .description('分布式GPU推理 Worker 节点')
+    .version('1.0.0')
+    .option('--use-system-python', '使用系统 Python（跳过虚拟环境与依赖安装）')
+    .option('--skip-install', '跳过依赖安装，仅使用已有环境');
+
+addCommonOptions(
+    program
+        .command('install')
+)
+    .description('安装/更新 Python 依赖')
+    .action(async function () {
+        const opts = { ...program.opts(), ...this.opts() };
+        if (opts.useSystemPython) {
+            console.log(chalk.yellow('install 仅针对虚拟环境，系统 Python 请自行安装依赖。'));
+            return;
+        }
+        await ensureSetup({ ...opts, useSystemPython: false, skipInstall: true, allowPrompt: false });
+        await installDependencies();
+    });
+
+addCommonOptions(
+    program
+        .command('configure')
+)
+    .description('交互式配置向导')
+    .action(async function () {
+        const opts = { ...program.opts(), ...this.opts() };
+        const setup = await ensureSetup({ ...opts, allowPrompt: false });
+        runPythonCLI(['configure'], setup.pythonCmd);
+    });
+
+addCommonOptions(
+    program
+        .command('start')
+)
+    .description('启动 Worker')
+    .option('-c, --config <path>', '配置文件路径', 'config.yaml')
+    .action(async function () {
+        const cmdOpts = this.opts();
+        const opts = { ...program.opts(), ...cmdOpts };
+        const setup = await ensureSetup({ ...opts, allowPrompt: false });
 
         // 检查配置文件
-        const configPath = path.resolve(options.config);
+        const configPath = path.resolve(cmdOpts.config);
         if (!fs.existsSync(configPath)) {
             console.log(chalk.yellow('No config file found. Starting configuration wizard...\n'));
-            runPythonCLI(['configure']);
+            runPythonCLI(['configure'], setup.pythonCmd);
             return;
         }
 
-        runPythonCLI(['start', '-c', configPath]);
-    });
-
-program
-    .command('status')
-    .description('查看状态')
-    .action(async () => {
-        await ensureSetup();
-        runPythonCLI(['status']);
-    });
-
-program
-    .command('set <key> <value>')
-    .description('设置配置项')
-    .action(async (key, value) => {
-        await ensureSetup();
-        runPythonCLI(['set', key, value]);
+        runPythonCLI(['start', '-c', configPath], setup.pythonCmd);
     });
 
-program
-    .command('setup')
-    .description('初始化环境（创建虚拟环境并安装依赖）')
-    .action(async () => {
-        const pythonCmd = findPython();
+addCommonOptions(
+    program
+        .command('status')
+)
+    .description('查看状态')
+    .action(async function () {
+        const opts = { ...program.opts(), ...this.opts() };
+        const setup = await ensureSetup({ ...opts, allowPrompt: false });
+        runPythonCLI(['status'], setup.pythonCmd);
+    });
+
+addCommonOptions(
+    program
+        .command('set <key> <value>')
+)
+    .description('设置配置项')
+    .action(async function (key, value) {
+        const opts = { ...program.opts(), ...this.opts() };
+        const setup = await ensureSetup({ ...opts, allowPrompt: false });
+        runPythonCLI(['set', key, value], setup.pythonCmd);
+    });
+
+addCommonOptions(
+    program
+        .command('setup')
+)
+    .description('初始化环境（创建虚拟环境并安装依赖）')
+    .action(async function () {
+        const opts = { ...program.opts(), ...this.opts() };
+        if (opts.useSystemPython) {
+            console.log(chalk.yellow('setup 仅用于虚拟环境，系统 Python 请自行安装依赖。'));
+            return;
+        }
+        const pythonCmd = findPython();
         if (!pythonCmd) {
             console.error(chalk.red('Python 3.9+ not found!'));
             process.exit(1);
@@ -224,8 +379,10 @@ program
         console.log(chalk.cyan('Setting up GPU Worker environment...\n'));
         console.log(chalk.green(`Python: ${pythonCmd}`));
 
-        await createVenv(pythonCmd);
-        await installDependencies();
+        await createVenv(pythonCmd);
+        if (!opts.skipInstall) {
+            await installDependencies();
+        }
 
         console.log(chalk.green('\n✓ Setup complete!'));
         console.log(chalk.cyan('\nNext steps:'));
@@ -234,10 +391,13 @@ program
     });
 
 // 快速启动命令 (无参数时的默认行为)
-program
-    .command('quick', { isDefault: true, hidden: true })
-    .action(async () => {
-        await ensureSetup();
+addCommonOptions(
+    program
+        .command('quick', { isDefault: true, hidden: true })
+)
+    .action(async function () {
+        const opts = { ...program.opts(), ...this.opts() };
+        const setup = await ensureSetup({ ...opts, allowPrompt: true });
 
         console.log(chalk.cyan.bold('\n  GPU Worker - 分布式GPU推理节点\n'));
 
@@ -264,12 +424,12 @@ program
             const configPath = path.join(process.cwd(), 'config.yaml');
             if (!fs.existsSync(configPath)) {
                 console.log(chalk.yellow('\n未找到配置文件，先进行配置...\n'));
-                runPythonCLI(['configure']);
+                runPythonCLI(['configure'], setup.pythonCmd);
                 return;
             }
         }
 
-        runPythonCLI([action]);
+        runPythonCLI([action], setup.pythonCmd);
     });
 
 program.parse();

package/cli.py

@@ -5,11 +5,12 @@ GPU Worker CLI 安装器和配置向导
 """
 import os
 import sys
-import argparse
-import subprocess
-import platform
-import shutil
-from pathlib import Path
+import argparse
+import subprocess
+import platform
+import shutil
+import re
+from pathlib import Path
 from typing import Optional, Dict, Any, List
 import json
 import time
@@ -73,13 +74,91 @@ def clear_screen():
     os.system('cls' if platform.system() == 'Windows' else 'clear')
 
 
-def check_gpu():
-    """检测GPU信息"""
+def _probe_nvidia_smi() -> Optional[Dict[str, Any]]:
+    """通过 nvidia-smi 获取 GPU 信息（无 PyTorch 时的兜底）"""
+    try:
+        result = subprocess.run(
+            ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader,nounits"],
+            capture_output=True,
+            text=True
+        )
+        if result.returncode != 0:
+            return None
+
+        lines = [line.strip() for line in result.stdout.splitlines() if line.strip()]
+        if not lines:
+            return None
+
+        first = [part.strip() for part in lines[0].split(",")]
+        model = first[0] if first else "Unknown"
+        memory_gb = 0
+        if len(first) > 1:
+            try:
+                memory_gb = round(float(first[1]) / 1024, 1)
+            except ValueError:
+                memory_gb = 0
+
+        return {
+            "count": len(lines),
+            "model": model,
+            "memory_gb": memory_gb
+        }
+    except Exception:
+        return None
+
+
+def _detect_cuda_version() -> Optional[Dict[str, int]]:
+    """从 nvidia-smi 输出中解析 CUDA 版本"""
+    try:
+        result = subprocess.run(
+            ["nvidia-smi"],
+            capture_output=True,
+            text=True
+        )
+        if result.returncode != 0:
+            return None
+
+        match = re.search(r"CUDA Version:\\s*(\\d+)\\.(\\d+)", result.stdout)
+        if not match:
+            return None
+
+        return {
+            "major": int(match.group(1)),
+            "minor": int(match.group(2))
+        }
+    except Exception:
+        return None
+
+
+def _select_torch_index_url(cuda_version: Optional[Dict[str, int]]) -> Optional[str]:
+    """根据 CUDA 版本选择 PyTorch 安装源"""
+    if not cuda_version:
+        return None
+
+    major = cuda_version["major"]
+    minor = cuda_version["minor"]
+    version_value = major * 100 + minor
+
+    if version_value >= 1204:
+        return "https://download.pytorch.org/whl/cu124"
+    if version_value >= 1201:
+        return "https://download.pytorch.org/whl/cu121"
+    if version_value >= 1108:
+        return "https://download.pytorch.org/whl/cu118"
+    return None
+
+
+def check_gpu():
+    """检测GPU信息"""
     gpu_info = {
         "available": False,
         "count": 0,
         "model": "Unknown",
-        "memory_gb": 0
+        "memory_gb": 0,
+        "nvidia_detected": False,
+        "nvidia_model": None,
+        "nvidia_memory_gb": None,
+        "nvidia_count": 0
     }
 
     try:
@@ -93,14 +172,22 @@ def check_gpu():
     except ImportError:
         pass
 
+    if not gpu_info["available"]:
+        nvidia_info = _probe_nvidia_smi()
+        if nvidia_info:
+            gpu_info["nvidia_detected"] = True
+            gpu_info["nvidia_count"] = nvidia_info["count"]
+            gpu_info["nvidia_model"] = nvidia_info["model"]
+            gpu_info["nvidia_memory_gb"] = nvidia_info["memory_gb"]
+
     return gpu_info
 
 
-def check_dependencies() -> Dict[str, bool]:
-    """检查依赖"""
-    deps = {
-        "python": sys.version_info >= (3, 9),
-        "torch": False,
+def check_dependencies() -> Dict[str, bool]:
+    """检查依赖"""
+    deps = {
+        "python": sys.version_info >= (3, 9),
+        "torch": False,
         "transformers": False,
         "cuda": False
     }
@@ -118,37 +205,75 @@ def check_dependencies() -> Dict[str, bool]:
     except ImportError:
         pass
 
-    return deps
-
-
-def install_dependencies(progress_callback=None):
-    """安装依赖"""
-    requirements = [
-        "torch>=2.0.0",
-        "transformers>=4.35.0",
+    return deps
+
+
+def _pip_install(
+    requirement: str,
+    progress_callback=None,
+    index_url: Optional[str] = None,
+    extra_args: Optional[List[str]] = None
+):
+    if progress_callback:
+        progress_callback(f"Installing {requirement}...")
+
+    command = [sys.executable, "-m", "pip", "install", requirement]
+    if index_url:
+        command.extend(["--index-url", index_url])
+    if extra_args:
+        command.extend(extra_args)
+
+    result = subprocess.run(
+        command,
+        capture_output=True,
+        text=True
+    )
+
+    if result.returncode != 0:
+        raise Exception(f"Failed to install {requirement}: {result.stderr}")
+
+
+def install_dependencies(progress_callback=None):
+    """安装依赖"""
+    requirements = [
+        "torch>=2.0.0",
+        "transformers>=4.35.0",
         "diffusers>=0.24.0",
         "accelerate>=0.24.0",
         "peft>=0.6.0",
         "bitsandbytes>=0.41.0",
         "httpx>=0.25.0",
         "pyyaml>=6.0",
-        "pydantic>=2.0.0",
-        "fastapi>=0.100.0",
-        "uvicorn>=0.23.0"
-    ]
-
-    for req in requirements:
-        if progress_callback:
-            progress_callback(f"Installing {req}...")
-
-        result = subprocess.run(
-            [sys.executable, "-m", "pip", "install", req],
-            capture_output=True,
-            text=True
-        )
-
-        if result.returncode != 0:
-            raise Exception(f"Failed to install {req}: {result.stderr}")
+        "pydantic>=2.0.0",
+        "fastapi>=0.100.0",
+        "uvicorn>=0.23.0"
+    ]
+
+    cuda_version = _detect_cuda_version()
+    torch_index_url = _select_torch_index_url(cuda_version)
+
+    if torch_index_url:
+        _pip_install(
+            "torch",
+            progress_callback,
+            index_url=torch_index_url,
+            extra_args=["--upgrade", "--force-reinstall"]
+        )
+    else:
+        if cuda_version and progress_callback:
+            progress_callback(
+                f"检测到 CUDA {cuda_version['major']}.{cuda_version['minor']}，"
+                "无匹配的 PyTorch 版本，将安装 CPU 版"
+            )
+        _pip_install("torch>=2.0.0", progress_callback)
+
+    non_torch_requirements = [
+        item for item in requirements
+        if not re.match(r"^torch([<>=!~].*)?$", item.strip())
+    ]
+
+    for req in non_torch_requirements:
+        _pip_install(req, progress_callback)
 
 
 def save_config(config: Dict[str, Any], path: str = CONFIG_FILE):
@@ -317,10 +442,25 @@ class ConfigWizard:
                 'enable_cpu_offload': gpu_info['memory_gb'] < 16
             }
         else:
-            if RICH_AVAILABLE:
-                console.print("[yellow]未检测到 GPU，将使用 CPU 模式（性能有限）[/yellow]")
+            nvidia_memory_gb = gpu_info.get("nvidia_memory_gb")
+            if gpu_info.get("nvidia_detected"):
+                if RICH_AVAILABLE:
+                    console.print("[yellow]检测到 NVIDIA GPU，但 CUDA 版 PyTorch 不可用，将使用 CPU 模式（性能有限）[/yellow]")
+                    console.print(f"  型号: {gpu_info.get('nvidia_model', 'Unknown')}")
+                    if nvidia_memory_gb:
+                        console.print(f"  显存: {nvidia_memory_gb} GB")
+                    console.print("[yellow]请安装 CUDA 版 PyTorch（例如：python -m pip install torch --index-url https://download.pytorch.org/whl/cu121）[/yellow]")
+                else:
+                    print("检测到 NVIDIA GPU，但 CUDA 版 PyTorch 不可用，将使用 CPU 模式（性能有限）")
+                    print(f"  型号: {gpu_info.get('nvidia_model', 'Unknown')}")
+                    if nvidia_memory_gb:
+                        print(f"  显存: {nvidia_memory_gb} GB")
+                    print("请安装 CUDA 版 PyTorch（例如：python -m pip install torch --index-url https://download.pytorch.org/whl/cu121）")
             else:
-                print("未检测到 GPU，将使用 CPU 模式（性能有限）")
+                if RICH_AVAILABLE:
+                    console.print("[yellow]未检测到 GPU，将使用 CPU 模式（性能有限）[/yellow]")
+                else:
+                    print("未检测到 GPU，将使用 CPU 模式（性能有限）")
 
             self.config['gpu'] = {
                 'model': 'CPU',
@@ -628,9 +768,17 @@ def cmd_status(args):
 
     # GPU信息
     gpu_info = check_gpu()
-    print(f"\nGPU: {gpu_info['model'] if gpu_info['available'] else '未检测到'}")
     if gpu_info['available']:
+        print(f"\nGPU: {gpu_info['model']}")
         print(f"显存: {gpu_info['memory_gb']} GB")
+    elif gpu_info.get("nvidia_detected"):
+        nvidia_memory_gb = gpu_info.get("nvidia_memory_gb")
+        print(f"\nGPU: {gpu_info.get('nvidia_model', 'Unknown')} (驱动可用，PyTorch CUDA 不可用)")
+        if nvidia_memory_gb:
+            print(f"显存: {nvidia_memory_gb} GB")
+        print("建议安装 CUDA 版 PyTorch（例如：python -m pip install torch --index-url https://download.pytorch.org/whl/cu121）")
+    else:
+        print("\nGPU: 未检测到")
 
     # 配置信息
     print(f"\n配置:")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gpu-worker",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Distributed GPU Inference Worker - Share idle GPU computing power for LLM and image generation",
   "keywords": [
     "gpu",
@@ -27,7 +27,7 @@
     "url": "https://github.com/Baozhi888/distributed-gpu-inference/issues"
   },
   "bin": {
-    "gpu-worker": "./bin/gpu-worker.js"
+    "gpu-worker": "bin/gpu-worker.js"
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",