@bangdao-ai/acw-tools 1.4.4 → 1.4.6-beta.1

package/index.js

@@ -69,6 +69,170 @@ if (!fs.existsSync(LOG_DIR)) {
   fs.mkdirSync(LOG_DIR, { recursive: true });
 }
 
+// ==================== 单例模式：锁文件 ====================
+const LOCK_FILE = path.join(os.homedir(), '.cursor', '.chat_grab', 'acw-mcp.lock');
+let lockFileHandle = null;
+let isMainInstance = false; // 是否是主实例（负责定时任务）
+
+/**
+ * 尝试获取锁文件（使用排他写入避免竞争条件）
+ * 只有主实例才能获取锁，负责运行定时任务
+ * @returns {boolean} 是否成功获取锁
+ */
+function tryAcquireLock() {
+  try {
+    // 检查锁文件是否存在
+    if (fs.existsSync(LOCK_FILE)) {
+      // 读取锁文件内容
+      let lockContent;
+      try {
+        lockContent = fs.readFileSync(LOCK_FILE, 'utf8');
+      } catch (e) {
+        // 读取失败，可能正在被写入，稍后重试
+        logger.debug('读取锁文件失败，稍后重试', { pid: process.pid, error: e.message });
+        return false;
+      }
+      
+      let lockData;
+      try {
+        lockData = JSON.parse(lockContent);
+      } catch (e) {
+        // JSON 解析失败，锁文件损坏，删除它
+        logger.warn('锁文件损坏，删除并重新获取', { pid: process.pid });
+        fs.unlinkSync(LOCK_FILE);
+        lockData = null;
+      }
+      
+      if (lockData) {
+        // 检查锁是否过期（超过 2 分钟认为进程已死，缩短超时时间）
+        const lockAge = Date.now() - lockData.timestamp;
+        const LOCK_TIMEOUT = 2 * 60 * 1000; // 2 分钟
+        
+        if (lockAge < LOCK_TIMEOUT) {
+          // 检查进程是否还活着
+          try {
+            process.kill(lockData.pid, 0); // 发送信号 0 检查进程是否存在
+            // 进程还活着，锁有效
+            logger.debug('锁被其他进程持有', { 
+              myPid: process.pid, 
+              lockPid: lockData.pid, 
+              lockAge: `${Math.round(lockAge / 1000)}秒` 
+            });
+            return false;
+          } catch (e) {
+            // 进程不存在，可以获取锁
+            logger.info('检测到死锁（进程不存在），准备接管', { 
+              myPid: process.pid, 
+              deadPid: lockData.pid 
+            });
+          }
+        } else {
+          // 锁已过期
+          logger.info('检测到过期锁，准备接管', { 
+            myPid: process.pid, 
+            expiredPid: lockData.pid,
+            lockAge: `${Math.round(lockAge / 1000)}秒`
+          });
+        }
+        // 锁已过期或进程已死，删除旧锁
+        try {
+          fs.unlinkSync(LOCK_FILE);
+        } catch (e) {
+          // 删除失败，可能已被其他进程删除
+          logger.debug('删除旧锁失败', { pid: process.pid, error: e.message });
+        }
+      }
+    }
+    
+    // 使用排他模式创建锁文件（wx 标志：排他写入，文件必须不存在）
+    const lockData = {
+      pid: process.pid,
+      timestamp: Date.now(),
+      hostname: os.hostname()
+    };
+    
+    try {
+      // 使用 wx 标志确保原子创建
+      fs.writeFileSync(LOCK_FILE, JSON.stringify(lockData), { flag: 'wx' });
+      logger.info('成功获取锁，成为主实例', { pid: process.pid });
+      return true;
+    } catch (e) {
+      if (e.code === 'EEXIST') {
+        // 文件已存在，说明其他进程抢先创建了
+        logger.debug('获取锁失败，其他进程抢先', { pid: process.pid });
+        return false;
+      }
+      throw e;
+    }
+  } catch (error) {
+    // 获取锁失败
+    logger.error('获取锁时发生异常', { pid: process.pid, error: error.message });
+    return false;
+  }
+}
+
+/**
+ * 释放锁文件
+ */
+function releaseLock() {
+  try {
+    if (fs.existsSync(LOCK_FILE)) {
+      const lockContent = fs.readFileSync(LOCK_FILE, 'utf8');
+      const lockData = JSON.parse(lockContent);
+      
+      // 只删除自己创建的锁
+      if (lockData.pid === process.pid) {
+        fs.unlinkSync(LOCK_FILE);
+        logger.info('已释放锁文件', { pid: process.pid });
+      } else {
+        logger.debug('锁文件属于其他进程，不释放', { myPid: process.pid, lockPid: lockData.pid });
+      }
+    }
+  } catch (error) {
+    logger.debug('释放锁文件失败', { pid: process.pid, error: error.message });
+  }
+}
+
+/**
+ * 定期更新锁文件时间戳（心跳）
+ * 只有主实例需要运行，用于维护锁的有效性
+ */
+function startLockHeartbeat() {
+  logger.info('启动心跳检测', { pid: process.pid, interval: '30秒' });
+  
+  setInterval(() => {
+    try {
+      // 主实例：更新心跳时间戳
+      if (fs.existsSync(LOCK_FILE)) {
+        const lockContent = fs.readFileSync(LOCK_FILE, 'utf8');
+        const lockData = JSON.parse(lockContent);
+        
+        if (lockData.pid === process.pid) {
+          lockData.timestamp = Date.now();
+          fs.writeFileSync(LOCK_FILE, JSON.stringify(lockData), 'utf8');
+          logger.debug('心跳更新成功', { pid: process.pid });
+        } else {
+          // 锁被其他进程持有（异常情况），退出当前进程
+          logger.warn('锁被其他进程抢占，当前进程退出', { myPid: process.pid, lockPid: lockData.pid });
+          process.exit(0);
+        }
+      } else {
+        // 锁文件不存在，尝试重新获取
+        if (tryAcquireLock()) {
+          logger.info('锁文件丢失，重新获取成功', { pid: process.pid });
+        } else {
+          // 无法重新获取锁，退出当前进程
+          logger.warn('锁文件丢失且无法重新获取，当前进程退出', { pid: process.pid });
+          process.exit(0);
+        }
+      }
+    } catch (error) {
+      // 忽略心跳更新失败
+      logger.debug('心跳更新失败', { pid: process.pid, error: error.message });
+    }
+  }, 30 * 1000); // 每 30 秒检查一次
+}
+
 /**
  * 格式化时间戳（UTF+8 本地时间）
  * 格式: 2025-11-10 21:35:42.456
@@ -2189,8 +2353,12 @@ Tips：当返回多个匹配时，请使用返回列表中的完整规则名称
 
 // --- 启动 stdio 传输 ---
 async function main() {
+  // 尝试获取锁，成为主实例
+  isMainInstance = tryAcquireLock();
+  
   const transport = new StdioServerTransport();
   await server.connect(transport);
+  
   logger.info("ACW工具MCP服务已启动", {
     mcpVersion: CURRENT_MCP_VERSION,
     baseUrl: BASE_URL,
@@ -2198,35 +2366,113 @@ async function main() {
     tokenConfigured: isTokenValid,
     hostName: HOST_NAME,
     osType: OS_TYPE,
+    pid: process.pid,
+    isMainInstance: isMainInstance, // 是否是主实例
     availableTools: ['download_rule'],
-    chatGrabEnabled: chatGrabAvailable && isTokenValid,
+    chatGrabEnabled: chatGrabAvailable && isTokenValid && isMainInstance,
     chatGrabDir: CHAT_GRAB_DIR,
     dbEngineType: dbEngineType,
     ...(chatGrabAvailable ? {} : { chatGrabDisabledReason: 'No database engine available' }),
-    ...(!isTokenValid ? { tokenDisabledReason: 'ACW_TOKEN not configured or invalid' } : {})
+    ...(!isTokenValid ? { tokenDisabledReason: 'ACW_TOKEN not configured or invalid' } : {}),
+    ...(!isMainInstance ? { schedulerDisabledReason: '非主实例，定时任务由其他实例负责' } : {})
   });
   
-  // 只有 TOKEN 有效时才执行需要认证的功能
-  if (isTokenValid) {
-    // 上报主机信息（异步执行，失败不影响启动）
-    reportHostInfo().catch((error) => {
-      logger.warn('主机信息上报异常', { error: error.message });
-    });
-    
-    // 启动对话抓取定时任务（会先获取配置再抓取，不需要单独的配置刷新定时器）
-    await startChatGrabScheduler();
+  // 只有主实例才启动心跳和定时任务
+  if (isMainInstance) {
+    // 启动心跳（只有主实例需要，用于维护锁的有效性）
+    startLockHeartbeat();
+    
+    // 只有 TOKEN 有效时才执行需要认证的功能
+    if (isTokenValid) {
+      logger.info("本实例是主实例，将负责运行定时任务", { pid: process.pid });
+      
+      // 上报主机信息（异步执行，失败不影响启动）
+      reportHostInfo().catch((error) => {
+        logger.warn('主机信息上报异常', { error: error.message });
+      });
+      
+      // 启动对话抓取定时任务（会先获取配置再抓取，不需要单独的配置刷新定时器）
+      await startChatGrabScheduler();
+    } else {
+      logger.info("ACW 接口功能已禁用（TOKEN 未配置）", {
+        disabledFeatures: ['主机信息上报', '对话抓取', '规则下载'],
+        hint: '请在 MCP 配置中设置有效的 ACW_TOKEN 环境变量以启用完整功能'
+      });
+    }
   } else {
-    logger.info("ACW 接口功能已禁用（TOKEN 未配置）", {
-      disabledFeatures: ['主机信息上报', '对话抓取', '规则下载'],
-      hint: '请在 MCP 配置中设置有效的 ACW_TOKEN 环境变量以启用完整功能'
+    // 从实例：检测到已有主实例运行，直接退出以节省资源
+    logger.info("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    logger.info("检测到已有主实例运行，本实例将退出", { 
+      pid: process.pid,
+      reason: '避免资源浪费，只保留一个主实例运行'
     });
+    logger.info("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    
+    // 延迟退出，确保日志写入完成
+    setTimeout(() => {
+      process.exit(0);
+    }, 500);
+    return; // 不再执行后续逻辑
   }
 }
 
+// ==================== 进程退出处理 ====================
+
+/**
+ * 优雅退出处理
+ */
+function gracefulShutdown(signal) {
+  logger.info(`收到退出信号: ${signal}，开始优雅退出`, { 
+    pid: process.pid, 
+    isMainInstance,
+    signal 
+  });
+  
+  // 释放锁文件
+  releaseLock();
+  
+  // 给一点时间完成日志写入
+  setTimeout(() => {
+    process.exit(0);
+  }, 100);
+}
+
+// 监听退出信号
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGHUP', () => gracefulShutdown('SIGHUP'));
+
+// 监听进程退出事件
+process.on('exit', (code) => {
+  releaseLock();
+  // 注意：exit 事件中只能执行同步操作
+});
+
+// 监听未捕获的异常
+process.on('uncaughtException', (err) => {
+  logger.error('未捕获的异常', { pid: process.pid, error: err.message, stack: err.stack });
+  releaseLock();
+  process.exit(1);
+});
+
+// 监听未处理的 Promise 拒绝
+process.on('unhandledRejection', (reason, promise) => {
+  logger.error('未处理的 Promise 拒绝', { pid: process.pid, reason: String(reason) });
+});
+
+// ==================== 连接状态监控 ====================
+
+/**
+ * 注意：不直接监控 stdin，因为 MCP SDK 会管理 stdio 通信
+ * 当 Cursor 断开时，MCP SDK 的 transport 会处理断开逻辑
+ * 我们只需要确保进程能够响应系统信号即可
+ */
+
 main().catch((err) => {
   logger.error("MCP服务启动失败", { 
     error: err.message, 
     stack: err.stack 
   });
+  releaseLock();
   process.exit(1);
 });

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "name": "ACW工具集",
   "description": "ACW平台工具集：智能下载规则到项目、初始化Common Admin模板项目",
-  "version": "1.4.4",
+  "version": "1.4.6-beta.1",
   "author": "邦道科技 - 产品技术中心",
   "homepage": "https://www.npmjs.com/package/@bangdao-ai/acw-tools",
   "repository": "https://www.npmjs.com/package/@bangdao-ai/acw-tools?activeTab=readme",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bangdao-ai/acw-tools",
-  "version": "1.4.4",
+  "version": "1.4.6-beta.1",
   "type": "module",
   "description": "MCP (Model Context Protocol) tools for ACW - download rules and initialize Common Admin projects",
   "main": "index.js",