SnowCatQQ/packages/snowcat-shell/snowcat.ts

import { NCoreInitShell } from './base';
import { SnowCatPathWrapper } from '@/snowcat-common/src/path';
import { LogWrapper } from '@/snowcat-core/helper/log';
import { connectToNamedPipe } from './pipe';
import { WebUiDataRuntime } from '@/snowcat-webui-backend/src/helper/Data';
import { AuthHelper } from '@/snowcat-webui-backend/src/helper/SignToken';
import { webUiRuntimePort } from '@/snowcat-webui-backend/index';
import { createProcessManager, type IProcessManager, type IWorkerProcess } from './process-api';
import path from 'path';
import fs from 'fs';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const pathWrapper = new SnowCatPathWrapper();
const envPath = path.join(__dirname, 'config', '.env');
if (fs.existsSync(envPath)) {
  try {
    const data = fs.readFileSync(envPath, 'utf8');
    data.split(/\r?\n/).forEach(line => {
      line = line.trim();
      if (line && !line.startsWith('#')) {
        const parts = line.split('=');
        const key = parts[0]?.trim();
        const value = parts.slice(1).join('=').trim();
        if (key && value) {
          process.env[key] = value;
        }
      }
    });
  } catch (e) {
    console.log('[SnowCat] Failed to load .env file:', e);
  }
}

// 环境变量配置
const ENV = {
  isWorkerProcess: process.env['NAPCAT_WORKER_PROCESS'] === '1',
  isMultiProcessDisabled: process.env['NAPCAT_DISABLE_MULTI_PROCESS'] === '1' || process.env['NAPCAT_DISABLE_MULTIPROCESSING'] === '1',
  isPipeDisabled: process.env['NAPCAT_DISABLE_PIPE'] === '1',
} as const;

// Worker 消息类型
interface WorkerMessage {
  type: 'restart' | 'restart-prepare' | 'shutdown' | 'login-success';
  secretKey?: string;
  port?: number;
}

const logger = new LogWrapper(pathWrapper.logsPath);
if (!ENV.isWorkerProcess && !ENV.isMultiProcessDisabled) {
  logger.setFileLogEnabled(false);
}

// 进程管理器和当前 Worker 进程引用
let processManager: IProcessManager | null = null;
let currentWorker: IWorkerProcess | null = null;
let isElectron = false;
let isRestarting = false;
let isShuttingDown = false;

// 进程崩溃保护：记录最近的异常退出时间戳
const recentCrashTimestamps: number[] = [];
const CRASH_TIME_WINDOW = 10000; // 10秒时间窗口
const MAX_CRASHES_IN_WINDOW = 3; // 最大崩溃次数

/**
 * 获取进程类型名称（用于日志）
 */
function getProcessTypeName (): string {
  return isElectron ? 'UtilityProcess' : 'Fork';
}

/**
 * 获取 Worker 脚本路径
 */
function getWorkerScriptPath (): string {
  return __filename.endsWith('.mjs')
    ? path.join(__dirname, 'napcat.mjs')
    : path.join(__dirname, 'napcat.js');
}

/**
 * 检查进程是否存在
 */
function isProcessAlive (pid: number): boolean {
  try {
    process.kill(pid, 0);
    return true;
  } catch {
    return false;
  }
}

/**
 * 强制终止进程
 */
function forceKillProcess (pid: number): void {
  try {
    process.kill(pid, 'SIGKILL');
  } catch (error) {
    // SIGKILL 失败，在 Windows 上使用 taskkill 兜底
    if (process.platform === 'win32') {
      try {
        require('child_process').execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore' });
      } catch {
        logger.logError(`[SnowCat] [Process] 强制终止进程失败: PID ${pid}`);
      }
    } else {
      logger.logError('[SnowCat] [Process] 强制终止进程失败:', error);
    }
  }
}

/**
 * 清理进程树中的残留子进程（Electron 模式专用）
 * 排除当前主进程和新 worker 进程
 */
