@bangdao-ai/acw-tools 1.4.3 → 1.4.5-beta.1

package/cursorConversationParser.js

@@ -136,14 +136,22 @@ function extractFilePath(toolResult, rawArgs) {
 }
 
 /**
- * 解析write工具的代码变更统计
+ * 解析代码编辑工具的代码变更统计
+ * 支持的工具：write、search_replace、edit_file、edit_file_v2
  * @param {Object} bubble - bubble数据
- * @returns {Object|null} 按语言聚合的代码变更统计，格式：{ languageId: { added: number, removed: number } }
+ * @returns {Object|null} 按语言聚合的代码变更统计，格式：{ languageId: { added: number, removed: number, filePath: string } }
  */
 function parseCodeChanges(bubble) {
-  // 1. 检查是否是accepted的write操作
   const toolFormerData = bubble.toolFormerData;
-  if (!toolFormerData || toolFormerData.name !== 'write' || toolFormerData.userDecision !== 'accepted') {
+  if (!toolFormerData) {
+    return null;
+  }
+
+  const toolName = toolFormerData.name;
+  
+  // 1. 检查是否是支持的代码编辑工具，且用户已接受
+  const supportedTools = ['write', 'search_replace', 'edit_file', 'edit_file_v2'];
+  if (!supportedTools.includes(toolName) || toolFormerData.userDecision !== 'accepted') {
     return null;
   }
 
@@ -161,13 +169,14 @@ function parseCodeChanges(bubble) {
     return null;
   }
 
-  // 3. 从rawArgs获取file_path
+  // 3. 从rawArgs获取file_path（不同工具的参数名可能不同）
   let filePath = null;
   try {
     const rawArgs = typeof toolFormerData.rawArgs === 'string'
       ? JSON.parse(toolFormerData.rawArgs)
       : toolFormerData.rawArgs;
-    filePath = rawArgs?.file_path;
+    // 尝试多种可能的参数名
+    filePath = rawArgs?.file_path || rawArgs?.target_file || rawArgs?.path || rawArgs?.filePath;
   } catch (error) {
     // 忽略解析错误
   }
@@ -197,6 +206,47 @@ function parseCodeChanges(bubble) {
       languageId = matchedBlock.languageId;
     }
   }
+  
+  // 如果仍未识别语言，尝试从文件扩展名推断
+  if (languageId === 'unknown' && filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    const extToLangMap = {
+      'js': 'javascript',
+      'jsx': 'javascriptreact',
+      'ts': 'typescript',
+      'tsx': 'typescriptreact',
+      'py': 'python',
+      'java': 'java',
+      'json': 'json',
+      'md': 'markdown',
+      'yml': 'yaml',
+      'yaml': 'yaml',
+      'xml': 'xml',
+      'html': 'html',
+      'css': 'css',
+      'scss': 'scss',
+      'less': 'less',
+      'sh': 'shellscript',
+      'bash': 'shellscript',
+      'sql': 'sql',
+      'go': 'go',
+      'rs': 'rust',
+      'rb': 'ruby',
+      'php': 'php',
+      'c': 'c',
+      'cpp': 'cpp',
+      'h': 'c',
+      'hpp': 'cpp',
+      'cs': 'csharp',
+      'swift': 'swift',
+      'kt': 'kotlin',
+      'vue': 'vue',
+      'svelte': 'svelte',
+    };
+    if (ext && extToLangMap[ext]) {
+      languageId = extToLangMap[ext];
+    }
+  }
 
   // 5. 统计所有chunks的增删行数
   let totalAdded = 0;
@@ -213,7 +263,7 @@ function parseCodeChanges(bubble) {
     [languageId]: {
       added: totalAdded,
       removed: totalRemoved,
-      filePath: filePath  // 新增：文件路径，用于后端识别真实语言
+      filePath: filePath  // 文件路径，用于后端识别真实语言
     }
   };
 }

package/index.js

