@zhin.js/cli 1.0.0

package/src/commands/start.ts

@@ -0,0 +1,236 @@
+import { Command } from 'commander';
+import { logger } from '../utils/logger.js';
+import { loadEnvFiles } from '../utils/env.js';
+import { spawn, ChildProcess } from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+import { startProcess } from '../utils/process.js';
+
+export const startCommand = new Command('start')
+  .description('生产模式启动机器人')
+  .option('-d, --daemon', '后台运行', false)
+  .option('--log-file [file]', '日志文件路径')
+  .option('--bun', '使用 bun 运行（默认使用 node）', false)
+  .action(async (options: { daemon: boolean; logFile?: string; bun: boolean }) => {
+    try {
+      const cwd = process.cwd();
+      
+      // 检查是否是Zhin项目
+      if (!isZhinProject(cwd)) {
+        logger.error('当前目录不是Zhin项目');
+        logger.info('请在Zhin项目根目录运行此命令');
+        process.exit(1);
+      }
+      
+      // 加载环境变量文件
+      logger.info('🔍 正在加载环境变量...');
+      loadEnvFiles(cwd, 'production');
+      
+      // 检查构建产物
+      const distPath = path.join(cwd, 'dist');
+      const sourcePath = path.join(cwd, 'src');
+      const sourceFile = path.join(sourcePath, 'index.ts');
+      const distFile = path.join(distPath, 'index.js');
+      const entryFile = options.bun ? path.relative(cwd,sourceFile) : path.relative(cwd,distFile);
+      
+      if (!fs.existsSync(entryFile)) {
+        logger.error('构建产物不存在，请先运行 zhin build');
+        process.exit(1);
+      }
+      
+      logger.info('🚀 正在生产模式启动机器人...');
+      
+      // 启动机器人的函数
+      const startBot = async (): Promise<ChildProcess> => {
+        // 设置环境变量
+        const env = {
+          ...process.env,
+          NODE_ENV: 'production'
+        };
+        
+        // 配置stdio
+        let stdio: any = 'inherit';
+        if (options.daemon) {
+          stdio = options.logFile ? 
+            ['ignore', fs.openSync(options.logFile, 'a'), fs.openSync(options.logFile, 'a')] :
+            'ignore';
+        }
+        
+        // 选择运行时
+        const runtime = options.bun ? 'bun' : 'node';
+        const args = options.bun ? [entryFile] : ['--expose-gc', entryFile];
+        
+        logger.info(`📦 启动命令: ${runtime} ${args.join(' ')}`);
+        return startProcess(runtime, args, cwd,options.daemon);
+      };
+      
+      let child = await startBot();
+      let isRestarting = false;
+      
+      // 重启函数
+      const restartBot =async () => {
+        if (isRestarting) return;
+        isRestarting = true;
+        
+        logger.info('🔄 正在重启机器人...');
+        
+        // 优雅关闭当前进程
+        if (child && !child.killed) {
+          const oldChild=child
+          oldChild.kill('SIGTERM');
+          // 如果5秒后还没关闭，强制杀掉
+          setTimeout(() => {
+            if (oldChild && !oldChild.killed) {
+              oldChild.kill('SIGKILL');
+            }
+          }, 5000);
+        }
+        child = await startBot();
+        setupChildHandlers(child);
+        isRestarting = false;
+      };
+      
+      // 设置子进程处理器
+      const setupChildHandlers = (childProcess: ChildProcess) => {
+        if (options.daemon) {
+          // 后台运行
+          childProcess.unref();
+          logger.info(`✅ 机器人已在后台启动 (子进程PID: ${childProcess.pid})`);
+          
+          if (options.logFile) {
+            logger.info(`📝 日志输出到: ${options.logFile}`);
+          }
+        } else {
+          // 前台运行
+          childProcess.on('error', (error) => {
+            if (!isRestarting) {
+              logger.error(`❌ 启动失败: ${error.message}`);
+              process.exit(1);
+            }
+          });
+          
+          childProcess.on('exit', async (code) => {
+            if (!isRestarting) {
+              if (code === 51) {
+                return await restartBot();
+              }
+              if (code !== 0) {
+                logger.error(`💀 进程异常退出，代码: ${code}`);
+              } else {
+                logger.info('✅ 机器人已正常退出');
+              }
+              process.exit(code || 0);
+            }
+          });
+        }
+      };
+      
+      // 设置初始子进程处理器
+      setupChildHandlers(child);
+      
+      let killing=false
+      // 处理退出信号
+      const cleanup = () => {
+        if(options.daemon) return process.exit(0)
+        if(killing) return
+        killing=true
+        logger.info('🛑 正在关闭机器人...');
+        if (child && !child.killed) {
+          child.kill('SIGTERM');
+          
+          setTimeout(() => {
+            if (child && !child.killed) {
+              child.kill('SIGKILL');
+              killing=false
+            }
+          }, 5000);
+        }
+        
+        // 清理PID文件
+        const pidFile = path.join(cwd, '.zhin.pid');
+        if (fs.existsSync(pidFile)) {
+          fs.removeSync(pidFile);
+        }
+      };
+      
+      process.on('SIGINT', cleanup);
+      process.on('SIGTERM', cleanup);
+      
+      // 如果是后台运行，保持主进程运行以管理子进程
+      if (options.daemon) {
+        logger.info('💡 重启方式: 在插件中调用 process.exit(51)');
+        logger.info('💡 停止机器人: kill -TERM ' + child.pid);
+        process.exit(0)
+      } else {
+        // 前台运行时也显示重启提示
+        logger.info('💡 前台运行模式，按 Ctrl+C 退出');
+        logger.info('💡 重启方式: 在插件中调用 process.exit(51)');
+      }
+    } catch (error) {
+      logger.error(`❌ 启动失败: ${error}`);
+      process.exit(1);
+    }
+  });
+
+export const restartCommand = new Command('restart')
+  .description('重启生产模式的机器人进程')
+  .action(async () => {
+    try {
+      const cwd = process.cwd();
+      const pidFile = path.join(cwd, '.zhin.pid');
+      
+      // 检查PID文件是否存在
+      if (!fs.existsSync(pidFile)) {
+        logger.error('未找到运行中的机器人进程');
+        logger.info('请先使用 zhin start 启动机器人');
+        process.exit(1);
+      }
+      
+      // 读取PID
+      const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim());
+      
+      if (isNaN(pid)) {
+        logger.error('PID文件格式错误');
+        process.exit(1);
+      }
+      
+      try {
+        // 检查进程是否存在
+        process.kill(pid, 0);
+        
+        // 发送重启信号
+        process.kill(pid, 51);
+        logger.info(`🔄 已发送重启信号给进程 ${pid}`);
+        
+      } catch (error: any) {
+        if (error.code === 'ESRCH') {
+          logger.error('进程不存在，清理PID文件');
+          fs.removeSync(pidFile);
+        } else {
+          logger.error(`发送信号失败: ${error.message}`);
+        }
+        process.exit(1);
+      }
+      
+    } catch (error) {
+      logger.error(`重启失败: ${error}`);
+      process.exit(1);
+    }
+  });
+
+function isZhinProject(cwd: string): boolean {
+  const packageJsonPath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    return false;
+  }
+  
+  try {
+    const packageJson = fs.readJsonSync(packageJsonPath);
+    return packageJson.dependencies && (
+      packageJson.dependencies['zhin.js'] ||
+      packageJson.devDependencies?.['zhin.js']
+    );
+  } catch {
+    return false;
+  }
+} 