async function cleanupOrphanedProcesses (excludePids: number[]): Promise<void> {
  if (!isElectron) return;

  try {
    // 使用 Electron 的 app.getAppMetrics() 获取所有相关进程
    // @ts-ignore - electron 运行时存在但类型声明可能缺失
    const electron = await import('electron');
    if (electron.app && typeof electron.app.getAppMetrics === 'function') {
      const metrics = electron.app.getAppMetrics();
      const mainPid = process.pid;

      for (const metric of metrics) {
        const pid = metric.pid;
        // 排除主进程、新 worker 进程和明确排除的 PID
        if (pid === mainPid || excludePids.includes(pid)) {
          continue;
        }
        // 尝试终止残留进程
        try {
          process.kill(pid, 'SIGTERM');
          logger.log(`[SnowCat] [Process] 已清理残留进程: PID ${pid} (${metric.type})`);
        } catch {
          // 进程可能已经不存在，忽略错误
        }
      }
    }
  } catch (error) {
    // Electron API 不可用或出错，静默忽略
    logger.logDebug?.('[SnowCat] [Process] 清理残留进程时出错:', error);
  }
}

/**
 * 重启 Worker 进程
 */
export async function restartWorker (secretKey?: string, port?: number): Promise<void> {
  isRestarting = true;

  if (!currentWorker) {
    logger.logWarn('[SnowCat] [Process] 没有运行中的Worker进程');
    await startWorker(false);
    isRestarting = false;
    return;
  }

  const workerPid = currentWorker.pid;

  // 1. 通知旧进程准备重启（旧进程会自行退出）
  currentWorker.postMessage({ type: 'restart-prepare' });

  // 2. 等待进程退出（最多 5 秒，给更多时间让进程自行清理）
  await new Promise<void>((resolve) => {
    const timeout = setTimeout(() => {
      logger.logWarn('[SnowCat] [Process] Worker进程未在 5 秒内退出，尝试发送强制关闭信号');
      currentWorker?.postMessage({ type: 'shutdown' });

      // 再等待 2 秒
      setTimeout(() => {
        logger.logWarn('[SnowCat] [Process] Worker进程仍未退出，尝试 kill');
        currentWorker?.kill();
        resolve();
      }, 2000);
    }, 5000);

    currentWorker?.once('exit', () => {
      clearTimeout(timeout);
      resolve();
    });
  });

  // 3. 二次确认进程是否真的被终止（兜底检查）
  if (workerPid && isProcessAlive(workerPid)) {
    logger.logWarn(`[SnowCat] [Process] 进程 ${workerPid} 仍在运行，尝试强制杀掉`);
    forceKillProcess(workerPid);
    await new Promise(resolve => setTimeout(resolve, 1000));
    if (isProcessAlive(workerPid)) {
      logger.logError(`[SnowCat] [Process] 进程 ${workerPid} 无法终止，可能需要手动处理`);
    }
  }

  // 4. 等待后启动新进程
  await new Promise(resolve => setTimeout(resolve, 3000));

  // 5. 启动新进程（重启模式不传递快速登录参数，传递密钥和端口）
  await startWorker(false, secretKey, port);

  // 6. Electron 模式下清理可能残留的子进程
  if (isElectron && currentWorker?.pid) {
    const excludePids = [process.pid, currentWorker.pid];
    await cleanupOrphanedProcesses(excludePids);
  }

  isRestarting = false;
}

/**
 * 启动 Worker 进程
 * @param passQuickLogin 是否传递快速登录参数，默认为 true，重启时为 false
 * @param secretKey WebUI JWT 密钥
 * @param preferredPort 优先使用的 WebUI 端口
 */
