metame-cli 1.5.4 → 1.5.5

package/scripts/daemon-agent-commands.js

@@ -13,6 +13,7 @@ function createAgentCommandHandler(deps) {
     sendBrowse,
     sendDirPicker,
     getSession,
+    getSessionForEngine,
     listRecentSessions,
     buildSessionCardElements,
     sessionLabel,
@@ -40,6 +41,103 @@ function createAgentCommandHandler(deps) {
     return n === 'codex' ? 'codex' : getDefaultEngine();
   }
 
+  function inferStoredEngine(rawSession) {
+    if (!rawSession || typeof rawSession !== 'object') return getDefaultEngine();
+    if (rawSession.engine) return normalizeEngineName(rawSession.engine);
+    const slots = rawSession.engines && typeof rawSession.engines === 'object' ? rawSession.engines : null;
+    if (!slots) return getDefaultEngine();
+    const started = Object.entries(slots).find(([, slot]) => slot && slot.started);
+    if (started) return normalizeEngineName(started[0]);
+    const available = Object.keys(slots);
+    return available.length === 1 ? normalizeEngineName(available[0]) : getDefaultEngine();
+  }
+
+  function buildBoundSessionChatId(projectKey) {
+    const key = String(projectKey || '').trim();
+    return key ? `_bound_${key}` : '';
+  }
+
+  function getSessionRoute(chatId) {
+    const cfg = loadConfig();
+    const state = loadState();
+    const chatKey = String(chatId);
+    const agentMap = { ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}), ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}) };
+    const boundKey = agentMap[chatKey] || null;
+    const boundProj = boundKey && cfg.projects ? cfg.projects[boundKey] : null;
+    const stickyKey = state && state.team_sticky ? state.team_sticky[chatKey] : null;
+    const stickyMember = stickyKey && boundProj && Array.isArray(boundProj.team)
+      ? boundProj.team.find((m) => m && m.key === stickyKey)
+      : null;
+
+    if (stickyMember) {
+      return {
+        sessionChatId: `_agent_${stickyMember.key}`,
+        cwd: stickyMember.cwd ? normalizeCwd(stickyMember.cwd) : (boundProj && boundProj.cwd ? normalizeCwd(boundProj.cwd) : null),
+        engine: normalizeEngineName(stickyMember.engine || (boundProj && boundProj.engine)),
+      };
+    }
+
+    if (boundProj) {
+      return {
+        sessionChatId: buildBoundSessionChatId(boundKey),
+        cwd: boundProj.cwd ? normalizeCwd(boundProj.cwd) : null,
+        engine: normalizeEngineName(boundProj.engine),
+      };
+    }
+
+    const rawSession = getSession(chatId);
+    return {
+      sessionChatId: String(chatId),
+      cwd: rawSession && rawSession.cwd ? normalizeCwd(rawSession.cwd) : null,
+      engine: inferStoredEngine(rawSession),
+    };
+  }
+
+  function getCurrentEngine(chatId) {
+    return getSessionRoute(chatId).engine;
+  }
+
+  function getLogicalSessionForRoute(route) {
+    if (!route || !route.sessionChatId) return null;
+    if (typeof getSessionForEngine === 'function') {
+      const engineSession = getSessionForEngine(route.sessionChatId, route.engine);
+      if (engineSession && engineSession.id) return engineSession;
+    }
+    const raw = getSession(route.sessionChatId);
+    if (!raw) return null;
+    const slot = raw.engines && raw.engines[route.engine];
+    if (slot && slot.id) return { cwd: raw.cwd, engine: route.engine, ...slot };
+    if (raw.id) return { cwd: raw.cwd, engine: route.engine, id: raw.id, started: !!raw.started };
+    return null;
+  }
+
+  function buildResumeChoices({ recentSessions, currentLogical, curCwd, currentEngine, isLogicalRoute }) {
+    const items = [];
+    const seen = new Set();
+    if (
+      isLogicalRoute
+      && currentLogical
+      && currentLogical.id
+      && currentLogical.started
+    ) {
+      items.push({
+        sessionId: currentLogical.id,
+        projectPath: currentLogical.cwd || curCwd || HOME,
+        engine: currentEngine,
+        customTitle: '当前会话',
+        summary: '优先续接当前智能体会话',
+      });
+      seen.add(String(currentLogical.id));
+    }
+    for (const session of recentSessions || []) {
+      const key = String(session && session.sessionId || '');
+      if (!key || seen.has(key)) continue;
+      items.push(session);
+      seen.add(key);
+    }
+    return items;
+  }
+
   function inferEngineByCwd(cfg, cwd) {
     if (!cfg || !cfg.projects || !cwd) return null;
     const targetCwd = normalizeCwd(cwd);
@@ -52,18 +150,20 @@ function createAgentCommandHandler(deps) {
     return null;
   }
 
+  async function autoCreateSessionOnEmptyResume(bot, chatId, cwd, engine) {
+    const resolvedCwd = cwd ? normalizeCwd(cwd) : null;
+    if (!resolvedCwd || !fs.existsSync(resolvedCwd) || typeof attachOrCreateSession !== 'function') {
+      await bot.sendMessage(chatId, `No sessions found${resolvedCwd ? ' in ' + path.basename(resolvedCwd) : ''}. Try /new first.`);
+      return true;
+    }
+    attachOrCreateSession(getSessionRoute(chatId).sessionChatId, resolvedCwd, '', engine || getDefaultEngine());
+    await bot.sendMessage(chatId, `📁 ${path.basename(resolvedCwd)}\n✅ 已自动创建新会话`);
+    return true;
+  }
+
   // Pending activations have no TTL — they persist until consumed.
   // The creating chatId is stored to prevent self-activation.
 
-  function storePendingActivation(agentKey, agentName, cwd, createdByChatId) {
-    if (!pendingActivations) return;
-    pendingActivations.set(agentKey, {
-      agentKey, agentName, cwd,
-      createdByChatId: String(createdByChatId),
-      createdAt: Date.now(),
-    });
-  }
-
   // Returns the latest pending activation, excluding the creating chat
   function getLatestActivationForChat(chatId) {
     if (!pendingActivations || pendingActivations.size === 0) return null;
@@ -188,25 +288,6 @@ function createAgentCommandHandler(deps) {
     return { ok: true, data: legacy };
   }
 
-  async function createAgentViaUnifiedApi(chatId, name, dir, roleDesc, opts = {}) {
-    // Default: skip binding the creating chat — let the target group activate via /activate
-    const { skipChatBinding = true, engine = null } = opts;
-    if (agentTools && typeof agentTools.createNewWorkspaceAgent === 'function') {
-      const res = await agentTools.createNewWorkspaceAgent(name, dir, roleDesc, chatId, { skipChatBinding, engine });
-      if (res.ok && skipChatBinding && res.data && res.data.projectKey) {
-        storePendingActivation(res.data.projectKey, name, res.data.cwd, chatId);
-      }
-      return res;
-    }
-    const bound = await doBindAgent({ sendMessage: async () => {} }, chatId, name, dir);
-    if (!bound || bound.ok === false) {
-      return { ok: false, error: (bound && bound.error) || 'bind failed' };
-    }
-    const merged = await mergeAgentRole(dir, roleDesc);
-    if (merged.error) return { ok: false, error: merged.error };
-    return { ok: true, data: { cwd: dir, project: { name }, role: merged } };
-  }
-
   async function listAgentsViaUnifiedApi(chatId) {
     if (agentTools && typeof agentTools.listAllAgents === 'function') {
       return agentTools.listAllAgents(chatId);
@@ -271,43 +352,66 @@ function createAgentCommandHandler(deps) {
       const arg = text.slice(7).trim();
 
       // Get current workdir to scope session list — prefer bound project cwd over session cwd
-      const cfgForResume = loadConfig();
-      const chatAgentMapForResume = { ...(cfgForResume.telegram ? cfgForResume.telegram.chat_agent_map : {}), ...(cfgForResume.feishu ? cfgForResume.feishu.chat_agent_map : {}) };
-      const boundKeyForResume = chatAgentMapForResume[String(chatId)];
-      const boundProjForResume = boundKeyForResume && cfgForResume.projects ? cfgForResume.projects[boundKeyForResume] : null;
-      const boundCwdForResume = (boundProjForResume && boundProjForResume.cwd) ? normalizeCwd(boundProjForResume.cwd) : null;
-      const curSession = getSession(chatId);
-      const curCwd = boundCwdForResume || (curSession ? curSession.cwd : null);
-      const recentSessions = listRecentSessions(5, curCwd);
+      const route = getSessionRoute(chatId);
+      const isLogicalRoute = route.sessionChatId !== String(chatId);
+      const currentLogical = getLogicalSessionForRoute(route);
+      const curSession = getSession(route.sessionChatId) || getSession(chatId);
+      const curCwd = route.cwd || (curSession ? curSession.cwd : null);
+      const currentEngine = getCurrentEngine(chatId);
+      const recentSessions = listRecentSessions(5, curCwd, currentEngine);
+      const resumeChoices = buildResumeChoices({
+        recentSessions,
+        currentLogical,
+        curCwd,
+        currentEngine,
+        isLogicalRoute,
+      });
 
       if (!arg) {
-        if (recentSessions.length === 0) {
-          await bot.sendMessage(chatId, `No sessions found${curCwd ? ' in ' + path.basename(curCwd) : ''}. Try /new first.`);
-          return true;
+        if (resumeChoices.length === 0) {
+          return autoCreateSessionOnEmptyResume(bot, chatId, curCwd, currentEngine);
         }
         const headerTitle = curCwd ? `📋 Sessions in ${path.basename(curCwd)}` : '📋 Recent Sessions';
-        if (bot.sendRawCard) {
-          await bot.sendRawCard(chatId, headerTitle, buildSessionCardElements(recentSessions));
-        } else if (bot.sendButtons) {
-          const buttons = recentSessions.map(s => {
-            return [{ text: sessionLabel(s), callback_data: `/resume ${s.sessionId}` }];
-          });
-          await bot.sendButtons(chatId, headerTitle, buttons);
-        } else {
-          const _tags2 = loadSessionTags();
-          let msg = `${headerTitle}\n\n`;
-          recentSessions.forEach((s, i) => {
-            msg += sessionRichLabel(s, i + 1, _tags2) + '\n';
-          });
-          await bot.sendMessage(chatId, msg);
+        try {
+          if (bot.sendRawCard) {
+            await bot.sendRawCard(chatId, headerTitle, buildSessionCardElements(resumeChoices));
+          } else {
+            throw new Error('raw-card-unavailable');
+          }
+        } catch {
+          try {
+            if (bot.sendButtons) {
+              const buttons = resumeChoices.map(s => {
+                return [{ text: sessionLabel(s), callback_data: `/resume ${s.sessionId}` }];
+              });
+              await bot.sendButtons(chatId, headerTitle, buttons);
+            } else {
+              throw new Error('buttons-unavailable');
+            }
+          } catch {
+            const _tags2 = loadSessionTags();
+            let msg = `${headerTitle}\n`;
+            msg += '\n';
+            resumeChoices.forEach((s, i) => {
+              msg += sessionRichLabel(s, i + 1, _tags2) + '\n';
+            });
+            await bot.sendMessage(chatId, msg);
+          }
         }
         return true;
       }
 
-      // Argument given -> match by name, then by session ID prefix
-      const allSessions = listRecentSessions(50);
+      // Argument given -> match current resume choices first (includes synthetic
+      // "当前会话" entry for logical routes), then fall back to global history.
+      const allSessions = listRecentSessions(50, null, currentEngine);
       const argLower = arg.toLowerCase();
-      let fullMatch = allSessions.find(s => s.customTitle && s.customTitle.toLowerCase() === argLower);
+      let fullMatch = resumeChoices.find(s => s.customTitle && s.customTitle.toLowerCase() === argLower);
+      if (!fullMatch) {
+        fullMatch = allSessions.find(s => s.customTitle && s.customTitle.toLowerCase() === argLower);
+      }
+      if (!fullMatch) {
+        fullMatch = resumeChoices.find(s => s.customTitle && s.customTitle.toLowerCase().includes(argLower));
+      }
       if (!fullMatch) {
         fullMatch = allSessions.find(s => s.customTitle && s.customTitle.toLowerCase().includes(argLower));
       }
@@ -315,35 +419,53 @@ function createAgentCommandHandler(deps) {
         fullMatch = recentSessions.find(s => s.sessionId.startsWith(arg))
           || allSessions.find(s => s.sessionId.startsWith(arg));
       }
+      if (!fullMatch) {
+        fullMatch = resumeChoices.find(s => s.sessionId.startsWith(arg));
+      }
       if (!fullMatch) {
         // keep historical behavior:
         // "/resume 看到的session信息太少了" should be treated as normal text
         return null;
       }
       const sessionId = fullMatch.sessionId;
-      const cwd = fullMatch.projectPath || (getSession(chatId) && getSession(chatId).cwd) || HOME;
+      const cwd = fullMatch.projectPath || (curSession && curSession.cwd) || HOME;
 
       const state2 = loadState();
       const cfgForEngine = loadConfig();
-      const engineByTargetCwd = inferEngineByCwd(cfgForEngine, cwd) || getDefaultEngine();
-      // For bound chats, write session to virtual chatId (_agent_{key}) so askClaude picks it up
-      const resumeChatAgentMap = { ...(cfgForEngine.telegram ? cfgForEngine.telegram.chat_agent_map : {}), ...(cfgForEngine.feishu ? cfgForEngine.feishu.chat_agent_map : {}) };
-      const resumeBoundKey = resumeChatAgentMap[String(chatId)];
-      const sessionKey = resumeBoundKey ? `_agent_${resumeBoundKey}` : String(chatId);
+      const sessionKey = route.sessionChatId;
       const existing = state2.sessions[sessionKey] || {};
+      const existingEngine = normalizeEngineName(
+        existing.engine
+        || (existing.engines && Object.entries(existing.engines).find(([, slot]) => slot && slot.started)?.[0])
+      );
+      const engineByTargetCwd = normalizeEngineName(fullMatch.engine)
+        || inferEngineByCwd(cfgForEngine, cwd)
+        || existingEngine;
+      const selectedLogicalCurrent = isLogicalRoute
+        && currentLogical
+        && currentLogical.id
+        && sessionId === currentLogical.id;
+      const targetSessionId = sessionId;
+      const targetCwd = cwd;
       const existingEngines = existing.engines || {};
       state2.sessions[sessionKey] = {
         ...existing,
-        cwd,
-        engines: { ...existingEngines, [engineByTargetCwd]: { id: sessionId, started: true } },
+        cwd: targetCwd,
+        id: targetSessionId,
+        started: true,
+        engine: engineByTargetCwd,
+        engines: { ...existingEngines, [engineByTargetCwd]: { id: targetSessionId, started: true } },
       };
       saveState(state2);
       const name = fullMatch.customTitle;
-      const label = name || (fullMatch.summary || fullMatch.firstPrompt || '').slice(0, 40) || sessionId.slice(0, 8);
+      const label = name || (fullMatch.summary || fullMatch.firstPrompt || '').slice(0, 40) || targetSessionId.slice(0, 8);
 
       // 读取最近对话片段，帮助确认是否切换到正确的 session
-      const recentCtx = getSessionRecentContext ? getSessionRecentContext(sessionId) : null;
+      const recentCtx = getSessionRecentContext ? getSessionRecentContext(targetSessionId) : null;
       let msg = `✅ 已切换: **${label}**\n📁 ${path.basename(cwd)}`;
+      if (selectedLogicalCurrent) {
+        msg += '\n\n已恢复当前智能体会话。';
+      }
       if (recentCtx) {
         if (recentCtx.lastUser) {
           const snippet = recentCtx.lastUser.replace(/\n/g, ' ').slice(0, 80);