package/src/commands/stop.ts

@@ -0,0 +1,27 @@
+import { Command } from 'commander';
+import { logger } from '../utils/logger.js';
+import { stopProcess, getProcessStatus } from '../utils/process.js';
+
+export const stopCommand = new Command('stop')
+  .description('停止机器人')
+  .action(async () => {
+    try {
+      const cwd = process.cwd();
+      
+      // 检查是否有运行中的进程
+      const status = await getProcessStatus(cwd);
+      if (!status.running) {
+        logger.warn('没有运行中的机器人进程');
+        return;
+      }
+      
+      logger.info(`正在停止机器人 (PID: ${status.pid})...`);
+      
+      // 停止进程
+      await stopProcess(cwd);
+      
+    } catch (error) {
+      logger.error(`停止失败: ${error}`);
+      process.exit(1);
+    }
+  }); 

package/src/index.ts

@@ -0,0 +1 @@
+export { logger } from './utils/logger.js';

package/src/utils/env.ts

@@ -0,0 +1,70 @@
+import dotenv from 'dotenv';
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from './logger.js';
+
+/**
+ * 加载环境变量文件
+ * 加载顺序：.env -> .env.${NODE_ENV}
+ * 后加载的文件会覆盖前面的配置
+ */
+export function loadEnvFiles(cwd: string, nodeEnv: string): void {
+  const envFiles = [
+    '.env',
+    `.env.${nodeEnv}`
+  ];
+
+  let loadedFiles: string[] = [];
+  let totalVars = 0;
+
+  for (const envFile of envFiles) {
+    const envPath = path.join(cwd, envFile);
+    
+    if (fs.existsSync(envPath)) {
+      try {
+        const result = dotenv.config({ path: envPath });
+        
+        if (result.parsed) {
+          const varCount = Object.keys(result.parsed).length;
+          totalVars += varCount;
+          loadedFiles.push(`${envFile} (${varCount} vars)`);
+          
+          // 在debug模式下显示详细信息
+          if (process.env.ZHIN_DEBUG === 'true') {
+            logger.info(`📄 已加载环境变量文件: ${envFile}`);
+            
+            // 打印加载的变量（仅在debug模式）
+            Object.keys(result.parsed).forEach(key => {
+              const value = result.parsed![key];
+              const displayValue = key.toLowerCase().includes('password') || 
+                                 key.toLowerCase().includes('secret') || 
+                                 key.toLowerCase().includes('token') 
+                                 ? '***' : value;
+              logger.info(`  - ${key}=${displayValue}`);
+            });
+          }
+        }
+      } catch (error) {
+        logger.warn(`⚠️  加载环境变量文件 ${envFile} 失败: ${error instanceof Error ? error.message : error}`);
+      }
+    }
+  }
+
+  if (loadedFiles.length > 0) {
+    logger.info(`🔧 已加载环境变量: ${loadedFiles.join(', ')} (共 ${totalVars} 个变量)`);
+  } else {
+    if (process.env.ZHIN_DEBUG === 'true') {
+      logger.info('💡 未找到环境变量文件，使用系统环境变量');
+    }
+  }
+}
+
+/**
+ * 获取环境变量优先级说明
+ */
+export function getEnvLoadOrder(nodeEnv: string): string[] {
+  return [
+    '.env (基础配置)',
+    `.env.${nodeEnv} (${nodeEnv}环境特定配置，优先级更高)`
+  ];
+} 