async function startWorker (passQuickLogin: boolean = true, secretKey?: string, preferredPort?: number): Promise<void> {
  if (!processManager) {
    throw new Error('进程管理器未初始化');
  }

  const workerScript = getWorkerScriptPath();
  const processType = getProcessTypeName();

  // 只在首次启动时传递 -q 或 --qq 参数给 worker 进程
  const workerArgs: string[] = [];
  if (passQuickLogin) {
    const args = process.argv.slice(2);
    const qIndex = args.findIndex(arg => arg === '-q' || arg === '--qq');
    if (qIndex !== -1 && qIndex + 1 < args.length) {
      const qFlag = args[qIndex];
      const qValue = args[qIndex + 1];
      if (qFlag && qValue) {
        workerArgs.push(qFlag, qValue);
      }
    }
  }

  const child = processManager.createWorker(workerScript, workerArgs, {
    env: {
      ...process.env,
      NAPCAT_WORKER_PROCESS: '1',
      ...(secretKey ? { NAPCAT_WEBUI_JWT_SECRET_KEY: secretKey } : {}),
      ...(preferredPort ? { NAPCAT_WEBUI_PREFERRED_PORT: String(preferredPort) } : {}),
    },
    stdio: isElectron ? 'pipe' : ['inherit', 'pipe', 'pipe', 'ipc'],
    // --no-sandbox 是 Chromium 开关，仅当子进程完整引导 Electron（未设 ELECTRON_RUN_AS_NODE）时
    // 才会被解析；纯 Node / Electron node 模式子进程会因 bad option 以退出码 9 拒绝启动
    // （ELECTRON_RUN_AS_NODE 变量存在即触发 node 模式，与取值无关）
    ...(!isElectron &&
      process.versions['electron'] &&
      process.env['ELECTRON_RUN_AS_NODE'] === undefined
      ? { execArgv: ['--no-sandbox'] }
      : {}),
  });

  currentWorker = child;

  // 监听标准输出（直接转发）
  if (child.stdout) {
    child.stdout.on('data', (data: Buffer) => {
      process.stdout.write(data);
    });
  }

  // 监听标准错误（直接转发）
  if (child.stderr) {
    child.stderr.on('data', (data: Buffer) => {
      process.stderr.write(data);
    });
  }

  // 监听子进程消息
  child.on('message', (msg: unknown) => {
    // 处理重启请求
    if (typeof msg === 'object' && msg !== null && 'type' in msg) {
      const message = msg as WorkerMessage;
      if (message.type === 'restart') {
        restartWorker(message.secretKey, message.port).catch(e => {
          logger.logError(`[SnowCat] [${processType}] 重启Worker进程失败:`, e);
        });
      } else if (message.type === 'login-success') {
        logger.log(`[SnowCat] [${processType}] Worker进程已登录成功，切换到正常重试策略`);
      }
    }
  });

  // 监听子进程退出
  child.on('exit', (code: unknown) => {
    const exitCode = typeof code === 'number' ? code : 0;
    if (exitCode !== 0) {
      logger.logError(`[SnowCat] [${processType}] Worker进程退出，退出码: ${exitCode}`);
    }
    // 如果不是由于主动重启或关闭引起的退出，尝试自动重新拉起
    if (!isRestarting && !isShuttingDown) {
      const now = Date.now();

      // 清理超出时间窗口的崩溃记录
      while (recentCrashTimestamps.length > 0 && now - recentCrashTimestamps[0]! > CRASH_TIME_WINDOW) {
        recentCrashTimestamps.shift();
      }

      // 记录本次崩溃
      recentCrashTimestamps.push(now);

      if (recentCrashTimestamps.length >= MAX_CRASHES_IN_WINDOW) {
        logger.logError(`[SnowCat] [${processType}] Worker进程在 ${CRASH_TIME_WINDOW / 1000} 秒内异常退出 ${MAX_CRASHES_IN_WINDOW} 次，主进程退出`);
        process.exit(1);
      }

      logger.logWarn(`[SnowCat] [${processType}] Worker进程意外退出 (${recentCrashTimestamps.length}/${MAX_CRASHES_IN_WINDOW})，正在尝试重新拉起...`);

      startWorker(true).catch(e => {
        logger.logError(`[SnowCat] [${processType}] 重新拉起Worker进程失败:`, e);
      });
    }
  });

  // 等待进程成功 spawn
  await new Promise<void>((resolve, reject) => {
    const onSpawn = () => {
      child.off('error', onError);
      resolve();
    };
    const onError = (...args: unknown[]) => {
      const err = args[0] as Error;
      logger.logError(`[SnowCat] [${processType}] Worker进程启动失败:`, err);
      child.off('spawn', onSpawn);
      reject(err);
    };
    child.once('spawn', onSpawn);
    child.once('error', onError);
  });
}

