enhance daemon lifecycle logic like connect ensurance

packages/pm/daemon.js

@@ -28,6 +28,9 @@ const net = require('net');
 const { spawn } = require('child_process');
 const path = require('path');
 const split2 = require('split2');
+const fs = require('fs')
+
+const ipcWritePipe = fs.createWriteStream(null, { fd: 3 })
 
 const PORT = 12345;
 const workers = new Map(); // workerId -> { process, status, restartCount, socket, latestScreenshot, latestScreenshotAt }
@@ -88,6 +91,13 @@ const server = net.createServer((socket) => {
 function handleMessage(socket, message) {
   console.log('收到消息:', message);
   const _callbackUuid = message._callbackUuid
+  if (message.type === 'ping') {
+    sendResponse(socket, _callbackUuid, {
+      success: true, 
+      message: 'pong'
+    });
+    return
+  }
 
   // 工具进程注册消息
   if (message.type === 'worker-register') {
@@ -214,9 +224,8 @@ function handleMessage(socket, message) {
 
     case 'get-status':
       const status = getWorkersStatus();
-      sendResponse(socket, _callbackUuid, { 
+      sendResponse(socket, _callbackUuid, {
         success: true, 
-        type: 'status',
         workers: status 
       });
       break;
@@ -442,9 +451,23 @@ function sendResponse(socket, _callbackUuid, response) {
 }
 
 // 启动服务器
-server.listen(PORT, () => {
-  console.log(`守护进程服务器运行在端口 ${PORT}`);
-});
+new Promise((resolve, reject) => {
+  server.once('error', (err) => {
+    ipcWritePipe.write(
+      JSON.stringify({ type: 'DAEMON_FATAL', error: err }),
+      (err) => void err
+    )
+    reject(err)
+  })
+  server.listen(PORT, () => {
+    console.log(`守护进程服务器运行在端口 ${PORT}`);
+    ipcWritePipe.write(
+      JSON.stringify({ type: 'DAEMON_READY' }),
+      (err) => void err
+    )
+    resolve(true)
+  });
+})
 
 // 优雅关闭
 process.on('SIGTERM', () => {

packages/pm/worker.js

@@ -1,244 +0,0 @@
-// 如果是通过 Electron 运行，禁用 GUI 和 Dock 图标
-if (typeof require !== 'undefined') {
-  try {
-    const { app } = require('electron');
-    if (app) {
-      // 隐藏 Dock 图标（macOS）
-      if (process.platform === 'darwin') {
-        app.dock?.hide();
-      }
-      
-      // 防止显示窗口
-      app.on('ready', () => {
-        // 不创建任何窗口，保持后台运行
-      });
-      
-      // 防止在没有窗口时退出
-      app.on('window-all-closed', (e) => {
-        e.preventDefault();
-        // 不退出应用，保持后台运行
-      });
-    }
-  } catch (e) {
-    // 不在 Electron 环境中，忽略
-  }
-}
-
-// 工具进程示例
-const net = require('net');
-const split2 = require('split2');
-
-// 解析命令行参数
-let workerId = 'unknown';
-let restartCount = 0;
-for (let i = 2; i < process.argv.length; i++) {
-  const arg = process.argv[i];
-  if (arg.startsWith('--worker-id=')) {
-    workerId = arg.split('=')[1] || 'unknown';
-  } else if (arg.startsWith('--restart-count=')) {
-    restartCount = parseInt(arg.split('=')[1] || '0', 10);
-  }
-}
-
-console.log(`工具进程 ${workerId} 已启动 (PID: ${process.pid})${restartCount > 0 ? `，这是第${restartCount}次重启` : ''}`);
-
-const DAEMON_PORT = 12345;
-let daemonSocket = null;
-let reconnectTimer = null;
-let isShuttingDown = false;
-
-// 连接到守护进程
-function connectToDaemon() {
-  if (isShuttingDown) return;
-  
-  daemonSocket = new net.Socket();
-  
-  daemonSocket.connect(DAEMON_PORT, 'localhost', () => {
-    console.log(`[工具进程 ${workerId}] 已连接到守护进程`);
-    
-    // 注册工具进程连接
-    sendToDaemon({
-      type: 'worker-register',
-      workerId: workerId
-    });
-    
-    // 连接成功后立即检查是否应该退出
-    setTimeout(() => {
-      checkShouldIExit();
-    }, 500);
-  });
-
-  // 使用 split2 按行分割流式数据，处理 JSONL 格式（每行一个 JSON）
-  // split2 会自动处理 TCP 分包问题，确保每条完整的消息（以换行符结尾）才会触发
-  const splitStream = split2();
-  
-  daemonSocket.pipe(splitStream).on('data', (line) => {
-    const trimmedLine = line.toString().trim();
-    if (!trimmedLine) {
-      return; // 跳过空行
-    }
-    
-    try {
-      const message = JSON.parse(trimmedLine);
-      handleDaemonMessage(message);
-    } catch (parseError) {
-      console.error(`[工具进程 ${workerId}] 解析JSON消息失败:`, parseError.message);
-      console.error('原始数据:', trimmedLine.substring(0, 100)); // 只打印前100个字符
-    }
-  });
-
-  splitStream.on('error', (err) => {
-    console.error(`[工具进程 ${workerId}] split2 流处理错误:`, err);
-  });
-
-  daemonSocket.on('error', (err) => {
-    console.error(`[工具进程 ${workerId}] 守护进程连接错误:`, err.message);
-    daemonSocket = null;
-    
-    // 尝试重连（如果不是正在关闭）
-    if (!isShuttingDown) {
-      if (reconnectTimer) clearTimeout(reconnectTimer);
-      reconnectTimer = setTimeout(() => {
-        console.log(`[工具进程 ${workerId}] 尝试重新连接守护进程...`);
-        connectToDaemon();
-      }, 2000);
-    }
-  });
-
-  daemonSocket.on('close', () => {
-    console.log(`[工具进程 ${workerId}] 守护进程连接已关闭`);
-    daemonSocket = null;
-    
-    // 尝试重连（如果不是正在关闭）
-    if (!isShuttingDown) {
-      if (reconnectTimer) clearTimeout(reconnectTimer);
-      reconnectTimer = setTimeout(() => {
-        console.log(`[工具进程 ${workerId}] 尝试重新连接守护进程...`);
-        connectToDaemon();
-      }, 2000);
-    }
-  });
-}
-
-// 发送消息到守护进程
-function sendToDaemon(message) {
-  if (daemonSocket && !daemonSocket.destroyed) {
-    try {
-      daemonSocket.write(JSON.stringify(message) + '\n');
-    } catch (e) {
-      console.error(`[工具进程 ${workerId}] 发送消息失败:`, e);
-    }
-  } else {
-    console.warn(`[工具进程 ${workerId}] 守护进程未连接，消息已丢弃:`, message.type);
-  }
-}
-
-// 处理守护进程消息
-function handleDaemonMessage(message) {
-  if (message.type === 'worker-registered') {
-    console.log(`[工具进程 ${workerId}] 连接已注册到守护进程`);
-  } else if (message.type === 'check-should-exit') {
-    // 处理是否应该退出的查询响应
-    if (message.shouldExit) {
-      console.log(`[工具进程 ${workerId}] 守护进程指示应该退出，正在退出...`);
-      shutdown();
-    }
-  } else if (message.error) {
-    console.error(`[工具进程 ${workerId}] 守护进程错误:`, message.error);
-    // 如果守护进程要求退出（例如：已被标记为停止）
-    if (message.shouldExit) {
-      console.log(`[工具进程 ${workerId}] 守护进程要求退出，正在退出...`);
-      shutdown();
-    }
-  }
-}
-
-// 检查是否应该退出
-function checkShouldIExit() {
-  if (isShuttingDown) return;
-  
-  if (!daemonSocket || daemonSocket.destroyed) {
-    // 如果守护进程未连接，暂时不检查，等待重连
-    return;
-  }
-  
-  sendToDaemon({
-    type: 'check-should-exit',
-    workerId: workerId
-  });
-}
-
-// 初始连接
-connectToDaemon();
-
-// 模拟工作负载
-let counter = 0;
-const interval = setInterval(() => {
-  counter++;
-  console.log(`[工具进程 ${workerId}] 运行中... 计数: ${counter}`);
-  
-  // 发送工作数据到守护进程
-  sendToDaemon({
-    type: 'worker-data',
-    workerId: workerId,
-    data: {
-      counter: counter,
-      timestamp: Date.now(),
-      message: `工具进程 ${workerId} 工作数据`
-    }
-  });
-  
-  // 模拟随机错误（用于测试自动重启功能）
-  // 取消下面的注释来测试自动重启
-  // if (Math.random() < 0.001) {
-  //   console.error(`[工具进程 ${workerId}] 模拟错误，退出`);
-  //   process.exit(1);
-  // }
-}, 2000);
-
-// 处理退出信号
-function shutdown() {
-  if (isShuttingDown) return;
-  isShuttingDown = true;
-  
-  clearInterval(interval);
-  if (reconnectTimer) clearTimeout(reconnectTimer);
-  
-  if (daemonSocket && !daemonSocket.destroyed) {
-    daemonSocket.destroy();
-  }
-  
-  console.log(`[工具进程 ${workerId}] 正在退出...`);
-  process.exit(0);
-}
-
-process.on('SIGTERM', () => {
-  console.log(`[工具进程 ${workerId}] 收到SIGTERM信号，正在退出...`);
-  shutdown();
-});
-
-process.on('SIGINT', () => {
-  console.log(`[工具进程 ${workerId}] 收到SIGINT信号，正在退出...`);
-  shutdown();
-});
-
-// 处理未捕获的异常
-process.on('uncaughtException', (error) => {
-  console.error(`[工具进程 ${workerId}] 未捕获的异常:`, error);
-  clearInterval(interval);
-  if (daemonSocket && !daemonSocket.destroyed) {
-    daemonSocket.destroy();
-  }
-  process.exit(1);
-});
-
-// 定期发送心跳到守护进程，并检查是否应该退出
-setInterval(() => {
-  sendToDaemon({
-    type: 'worker-heartbeat',
-    workerId: workerId,
-    timestamp: Date.now()
-  });
-  // 每次心跳时也检查是否应该退出
-  checkShouldIExit();
-}, 5000);