metame-cli 1.5.2 → 1.5.3

package/scripts/daemon-bridges.js

@@ -16,6 +16,8 @@ function createBridgeStarter(deps) {
     getSession,
     handleCommand,
     pendingActivations,  // optional — used to show smart activation hint
+    activeProcesses,     // optional — used for auto-dispatch to clones
+    messageQueue,        // optional — used for /stop to clear queued messages
   } = deps;
 
   async function sendAclReply(bot, chatId, text) {
@@ -84,6 +86,156 @@ function createBridgeStarter(deps) {
     return '⚠️ 此群未授权\n\n如已创建 Agent，发送 `/activate` 完成绑定。\n否则请先在主群创建 Agent。';
   }
 
+  // ── Team group helpers ─────────────────────────────────────────────────
+  function _getBoundProject(chatId, cfg) {
+    const map = {
+      ...(cfg.telegram ? cfg.telegram.chat_agent_map || {} : {}),
+      ...(cfg.feishu ? cfg.feishu.chat_agent_map || {} : {}),
+    };
+    const key = map[String(chatId)];
+    const proj = key && cfg.projects ? cfg.projects[key] : null;
+    return { key: key || null, project: proj || null };
+  }
+
+  function _escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
+  function _findTeamMember(text, team) {
+    const t = String(text || '').trim();
+    for (const member of team) {
+      const nicks = Array.isArray(member.nicknames) ? member.nicknames : [];
+      for (const nick of nicks) {
+        const n = String(nick || '').trim();
+        if (!n) continue;
+        if (t.toLowerCase() === n.toLowerCase()) return { member, rest: '' };
+        const re = new RegExp(`^${_escapeRe(n)}[\\s,，、:：]+`, 'i');
+        const m = t.match(re);
+        if (m) return { member, rest: t.slice(m[0].length).trim() };
+      }
+    }
+    return null;
+  }
+
+  // Creates a bot proxy that redirects all send methods to replyChatId
+  function _createTeamProxyBot(bot, replyChatId) {
+    const SEND = new Set(['sendMessage', 'sendMarkdown', 'sendCard', 'editMessage', 'deleteMessage', 'sendTyping', 'sendFile', 'sendButtonCard']);
+    return new Proxy(bot, {
+      get(target, prop) {
+        const orig = target[prop];
+        if (typeof orig !== 'function') return orig;
+        if (!SEND.has(prop)) return orig.bind(target);
+        return function(_chatId, ...args) { return orig.call(target, replyChatId, ...args); };
+      },
+    });
+  }
+  // Get team member's working directory using subdir (not worktree).
+  // Creates agents/<key>/ directory and symlinks CLAUDE.md from parent.
+  function _getMemberCwd(parentCwd, key) {
+    const { existsSync, mkdirSync, symlinkSync, readFileSync, writeFileSync } = require('fs');
+    const { execFileSync } = require('child_process');
+    const WIN_HIDE = process.platform === 'win32' ? { windowsHide: true } : {};
+
+    // Sanitize key to prevent path traversal
+    const safeKey = String(key).replace(/[^a-zA-Z0-9_\-]/g, '').slice(0, 50);
+    if (safeKey !== key) {
+      log('WARN', `Sanitized team member key: ${key} -> ${safeKey}`);
+    }
+
+    // Use agents/<key>/ as the working directory
+    const agentsDir = path.join(parentCwd, 'agents');
+    const memberDir = path.join(agentsDir, safeKey);
+
+    // Create agents directory if not exists
+    if (!existsSync(agentsDir)) {
+      mkdirSync(agentsDir, { recursive: true });
+    }
+
+    // Create member directory if not exists
+    if (!existsSync(memberDir)) {
+      mkdirSync(memberDir, { recursive: true });
+      log('INFO', `Created agent directory: ${memberDir}`);
+    }
+
+    // Initialize git for checkpoint support
+    const gitDir = path.join(memberDir, '.git');
+    if (!existsSync(gitDir)) {
+      try {
+        execFileSync('git', ['init'], { cwd: memberDir, stdio: 'ignore', ...WIN_HIDE });
+        log('INFO', `Git repo initialized: ${memberDir}`);
+      } catch (e) {
+        log('WARN', `Failed to init git for ${memberDir}: ${e.message}`);
+      }
+    }
+
+    // Set up CLAUDE.md: use dedicated, or template, or symlink from parent
+    const claudeMd = path.join(memberDir, 'CLAUDE.md');
+    const parentClaudeMd = path.join(parentCwd, 'CLAUDE.md');
+    if (!existsSync(claudeMd)) {
+      // Priority 1: dedicated CLAUDE.md in agents/<key>/ directory
+      const dedicatedPath = path.join(parentCwd, 'agents', safeKey, 'CLAUDE.md');
+      if (existsSync(dedicatedPath)) {
+        try {
+          // Copy instead of symlink to avoid cross-device issues
+          const content = readFileSync(dedicatedPath, 'utf8');
+          writeFileSync(claudeMd, content, 'utf8');
+          log('INFO', `Copied dedicated CLAUDE.md for ${safeKey}`);
+        } catch (e) {
+          log('WARN', `Failed to copy CLAUDE.md for ${safeKey}: ${e.message}`);
+        }
+      } else if (existsSync(parentClaudeMd)) {
+        // Priority 2: symlink to parent CLAUDE.md
+        try {
+          // Use 'junction' on Windows for directories, 'file' for files
+          const linkType = process.platform === 'win32' ? 'junction' : 'file';
+          symlinkSync(parentClaudeMd, claudeMd, linkType);
+          log('INFO', `Symlinked CLAUDE.md for ${safeKey}`);
+        } catch (e) {
+          // Fallback: copy file
+          try {
+            const content = readFileSync(parentClaudeMd, 'utf8');
+            writeFileSync(claudeMd, content, 'utf8');
+            log('INFO', `Copied CLAUDE.md for ${safeKey} (symlink failed)`);
+          } catch (e2) {
+            log('WARN', `Failed to create CLAUDE.md for ${safeKey}: ${e2.message}`);
+          }
+        }
+      }
+    }
+
+    return memberDir;
+  }
+
+  function _dispatchToTeamMember(member, boundProj, text, cfg, bot, realChatId, executeTaskByName, acl) {
+    const virtualChatId = `_agent_${member.key}`;
+    const parentCwd = member.cwd || boundProj.cwd;
+    const resolvedParentCwd = parentCwd.replace(/^~/, require('os').homedir());
+    const memberCwd = _getMemberCwd(resolvedParentCwd, member.key);
+    if (!memberCwd) {
+      log('ERROR', `Team [${member.key}] cannot start: directory unavailable`);
+      bot.sendMessage(realChatId, `❌ ${member.icon || '🤖'} ${member.name} 启动失败：工作目录创建失败`).catch(() => {});
+      return;
+    }
+    log('INFO', `Team [${member.key}] using cwd: ${memberCwd}`);
+    const teamCfg = {
+      ...cfg,
+      projects: {
+        ...(cfg.projects || {}),
+        [member.key]: {
+          cwd: memberCwd,
+          name: member.name,
+          icon: member.icon || '🤖',
+          color: member.color || 'blue',
+          engine: member.engine || boundProj.engine,
+        },
+      },
+    };
+    const proxyBot = _createTeamProxyBot(bot, realChatId);
+    handleCommand(proxyBot, virtualChatId, text, teamCfg, executeTaskByName, acl.senderId, acl.readOnly)
+      .catch(e => log('ERROR', `Team [${member.key}] error: ${e.message}`));
+  }
+  // ────────────────────────────────────────────────────────────────────────
+
   async function startTelegramBridge(config, executeTaskByName) {
     if (!config.telegram || !config.telegram.enabled) return null;
     if (!config.telegram.bot_token) {
@@ -218,6 +370,99 @@ function createBridgeStarter(deps) {
                 bypassAcl: !isAllowedChat && !!isBindCmd,
               });
               if (acl.blocked) continue;
+
+              // Team group routing for Telegram (same logic as Feishu)
+              const trimmedText = text.trim();
+              const { key: _boundKey, project: _boundProj } = _getBoundProject(chatId, liveCfg);
+              const _isTeamSlashCmd = trimmedText.startsWith('/') && !/^\/stop(\s|$)/i.test(trimmedText);
+
+              // Load sticky state
+              const _st = loadState();
+              const _chatKey = String(chatId);
+              const _setSticky = (key) => {
+                if (!_st.team_sticky) _st.team_sticky = {};
+                _st.team_sticky[_chatKey] = key;
+                saveState(_st);
+              };
+              const _clearSticky = () => {
+                if (_st.team_sticky) delete _st.team_sticky[_chatKey];
+                saveState(_st);
+              };
+              const _stickyKey = (_st.team_sticky || {})[_chatKey] || null;
+
+              if (_boundProj && Array.isArray(_boundProj.team) && _boundProj.team.length > 0 && !_isTeamSlashCmd) {
+                // Team dispatch logic (same as Feishu)
+                const _stopMatch = trimmedText && trimmedText.match(/^\/stop(?:\s+(.+))?$/i);
+                if (_stopMatch) {
+                  const _stopArg = (_stopMatch[1] || '').trim();
+                  if (_stopArg) {
+                    const _sa = _stopArg.toLowerCase();
+                    const m = _boundProj.team.find(t =>
+                      (t.nicknames || []).some(n => n.toLowerCase() === _sa) || (t.name && t.name.toLowerCase() === _sa) || t.key === _sa
+                    );
+                    if (m) {
+                      _clearSticky();
+                      log('INFO', `Team /stop: ${_chatKey.slice(-8)} → cleared sticky`);
+                      await bot.sendMessage(chatId, `⏹ 已切换回主 Agent`).catch(() => {});
+                    } else {
+                      await bot.sendMessage(chatId, `❌ 未找到团队成员: ${_stopArg}`).catch(() => {});
+                    }
+                    continue;
+                  }
+                  // Bare /stop, clear sticky
+                  _clearSticky();
+                  await bot.sendMessage(chatId, `⏹ 已切换回主 Agent`).catch(() => {});
+                  continue;
+                }
+
+                // 1. Explicit nickname → route + set sticky
+                const teamMatch = _findTeamMember(trimmedText, _boundProj.team);
+                if (teamMatch) {
+                  const { member, rest } = teamMatch;
+                  _setSticky(member.key);
+                  if (!rest) {
+                    log('INFO', `Sticky set (pure nickname): ${_chatKey.slice(-8)} → ${member.key}`);
+                    bot.sendMarkdown(chatId, `${member.icon || '🤖'} **${member.name}** 在线`).catch(() => {});
+                    continue;
+                  }
+                  log('INFO', `Sticky set: ${_chatKey.slice(-8)} → ${member.key}`);
+                  _dispatchToTeamMember(member, _boundProj, rest, liveCfg, bot, chatId, executeTaskByName, acl);
+                  continue;
+                }
+
+                // 1.5. Main project nickname → clear sticky, route to main
+                const _mainNicks = Array.isArray(_boundProj.nicknames) ? _boundProj.nicknames : [];
+                const _trimLower = trimmedText.toLowerCase();
+                const _mainMatch = _mainNicks.find(n => _trimLower === n.toLowerCase() || _trimLower.startsWith(n.toLowerCase() + ' ') || _trimLower.startsWith(n.toLowerCase() + '，') || _trimLower.startsWith(n.toLowerCase() + ','));
+                if (_mainMatch) {
+                  _clearSticky();
+                  const rest = trimmedText.slice(_mainMatch.length).replace(/^[\s,，:：]+/, '');
+                  log('INFO', `Main nickname → cleared sticky, routing to main${rest ? ` (task: ${rest.slice(0, 30)})` : ''}`);
+                  if (!rest) {
+                    bot.sendMarkdown(chatId, `${_boundProj.icon || '🤖'} **${_boundProj.name}** 在线`).catch(() => {});
+                    continue;
+                  }
+                  try {
+                    await handleCommand(bot, chatId, rest, liveCfg, executeTaskByName, acl.senderId, acl.readOnly);
+                  } catch (e) {
+                    log('ERROR', `Team main-route handleCommand failed: ${e.message}`);
+                    bot.sendMessage(chatId, `❌ 执行失败: ${e.message}`).catch(() => {});
+                  }
+                  continue;
+                }
+
+                // 2. Sticky: no nickname given → route to last explicitly named member
+                if (_stickyKey) {
+                  const member = _boundProj.team.find(m => m.key === _stickyKey);
+                  if (member) {
+                    log('INFO', `Sticky route: → ${_stickyKey}`);
+                    _dispatchToTeamMember(member, _boundProj, trimmedText, liveCfg, bot, chatId, executeTaskByName, acl);
+                    continue;
+                  }
+                }
+              }
+
+              // Default: route to main project
               handleCommand(bot, chatId, text, liveCfg, executeTaskByName, acl.senderId, acl.readOnly).catch(e => {
                 log('ERROR', `Telegram handler error: ${e.message}`);
               });
@@ -255,9 +500,11 @@ function createBridgeStarter(deps) {
 
     const { createBot } = require('./feishu-adapter.js');
     const bot = createBot(config.feishu);
+
     try {
       const receiver = await bot.startReceiving(async (chatId, text, event, fileInfo, senderId) => {
         const liveCfg = loadConfig();
+
         const allowedIds = (liveCfg.feishu && liveCfg.feishu.allowed_chat_ids) || [];
         const trimmedText = text && text.trim();
         const isBindCmd = trimmedText && (
@@ -319,21 +566,153 @@ function createBridgeStarter(deps) {
           if (acl.blocked) return;
           log('INFO', `Feishu message from ${chatId}: ${text.slice(0, 50)}`);
           const parentId = event?.message?.parent_id;
+          let _replyAgentKey = null;
+          // Load state once for the entire routing block
+          const _st = loadState();
           if (parentId) {
-            const st = loadState();
-            const mapped = st.msg_sessions && st.msg_sessions[parentId];
+            const mapped = _st.msg_sessions && _st.msg_sessions[parentId];
             if (mapped) {
-              st.sessions[chatId] = { id: mapped.id, cwd: mapped.cwd, started: true };
-              saveState(st);
+              if (!_st.sessions) _st.sessions = {};
+              _st.sessions[chatId] = { id: mapped.id, cwd: mapped.cwd, started: true };
+              saveState(_st);
               log('INFO', `Session restored via reply: ${mapped.id.slice(0, 8)} (${path.basename(mapped.cwd)})`);
+              _replyAgentKey = mapped.agentKey || null;
+            }
+          }
+
+          // Helper: set/clear sticky on shared state object and persist
+          const _chatKey = String(chatId);
+          const _setSticky = (key) => {
+            if (!_st.team_sticky) _st.team_sticky = {};
+            _st.team_sticky[_chatKey] = key;
+            saveState(_st);
+          };
+          const _clearSticky = () => {
+            if (_st.team_sticky) delete _st.team_sticky[_chatKey];
+            saveState(_st);
+          };
+          const _stickyKey = (_st.team_sticky || {})[_chatKey] || null;
+
+          // Team group routing: if bound project has a team array, check message for member nickname
+          // Non-/stop slash commands bypass team routing → handled by main project
+          const { key: _boundKey, project: _boundProj } = _getBoundProject(chatId, liveCfg);
+          const _isTeamSlashCmd = trimmedText.startsWith('/') && !/^\/stop(\s|$)/i.test(trimmedText);
+          if (_boundProj && Array.isArray(_boundProj.team) && _boundProj.team.length > 0 && !_isTeamSlashCmd) {
+            // ── /stop precise routing for team groups ──
+            const _stopMatch = trimmedText && trimmedText.match(/^\/stop(?:\s+(.+))?$/i);
+            if (_stopMatch) {
+              const _stopArg = (_stopMatch[1] || '').trim();
+              let _targetKey = null;
+              // Priority 1: quoted reply → stop that agent
+              if (_replyAgentKey) {
+                const m = _boundProj.team.find(t => t.key === _replyAgentKey);
+                if (m) _targetKey = m.key;
+              }
+              // Priority 2: /stop <nickname> → match team member (case-insensitive)
+              if (!_targetKey && _stopArg) {
+                const _sa = _stopArg.toLowerCase();
+                const m = _boundProj.team.find(t =>
+                  (t.nicknames || []).some(n => n.toLowerCase() === _sa) || (t.name && t.name.toLowerCase() === _sa) || t.key === _sa
+                );
+                if (m) _targetKey = m.key;
+              }
+              // Priority 3: bare /stop → sticky
+              if (!_targetKey && !_stopArg) _targetKey = _stickyKey;
+              if (_targetKey) {
+                const vid = `_agent_${_targetKey}`;
+                const member = _boundProj.team.find(t => t.key === _targetKey);
+                const label = member ? `${member.icon || '🤖'} ${member.name}` : _targetKey;
+                // Clear message queue for this virtual agent
+                if (messageQueue.has(vid)) {
+                  const vq = messageQueue.get(vid);
+                  if (vq && vq.timer) clearTimeout(vq.timer);
+                  messageQueue.delete(vid);
+                }
+                const vproc = activeProcesses && activeProcesses.get(vid);
+                if (vproc && vproc.child) {
+                  vproc.aborted = true;
+                  const sig = vproc.killSignal || 'SIGTERM';
+                  try { process.kill(-vproc.child.pid, sig); } catch { try { vproc.child.kill(sig); } catch { /* */ } }
+                  await bot.sendMessage(chatId, `⏹ Stopping ${label}...`);
+                } else {
+                  await bot.sendMessage(chatId, `${label} 当前没有活跃任务`);
+                }
+                return;
+              }
+              // /stop <bad-nickname> → no match, report error instead of falling through
+              if (_stopArg) {
+                await bot.sendMessage(chatId, `❌ 未找到团队成员: ${_stopArg}`);
+                return;
+              }
+              // Bare /stop, no sticky set → fall through to handleCommand
             }
+
+            // 0. Quoted reply → force route + set sticky
+            if (_replyAgentKey) {
+              const member = _boundProj.team.find(m => m.key === _replyAgentKey);
+              if (member) {
+                _setSticky(member.key);
+                log('INFO', `Quoted reply → force route to ${_replyAgentKey} (sticky set)`);
+                _dispatchToTeamMember(member, _boundProj, trimmedText, liveCfg, bot, chatId, executeTaskByName, acl);
+                return;
+              }
+              log('INFO', `Quoted reply agentKey=${_replyAgentKey} not in team, falling through`);
+            }
+            // 1. Explicit nickname → route + set sticky
+            const teamMatch = _findTeamMember(trimmedText, _boundProj.team);
+            if (teamMatch) {
+              const { member, rest } = teamMatch;
+              _setSticky(member.key);
+              if (!rest) {
+                // Pure nickname, no task — confirm member is online
+                log('INFO', `Sticky set (pure nickname): ${_chatKey.slice(-8)} → ${member.key}`);
+                bot.sendMarkdown(chatId, `${member.icon || '🤖'} **${member.name}** 在线`).catch(() => {});
+                return;
+              }
+              log('INFO', `Sticky set: ${_chatKey.slice(-8)} → ${member.key}`);
+              _dispatchToTeamMember(member, _boundProj, rest, liveCfg, bot, chatId, executeTaskByName, acl);
+              return;
+            }
+
+            // 1.5. Main project nickname → clear sticky, route to main
+            const _mainNicks = Array.isArray(_boundProj.nicknames) ? _boundProj.nicknames : [];
+            const _trimLower = trimmedText.toLowerCase();
+            const _mainMatch = _mainNicks.find(n => _trimLower === n.toLowerCase() || _trimLower.startsWith(n.toLowerCase() + ' ') || _trimLower.startsWith(n.toLowerCase() + '，') || _trimLower.startsWith(n.toLowerCase() + ','));
+            if (_mainMatch) {
+              _clearSticky();
+              const rest = trimmedText.slice(_mainMatch.length).replace(/^[\s,，:：]+/, '');
+              log('INFO', `Main nickname → cleared sticky, routing to main${rest ? ` (task: ${rest.slice(0, 30)})` : ''}`);
+              if (!rest) {
+                bot.sendMarkdown(chatId, `${_boundProj.icon || '🤖'} **${_boundProj.name}** 在线`).catch(() => {});
+                return;
+              }
+              try {
+                await handleCommand(bot, chatId, rest, liveCfg, executeTaskByName, acl.senderId, acl.readOnly);
+              } catch (e) {
+                log('ERROR', `Team main-route handleCommand failed: ${e.message}`);
+                bot.sendMessage(chatId, `❌ 执行失败: ${e.message}`).catch(() => {});
+              }
+              return;
+            }
+
+            // 2. Sticky: no nickname given → route to last explicitly named member
+            if (_stickyKey) {
+              const member = _boundProj.team.find(m => m.key === _stickyKey);
+              if (member) {
+                log('INFO', `Sticky route: → ${_stickyKey}`);
+                _dispatchToTeamMember(member, _boundProj, trimmedText, liveCfg, bot, chatId, executeTaskByName, acl);
+                return;
+              }
+            }
+
           }
+
           await handleCommand(bot, chatId, text, liveCfg, executeTaskByName, acl.senderId, acl.readOnly);
         }
-      });
+      }, { log: (lvl, msg) => log(lvl, msg) });
 
       log('INFO', 'Feishu bot connected (WebSocket long connection)');
-      return { stop: () => receiver.stop(), bot };
+      return { stop: () => receiver.stop(), bot, reconnect: () => receiver.reconnect(), isAlive: () => receiver.isAlive() };
     } catch (e) {
       log('ERROR', `Feishu bridge failed: ${e.message}`);
       return null;