@bolloon/bolloon-agent 0.1.8 → 0.1.10

package/bin/bolloon-cli.cjs

@@ -114,10 +114,17 @@ async function startCLI(additionalArgs) {
 }
 
 async function main() {
+  // Get version from package.json
+  const binPath = require.main.filename;
+  const binDir = path.dirname(binPath);
+  const packageDir = path.dirname(binDir);
+  const packageJson = JSON.parse(fs.readFileSync(path.join(packageDir, "package.json"), "utf-8"));
+  const version = packageJson.version;
+
   const { mode, args } = parseArgs();
   switch (mode) {
     case "version":
-      console.log("Bolloon Agent v0.1.2");
+      console.log("Bolloon Agent v" + version);
       break;
     case "help":
       printBanner();

package/bin/bolloon.cjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+const path = require("path");
+const { spawn } = require("child_process");
+const fs = require("fs");
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const MAGENTA = "\x1b[35m";
+
+function log(msg, color) {
+  console.log((color || RESET) + msg + RESET);
+}
+
+function printBanner() {
+  console.log("\n" + CYAN + BOLD + [
+    "   ╔═══════════════════════════════════════════╗",
+    "   ║      🤖 Bolloon Agent                     ║",
+    "   ║      P2P AI Document Processor            ║",
+    "   ╚═══════════════════════════════════════════╝"
+  ].join("\n") + RESET + "\n");
+}
+
+function getMainEntry() {
+  const distDir = path.dirname(require.main.filename);
+  const distIndex = path.join(distDir, "index.js");
+  if (fs.existsSync(distIndex)) {
+    return distIndex;
+  }
+  return path.join(process.cwd(), "src", "index.ts");
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    return { mode: "gui", args: [] };
+  }
+  const first = args[0];
+  switch (first) {
+    case "-v":
+    case "--version":
+      return { mode: "version", args: [] };
+    case "-h":
+    case "--help":
+      return { mode: "help", args: [] };
+    case "-g":
+    case "--gui":
+      return { mode: "gui", args: args.slice(1) };
+    case "-w":
+    case "--web":
+      return { mode: "web", args: args.slice(1) };
+    case "-c":
+    case "--cli":
+      return { mode: "cli", args: args.slice(1) };
+    default:
+      return { mode: "passthrough", args };
+  }
+}
+
+async function startElectron(additionalArgs) {
+  try {
+    const electron = require("electron");
+    const distDir = path.dirname(require.main.filename);
+    let mainPath = path.join(distDir, "electron.js");
+    if (!fs.existsSync(mainPath)) {
+      mainPath = path.join(process.cwd(), "src", "electron.ts");
+    }
+    log("启动 Electron...", CYAN);
+    const child = spawn(electron, [mainPath, ...additionalArgs], {
+      stdio: "inherit",
+      env: { ...process.env, NODE_ENV: "development" }
+    });
+    child.on("error", (err) => {
+      log("Electron 启动失败: " + err.message, MAGENTA);
+      process.exit(1);
+    });
+    child.on("exit", (code) => process.exit(code || 0));
+  } catch (err) {
+    log("Electron 不可用，切换到 Web 模式...", CYAN);
+    await startWebServer(additionalArgs);
+  }
+}
+
+async function startWebServer(additionalArgs) {
+  const mainPath = getMainEntry();
+  const webArgs = ["--web", ...additionalArgs];
+  log("启动 Web 服务...", CYAN);
+  const child = spawn(process.execPath, [mainPath, ...webArgs], { stdio: "inherit" });
+  child.on("error", (err) => {
+    log("Web 服务启动失败: " + err.message, MAGENTA);
+    process.exit(1);
+  });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
+async function startCLI(additionalArgs) {
+  const mainPath = getMainEntry();
+  log("启动命令行界面...", CYAN);
+  const child = spawn(process.execPath, [mainPath, ...additionalArgs], { stdio: "inherit" });
+  child.on("error", (err) => {
+    log("CLI 启动失败: " + err.message, MAGENTA);
+    process.exit(1);
+  });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
+async function main() {
+  const { mode, args } = parseArgs();
+  switch (mode) {
+    case "version":
+      console.log("Bolloon Agent v0.1.1");
+      break;
+    case "help":
+      printBanner();
+      console.log(BOLD + "用法:" + RESET + "  bolloon [选项] [命令] [参数]");
+      console.log(BOLD + "选项:" + RESET + "  --gui, -g           启动图形界面");
+      console.log("         --web, -w           启动 Web UI");
+      console.log("         --cli, -c           启动命令行界面");
+      console.log("         --version, -v       显示版本");
+      console.log("         --help, -h          显示帮助");
+      console.log(BOLD + "示例:" + RESET + "  bolloon              # 启动图形界面");
+      console.log("         bolloon --web        # 启动 Web UI");
+      console.log("         bolloon --read file  # 读取文档");
+      break;
+    case "gui":
+      printBanner();
+      await startElectron(args);
+      break;
+    case "web":
+      printBanner();
+      await startWebServer(args);
+      break;
+    case "cli":
+      await startCLI(args);
+      break;
+    case "passthrough":
+      const mainPath = getMainEntry();
+      const child = spawn(process.execPath, [mainPath, ...args], { stdio: "inherit" });
+      child.on("error", (err) => {
+        log("执行失败: " + err.message, MAGENTA);
+        process.exit(1);
+      });
+      child.on("exit", (code) => process.exit(code || 0));
+      break;
+    default:
+      log("未知模式: " + mode, MAGENTA);
+      printBanner();
+      console.log("输入 --help 查看帮助");
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/dist/index.js

@@ -11,6 +11,7 @@ import { createSubAgentManager } from './agents/subagent-manager.js';
 import { getGlobalSharedContext } from './social/global-shared-context.js';
 import { createBollharnessIntegration } from './bollharness-integration/index.js';
 import * as readline from 'readline';
+import { checkAndUpdate } from './utils/auto-update.js';
 const RESET = '\x1b[0m';
 const BOLD = '\x1b[1m';
 const DIM = '\x1b[2m';
@@ -496,6 +497,8 @@ const AVAILABLE_TOOLS = [
     { name: 'harness_classify', description: '分类变更类型', example: '--harness-classify <description>' },
     { name: 'harness_context', description: '获取文件上下文', example: '--harness-context <file>' },
     { name: 'harness_check', description: '执行 Guard 检查', example: '--harness-check <file>' },
+    { name: 'update_check', description: '检查 npm 包更新', example: '--update-check' },
+    { name: 'update_now', description: '立即更新到最新版本', example: '--update-now [package]' },
 ];
 async function runToolCommand(tool, args, outputJson, comm) {
     const a = await getAgent();
@@ -891,6 +894,38 @@ async function runToolCommand(tool, args, outputJson, comm) {
                 response = `✅ 已添加用户行动: ${content.substring(0, 50)}...`;
                 break;
             }
+            // ==================== Update Commands ====================
+            case 'update-check': {
+                const { checkForUpdates } = await import('./utils/auto-update.js');
+                const info = await checkForUpdates();
+                if (info && info.outdated) {
+                    response = `📦 发现更新可用:\n\n` +
+                        `当前版本: ${info.version}\n` +
+                        `最新版本: ${info.latest}\n\n` +
+                        `待更新包:\n${info.packages.map(p => `  - ${p.name}: ${p.current} → ${p.latest}`).join('\n')}\n\n` +
+                        `运行 --update-now 进行更新`;
+                }
+                else {
+                    response = `✅ 已是最新版本 (${info?.version || 'unknown'})`;
+                }
+                break;
+            }
+            case 'update-now': {
+                const { performUpdate } = await import('./utils/auto-update.js');
+                const packages = args.length > 0 ? args : undefined;
+                const result = await performUpdate(packages);
+                if (result.success) {
+                    response = `✅ 更新成功${result.updatedPackages ? `: ${result.updatedPackages.join(', ')}` : ''}`;
+                    if (result.updated) {
+                        response += `\n\n${YELLOW}请重新启动应用以使用新版本${RESET}`;
+                    }
+                }
+                else {
+                    response = `❌ 更新失败: ${result.error}`;
+                    error = response;
+                }
+                break;
+            }
             default:
                 response = `错误: 未知工具 "${tool}"`;
                 error = response;
@@ -1155,6 +1190,19 @@ function parseArgs() {
                 }
                 result.toolArgs = sessionArgs;
                 break;
+            case '--update-check':
+                result.updateCheck = true;
+                result.tool = 'update-check';
+                break;
+            case '--update-now':
+                result.updateNow = true;
+                result.tool = 'update-now';
+                const updateArgs = [];
+                while (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                    updateArgs.push(args[++i]);
+                }
+                result.toolArgs = updateArgs;
+                break;
             case '--tui':
                 result.tui = true;
                 break;
@@ -1224,6 +1272,10 @@ function printHelp() {
   --harness-sessions         列出 Session 归档记录
   --harness-session-context [id]  获取 Session 上下文
 
+  # 自动更新
+  --update-check             检查 npm 包更新
+  --update-now [pkg]        更新到最新版本
+
   # AI 对话
   --prompt, -p <text>        通用 AI 对话（默认）
   --model <name>             指定使用的模型
@@ -1272,6 +1324,13 @@ async function main() {
         printHelp();
         process.exit(0);
     }
+    // 启动时检查 npm 包更新
+    const updateResult = await checkAndUpdate();
+    if (updateResult.hasUpdate && updateResult.updated) {
+        console.log(`\n${YELLOW}更新完成，请重新启动 bolloon${RESET}\n`);
+        // 更新完成后退出，让用户重新启动
+        process.exit(0);
+    }
     const mode = args.web ? 'web' : 'cli';
     const isNonInteractive = !!(args.tool || args.prompt);
     const isTuiMode = mode === 'cli' && !isNonInteractive && args.tui;

package/dist/utils/auto-update.js

@@ -0,0 +1,310 @@
+/**
+ * npm 自动更新检查器
+ *
+ * 功能：
+ * - 启动时检查 npm 注册表是否有新版本
+ * - 自动下载并安装最新版本
+ * - 支持增量更新（只更新新增的包）
+ */
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import * as http from 'http';
+// ANSI 颜色
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const MAGENTA = '\x1b[35m';
+function log(msg, color = RESET) {
+    process.stdout.write(`${color}${msg}${RESET}`);
+}
+function httpGet(url) {
+    return new Promise((resolve, reject) => {
+        const client = url.startsWith('https') ? https : http;
+        const req = client.get(url, { timeout: 10000 }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => data += chunk);
+            res.on('end', () => resolve(data));
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('请求超时'));
+        });
+    });
+}
+/**
+ * 获取当前安装的包版本
+ */
+function getInstalledVersion(packageName) {
+    try {
+        const packageJsonPath = findPackageJson(packageName);
+        if (packageJsonPath) {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            return pkg.version || null;
+        }
+    }
+    catch (e) {
+        // 忽略错误
+    }
+    return null;
+}
+/**
+ * 查找包的 package.json 路径
+ */
+function findPackageJson(packageName) {
+    // 检查当前项目的 node_modules
+    const checkPaths = [
+        path.join(process.cwd(), 'node_modules', packageName, 'package.json'),
+        path.join(process.cwd(), 'node_modules', '@' + packageName.split('/')[0], packageName.split('/')[1] || '', 'package.json'),
+    ];
+    for (const p of checkPaths) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    return null;
+}
+/**
+ * 检查 npm 注册表获取最新版本
+ */
+async function getLatestVersion(packageName) {
+    try {
+        const encodedName = encodeURIComponent(packageName);
+        const url = `https://registry.npmjs.org/${encodedName}`;
+        const response = await httpGet(url);
+        const data = JSON.parse(response);
+        return data['dist-tags']?.latest || null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * 比较版本号
+ */
+function compareVersions(current, latest) {
+    const currentParts = current.split('.').map(Number);
+    const latestParts = latest.split('.').map(Number);
+    for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+        const c = currentParts[i] || 0;
+        const l = latestParts[i] || 0;
+        if (c < l)
+            return -1;
+        if (c > l)
+            return 1;
+    }
+    return 0;
+}
+/**
+ * 检查 @bolloon 相关的包是否有更新
+ */
+async function checkBolloonUpdates() {
+    const packagesToCheck = [
+        '@bolloon/bolloon-agent',
+        '@bolloon/constraint-runtime',
+    ];
+    const outdatedPackages = [];
+    let hasUpdate = false;
+    let currentVersion = '';
+    let latestVersion = '';
+    for (const pkg of packagesToCheck) {
+        const installed = getInstalledVersion(pkg);
+        if (!installed)
+            continue;
+        currentVersion = installed;
+        const latest = await getLatestVersion(pkg);
+        if (latest && compareVersions(installed, latest) < 0) {
+            hasUpdate = true;
+            latestVersion = latest;
+            outdatedPackages.push({
+                name: pkg,
+                current: installed,
+                wanted: latest,
+                latest,
+                location: pkg
+            });
+        }
+    }
+    if (outdatedPackages.length === 0) {
+        return {
+            name: '@bolloon/bolloon-agent',
+            version: currentVersion,
+            latest: currentVersion,
+            outdated: false,
+            packages: []
+        };
+    }
+    return {
+        name: '@bolloon/bolloon-agent',
+        version: currentVersion,
+        latest: latestVersion,
+        outdated: hasUpdate,
+        packages: outdatedPackages
+    };
+}
+/**
+ * 使用 npm outdated 检查所有包的更新
+ */
+function checkNpmOutdated() {
+    try {
+        const output = execSync('npm outdated --json', {
+            encoding: 'utf-8',
+            timeout: 30000,
+            maxBuffer: 10 * 1024 * 1024,
+            cwd: process.cwd()
+        });
+        if (!output.trim())
+            return [];
+        const data = JSON.parse(output);
+        const packages = [];
+        for (const [name, info] of Object.entries(data)) {
+            const pkg = info;
+            packages.push({
+                name,
+                current: pkg.current || '0.0.0',
+                wanted: pkg.wanted || '0.0.0',
+                latest: pkg.latest || '0.0.0',
+                location: pkg.location || name
+            });
+        }
+        return packages;
+    }
+    catch (e) {
+        // npm outdated 在没有过时包时会返回非零退出码
+        if (e.status !== 0 && !e.message?.includes('npm outdated')) {
+            return [];
+        }
+        return [];
+    }
+}
+/**
+ * 自动更新 npm 包
+ */
+async function updatePackages(packages) {
+    try {
+        const args = packages && packages.length > 0
+            ? ['npm', 'install', ...packages, '--save']
+            : ['npm', 'install', '-g', '@bolloon/bolloon-agent'];
+        log(`\n${CYAN}📦 正在更新包...${RESET}\n`, RESET);
+        // 执行 npm install
+        const result = execSync(args.join(' '), {
+            encoding: 'utf-8',
+            timeout: 300000, // 5分钟超时
+            stdio: 'inherit',
+            cwd: process.cwd()
+        });
+        return {
+            success: true,
+            updated: true,
+            message: '更新成功',
+            updatedPackages: packages
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            updated: false,
+            message: '更新失败',
+            error: e.message
+        };
+    }
+}
+/**
+ * 检查并自动更新（启动时调用）
+ */
+export async function checkAndUpdate() {
+    // 检查是否有 --no-update 标志
+    if (process.argv.includes('--no-update') || process.argv.includes('--skip-update')) {
+        return { hasUpdate: false, info: null, updated: false, message: '跳过更新检查' };
+    }
+    // 检查环境变量
+    if (process.env.BOLLOON_SKIP_UPDATE === 'true') {
+        return { hasUpdate: false, info: null, updated: false, message: '跳过更新检查（环境变量）' };
+    }
+    log(`\n${CYAN}🔍 检查更新...${RESET}`, RESET);
+    try {
+        // 检查 @bolloon 包的更新
+        const bolloonInfo = await checkBolloonUpdates();
+        if (bolloonInfo && bolloonInfo.outdated) {
+            log(`\n${YELLOW}⚠️  发现新版本: ${bolloonInfo.latest}${RESET}\n`, RESET);
+            log(`   当前版本: ${bolloonInfo.version}\n`, RESET);
+            log(`   最新版本: ${bolloonInfo.latest}\n\n`, RESET);
+            // 自动更新
+            const result = await updatePackages(bolloonInfo.packages.map(p => p.name));
+            if (result.success) {
+                log(`\n${GREEN}✅ 更新成功！请重新启动应用${RESET}\n`, RESET);
+                // 提示用户重启
+                log(`${YELLOW}💡 请重新运行 bolloon 以使用新版本${RESET}\n\n`, RESET);
+                // 通知主进程更新完成
+                process.emit('bolloon-update-complete', result);
+                return {
+                    hasUpdate: true,
+                    info: bolloonInfo,
+                    updated: true,
+                    message: `已更新到 ${bolloonInfo.latest}`
+                };
+            }
+            else {
+                return {
+                    hasUpdate: true,
+                    info: bolloonInfo,
+                    updated: false,
+                    message: `更新失败: ${result.error}`
+                };
+            }
+        }
+        else {
+            log(` ${GREEN}✓${RESET} 已是最新版本 (${bolloonInfo?.version || 'unknown'})\n`, RESET);
+            return {
+                hasUpdate: false,
+                info: bolloonInfo,
+                updated: false,
+                message: '已是最新版本'
+            };
+        }
+    }
+    catch (e) {
+        log(` ${YELLOW}⚠${RESET} 更新检查失败: ${e.message}\n`, RESET);
+        return {
+            hasUpdate: false,
+            info: null,
+            updated: false,
+            message: `检查失败: ${e.message}`
+        };
+    }
+}
+/**
+ * 仅检查更新，不自动安装
+ */
+export async function checkForUpdates() {
+    return await checkBolloonUpdates();
+}
+/**
+ * 手动触发更新
+ */
+export async function performUpdate(packages) {
+    return await updatePackages(packages);
+}
+// CLI 入口
+if (import.meta.url === `file://${process.argv[1]}`) {
+    (async () => {
+        const command = process.argv[2];
+        switch (command) {
+            case 'check':
+                const info = await checkForUpdates();
+                if (info) {
+                    console.log(JSON.stringify(info, null, 2));
+                }
+                break;
+            case 'update':
+                const result = await performUpdate(process.argv.slice(3));
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            default:
+                await checkAndUpdate();
+        }
+    })();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolloon/bolloon-agent",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
   "main": "dist/cli.js",
@@ -32,7 +32,7 @@
     "src/constraint-runtime"
   ],
   "dependencies": {
-    "@bolloon/bolloon-agent": "^0.1.5",
+    "@bolloon/bolloon-agent": "^0.1.9",
     "@bolloon/constraint-runtime": "0.1.0",
     "@chainsafe/libp2p-noise": "^17.0.0",
     "@chainsafe/libp2p-yamux": "^8.0.1",

package/src/index.ts

@@ -22,6 +22,7 @@ import { createSubAgentManager } from './agents/subagent-manager.js';
 import { getGlobalSharedContext } from './social/global-shared-context.js';
 import { BollharnessIntegration, createBollharnessIntegration } from './bollharness-integration/index.js';
 import * as readline from 'readline';
+import { checkAndUpdate } from './utils/auto-update.js';
 
 const RESET = '\x1b[0m';
 const BOLD = '\x1b[1m';
@@ -601,6 +602,8 @@ const AVAILABLE_TOOLS = [
   { name: 'harness_classify', description: '分类变更类型', example: '--harness-classify <description>' },
   { name: 'harness_context', description: '获取文件上下文', example: '--harness-context <file>' },
   { name: 'harness_check', description: '执行 Guard 检查', example: '--harness-check <file>' },
+  { name: 'update_check', description: '检查 npm 包更新', example: '--update-check' },
+  { name: 'update_now', description: '立即更新到最新版本', example: '--update-now [package]' },
 ];
 
 async function runToolCommand(
@@ -1036,6 +1039,39 @@ async function runToolCommand(
 break;
       }
 
+      // ==================== Update Commands ====================
+
+      case 'update-check': {
+        const { checkForUpdates } = await import('./utils/auto-update.js');
+        const info = await checkForUpdates();
+        if (info && info.outdated) {
+          response = `📦 发现更新可用:\n\n` +
+            `当前版本: ${info.version}\n` +
+            `最新版本: ${info.latest}\n\n` +
+            `待更新包:\n${info.packages.map(p => `  - ${p.name}: ${p.current} → ${p.latest}`).join('\n')}\n\n` +
+            `运行 --update-now 进行更新`;
+        } else {
+          response = `✅ 已是最新版本 (${info?.version || 'unknown'})`;
+        }
+        break;
+      }
+
+      case 'update-now': {
+        const { performUpdate } = await import('./utils/auto-update.js');
+        const packages = args.length > 0 ? args : undefined;
+        const result = await performUpdate(packages as string[] | undefined);
+        if (result.success) {
+          response = `✅ 更新成功${result.updatedPackages ? `: ${result.updatedPackages.join(', ')}` : ''}`;
+          if (result.updated) {
+            response += `\n\n${YELLOW}请重新启动应用以使用新版本${RESET}`;
+          }
+        } else {
+          response = `❌ 更新失败: ${result.error}`;
+          error = response;
+        }
+        break;
+      }
+
       default:
         response = `错误: 未知工具 "${tool}"`;
         error = response;
@@ -1151,6 +1187,8 @@ interface ParsedArgs {
   globalAgents?: boolean;
   addAction?: boolean;
   tui?: boolean;
+  updateCheck?: boolean;
+  updateNow?: boolean;
 }
 
 function parseArgs(): ParsedArgs {
@@ -1338,6 +1376,19 @@ function parseArgs(): ParsedArgs {
         }
         result.toolArgs = sessionArgs;
         break;
+      case '--update-check':
+        result.updateCheck = true;
+        result.tool = 'update-check';
+        break;
+      case '--update-now':
+        result.updateNow = true;
+        result.tool = 'update-now';
+        const updateArgs: string[] = [];
+        while (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+          updateArgs.push(args[++i]);
+        }
+        result.toolArgs = updateArgs;
+        break;
       case '--tui':
         result.tui = true;
         break;
@@ -1409,6 +1460,10 @@ function printHelp(): void {
   --harness-sessions         列出 Session 归档记录
   --harness-session-context [id]  获取 Session 上下文
 
+  # 自动更新
+  --update-check             检查 npm 包更新
+  --update-now [pkg]        更新到最新版本
+
   # AI 对话
   --prompt, -p <text>        通用 AI 对话（默认）
   --model <name>             指定使用的模型
@@ -1461,6 +1516,14 @@ async function main() {
     process.exit(0);
   }
 
+  // 启动时检查 npm 包更新
+  const updateResult = await checkAndUpdate();
+  if (updateResult.hasUpdate && updateResult.updated) {
+    console.log(`\n${YELLOW}更新完成，请重新启动 bolloon${RESET}\n`);
+    // 更新完成后退出，让用户重新启动
+    process.exit(0);
+  }
+
   const mode = args.web ? 'web' : 'cli';
   const isNonInteractive = !!(args.tool || args.prompt);
   const isTuiMode = mode === 'cli' && !isNonInteractive && args.tui;

package/src/utils/auto-update.ts

@@ -0,0 +1,369 @@
+/**
+ * npm 自动更新检查器
+ *
+ * 功能：
+ * - 启动时检查 npm 注册表是否有新版本
+ * - 自动下载并安装最新版本
+ * - 支持增量更新（只更新新增的包）
+ */
+
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import * as http from 'http';
+
+// ANSI 颜色
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const MAGENTA = '\x1b[35m';
+
+interface PackageInfo {
+  name: string;
+  version: string;
+  latest: string;
+  outdated: boolean;
+  packages: OutdatedPackage[];
+}
+
+interface OutdatedPackage {
+  name: string;
+  current: string;
+  wanted: string;
+  latest: string;
+  location: string;
+}
+
+interface UpdateResult {
+  success: boolean;
+  updated: boolean;
+  message: string;
+  updatedPackages?: string[];
+  error?: string;
+}
+
+function log(msg: string, color: string = RESET) {
+  process.stdout.write(`${color}${msg}${RESET}`);
+}
+
+function httpGet(url: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith('https') ? https : http;
+    const req = client.get(url, { timeout: 10000 }, (res: any) => {
+      let data = '';
+      res.on('data', (chunk: string) => data += chunk);
+      res.on('end', () => resolve(data));
+    });
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('请求超时'));
+    });
+  });
+}
+
+/**
+ * 获取当前安装的包版本
+ */
+function getInstalledVersion(packageName: string): string | null {
+  try {
+    const packageJsonPath = findPackageJson(packageName);
+    if (packageJsonPath) {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+      return pkg.version || null;
+    }
+  } catch (e) {
+    // 忽略错误
+  }
+  return null;
+}
+
+/**
+ * 查找包的 package.json 路径
+ */
+function findPackageJson(packageName: string): string | null {
+  // 检查当前项目的 node_modules
+  const checkPaths = [
+    path.join(process.cwd(), 'node_modules', packageName, 'package.json'),
+    path.join(process.cwd(), 'node_modules', '@' + packageName.split('/')[0], packageName.split('/')[1] || '', 'package.json'),
+  ];
+
+  for (const p of checkPaths) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+/**
+ * 检查 npm 注册表获取最新版本
+ */
+async function getLatestVersion(packageName: string): Promise<string | null> {
+  try {
+    const encodedName = encodeURIComponent(packageName);
+    const url = `https://registry.npmjs.org/${encodedName}`;
+    const response = await httpGet(url);
+    const data = JSON.parse(response);
+    return data['dist-tags']?.latest || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 比较版本号
+ */
+function compareVersions(current: string, latest: string): -1 | 0 | 1 {
+  const currentParts = current.split('.').map(Number);
+  const latestParts = latest.split('.').map(Number);
+
+  for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+    const c = currentParts[i] || 0;
+    const l = latestParts[i] || 0;
+    if (c < l) return -1;
+    if (c > l) return 1;
+  }
+  return 0;
+}
+
+/**
+ * 检查 @bolloon 相关的包是否有更新
+ */
+async function checkBolloonUpdates(): Promise<PackageInfo | null> {
+  const packagesToCheck = [
+    '@bolloon/bolloon-agent',
+    '@bolloon/constraint-runtime',
+  ];
+
+  const outdatedPackages: OutdatedPackage[] = [];
+  let hasUpdate = false;
+  let currentVersion = '';
+  let latestVersion = '';
+
+  for (const pkg of packagesToCheck) {
+    const installed = getInstalledVersion(pkg);
+    if (!installed) continue;
+
+    currentVersion = installed;
+    const latest = await getLatestVersion(pkg);
+
+    if (latest && compareVersions(installed, latest) < 0) {
+      hasUpdate = true;
+      latestVersion = latest;
+      outdatedPackages.push({
+        name: pkg,
+        current: installed,
+        wanted: latest,
+        latest,
+        location: pkg
+      });
+    }
+  }
+
+  if (outdatedPackages.length === 0) {
+    return {
+      name: '@bolloon/bolloon-agent',
+      version: currentVersion,
+      latest: currentVersion,
+      outdated: false,
+      packages: []
+    };
+  }
+
+  return {
+    name: '@bolloon/bolloon-agent',
+    version: currentVersion,
+    latest: latestVersion,
+    outdated: hasUpdate,
+    packages: outdatedPackages
+  };
+}
+
+/**
+ * 使用 npm outdated 检查所有包的更新
+ */
+function checkNpmOutdated(): OutdatedPackage[] {
+  try {
+    const output = execSync('npm outdated --json', {
+      encoding: 'utf-8',
+      timeout: 30000,
+      maxBuffer: 10 * 1024 * 1024,
+      cwd: process.cwd()
+    });
+
+    if (!output.trim()) return [];
+
+    const data = JSON.parse(output);
+    const packages: OutdatedPackage[] = [];
+
+    for (const [name, info] of Object.entries(data)) {
+      const pkg = info as any;
+      packages.push({
+        name,
+        current: pkg.current || '0.0.0',
+        wanted: pkg.wanted || '0.0.0',
+        latest: pkg.latest || '0.0.0',
+        location: pkg.location || name
+      });
+    }
+
+    return packages;
+  } catch (e: any) {
+    // npm outdated 在没有过时包时会返回非零退出码
+    if (e.status !== 0 && !e.message?.includes('npm outdated')) {
+      return [];
+    }
+    return [];
+  }
+}
+
+/**
+ * 自动更新 npm 包
+ */
+async function updatePackages(packages?: string[]): Promise<UpdateResult> {
+  try {
+    const args = packages && packages.length > 0
+      ? ['npm', 'install', ...packages, '--save']
+      : ['npm', 'install', '-g', '@bolloon/bolloon-agent'];
+
+    log(`\n${CYAN}📦 正在更新包...${RESET}\n`, RESET);
+
+    // 执行 npm install
+    const result = execSync(args.join(' '), {
+      encoding: 'utf-8',
+      timeout: 300000, // 5分钟超时
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+
+    return {
+      success: true,
+      updated: true,
+      message: '更新成功',
+      updatedPackages: packages
+    };
+  } catch (e: any) {
+    return {
+      success: false,
+      updated: false,
+      message: '更新失败',
+      error: e.message
+    };
+  }
+}
+
+/**
+ * 检查并自动更新（启动时调用）
+ */
+export async function checkAndUpdate(): Promise<{
+  hasUpdate: boolean;
+  info: PackageInfo | null;
+  updated: boolean;
+  message: string;
+}> {
+  // 检查是否有 --no-update 标志
+  if (process.argv.includes('--no-update') || process.argv.includes('--skip-update')) {
+    return { hasUpdate: false, info: null, updated: false, message: '跳过更新检查' };
+  }
+
+  // 检查环境变量
+  if (process.env.BOLLOON_SKIP_UPDATE === 'true') {
+    return { hasUpdate: false, info: null, updated: false, message: '跳过更新检查（环境变量）' };
+  }
+
+  log(`\n${CYAN}🔍 检查更新...${RESET}`, RESET);
+
+  try {
+    // 检查 @bolloon 包的更新
+    const bolloonInfo = await checkBolloonUpdates();
+
+    if (bolloonInfo && bolloonInfo.outdated) {
+      log(`\n${YELLOW}⚠️  发现新版本: ${bolloonInfo.latest}${RESET}\n`, RESET);
+      log(`   当前版本: ${bolloonInfo.version}\n`, RESET);
+      log(`   最新版本: ${bolloonInfo.latest}\n\n`, RESET);
+
+      // 自动更新
+      const result = await updatePackages(bolloonInfo.packages.map(p => p.name));
+
+      if (result.success) {
+        log(`\n${GREEN}✅ 更新成功！请重新启动应用${RESET}\n`, RESET);
+
+        // 提示用户重启
+        log(`${YELLOW}💡 请重新运行 bolloon 以使用新版本${RESET}\n\n`, RESET);
+
+        // 通知主进程更新完成
+        process.emit('bolloon-update-complete', result);
+
+        return {
+          hasUpdate: true,
+          info: bolloonInfo,
+          updated: true,
+          message: `已更新到 ${bolloonInfo.latest}`
+        };
+      } else {
+        return {
+          hasUpdate: true,
+          info: bolloonInfo,
+          updated: false,
+          message: `更新失败: ${result.error}`
+        };
+      }
+    } else {
+      log(` ${GREEN}✓${RESET} 已是最新版本 (${bolloonInfo?.version || 'unknown'})\n`, RESET);
+      return {
+        hasUpdate: false,
+        info: bolloonInfo,
+        updated: false,
+        message: '已是最新版本'
+      };
+    }
+  } catch (e: any) {
+    log(` ${YELLOW}⚠${RESET} 更新检查失败: ${e.message}\n`, RESET);
+    return {
+      hasUpdate: false,
+      info: null,
+      updated: false,
+      message: `检查失败: ${e.message}`
+    };
+  }
+}
+
+/**
+ * 仅检查更新，不自动安装
+ */
+export async function checkForUpdates(): Promise<PackageInfo | null> {
+  return await checkBolloonUpdates();
+}
+
+/**
+ * 手动触发更新
+ */
+export async function performUpdate(packages?: string[]): Promise<UpdateResult> {
+  return await updatePackages(packages);
+}
+
+// CLI 入口
+if (process.argv[1]?.includes('auto-update')) {
+  (async () => {
+    const command = process.argv[2];
+
+    switch (command) {
+      case 'check':
+        const info = await checkForUpdates();
+        if (info) {
+          console.log(JSON.stringify(info, null, 2));
+        }
+        break;
+
+      case 'update':
+        const result = await performUpdate(process.argv.slice(3));
+        console.log(JSON.stringify(result, null, 2));
+        break;
+
+      default:
+        await checkAndUpdate();
+    }
+  })();
+}