@bolloon/bolloon-agent 0.1.0 → 0.1.2

package/src/cli-entry.ts

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+/**
+ * Bolloon CLI 入口
+ *
+ * 使用方式:
+ *   bolloon                    # 启动 GUI（Electron 或 Web）
+ *   bolloon --cli              # 启动命令行界面
+ *   bolloon --read <file>      # 读取文档
+ *   bolloon --summarize <file> # 总结文档
+ *   bolloon --web              # 启动 Web UI
+ *   bolloon --version          # 显示版本
+ */
+
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+
+const isWindows = process.platform === 'win32';
+
+// ANSI 颜色
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const CYAN = '\x1b[36m';
+const YELLOW = '\x1b[33m';
+const GREEN = '\x1b[32m';
+const MAGENTA = '\x1b[35m';
+
+// 版本信息
+const VERSION = '0.1.1';
+
+function log(msg: string, color: string = RESET) {
+  console.log(`${color}${msg}${RESET}`);
+}
+
+function printBanner() {
+  console.log(`
+${CYAN}${BOLD}
+   ╔═══════════════════════════════════════════╗
+   ║      🤖 Bolloon Agent ${VERSION}              ║
+   ║      P2P AI Document Processor            ║
+   ╚═══════════════════════════════════════════╝${RESET}
+`);
+}
+
+function printHelp() {
+  console.log(`
+${BOLD}用法:${RESET}
+  bolloon [选项] [命令] [参数]
+
+${BOLD}选项:${RESET}
+  --gui, -g           启动图形界面 (Electron)
+  --web, -w           启动 Web UI (浏览器)
+  --cli, -c           启动命令行界面
+  --version, -v       显示版本信息
+  --help, -h          显示帮助信息
+
+${BOLD}命令:${RESET}
+  bolloon --read <file>           读取文档
+  bolloon --summarize <file>      总结文档
+  bolloon --improve <file> <req>  改进文档
+
+${BOLD}示例:${RESET}
+  bolloon                    # 启动图形界面
+  bolloon --web              # 启动 Web UI
+  bolloon --read 想法.md     # 读取文档
+  bolloon --cli              # 命令行模式
+
+${BOLD}环境变量:${RESET}
+  MINIMAX_API_KEY           MiniMax API 密钥
+  OPENAI_API_KEY            OpenAI API 密钥
+  ANTHROPIC_API_KEY         Anthropic API 密钥
+  PORT                      Web 服务端口 (默认 54188)
+`);
+}
+
+function getDistDir(): string {
+  // 对于打包后的应用，__dirname 是 dist 目录
+  return __dirname;
+}
+
+function getMainScript(): string {
+  const distDir = getDistDir();
+
+  // 检查 dist/index.js 是否存在
+  const indexPath = path.join(distDir, 'index.js');
+  if (fs.existsSync(indexPath)) {
+    return indexPath;
+  }
+
+  // 回退到源目录
+  const srcPath = path.join(process.cwd(), 'src', 'index.ts');
+  if (fs.existsSync(srcPath)) {
+    return path.join(process.cwd(), 'src', 'index.ts');
+  }
+
+  throw new Error('找不到入口脚本，请确保已执行 npm run build');
+}
+
+function getElectronPath(): string {
+  // 获取 electron 可执行文件路径
+  const electronPath = require('electron');
+  return electronPath;
+}
+
+// 解析命令行参数
+function parseArgs(): { mode: string; args: string[] } {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    return { mode: 'gui', args: [] };
+  }
+
+  const mode = args[0];
+
+  // 处理简写选项
+  switch (mode) {
+    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 };
+  }
+}
+
+// 执行 Node.js 脚本
+async function runNodeScript(scriptPath: string, additionalArgs: string[]) {
+  return new Promise<void>((resolve, reject) => {
+    const child = spawn(process.execPath, [scriptPath, ...additionalArgs], {
+      stdio: 'inherit',
+      env: { ...process.env }
+    });
+
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`进程退出，代码: ${code}`));
+      }
+    });
+  });
+}
+
+// 启动 Electron
+async function startElectron(additionalArgs: string[]) {
+  const electronPath = getElectronPath();
+  const distDir = getDistDir();
+
+  // 确定主进程入口
+  let mainPath = path.join(distDir, 'electron.js');
+  if (!fs.existsSync(mainPath)) {
+    mainPath = path.join(distDir, '..', 'src', 'electron.js');
+  }
+
+  if (!fs.existsSync(mainPath)) {
+    // 回退到开发模式
+    mainPath = path.join(process.cwd(), 'src', 'electron.ts');
+  }
+
+  log('启动 Electron...', CYAN);
+
+  const child = spawn(electronPath, [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);
+  });
+}
+
+// 启动 Web 服务
+async function startWebServer(additionalArgs: string[]) {
+  log('启动 Web 服务...', CYAN);
+
+  try {
+    const mainPath = getMainScript();
+    const webArgs = ['--web', ...additionalArgs];
+
+    const child = spawn(process.execPath, [mainPath, ...webArgs], {
+      stdio: 'inherit',
+      env: { ...process.env }
+    });
+
+    child.on('error', (err) => {
+      log(`Web 服务启动失败: ${err.message}`, MAGENTA);
+      process.exit(1);
+    });
+
+    child.on('exit', (code) => {
+      process.exit(code || 0);
+    });
+  } catch (err: any) {
+    log(`启动失败: ${err.message}`, MAGENTA);
+    process.exit(1);
+  }
+}
+
+// 启动 CLI
+async function startCLI(additionalArgs: string[]) {
+  log('启动命令行界面...', CYAN);
+
+  try {
+    const mainPath = getMainScript();
+    const cliArgs = [...additionalArgs];
+
+    const child = spawn(process.execPath, [mainPath, ...cliArgs], {
+      stdio: 'inherit',
+      env: { ...process.env }
+    });
+
+    child.on('error', (err) => {
+      log(`CLI 启动失败: ${err.message}`, MAGENTA);
+      process.exit(1);
+    });
+
+    child.on('exit', (code) => {
+      process.exit(code || 0);
+    });
+  } catch (err: any) {
+    log(`启动失败: ${err.message}`, MAGENTA);
+    process.exit(1);
+  }
+}
+
+// 主入口
+async function main() {
+  const { mode, args } = parseArgs();
+
+  switch (mode) {
+    case 'version':
+      console.log(`Bolloon Agent v${VERSION}`);
+      break;
+
+    case 'help':
+      printHelp();
+      break;
+
+    case 'gui':
+      printBanner();
+      await startElectron(args);
+      break;
+
+    case 'web':
+      printBanner();
+      await startWebServer(args);
+      break;
+
+    case 'cli':
+      await startCLI(args);
+      break;
+
+    case 'passthrough':
+      // 传递所有参数给主程序
+      try {
+        const mainPath = getMainScript();
+        const child = spawn(process.execPath, [mainPath, ...args], {
+          stdio: 'inherit',
+          env: { ...process.env }
+        });
+
+        child.on('error', (err) => {
+          log(`执行失败: ${err.message}`, MAGENTA);
+          process.exit(1);
+        });
+
+        child.on('exit', (code) => {
+          process.exit(code || 0);
+        });
+      } catch (err: any) {
+        log(`执行失败: ${err.message}`, MAGENTA);
+        process.exit(1);
+      }
+      break;
+
+    default:
+      log(`未知模式: ${mode}`, MAGENTA);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/src/heartbeat/DaemonManager.ts

@@ -0,0 +1,283 @@
+/**
+ * DaemonManager - 守护进程管理器
+ * 支持自动重启、日志轮转、PID 管理
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import type { DaemonConfig } from './types.js';
+
+export interface DaemonState {
+  pid: number;
+  startedAt: number;
+  restartCount: number;
+  lastRestartAt?: number;
+  lastError?: string;
+}
+
+export class DaemonManager {
+  private config: Required<DaemonConfig>;
+  private state: DaemonState | null = null;
+  private stopRequested: boolean = false;
+  private isChildProcess: boolean = false;
+
+  constructor(config: Partial<DaemonConfig> = {}) {
+    this.config = {
+      maxRestarts: config.maxRestarts || 5,
+      restartDelayMs: config.restartDelayMs || 5000,
+      logFile: config.logFile || path.join(process.env.HOME || '/tmp', '.bolloon', 'daemon.log'),
+      pidFile: config.pidFile || path.join(process.env.HOME || '/tmp', '.bolloon', 'daemon.pid')
+    };
+    this.isChildProcess = process.env.BOLLOON_DAEMON_CHILD === '1';
+  }
+
+  /**
+   * 获取当前守护进程状态
+   */
+  async getState(): Promise<DaemonState | null> {
+    try {
+      const pidData = await fs.readFile(this.config.pidFile, 'utf-8');
+      const pid = parseInt(pidData.trim(), 10);
+
+      if (isNaN(pid)) return null;
+
+      // 检查进程是否仍在运行
+      try {
+        process.kill(pid, 0); // Signal 0 只是检查进程是否存在
+        return { ...this.state!, pid };
+      } catch {
+        // 进程不存在
+        return null;
+      }
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 检查是否已有守护进程在运行
+   */
+  async isRunning(): Promise<boolean> {
+    const state = await this.getState();
+    return state !== null;
+  }
+
+  /**
+   * 保存 PID 文件
+   */
+  private async savePid(): Promise<void> {
+    await fs.mkdir(path.dirname(this.config.pidFile), { recursive: true });
+    await fs.writeFile(this.config.pidFile, String(process.pid));
+    console.log(`[Daemon] PID saved: ${process.pid}`);
+  }
+
+  /**
+   * 删除 PID 文件
+   */
+  async clearPid(): Promise<void> {
+    try {
+      await fs.unlink(this.config.pidFile);
+    } catch {
+      // 忽略删除失败
+    }
+  }
+
+  /**
+   * 写入日志
+   */
+  private async writeLog(message: string): Promise<void> {
+    if (!this.config.logFile) return;
+
+    try {
+      await fs.mkdir(path.dirname(this.config.logFile), { recursive: true });
+      const timestamp = new Date().toISOString();
+      await fs.appendFile(this.config.logFile, `[${timestamp}] ${message}\n`);
+    } catch {
+      // 忽略日志写入失败
+    }
+  }
+
+  /**
+   * 启动主进程（父进程调用）
+   */
+  async spawn(processArgv: string[] = process.argv): Promise<void> {
+    // 检查是否已在运行
+    if (await this.isRunning()) {
+      console.log('[Daemon] Already running, pid:', (await this.getState())?.pid);
+      return;
+    }
+
+    this.state = {
+      pid: process.pid,
+      startedAt: Date.now(),
+      restartCount: 0
+    };
+
+    await this.savePid();
+    await this.writeLog('Daemon started');
+
+    // 设置优雅退出
+    this.setupGracefulShutdown();
+
+    // 注册信号处理
+    this.setupSignalHandlers();
+
+    console.log('[Daemon] Manager initialized');
+  }
+
+  /**
+   * 启动子进程并管理其生命周期
+   */
+  async runWithAutoRestart(childArgs: string[]): Promise<void> {
+    if (!this.isChildProcess) {
+      // 父进程：启动子进程
+      await this.runChildProcess(childArgs);
+      return;
+    }
+
+    // 子进程：正常运行主程序
+    console.log('[Daemon] Running as child process');
+  }
+
+  /**
+   * 启动子进程
+   */
+  private async runChildProcess(childArgs: string[]): Promise<void> {
+    const { spawn } = await import('child_process');
+    let consecutiveFailures = 0;
+
+    while (!this.stopRequested && consecutiveFailures < this.config.maxRestarts) {
+      console.log(`[Daemon] Spawning child process (attempt ${consecutiveFailures + 1}/${this.config.maxRestarts})`);
+
+      const child = spawn(process.execPath, childArgs, {
+        stdio: 'inherit',
+        env: { ...process.env, BOLLOON_DAEMON_CHILD: '1' }
+      });
+
+      child.on('exit', async (code, signal) => {
+        const reason = signal || `exit code ${code}`;
+        console.log(`[Daemon] Child exited: ${reason}`);
+
+        if (this.stopRequested) {
+          console.log('[Daemon] Stop requested, not restarting');
+          await this.clearPid();
+          process.exit(0);
+        }
+
+        consecutiveFailures++;
+        this.state = {
+          ...this.state!,
+          restartCount: consecutiveFailures,
+          lastRestartAt: Date.now(),
+          lastError: reason
+        };
+
+        if (consecutiveFailures < this.config.maxRestarts) {
+          console.log(`[Daemon] Restarting in ${this.config.restartDelayMs}ms...`);
+          await this.writeLog(`Child exited ${reason}, restarting (${consecutiveFailures}/${this.config.maxRestarts})`);
+
+          await new Promise(resolve => setTimeout(resolve, this.config.restartDelayMs));
+          // 继续 while 循环，重启子进程
+        } else {
+          console.error('[Daemon] Max restarts reached, giving up');
+          await this.writeLog(`Max restarts reached (${this.config.maxRestarts})`);
+          await this.clearPid();
+          process.exit(1);
+        }
+      });
+
+      child.on('error', async (err) => {
+        console.error('[Daemon] Child process error:', err.message);
+        await this.writeLog(`Child error: ${err.message}`);
+      });
+
+      // 等待子进程退出
+      await new Promise<void>((resolve) => {
+        child.on('exit', () => resolve());
+      });
+    }
+  }
+
+  /**
+   * 设置优雅退出
+   */
+  private setupGracefulShutdown(): void {
+    let isShuttingDown = false;
+
+    const shutdown = async () => {
+      if (isShuttingDown) return;
+      isShuttingDown = true;
+
+      console.log('[Daemon] Graceful shutdown...');
+      await this.writeLog('Graceful shutdown');
+      this.stopRequested = true;
+
+      await this.clearPid();
+      process.exit(0);
+    };
+
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+    process.on('uncaughtException', async (err) => {
+      console.error('[Daemon] Uncaught exception:', err);
+      await this.writeLog(`Uncaught exception: ${err.message}`);
+      await shutdown();
+    });
+  }
+
+  /**
+   * 设置信号处理
+   */
+  private setupSignalHandlers(): void {
+    process.on('SIGHUP', () => {
+      console.log('[Daemon] Received SIGHUP, reloading...');
+      // 可以实现配置重载逻辑
+    });
+  }
+
+  /**
+   * 请求停止守护进程
+   */
+  async stop(): Promise<void> {
+    const state = await this.getState();
+    if (state) {
+      console.log(`[Daemon] Sending SIGTERM to pid ${state.pid}`);
+      try {
+        process.kill(state.pid, 'SIGTERM');
+      } catch {
+        console.log('[Daemon] Process not found, clearing PID');
+      }
+    }
+    await this.clearPid();
+    this.stopRequested = true;
+  }
+
+  /**
+   * 获取重启次数
+   */
+  async getRestartCount(): Promise<number> {
+    return this.state?.restartCount || 0;
+  }
+
+  /**
+   * 检查是否可以继续重启
+   */
+  canRestart(): boolean {
+    return (this.state?.restartCount || 0) < this.config.maxRestarts;
+  }
+}
+
+// 全局实例
+let daemonManagerInstance: DaemonManager | null = null;
+
+export function getDaemonManager(): DaemonManager {
+  if (!daemonManagerInstance) {
+    daemonManagerInstance = new DaemonManager();
+  }
+  return daemonManagerInstance;
+}
+
+export function createDaemonManager(config?: Partial<DaemonConfig>): DaemonManager {
+  daemonManagerInstance = new DaemonManager(config);
+  return daemonManagerInstance;
+}