package/src/utils/logger.ts

@@ -0,0 +1,21 @@
+export const logger = {
+  info: (message: string,...args: any[]) => {
+    console.log('[INFO] [CLI]:', message,...args);
+  },
+  
+  success: (message: string,...args: any[]) => {
+    console.log('[SUCCESS] [CLI]:', message,...args);
+  },
+  
+  warn: (message: string,...args: any[]) => {
+    console.log('[WARN] [CLI]:', message,...args);
+  },
+  
+  error: (message: string,...args: any[]) => {
+    console.log('[ERROR] [CLI]:', message,...args);
+  },
+  
+  log: (message: string,...args: any[]) => {
+    console.log('[LOG] [CLI]:', message,...args);
+  }
+}; 

package/src/utils/process.ts

@@ -0,0 +1,348 @@
+import { spawn, ChildProcess, exec } from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from './logger.js';
+import os from 'os';
+
+const PID_FILE = '.zhin.pid';
+
+/**
+ * 检查进程是否存在的跨平台实现
+ */
+async function isProcessRunning(pid: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const platform = os.platform();
+    
+    if (platform === 'win32') {
+      // Windows: 使用 tasklist 命令
+      exec(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, (error, stdout) => {
+        if (error) {
+          resolve(false);
+          return;
+        }
+        // tasklist 输出包含进程信息表示进程存在
+        resolve(stdout.trim().length > 0 && !stdout.includes('INFO: No tasks'));
+      });
+    } else {
+      // Linux/macOS: 使用 ps 命令
+      exec(`ps -p ${pid} -o pid=`, (error, stdout) => {
+        if (error) {
+          resolve(false);
+          return;
+        }
+        // ps 输出包含 PID 表示进程存在
+        resolve(stdout.trim().length > 0);
+      });
+    }
+  });
+}
+
+/**
+ * 终止进程的跨平台实现
+ */
+async function killProcess(pid: number, signal: string = 'SIGTERM'): Promise<boolean> {
+  return new Promise((resolve) => {
+    const platform = os.platform();
+    
+    if (platform === 'win32') {
+      // Windows: 使用 taskkill 命令
+      const forceFlag = signal === 'SIGKILL' ? '/F' : '';
+      exec(`taskkill /PID ${pid} ${forceFlag}`, (error) => {
+        resolve(!error);
+      });
+    } else {
+      // Linux/macOS: 使用 kill 命令
+      const signalFlag = signal === 'SIGKILL' ? '-9' : '-15';
+      exec(`kill ${signalFlag} ${pid}`, (error) => {
+        resolve(!error);
+      });
+    }
+  });
+}
+
+export async function startProcess(command: string, args: string[], cwd: string,daemon:boolean): Promise<ChildProcess> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      detached: daemon,
+      stdio: 'ignore',
+      env: { ...process.env }
+    });
+
+    if(daemon) child.unref();
+
+    child.on('spawn', () => {
+      // 保存进程ID
+      const pidFile = path.join(cwd, PID_FILE);
+      fs.writeFileSync(pidFile, child.pid!.toString());
+      logger.success(`机器人已启动，PID: ${child.pid}`);
+      resolve(child);
+    });
+
+    child.on('error', (error) => {
+      logger.error(`启动失败: ${error.message}`);
+      reject(error);
+    });
+
+    // 设置超时检查
+    setTimeout(() => {
+      if (child.killed) {
+        reject(new Error('进程启动超时'));
+      }
+    }, 5000);
+  });
+}
+
+export async function stopProcess(cwd: string): Promise<void> {
+  const pidFile = path.join(cwd, PID_FILE);
+  
+  if (!fs.existsSync(pidFile)) {
+    logger.warn('没有找到运行中的机器人进程');
+    return;
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf8'));
+    
+    // 检查进程是否存在
+    const isRunning = await isProcessRunning(pid);
+    if (!isRunning) {
+      logger.warn('进程已不存在，清理PID文件');
+      fs.removeSync(pidFile);
+      return;
+    }
+
+    // 终止进程
+    const killed = await killProcess(pid, 'SIGTERM');
+    if (!killed) {
+      logger.warn('无法终止进程，可能进程已结束');
+      fs.removeSync(pidFile);
+      return;
+    }
+    
+    // 等待进程结束
+    let attempts = 0;
+    while (attempts < 30) {
+      const stillRunning = await isProcessRunning(pid);
+      if (!stillRunning) {
+        break;
+      }
+      await new Promise(resolve => setTimeout(resolve, 100));
+      attempts++;
+    }
+
+    // 如果进程仍然存在，强制结束
+    if (attempts >= 30) {
+      logger.warn('进程未响应，尝试强制结束');
+      await killProcess(pid, 'SIGKILL');
+      
+      // 再次等待
+      attempts = 0;
+      while (attempts < 10) {
+        const stillRunning = await isProcessRunning(pid);
+        if (!stillRunning) {
+          break;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+        attempts++;
+      }
+    }
+
+    fs.removeSync(pidFile);
+    logger.success('机器人已停止');
+    
+  } catch (error) {
+    logger.error(`停止进程时发生错误: ${error}`);
+    // 清理PID文件
+    fs.removeSync(pidFile);
+  }
+}
+
+export async function getProcessStatus(cwd: string): Promise<{ running: boolean; pid?: number }> {
+  const pidFile = path.join(cwd, PID_FILE);
+  
+  if (!fs.existsSync(pidFile)) {
+    return { running: false };
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf8'));
+    
+    // 检查进程是否存在
+    const isRunning = await isProcessRunning(pid);
+    if (!isRunning) {
+      // 进程不存在，清理PID文件
+      fs.removeSync(pidFile);
+      return { running: false };
+    }
+    
+    return { running: true, pid };
+  } catch {
+    return { running: false };
+  }
+}
+
+/**
+ * 获取进程详细状态信息
+ */
+export async function getProcessStatusDetailed(cwd: string): Promise<{ 
+  running: boolean; 
+  pid?: number; 
+  info?: { name: string; memory?: string; cpu?: string } 
+}> {
+  const pidFile = path.join(cwd, PID_FILE);
+  
+  if (!fs.existsSync(pidFile)) {
+    return { running: false };
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf8'));
+    
+    // 检查进程是否存在
+    const isRunning = await isProcessRunning(pid);
+    if (!isRunning) {
+      // 进程不存在，清理PID文件
+      fs.removeSync(pidFile);
+      return { running: false };
+    }
+    
+    // 获取进程详细信息
+    const info = await getProcessInfo(pid);
+    
+    return { running: true, pid, info: info || undefined };
+  } catch {
+    return { running: false };
+  }
+}
+
+/**
+ * 获取进程详细信息的跨平台实现
+ */
+async function getProcessInfo(pid: number): Promise<{ name: string; memory?: string; cpu?: string } | null> {
+  return new Promise((resolve) => {
+    const platform = os.platform();
+    
+    if (platform === 'win32') {
+      // Windows: 使用 tasklist 命令获取详细信息
+      exec(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, (error, stdout) => {
+        if (error || !stdout.trim() || stdout.includes('INFO: No tasks')) {
+          resolve(null);
+          return;
+        }
+        
+        // 解析 CSV 格式输出: "进程名","PID","会话名","会话#","内存使用"
+        const lines = stdout.trim().split('\n');
+        if (lines.length > 0) {
+          const parts = lines[0].split(',');
+          if (parts.length >= 5) {
+            const name = parts[0].replace(/"/g, '');
+            const memory = parts[4].replace(/"/g, '');
+            resolve({ name, memory });
+          } else {
+            resolve({ name: 'Unknown' });
+          }
+        } else {
+          resolve(null);
+        }
+      });
+    } else {
+      // Linux/macOS: 使用 ps 命令获取详细信息
+      exec(`ps -p ${pid} -o comm=,rss=,pcpu=`, (error, stdout) => {
+        if (error || !stdout.trim()) {
+          resolve(null);
+          return;
+        }
+        
+        const lines = stdout.trim().split('\n');
+        if (lines.length > 0) {
+          const parts = lines[0].trim().split(/\s+/);
+          if (parts.length >= 3) {
+            const name = parts[0];
+            const memory = `${(parseInt(parts[1]) / 1024).toFixed(1)}MB`;
+            const cpu = `${parseFloat(parts[2]).toFixed(1)}%`;
+            resolve({ name, memory, cpu });
+          } else {
+            resolve({ name: 'Unknown' });
+          }
+        } else {
+          resolve(null);
+        }
+      });
+    }
+  });
+}
+
+/**
+ * 获取所有相关进程的列表
+ */
+async function getRelatedProcessesInternal(processName: string): Promise<Array<{ pid: number; name: string; memory?: string; cpu?: string }>> {
+  return new Promise((resolve) => {
+    const platform = os.platform();
+    
+    if (platform === 'win32') {
+      // Windows: 使用 tasklist 命令
+      exec(`tasklist /FI "IMAGENAME eq ${processName}*" /FO CSV /NH`, (error, stdout) => {
+        if (error || !stdout.trim() || stdout.includes('INFO: No tasks')) {
+          resolve([]);
+          return;
+        }
+        
+        const processes: Array<{ pid: number; name: string; memory?: string; cpu?: string }> = [];
+        const lines = stdout.trim().split('\n');
+        
+        for (const line of lines) {
+          const parts = line.split(',');
+          if (parts.length >= 5) {
+            const name = parts[0].replace(/"/g, '');
+            const pid = parseInt(parts[1].replace(/"/g, ''));
+            const memory = parts[4].replace(/"/g, '');
+            if (!isNaN(pid)) {
+              processes.push({ pid, name, memory });
+            }
+          }
+        }
+        
+        resolve(processes);
+      });
+    } else {
+      // Linux/macOS: 使用 ps 命令
+      exec(`ps -C "${processName}" -o pid=,comm=,rss=,pcpu=`, (error, stdout) => {
+        if (error || !stdout.trim()) {
+          resolve([]);
+          return;
+        }
+        
+        const processes: Array<{ pid: number; name: string; memory?: string; cpu?: string }> = [];
+        const lines = stdout.trim().split('\n');
+        
+        for (const line of lines) {
+          const parts = line.trim().split(/\s+/);
+          if (parts.length >= 4) {
+            const pid = parseInt(parts[0]);
+            const name = parts[1];
+            const memory = `${(parseInt(parts[2]) / 1024).toFixed(1)}MB`;
+            const cpu = `${parseFloat(parts[3]).toFixed(1)}%`;
+            if (!isNaN(pid)) {
+              processes.push({ pid, name, memory, cpu });
+            }
+          }
+        }
+        
+        resolve(processes);
+      });
+    }
+  });
+}
+
+/**
+ * 获取所有相关进程列表
+ */
+export async function getRelatedProcesses(processName: string): Promise<Array<{ 
+  pid: number; 
+  name: string; 
+  memory?: string; 
+  cpu?: string 
+}>> {
+  return await getRelatedProcessesInternal(processName);
+}