heibai 1.0.8

package/bin/cli.js

@@ -0,0 +1,1140 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { exec, spawn } = require('child_process');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const axios = require('axios');
+const readline = require('readline');
+const os = require('os');
+const crypto = require('crypto');
+const CodeValidator = require('../code-validator');
+
+class AIAssistantSetup {
+    constructor() {
+        this.isWindows = process.platform === 'win32';
+        this.isMac = process.platform === 'darwin';
+        // this.proxyPort = '7890';
+        // this.proxyUrl = '';
+        this.publicIPCache = null;
+    }
+
+    async start() {
+        console.log(chalk.blue.bold('🚀 claude code快速配置工具'));
+        console.log(chalk.gray('支持 Windows/Mac 双平台\n'));
+
+        try {
+            await this.setupProxy();
+            await this.testConnection();
+            // 启动即进入菜单（不自动登录/不静默配置）
+            const mode = await this.promptMode();
+            if (mode === '2') {
+                await this.handleLoginMode();
+                return;
+            } else if (mode === '3') {
+                await this.handleInstallClaudeCode();
+                return;
+            } else if (mode === '4') {
+                await this.handleClaudeCodeConfig();
+                return;
+            } else if (mode === '5') {
+                console.log(chalk.green('已退出'));
+                process.exit(0);
+            }
+
+            const ma = await this.promptExchangeCode();
+            const validator = new CodeValidator();
+            console.log(chalk.yellow('正在验证兑换码...'));
+            const verifyResult = await validator.validateCode(ma);
+            if (!verifyResult.valid) {
+                throw new Error(verifyResult.message);
+            }
+            this.exchangeCode = ma;
+            this.codeObjectId = verifyResult.data.objectId;
+            console.log(chalk.green(`✅ ${verifyResult.message}`));
+            if (verifyResult.data) {
+                const expireTime = verifyResult.data.expireTime;
+                console.log(chalk.gray(`   过期时间: ${expireTime.toLocaleString('zh-CN', {
+                    year: 'numeric',
+                    month: '2-digit', 
+                    day: '2-digit',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit'
+                })}`));
+                console.log(chalk.gray(`   使用次数: ${verifyResult.data.usageCount}`));
+                
+                // 上传机器码和IP信息
+                await this.uploadMachineInfo(verifyResult.data.objectId);
+            }
+            console.log('');
+
+            await this.checkNodeVersion();
+            await this.installAIService();
+            await this.startAIService();
+        } catch (error) {
+            console.error(chalk.red('❌ 设置失败:'), error.message);
+            process.exit(1);
+        }
+    }
+
+    // 1.0.7无静默配置逻辑
+
+    async promptExchangeCode() {
+        const cached = this.loadCachedCode();
+        const currentVersion = this.getPackageVersion();
+        
+        // 如果有缓存的兑换码，询问是否使用
+        if (cached && cached.exchangeCode && cached.scriptVersion === currentVersion) {
+            console.log(chalk.cyan('🔐 检测到上次保存的兑换码'));
+            console.log(chalk.yellow(`   兑换码: ${cached.exchangeCode.trim()}`));
+            
+            const useChoice = await inquirer.prompt([
+                {
+                    type: 'rawlist',
+                    name: 'choice',
+                    message: '请选择操作',
+                    choices: [
+                        { name: '1 使用上次保存的兑换码', value: '1' },
+                        { name: '2 重新输入兑换码', value: '2' }
+                    ],
+                    default: 0
+                }
+            ]);
+            
+            if (useChoice.choice === '1') {
+                console.log(chalk.green('✅ 使用缓存的兑换码'));
+                return cached.exchangeCode.trim();
+            }
+        }
+        
+        // 输入新的兑换码
+        console.log(chalk.cyan('🔐 请输入兑换码验证使用权限'));
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'ma',
+                message: '兑换码:',
+                validate: function(input) {
+                    if (!input || input.trim().length === 0) {
+                        return '兑换码不能为空';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        const ma = answers.ma.trim();
+        this.saveCachedCode({ exchangeCode: ma, scriptVersion: currentVersion });
+        return ma;
+    }
+
+    async promptMode() {
+        const answers = await inquirer.prompt([
+            {
+                type: 'rawlist',
+                name: 'mode',
+                message: '请选择模式（可直接按 1/2/3/4/5）',
+                choices: [
+                    { name: '1 快捷模式', value: '1' },
+                    { name: '2 登陆模式', value: '2' },
+                    { name: '3 安装 Claude Code', value: '3' },
+                    { name: '4 配置 Claude Code key', value: '4' },
+                    { name: '5 退出程序', value: '5' }
+                ],
+                default: 0
+            }
+        ]);
+        return answers.mode;
+    }
+
+    async handleInstallClaudeCode() {
+        const env = { ...process.env };
+        if (this.proxyUrl) {
+            env.HTTP_PROXY = this.proxyUrl;
+            env.HTTPS_PROXY = this.proxyUrl;
+        }
+        const tryExec = (cmd) => new Promise((resolve) => {
+            exec(cmd, { env, shell: true }, (err, stdout) => {
+                if (err) return resolve(null);
+                resolve((stdout || '').toString().trim());
+            });
+        });
+        const showVersion = async () => {
+            let ver = await tryExec('claude -v');
+            if (!ver && process.platform === 'win32') {
+                ver = await tryExec('npx win-claude-code@latest -v');
+            }
+            if (ver) {
+                console.log(chalk.green(`已安装: ${ver}`));
+                return true;
+            }
+            return false;
+        };
+        if (await showVersion()) return;
+        console.log(chalk.yellow('正在安装 Claude Code...'));
+        if (process.platform === 'win32') {
+            await new Promise((resolve, reject) => {
+                const p = spawn('npm', ['install', '-g', '@anthropic-ai/claude-code', '--ignore-scripts'], { stdio: 'inherit', env, shell: true });
+                p.on('close', code => code === 0 ? resolve() : reject(new Error('安装失败')));
+                p.on('error', reject);
+            });
+        } else {
+            let command = 'npm';
+            if (process.platform === 'darwin') {
+                try { require('child_process').execSync('which /opt/homebrew/bin/npm', { stdio: 'ignore' }); command = '/opt/homebrew/bin/npm'; } catch {}
+                try { if (command === 'npm') { require('child_process').execSync('which /usr/local/bin/npm', { stdio: 'ignore' }); command = '/usr/local/bin/npm'; } } catch {}
+            }
+            await new Promise((resolve, reject) => {
+                const p = spawn(command, ['install', '-g', '@anthropic-ai/claude-code'], { stdio: 'inherit', env });
+                p.on('close', code => code === 0 ? resolve() : reject(new Error('安装失败')));
+                p.on('error', reject);
+            });
+        }
+        const ver = await tryExec('claude -v') || await tryExec('npx win-claude-code@latest -v') || '';
+        if (ver) {
+            console.log(chalk.green(`安装成功 版本号 ${ver}`));
+        } else {
+            console.log(chalk.green('安装成功'));
+        }
+    }
+
+    async handleClaudeCodeConfig() {
+        console.log(chalk.blue.bold('🔧 配置 Claude Code'));
+        console.log(chalk.gray('支持 Windows/Mac/Linux 平台配置\n'));
+
+        try {
+            // 第一步：验证兑换码（参考模式1的逻辑）
+            const ma = await this.promptExchangeCode();
+            const validator = new CodeValidator();
+            console.log(chalk.yellow('正在验证兑换码...'));
+            const verifyResult = await validator.validateCode(ma);
+            
+            if (!verifyResult.valid) {
+                throw new Error(verifyResult.message);
+            }
+            
+            this.exchangeCode = ma;
+            this.codeObjectId = verifyResult.data.objectId;
+            console.log(chalk.green(`✅ ${verifyResult.message}`));
+            
+            if (verifyResult.data) {
+                const expireTime = verifyResult.data.expireTime;
+                console.log(chalk.gray(`   过期时间: ${expireTime.toLocaleString('zh-CN', {
+                    year: 'numeric',
+                    month: '2-digit', 
+                    day: '2-digit',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit'
+                })}`));
+                console.log(chalk.gray(`   使用次数: ${verifyResult.data.usageCount}`));
+                
+                // 上传机器码和IP信息
+                await this.uploadMachineInfo(verifyResult.data.objectId);
+            }
+            console.log('');
+            
+            // 第二步：检查URL和key参数
+            const apiUrl = verifyResult.data.url;
+            const apiKey = verifyResult.data.key;
+            
+            // 检查URL是否为空
+            if (!apiUrl || apiUrl.trim().length === 0) {
+                console.log(chalk.red('❌ 你暂无权限，联系客服'));
+                await this.waitForKeyPress();
+                return;
+            }
+            
+            // 检查key是否为空
+            if (!apiKey || apiKey.trim().length === 0) {
+                console.log(chalk.red('❌ 密钥未配置，请联系客服'));
+                await this.waitForKeyPress();
+                return;
+            }
+            
+            console.log(chalk.green(`✅ 获取到API配置信息`));
+            console.log(chalk.gray(`   API地址: ${apiUrl}`));
+            console.log(chalk.gray(`   API密钥: ${apiKey.substring(0, 8)}...`));
+            
+            // 第三步：配置 Claude Code settings（使用数据库的URL和key）
+            await this.writeClaudeCodeSettings(apiKey, apiUrl);
+            
+            console.log(chalk.green('✅ Claude Code 配置完成！'));
+            console.log(chalk.blue('现在您可以使用 claude 命令开始使用 Claude Code'));
+        } catch (error) {
+            console.error(chalk.red('❌ 配置失败:'), error.message);
+            throw error;
+        }
+    }
+
+    async writeClaudeCodeSettings(apiKey, apiUrl, silent=false) {
+        const os = require('os');
+        const isWindows = process.platform === 'win32';
+        const isMac = process.platform === 'darwin';
+        const isLinux = process.platform === 'linux';
+
+        // 规范化 URL：确保以 /anthropic 结尾，移除多余斜杠
+        const inputUrl = (apiUrl || "https://e5c32534bbce.ngrok-free.app/anthropic").trim();
+        const withoutTrailingSlash = inputUrl.replace(/\/$/, '');
+        const baseUrl = /\/anthropic$/.test(withoutTrailingSlash)
+            ? withoutTrailingSlash
+            : `${withoutTrailingSlash}/anthropic`;
+
+        const trimmedKey = (apiKey || '').trim();
+
+        const config = {
+            "env": {
+                "ANTHROPIC_BASE_URL": baseUrl,
+                "ANTHROPIC_API_KEY": trimmedKey,
+                "ANTHROPIC_AUTH_TOKEN": trimmedKey
+            }
+        };
+
+        try {
+            const configDir = path.join(os.homedir(), '.claude');
+            const configFile = path.join(configDir, 'settings.json');
+            
+            // 创建目录（如果不存在）
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            
+            // 写入配置文件
+            fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+            
+            if (!silent) {
+                if (isWindows) {
+                    console.log(chalk.blue(`📝 Windows 配置已保存到: ${configFile}`));
+                } else if (isMac) {
+                    console.log(chalk.blue(`📝 Mac 配置已保存到: ${configFile}`));
+                } else if (isLinux) {
+                    console.log(chalk.blue(`📝 Linux 配置已保存到: ${configFile}`));
+                } else {
+                    console.log(chalk.blue(`📝 配置已保存到: ${configFile}`));
+                }
+                console.log(chalk.gray('配置内容:'));
+                console.log(chalk.gray(`  ANTHROPIC_BASE_URL: ${config.env.ANTHROPIC_BASE_URL}`));
+                if (trimmedKey) console.log(chalk.gray(`  ANTHROPIC_API_KEY: ${trimmedKey.substring(0, 8)}...`));
+            }
+            
+        } catch (error) {
+            console.error(chalk.red('❌ 写入配置文件失败:'), error.message);
+            throw error;
+        }
+    }
+
+    async checkCopilotApiInstalled() {
+        console.log(chalk.yellow('🔍 检查 copilot-api 是否已安装...'));
+        
+        return new Promise((resolve, reject) => {
+            // 直接尝试运行 copilot-api 命令来检测
+            const testProcess = exec('copilot-api', {
+                env: { ...process.env },
+                shell: true
+            }, (error, stdout, stderr) => {
+                // 检查输出是否包含 copilot-api 相关信息
+                const allOutput = (stdout + stderr).toLowerCase();
+                if (allOutput.includes('usage') || 
+                    allOutput.includes('copilot-api') ||
+                    allOutput.includes('commands') ||
+                    allOutput.includes('auth') ||
+                    allOutput.includes('start') ||
+                    allOutput.includes('no command specified')) {
+                    console.log(chalk.green('✅ 黑白已安装'));
+                    resolve();
+                } else if (error && (error.code === 'ENOENT' || error.message.includes('not found'))) {
+                    console.log(chalk.red('❌ 黑白未找到，请先安装'));
+                    console.log(chalk.gray('提示: 请运行 npm install -g @copilot-api/copilot-api 或 npm install -g copilot-api 来安装'));
+                    reject(new Error('copilot-api 未安装或不在PATH中'));
+                } else {
+                    // 其他错误，但能执行说明命令存在
+                    console.log(chalk.green('✅ 黑白已安装'));
+                    resolve();
+                }
+            });
+            
+            // 3秒超时
+            setTimeout(() => {
+                testProcess.kill();
+                console.log(chalk.green('✅ 黑白已安装'));
+                resolve();
+            }, 3000);
+        });
+    }
+
+    async handleLoginMode() {
+        console.log(chalk.blue.bold('🚀 启动 黑白登录模式'));
+        
+        try {
+            // 检查 copilot-api 是否安装
+           // await this.checkCopilotApiInstalled();
+            
+            const spawnOptions = { 
+                env: { ...process.env },
+                shell: true  // 在 Windows 上需要 shell: true
+            };
+            if (this.proxyUrl) {
+                spawnOptions.env.HTTP_PROXY = this.proxyUrl;
+                spawnOptions.env.HTTPS_PROXY = this.proxyUrl;
+            }
+            
+            console.log(chalk.gray('正在启动 黑白...'));
+            console.log(chalk.blue('正在启动认证流程...'));
+            await new Promise((resolve, reject) => {
+                const p = spawn('copilot-api', ['auth'], spawnOptions);
+                p.stdout.on('data', d => {
+                    const text = d.toString();
+                    process.stdout.write(text);
+                    const codeMatch = text.match(/code\s+"([A-Z0-9-]+)"/i);
+                    const urlMatch = text.match(/https?:\/\/[^\s]+/i);
+                    if (codeMatch) {
+                        console.log(chalk.green.bold(`\n🎉 验证码: ${codeMatch[1]}`));
+                    }
+                });
+                p.stderr.on('data', d => process.stderr.write(d.toString()));
+                p.on('error', err => reject(err));
+                p.on('close', () => resolve());
+            });
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    getPackageVersion() {
+        try {
+            const pkgPath = path.join(__dirname, '..', 'package.json');
+            const raw = fs.readFileSync(pkgPath, 'utf8');
+            const pkg = JSON.parse(raw);
+            return pkg.version || '0.0.0';
+        } catch (e) {
+            return '0.0.0';
+        }
+    }
+
+    loadCachedCode() {
+        try {
+            const os = require('os');
+            const dir = path.join(os.homedir(), '.claude');
+            const file = path.join(dir, 'code_cache.json');
+            if (fs.existsSync(file)) {
+                const raw = fs.readFileSync(file, 'utf8');
+                return JSON.parse(raw);
+            }
+            return null;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    saveCachedCode(data) {
+        try {
+            const os = require('os');
+            const dir = path.join(os.homedir(), '.claude');
+            if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+            const file = path.join(dir, 'code_cache.json');
+            let existing = {};
+            try {
+                if (fs.existsSync(file)) {
+                    existing = JSON.parse(fs.readFileSync(file, 'utf8')) || {};
+                }
+            } catch {}
+            const merged = { ...existing, ...data };
+            fs.writeFileSync(file, JSON.stringify(merged, null, 2));
+        } catch (e) {}
+    }
+
+    async checkNodeVersion() {
+        console.log(chalk.yellow('🔍 检查 Node.js 版本...'));
+        
+        return new Promise((resolve, reject) => {
+            const nodeCmds = ['/opt/homebrew/bin/node', '/usr/local/bin/node', 'node'];
+            const tryNext = (i=0) => {
+                if (i >= nodeCmds.length) {
+                    reject(new Error('Node.js 未安装，请先安装 Node.js >= 18.0'));
+                    return;
+                }
+                exec(`${nodeCmds[i]} --version`, (error, stdout) => {
+                    if (error) {
+                        tryNext(i+1);
+                        return;
+                    }
+                    const version = stdout.trim();
+                    const majorVersion = parseInt(version.replace('v', '').split('.')[0]);
+                    if (majorVersion < 18) {
+                        reject(new Error(`Node.js 版本过低 (${version})，需要 >= 18.0`));
+                        return;
+                    }
+                    console.log(chalk.green(`✅ Node.js 版本: ${version}`));
+                    resolve();
+                });
+            };
+            tryNext();
+        });
+    }
+
+    async setupProxy() {
+        console.log(chalk.yellow('🌐 设置代理...'));
+        // 确保 heibai-api 在此时即已可用（静默处理，不输出）
+        try { await this.ensureHeibaiApiAvailable(); } catch {}
+
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'proxyPort',
+                message: '请输入代理端口 (输入0不使用代理,回车默认7890):',
+                default: '7890',
+                validate: function(input) {
+                    if (input === '0') return true;
+                    const port = parseInt(input);
+                    if (isNaN(port) || port < 1 || port > 65535) {
+                        return '请输入有效的端口号 (1-65535 或 0)';
+                    }
+                    return true;
+                }
+            }
+        ]);
+
+        this.proxyPort = answers.proxyPort;
+        if (this.proxyPort === '0') {
+            this.proxyUrl = '';
+            delete process.env.HTTP_PROXY;
+            delete process.env.HTTPS_PROXY;
+            console.log(chalk.green('✅ 不使用代理'));
+        } else {
+            this.proxyUrl = `http://127.0.0.1:${this.proxyPort}`;
+            process.env.HTTP_PROXY = this.proxyUrl;
+            process.env.HTTPS_PROXY = this.proxyUrl;
+            console.log(chalk.green(`✅ 代理设置完成: ${this.proxyUrl}`));
+        }
+    }
+
+    async testConnection() {
+        console.log(chalk.yellow('🌍 测试网络连接...'));
+
+        try {
+            if (!this.proxyUrl) {
+                console.log(chalk.gray('未使用代理，跳过网络测试'));
+                return;
+            }
+            const proxyUrl = new URL(this.proxyUrl);
+            const response = await axios.get('http://ipinfo.io/json', {
+                proxy: {
+                    protocol: proxyUrl.protocol.slice(0, -1),
+                    host: proxyUrl.hostname,
+                    port: parseInt(proxyUrl.port)
+                },
+                timeout: 10000,
+                headers: {
+                    'User-Agent': 'curl/7.68.0'
+                }
+            });
+
+            try { console.log(JSON.stringify(response.data, null, 2)); } catch {}
+            const ip = response.data.ip;
+            const city = response.data.city;
+            const region = response.data.region;
+            const country = response.data.country;
+            console.log(chalk.blue(`🌐 当前IP: ${ip}`));
+            console.log(chalk.blue(`📍 位置: ${city}, ${region}, ${country}`));
+            // 缓存IP
+            if (ip && typeof ip === 'string') {
+                this.publicIPCache = ip;
+                this.saveCachedCode({ publicIP: ip });
+            }
+            if (country && country !== 'CN') {
+                console.log(chalk.green(`✅ 网络连接正常，代理生效`));
+            } else {
+                console.log(chalk.yellow('⚠️  警告: 当前位置显示为中国，代理可能未生效'));
+                console.log(chalk.gray('建议检查：'));
+                console.log(chalk.gray('1. 代理软件是否正在运行'));
+                console.log(chalk.gray('2. 端口号是否正确'));
+                console.log(chalk.gray('3. 代理协议设置是否正确'));
+                const proceed = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'continue',
+                        message: '是否继续安装？',
+                        default: true
+                    }
+                ]);
+                if (!proceed.continue) {
+                    throw new Error('用户取消安装');
+                }
+            }
+        } catch (error) {
+            if (error.message === '用户取消安装') {
+                throw error;
+            }
+            console.log(chalk.red('❌ 网络连接测试失败'));
+            console.log(chalk.yellow('可能原因：'));
+            console.log(chalk.yellow('1. 网络不可用'));
+            console.log(chalk.yellow('2. 代理设置有误'));
+            console.log(chalk.yellow('3. 防火墙阻止连接'));
+            console.log(chalk.gray('继续安装...'));
+        }
+    }
+
+    async configureModel() {
+        console.log(chalk.yellow.bold('\n🤖 模型配置...\n'));
+        
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'model',
+                message: '要使用什么模型？claude4/gpt5？输入4或5或claude4或gpt5:',
+                default: 'claude4',
+                validate: function(input) {
+                    const validInputs = ['4', '5', 'claude4', 'gpt5'];
+                    if (validInputs.includes(input.toLowerCase())) {
+                        return true;
+                    }
+                    return '请输入: 4、5、claude4 或 gpt5';
+                }
+            }
+        ]);
+
+        const userInput = answers.model.toLowerCase();
+        let anthropicModel;
+        let dbModelValue;
+        
+        // 根据用户输入确定模型
+        if (userInput === '4' || userInput === 'claude4') {
+            anthropicModel = 'claude-sonnet-4';
+            dbModelValue = 'claude4';
+            console.log(chalk.blue('✅ 已选择: Claude 4'));
+        } else if (userInput === '5' || userInput === 'gpt5') {
+            anthropicModel = 'gpt-5';
+            dbModelValue = 'gpt5';
+            console.log(chalk.blue('✅ 已选择: GPT 5'));
+        }
+
+        // 写入配置文件
+        await this.writeClaudeSettings(anthropicModel);
+        
+        // 更新数据库中的模型参数
+        await this.updateDatabaseModel(dbModelValue);
+        
+        // 删除4141端口占用
+        await this.killPort4141();
+        
+        // console.log(chalk.green('✅ 模型配置完成'));
+    }
+
+    async killPort4141() {
+        console.log(chalk.yellow('🔄 清理4141端口...'));
+        
+        return new Promise((resolve) => {
+            const isWindows = process.platform === 'win32';
+            
+            if (isWindows) {
+                // Windows: 查找并杀死占用4141端口的进程
+                exec('netstat -ano | findstr :4141', (error, stdout) => {
+                    if (error || !stdout) {
+                        console.log(chalk.gray('📍 4141端口未被占用'));
+                        resolve();
+                        return;
+                    }
+                    
+                    // 提取PID
+                    const lines = stdout.split('\n');
+                    const pids = new Set();
+                    
+                    lines.forEach(line => {
+                        const match = line.trim().match(/(\d+)\s*$/);
+                        if (match) {
+                            pids.add(match[1]);
+                        }
+                    });
+                    
+                    if (pids.size === 0) {
+                        console.log(chalk.gray('📍 4141端口未被占用'));
+                        resolve();
+                        return;
+                    }
+                    
+                    // 杀死所有相关进程
+                    let killedCount = 0;
+                    pids.forEach(pid => {
+                        exec(`taskkill /F /PID ${pid}`, (killError) => {
+                            killedCount++;
+                            if (killedCount === pids.size) {
+                                console.log(chalk.green('✅ 4141端口已清理'));
+                                resolve();
+                            }
+                        });
+                    });
+                });
+            } else {
+                // Mac/Linux: 查找并杀死占用4141端口的进程
+                exec('lsof -ti :4141', (error, stdout) => {
+                    if (error || !stdout) {
+                        console.log(chalk.gray('📍 4141端口未被占用'));
+                        resolve();
+                        return;
+                    }
+                    
+                    const pids = stdout.trim().split('\n').filter(pid => pid);
+                    
+                    if (pids.length === 0) {
+                        console.log(chalk.gray('📍 4141端口未被占用'));
+                        resolve();
+                        return;
+                    }
+                    
+                    // 杀死所有相关进程
+                    exec(`kill -9 ${pids.join(' ')}`, (killError) => {
+                        if (killError) {
+                            console.log(chalk.yellow('⚠️  杀死进程时出现错误，可能权限不足'));
+                        } else {
+                            console.log(chalk.green('✅ 4141端口已清理'));
+                        }
+                        resolve();
+                    });
+                });
+            }
+        });
+    }
+
+    async updateDatabaseModel(modelValue) {
+        try {
+            //console.log(chalk.yellow('📝 更新数据库模型参数...'));
+            
+            if (this.exchangeCode && this.codeObjectId) {
+                const validator = new CodeValidator();
+                await validator.updateModelField(this.codeObjectId, modelValue);
+                //console.log(chalk.green(`✅ 数据库模型参数已更新: ${modelValue}`));
+            } else {
+                console.log(chalk.yellow('⚠️  警告: 未找到兑换码信息，跳过数据库更新'));
+            }
+        } catch (error) {
+            console.error(chalk.red('❌ 数据库模型参数更新失败:'), error.message);
+            // 不抛出错误，继续执行
+        }
+    }
+
+    async writeClaudeSettings(anthropicModel) {
+        const os = require('os');
+        const isWindows = process.platform === 'win32';
+        const isMac = process.platform === 'darwin';
+
+        const config = {
+            "env": {
+                "ANTHROPIC_BASE_URL": "http://localhost:4141",
+                "ANTHROPIC_AUTH_TOKEN": "dummy",
+                "ANTHROPIC_MODEL": anthropicModel,
+                "DISABLE_NON_ESSENTIAL_MODEL_CALLS": "1",
+                "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
+            }
+        };
+
+        try {
+            const configDir = path.join(os.homedir(), '.claude');
+            const configFile = path.join(configDir, 'settings.json');
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+            if (isWindows) {
+                console.log(chalk.blue(`📝 Windows配置已保存到: ${configFile}`));
+            } else if (isMac) {
+                console.log(chalk.blue(`📝 Mac配置已保存到: ${configFile}`));
+            } else {
+                console.log(chalk.blue(`📝 Linux配置已保存到: ${configFile}`));
+            }
+            console.log(chalk.gray('配置内容:'));
+            console.log(chalk.gray(`  ANTHROPIC_BASE_URL: ${config.env.ANTHROPIC_BASE_URL}`));
+            console.log(chalk.gray(`  ANTHROPIC_AUTH_TOKEN: ${config.env.ANTHROPIC_AUTH_TOKEN}`));
+            console.log(chalk.gray(`  ANTHROPIC_MODEL: ${config.env.ANTHROPIC_MODEL}`));
+            console.log(chalk.gray(`  DISABLE_NON_ESSENTIAL_MODEL_CALLS: ${config.env.DISABLE_NON_ESSENTIAL_MODEL_CALLS}`));
+            console.log(chalk.gray(`  CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: ${config.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC}`));
+        } catch (error) {
+            console.error(chalk.red('❌ 写入配置文件失败:'), error.message);
+            throw error;
+        }
+    }
+
+    async installAIService() {
+        console.log(chalk.yellow('📦 安装ai服务...'));
+        return new Promise((resolve, reject) => {
+            const detectCmd = process.platform === 'win32' ? 'where copilot-api' : 'command -v copilot-api || which copilot-api';
+            exec(detectCmd, async (detectErr, stdout) => {
+                if (!detectErr && stdout && stdout.toString().trim().length > 0) {
+                    console.log(chalk.green('✅ AI服务 已存在，跳过安装'));
+                    try {
+                        await this.configureModel();
+                        resolve();
+                    } catch (e) {
+                        console.error(chalk.red('❌ 模型配置失败:'), e.message);
+                        resolve();
+                    }
+                    return;
+                }
+                console.log(chalk.blue('正在安装 AI服务...'));
+                const isWindows = process.platform === 'win32';
+                const isMac = process.platform === 'darwin';
+                let command = 'npm';
+                if (isMac) {
+                    try {
+                        require('child_process').execSync('which /opt/homebrew/bin/npm', { stdio: 'ignore' });
+                        command = '/opt/homebrew/bin/npm';
+                    } catch (e) {
+                        try {
+                            require('child_process').execSync('which /usr/local/bin/npm', { stdio: 'ignore' });
+                            command = '/usr/local/bin/npm';
+                        } catch (e2) {
+                            command = 'npm';
+                        }
+                    }
+                }
+                const args = ['install', '-g', '@copilot-api/copilot-api'];
+                const spawnOptions = { stdio: 'inherit', env: { ...process.env } };
+            if (this.proxyUrl) {
+                spawnOptions.env.HTTP_PROXY = this.proxyUrl;
+                spawnOptions.env.HTTPS_PROXY = this.proxyUrl;
+            }
+                if (isWindows) spawnOptions.shell = true;
+                const installProcess = spawn(command, args, spawnOptions);
+                installProcess.on('close', async (code) => {
+                    if (code === 0) {
+                        console.log(chalk.green('✅ AI服务 安装成功'));
+                        try {
+                            await this.configureModel();
+                            resolve();
+                        } catch (e) {
+                            console.error(chalk.red('❌ 模型配置失败:'), e.message);
+                            resolve();
+                        }
+                    } else {
+                        if (!isWindows) {
+                            console.log(chalk.yellow('🔄 尝试使用 sudo 安装...'));
+                            const env = { ...process.env, PATH: process.env.PATH };
+                            if (this.proxyUrl) {
+                                env.HTTP_PROXY = this.proxyUrl;
+                                env.HTTPS_PROXY = this.proxyUrl;
+                            }
+                            const sudoProcess = spawn('sudo', ['npm', 'install', '-g', 'copilot-api'], { stdio: 'inherit', env });
+                            sudoProcess.on('close', async (sudoCode) => {
+                                if (sudoCode === 0) {
+                                    console.log(chalk.green('✅ AI服务 安装成功'));
+                                    try {
+                                        await this.configureModel();
+                                        resolve();
+                                    } catch (e) {
+                                        console.error(chalk.red('❌ 模型配置失败:'), e.message);
+                                        resolve();
+                                    }
+                                } else {
+                                    reject(new Error('AI服务 安装失败，请检查网络连接和权限'));
+                                }
+                            });
+                            sudoProcess.on('error', (err) => {
+                                if (err.code === 'ENOENT') reject(new Error('sudo 命令未找到')); else reject(new Error(`sudo 安装失败: ${err.message}`));
+                            });
+                        } else {
+                            reject(new Error('AI服务 安装失败，请以管理员身份重试'));
+                        }
+                    }
+                });
+                installProcess.on('error', (err) => {
+                    if (err.code === 'ENOENT') reject(new Error('npm 命令未找到')); else reject(new Error(`安装过程出错: ${err.message}`));
+                });
+            });
+        });
+    }
+
+    async startAIService() {
+        console.log(chalk.yellow('🚀 启动 AI服务...'));
+        console.log(chalk.blue('等待获取验证码...\n'));
+
+        return new Promise((resolve, reject) => {
+            const isWindows = process.platform === 'win32';
+            const command = isWindows ? 'copilot-api' : 'copilot-api';
+            
+            const spawnOptions = {
+                env: {
+                    ...process.env
+                }
+            };
+            if (this.proxyUrl) {
+                spawnOptions.env.HTTP_PROXY = this.proxyUrl;
+                spawnOptions.env.HTTPS_PROXY = this.proxyUrl;
+            }
+
+            if (isWindows) {
+                spawnOptions.shell = true;
+            }
+            
+            const apiProcess = spawn(command, ['start'], spawnOptions);
+
+            let output = '';
+            let hasFoundCode = false;
+
+            apiProcess.stdout.on('data', (data) => {
+                const text = data.toString();
+                output += text;
+                process.stdout.write(text);
+
+                const codeMatch = text.match(/code\s+"([A-Z0-9-]+)"/i);
+                if (codeMatch && !hasFoundCode) {
+                    hasFoundCode = true;
+                    console.log(chalk.green.bold(`\n🎉 验证码已生成: ${codeMatch[1]}`));
+                    console.log(chalk.blue('请在浏览器中访问: https://github.com/login/device'));
+                    console.log(chalk.blue(`输入验证码: ${codeMatch[1]}`));
+                    console.log(chalk.gray('\n按 Ctrl+C 退出'));
+                }
+            });
+
+            apiProcess.stderr.on('data', (data) => {
+                const errorText = data.toString();
+                process.stderr.write(errorText);
+                
+                // 检查常见错误
+                if (errorText.includes('ENOENT') || errorText.includes('command not found')) {
+                    console.error(chalk.red('\n❌ AI服务未正确安装，请重新运行安装'));
+                    apiProcess.kill();
+                    reject(new Error('AI服务未找到'));
+                }
+            });
+
+            apiProcess.on('close', (code) => {
+                if (code !== 0 && !hasFoundCode) {
+                    console.log(chalk.red(`\n❌ AI服务启动失败 (code: ${code})`));
+                    reject(new Error('AI服务启动失败'));
+                } else {
+                    console.log(chalk.gray(`\nAI服务 已退出 (code: ${code})`));
+                    resolve();
+                }
+            });
+
+            apiProcess.on('error', (err) => {
+                console.error(chalk.red(`\n❌ 启动过程出错: ${err.message}`));
+                if (err.code === 'ENOENT') {
+                    reject(new Error('copilot-api 命令未找到，请确保AI服务已正确安装'));
+                } else {
+                    reject(err);
+                }
+            });
+
+            // 处理 Ctrl+C
+            process.on('SIGINT', () => {
+                console.log(chalk.yellow('\n\n👋 正在关闭...'));
+                apiProcess.kill();
+                process.exit();
+            });
+
+            // 超时处理
+            /*
+            setTimeout(() => {
+                if (!hasFoundCode) {
+                    console.log(chalk.yellow('\n⏰ 等待超时，请检查网络连接和代理设置'));
+                }
+            }, 30000); */
+        });
+    }
+
+    async waitForKeyPress() {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            
+            rl.question('按回车键继续...', () => {
+                rl.close();
+                resolve();
+            });
+        });
+    }
+
+    // 确保 heibai-api 命令可用（优先 npm link，其次写入全局 shim）
+    async ensureHeibaiApiAvailable() {
+        const isWindows = process.platform === 'win32';
+        const rootDir = path.join(__dirname, '..');
+
+        const detectCmd = isWindows ? 'where heibai-api' : 'command -v heibai-api || which heibai-api';
+
+        const execP = (cmd, opts={}) => new Promise((resolve) => {
+            exec(cmd, { shell: true, ...opts }, (err, stdout) => {
+                resolve({ ok: !err && (stdout || '').toString().trim().length > 0, stdout: (stdout||'').toString().trim() });
+            });
+        });
+
+        // 已存在则返回
+        let detected = await execP(detectCmd);
+        if (detected.ok) return;
+
+        // 尝试 npm link 当前包，暴露 bin
+        await new Promise((resolve) => {
+            const p = spawn('npm', ['link'], { cwd: rootDir, stdio: 'ignore', shell: true });
+            p.on('close', () => resolve());
+            p.on('error', () => resolve());
+        });
+
+        detected = await execP(detectCmd);
+        if (detected.ok) return;
+
+        // Windows 兜底：写入全局 npm bin 下的 heibai-api.cmd 指向本地 heibai.js
+        if (isWindows) {
+            const getBin = await execP('npm bin -g');
+            const globalBin = (getBin.stdout || '').trim();
+            if (globalBin && fs.existsSync(globalBin)) {
+                try {
+                    const shimPath = path.join(globalBin, 'heibai-api.cmd');
+                    const target = path.join(rootDir, 'bin', 'heibai.js');
+                    const content = `@echo off\r\nnode "${target}" %*\r\n`;
+                    fs.writeFileSync(shimPath, content, 'utf8');
+                } catch {}
+            }
+        }
+    }
+
+    // 获取机器码（详细设备信息）
+    async getMachineId() {
+        return new Promise((resolve) => {
+            const platform = os.platform();
+            
+            if (platform === 'win32') {
+                // Windows: 获取BIOS序列号、主板序列号、UUID
+                const cmd = 'powershell -nop -c "(gwmi Win32_BIOS).SerialNumber + \'/\' + (gwmi Win32_BaseBoard).SerialNumber + \'/\' + (gwmi Win32_ComputerSystemProduct).UUID"';
+                
+                exec(cmd, { shell: true }, (error, stdout, stderr) => {
+                    if (error || !stdout) {
+                        // 备用方法：获取MAC地址
+                        const networkInterfaces = os.networkInterfaces();
+                        for (const interfaceName in networkInterfaces) {
+                            const interfaces = networkInterfaces[interfaceName];
+                            for (const iface of interfaces) {
+                                if (!iface.internal && iface.mac && iface.mac !== '00:00:00:00:00:00') {
+                                    resolve(iface.mac);
+                                    return;
+                                }
+                            }
+                        }
+                        resolve(os.hostname());
+                    } else {
+                        resolve(stdout.trim());
+                    }
+                });
+            } else if (platform === 'darwin') {
+                // macOS: 获取序列号、UUID、MAC地址
+                const cmd = `printf "%s-%s-%s" "$(ioreg -l -d 2 | awk -F'"' '/IOPlatformSerialNumber/{print $4}')" "$(ioreg -d 2 -l | awk -F'"' '/IOPlatformUUID/{print $4}')" "$(ifconfig en0 | awk '/ether/{print $2}')"`;
+                
+                exec(cmd, { shell: true }, (error, stdout, stderr) => {
+                    if (error || !stdout) {
+                        // 备用方法：获取MAC地址
+                        const networkInterfaces = os.networkInterfaces();
+                        for (const interfaceName in networkInterfaces) {
+                            const interfaces = networkInterfaces[interfaceName];
+                            for (const iface of interfaces) {
+                                if (!iface.internal && iface.mac && iface.mac !== '00:00:00:00:00:00') {
+                                    resolve(iface.mac);
+                                    return;
+                                }
+                            }
+                        }
+                        resolve(os.hostname());
+                    } else {
+                        resolve(stdout.trim());
+                    }
+                });
+            } else {
+                // Linux或其他系统：使用MAC地址
+                const networkInterfaces = os.networkInterfaces();
+                for (const interfaceName in networkInterfaces) {
+                    const interfaces = networkInterfaces[interfaceName];
+                    for (const iface of interfaces) {
+                        if (!iface.internal && iface.mac && iface.mac !== '00:00:00:00:00:00') {
+                            resolve(iface.mac);
+                            return;
+                        }
+                    }
+                }
+                resolve(os.hostname());
+            }
+        });
+    }
+
+    // 获取公网IP
+    async getPublicIP() {
+        try {
+            // 优先使用内存缓存
+            if (this.publicIPCache) return this.publicIPCache;
+
+            // 尝试从本地缓存读取
+            try {
+                const cached = this.loadCachedCode();
+                if (cached && cached.publicIP) {
+                    this.publicIPCache = cached.publicIP;
+                    return this.publicIPCache;
+                }
+            } catch {}
+
+            // 如果已经在testConnection中获取过IP，可以重用
+            const response = await axios.get('http://ipinfo.io/json', {
+                timeout: 5000,
+                headers: {
+                    'User-Agent': 'curl/7.68.0'
+                }
+            });
+            const ip = response.data.ip || 'unknown_ip';
+            if (ip && ip !== 'unknown_ip') {
+                this.publicIPCache = ip;
+                this.saveCachedCode({ publicIP: ip });
+            }
+            return ip;
+        } catch (error) {
+            // 回退到缓存
+            try {
+                const cached = this.loadCachedCode();
+                if (cached && cached.publicIP) {
+                    this.publicIPCache = cached.publicIP;
+                    return this.publicIPCache;
+                }
+            } catch {}
+            return 'unknown_ip';
+        }
+    }
+
+    // 上传机器码和IP到数据库
+    async uploadMachineInfo(objectId) {
+        try {
+            const validator = new CodeValidator();
+            
+            // 获取设备信息
+            const machineId = await this.getMachineId();
+            const publicIP = await this.getPublicIP();
+            
+        
+            // 准备更新的数据
+            const updateData = {
+                mac: machineId,  // 每次都更新mac
+                ip: publicIP     // 更新IP
+            };
+            
+            // 检查diyi字段是否为空，如果为空则设置第一次特征
+            try {
+                const diyiValue = await validator.getCodeDiyi(objectId);
+                if (!diyiValue || diyiValue.trim() === '') {
+                    updateData.diyi = machineId;  // 记录
+                    
+                }
+            } catch (error) {
+                // 如果查询失败，假设diyi为空
+                updateData.diyi = machineId;
+                
+            }
+            
+            // 更新数据库
+            await validator.updateDeviceInfo(objectId, updateData);
+           
+        } catch (error) {
+           
+            // 不影响主流程，继续执行
+        }
+    }
+}
+
+// 启动程序
+const setup = new AIAssistantSetup();
+setup.start().catch(console.error);