/**
 * 启动 Master 进程
 */
async function startMasterProcess (): Promise<void> {
  // 连接命名管道（可通过环境变量禁用）
  if (!ENV.isPipeDisabled) {
    await connectToNamedPipe(logger).catch(e =>
      logger.logError('命名管道连接失败', e)
    );
  }

  // 启动 Worker 进程
  await startWorker();

  // 优雅关闭处理
  const shutdown = () => {
    isShuttingDown = true;
    if (currentWorker) {
      currentWorker.postMessage({ type: 'shutdown' });
      setTimeout(() => {
        currentWorker?.kill();
        process.exit(0);
      }, 1000);
    } else {
      process.exit(0);
    }
  };

  process.on('SIGINT', () => shutdown());
  process.on('SIGTERM', () => shutdown());
}

/**
 * 启动 Worker 进程（子进程入口）
 */
async function startWorkerProcess (): Promise<void> {
  if (!processManager) {
    throw new Error('进程管理器未初始化');
  }

  // 预加载 Node Addon（如果设置了环境变量）
  const preloadAddonPath = process.env['NAPCAT_PRELOAD_NODE_ADDON_PATH'];
  if (preloadAddonPath) {
    try {
      const os = await import('os');
      process.dlopen({ exports: {} }, preloadAddonPath, os.constants.dlopen.RTLD_NOW | os.constants.dlopen.RTLD_GLOBAL);
      logger.log(`[SnowCat] [Worker] 已预加载 Node Addon: ${preloadAddonPath}`);
    } catch (error) {
      logger.logError(`[SnowCat] [Worker] 预加载 Node Addon 失败: ${preloadAddonPath}`, error);
    }
  }

  // 监听来自父进程的消息
  processManager.onParentMessage((msg: unknown) => {
    if (typeof msg === 'object' && msg !== null && 'type' in msg) {
      if (msg.type === 'restart-prepare' || msg.type === 'shutdown') {
        setTimeout(() => {
          process.exit(0);
        }, 100);
      }
    }
  });

  // 注册重启进程函数到 WebUI
  WebUiDataRuntime.setRestartProcessCall(async () => {
    try {
      const success = processManager!.sendToParent({
        type: 'restart',
        secretKey: AuthHelper.getSecretKey(),
        port: webUiRuntimePort,
      });

      if (success) {
        return { result: true, message: '进程重启请求已发送' };
      } else {
        return { result: false, message: '无法与主进程通信' };
      }
    } catch (e) {
      logger.logError('[SnowCat] [Process] 发送重启请求失败:', e);
      return {
        result: false,
        message: '发送重启请求失败: ' + (e as Error).message,
      };
    }
  });

  // 启动 NapCat 核心
  await NCoreInitShell();
}

/**
 * 主入口
 */
async function main (): Promise<void> {
  // 单进程模式：直接启动核心
  if (ENV.isMultiProcessDisabled) {
    await NCoreInitShell();
    return;
  }

  // 多进程模式：初始化进程管理器
  const result = await createProcessManager();
  processManager = result.manager;
  isElectron = result.isElectron;

  // 根据进程类型启动
  if (ENV.isWorkerProcess) {
    await startWorkerProcess();
  } else {
    await startMasterProcess();
  }
}

// 启动应用
main().catch((e: Error) => {
  logger.logError('[SnowCat] [Process] 启动失败:', e);
  process.exit(1);
});