@@ -69,6 +69,188 @@ 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, isMainInstance, interval: '30秒' });
+  
+  setInterval(() => {
+    try {
+      if (isMainInstance) {
+        // 主实例：更新心跳时间戳
+        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 {
+            // 锁被其他进程持有，降级为从实例
+            isMainInstance = false;
+            logger.warn('锁被其他进程持有，降级为从实例', { myPid: process.pid, lockPid: lockData.pid });
+          }
+        } else {
+          // 锁文件不存在，尝试重新获取
+          if (tryAcquireLock()) {
+            logger.info('锁文件丢失，重新获取成功', { pid: process.pid });
+          } else {
+            isMainInstance = false;
+            logger.warn('锁文件丢失且无法重新获取，降级为从实例', { pid: process.pid });
+          }
+        }
+      } else {
+        // 从实例：尝试升级为主实例
+        logger.debug('从实例尝试获取锁', { pid: process.pid });
+        if (tryAcquireLock()) {
+          isMainInstance = true;
+          logger.info('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          logger.info('从实例升级为主实例，开始运行定时任务', { pid: process.pid });
+          logger.info('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          
+          // 启动定时任务（如果 TOKEN 有效）
+          if (isTokenValid && chatGrabAvailable) {
+            startChatGrabScheduler().catch((error) => {
+              logger.error('启动定时任务失败', { pid: process.pid, error: error.message });
+            });
+          }
+        }
+      }
+    } catch (error) {
+      // 忽略心跳更新失败
+      logger.debug('心跳更新失败', { pid: process.pid, error: error.message });
+    }
+  }, 30 * 1000); // 每 30 秒检查一次（缩短间隔以便更快接管）
+}
+
 /**
  * 格式化时间戳（UTF+8 本地时间）
  * 格式: 2025-11-10 21:35:42.456
@@ -2189,8 +2371,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,23 +2384,39 @@ 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: '非主实例，定时任务由其他实例负责' } : {})
   });
   
+  // 启动心跳（所有实例都需要，从实例用于尝试升级为主实例）
+  startLockHeartbeat();
+  
   // 只有 TOKEN 有效时才执行需要认证的功能
   if (isTokenValid) {
-    // 上报主机信息（异步执行，失败不影响启动）
-    reportHostInfo().catch((error) => {
-      logger.warn('主机信息上报异常', { error: error.message });
-    });
-    
-    // 启动对话抓取定时任务（会先获取配置再抓取，不需要单独的配置刷新定时器）
-    await startChatGrabScheduler();
+    // 只有主实例才运行定时任务（避免多个进程同时抓取）
+    if (isMainInstance) {
+      logger.info("本实例是主实例，将负责运行定时任务", { pid: process.pid });
+      
+      // 上报主机信息（异步执行，失败不影响启动）
+      reportHostInfo().catch((error) => {
+        logger.warn('主机信息上报异常', { error: error.message });
+      });
+      
+      // 启动对话抓取定时任务（会先获取配置再抓取，不需要单独的配置刷新定时器）
+      await startChatGrabScheduler();
+    } else {
+      logger.info("本实例是从实例，不运行定时任务", { 
+        pid: process.pid,
+        hint: '已有其他实例负责对话抓取，本实例仅提供工具调用服务，会定期尝试升级为主实例'
+      });
+    }
   } else {
     logger.info("ACW 接口功能已禁用（TOKEN 未配置）", {
       disabledFeatures: ['主机信息上报', '对话抓取', '规则下载'],
@@ -2223,10 +2425,63 @@ async function main() {
   }
 }
 
+// ==================== 进程退出处理 ====================
+
+/**
+ * 优雅退出处理
+ */
+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.3",
+  "version": "1.4.5",
   "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.3",
+  "version": "1.4.5-beta.1",
   "type": "module",
   "description": "MCP (Model Context Protocol) tools for ACW - download rules and initialize Common Admin projects",
   "main": "index.js",