metame-cli 1.5.19 → 1.5.21

package/scripts/daemon-session-commands.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { normalizeEngineName: _normalizeEngine } = require('./daemon-utils');
+const { rawChatId: _rawChatId } = require('./core/thread-chat-id');
 
 function createSessionCommandHandler(deps) {
   const {
@@ -19,6 +20,7 @@ function createSessionCommandHandler(deps) {
     getCachedFile,
     getSession,
     listRecentSessions,
+    findAttachableSession,
     getSessionFileMtime,
     formatRelativeTime,
     sendDirListing,
@@ -27,6 +29,7 @@ function createSessionCommandHandler(deps) {
     loadSessionTags,
     sessionRichLabel,
     buildSessionCardElements,
+    getSessionRecentContext,
     getDefaultEngine = () => 'claude',
   } = deps;
 
@@ -55,9 +58,9 @@ function createSessionCommandHandler(deps) {
     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 boundKey = agentMap[chatKey] || agentMap[_rawChatId(chatKey)] || null;
     const boundProj = boundKey && cfg.projects ? cfg.projects[boundKey] : null;
-    const stickyKey = state && state.team_sticky ? state.team_sticky[chatKey] : null;
+    const stickyKey = state && state.team_sticky ? (state.team_sticky[chatKey] || state.team_sticky[_rawChatId(chatKey)]) : null;
     const stickyMember = stickyKey && boundProj && Array.isArray(boundProj.team)
       ? boundProj.team.find((m) => m && m.key === stickyKey)
       : null;
@@ -97,14 +100,26 @@ function createSessionCommandHandler(deps) {
   }
 
   // Write per-engine session slot, preserving cwd and other engine slots.
-  function attachEngineSession(state, chatId, engine, sessionId, cwd) {
+  function attachEngineSession(state, chatId, engine, sessionId, cwd, meta = {}) {
     const effectiveId = getSessionRoute(chatId).sessionChatId;
     const existing = state.sessions[effectiveId] || {};
     const existingEngines = existing.engines || {};
+    const nextSlot = {
+      ...(existingEngines[engine] || {}),
+      ...(sessionId ? { id: sessionId } : { id: null }),
+      started: meta.started !== false,
+    };
+    if (meta.compactContext) nextSlot.compactContext = String(meta.compactContext);
+    else if (meta.clearCompactContext) delete nextSlot.compactContext;
+    if (meta.runtimeSessionObserved === false) nextSlot.runtimeSessionObserved = false;
+    else if (meta.runtimeSessionObserved === true) nextSlot.runtimeSessionObserved = true;
+    if (meta.sandboxMode) nextSlot.sandboxMode = meta.sandboxMode;
+    if (meta.approvalPolicy) nextSlot.approvalPolicy = meta.approvalPolicy;
+    if (meta.permissionMode) nextSlot.permissionMode = meta.permissionMode;
     state.sessions[effectiveId] = {
       ...existing,
       cwd: cwd || existing.cwd || HOME,
-      engines: { ...existingEngines, [engine]: { id: sessionId, started: true } },
+      engines: { ...existingEngines, [engine]: nextSlot },
     };
   }
 
@@ -118,16 +133,52 @@ function createSessionCommandHandler(deps) {
     return null;
   }
 
-  async function autoCreateSessionWhenEmpty(bot, chatId, cwd, engine) {
-    const resolvedCwd = cwd ? normalizeCwd(cwd) : null;
-    if (!resolvedCwd || !fs.existsSync(resolvedCwd)) {
-      await bot.sendMessage(chatId, `No sessions found${resolvedCwd ? ' in ' + path.basename(resolvedCwd) : ''}. Try /new first.`);
-      return true;
+  function resolveAttachableSession(engine, cwd, options = {}) {
+    if (typeof findAttachableSession === 'function') {
+      return findAttachableSession({ engine, cwd, ...options });
     }
-    const route = getSessionRoute(chatId);
-    const session = createSession(route.sessionChatId, resolvedCwd, '', engine || getDefaultEngine());
-    await bot.sendMessage(chatId, `📁 ${path.basename(resolvedCwd)}\n✅ 已自动创建新会话\nWorkdir: ${session.cwd}`);
-    return true;
+    const matches = listRecentSessions(options.limit || 10, cwd || null, engine);
+    if (matches.length > 0) return matches[0];
+    if (!options.allowGlobalFallback) return null;
+    const global = listRecentSessions(options.limit || 10, null, engine);
+    return global[0] || null;
+  }
+
+  function attachResolvedTarget(state, chatId, engine, target, fallbackCwd) {
+    const targetCwd = target && target.projectPath ? target.projectPath : fallbackCwd;
+    if (target && target.pendingState) {
+      attachEngineSession(state, chatId, engine, null, targetCwd, {
+        started: false,
+        compactContext: target.compactContext || '',
+        runtimeSessionObserved: false,
+        ...(target.sandboxMode ? { sandboxMode: target.sandboxMode } : {}),
+        ...(target.approvalPolicy ? { approvalPolicy: target.approvalPolicy } : {}),
+        ...(target.permissionMode ? { permissionMode: target.permissionMode } : {}),
+      });
+      return {
+        cwd: targetCwd,
+        pendingState: true,
+        label: target.customTitle || target.summary || '待接续上下文',
+      };
+    }
+    attachEngineSession(state, chatId, engine, target && target.sessionId ? target.sessionId : null, targetCwd, {
+      started: true,
+      runtimeSessionObserved: true,
+      clearCompactContext: true,
+    });
+    return {
+      cwd: targetCwd,
+      pendingState: false,
+      label: target && (target.customTitle || target.summary || target.sessionId) ? (target.customTitle || target.summary || target.sessionId) : 'Session',
+    };
+  }
+
+  function listResumeCandidates(chatId, limit = 15) {
+    const boundCwd = getBoundCwd(chatId);
+    const currentEngine = getCurrentEngine(chatId);
+    const local = listRecentSessions(limit, boundCwd, currentEngine);
+    if (local && local.length > 0) return local;
+    return listRecentSessions(limit, null, currentEngine);
   }
 
   async function handleSessionCommand(ctx) {
@@ -235,15 +286,10 @@ function createSessionCommandHandler(deps) {
       const curCwd = curSession ? curSession.cwd : null;
 
       // Strategy: try current cwd first, then fall back to global
-      let s = null;
-      if (curCwd) {
-        const cwdSessions = listRecentSessions(1, curCwd, currentEngine);
-        if (cwdSessions.length > 0) s = cwdSessions[0];
-      }
-      if (!s) {
-        const globalSessions = listRecentSessions(1, null, currentEngine);
-        if (globalSessions.length > 0) s = globalSessions[0];
-      }
+      const s = resolveAttachableSession(currentEngine, curCwd, {
+        allowGlobalFallback: true,
+        preferredSessionId: curSession && curSession.id,
+      });
 
       if (!s) {
         // Last resort: use __continue__ to resume whatever Claude thinks is last
@@ -259,8 +305,12 @@ function createSessionCommandHandler(deps) {
       const state2 = loadState();
       const cfgForEngine = loadConfig();
       const engineByCwd = normalizeEngineName(s.engine) || inferEngineByCwd(cfgForEngine, s.projectPath || HOME) || getDefaultEngine();
-      attachEngineSession(state2, chatId, engineByCwd, s.sessionId, s.projectPath || HOME);
+      const attached = attachResolvedTarget(state2, chatId, engineByCwd, s, s.projectPath || HOME);
       saveState(state2);
+      if (attached.pendingState) {
+        await bot.sendMessage(chatId, `⚡ 已接入待接续上下文\n📁 ${path.basename(attached.cwd || curCwd || HOME)}`);
+        return true;
+      }
       // Display: name/summary + id on separate lines
       const name = s.customTitle;
       const shortId = s.sessionId.slice(0, 8);
@@ -326,12 +376,9 @@ function createSessionCommandHandler(deps) {
     if (text === '/sessions') {
       const allSessions = listRecentSessions(15, getBoundCwd(chatId), getCurrentEngine(chatId));
       if (allSessions.length === 0) {
-        return autoCreateSessionWhenEmpty(
-          bot,
-          chatId,
-          getBoundCwd(chatId) || (getSession(chatId) && getSession(chatId).cwd),
-          getCurrentEngine(chatId)
-        );
+        const resolvedCwd = getBoundCwd(chatId) || (getSession(chatId) && getSession(chatId).cwd);
+        await bot.sendMessage(chatId, `No sessions found${resolvedCwd ? ' in ' + path.basename(resolvedCwd) : ''}. Try /new first.`);
+        return true;
       }
       if (bot.sendButtons) {
         await bot.sendRawCard(chatId, '📋 Recent Sessions', buildSessionCardElements(allSessions));
@@ -346,6 +393,52 @@ function createSessionCommandHandler(deps) {
       return true;
     }
 
+    // /resume [id] — show recent sessions or attach a selected one
+    if (text === '/resume' || text.startsWith('/resume ')) {
+      const arg = text.slice(7).trim();
+      const allSessions = listResumeCandidates(chatId, arg ? 50 : 15);
+
+      if (!arg) {
+        if (allSessions.length === 0) {
+          await bot.sendMessage(chatId, 'No sessions found. Try /new first.');
+          return true;
+        }
+        if (bot.sendRawCard && (bot.sendButtons || bot.sendCard)) {
+          await bot.sendRawCard(chatId, '📋 Resume Session', buildSessionCardElements(allSessions));
+        } else {
+          const sessionTags = loadSessionTags();
+          let msg = '📋 Resume Session\n\n';
+          allSessions.forEach((s, i) => {
+            msg += sessionRichLabel(s, i + 1, sessionTags) + '\n';
+          });
+          await bot.sendMessage(chatId, msg.trim());
+        }
+        return true;
+      }
+
+      const target = allSessions.find((s) => s.sessionId === arg || s.sessionId.startsWith(arg));
+      if (!target) {
+        await bot.sendMessage(chatId, `Session not found: ${arg.slice(0, 8)}`);
+        return true;
+      }
+
+      const state2 = loadState();
+      const targetEngine = normalizeEngineName(target.engine) || getCurrentEngine(chatId);
+      const attached = attachResolvedTarget(state2, chatId, targetEngine, target, target.projectPath || HOME);
+      saveState(state2);
+
+      const recentCtx = typeof getSessionRecentContext === 'function'
+        ? getSessionRecentContext(target.sessionId)
+        : null;
+      const title = target.customTitle || target.summary || target.sessionId.slice(0, 8);
+      const lines = [`▶️ Resumed: ${title}`];
+      if (attached.cwd) lines.push(`📁 ${path.basename(attached.cwd)}`);
+      if (recentCtx && recentCtx.lastUser) lines.push(`👤 ${String(recentCtx.lastUser).replace(/\n/g, ' ').slice(0, 80)}`);
+      if (recentCtx && recentCtx.lastAssistant) lines.push(`🤖 ${String(recentCtx.lastAssistant).replace(/\n/g, ' ').slice(0, 80)}`);
+      await bot.sendMessage(chatId, lines.join('\n'));
+      return true;
+    }
+
     // /sess <id> — show session detail card with switch button
     if (text.startsWith('/sess ')) {
       const sid = text.slice(6).trim();
@@ -430,27 +523,24 @@ function createSessionCommandHandler(deps) {
         const route = getSessionRoute(chatId);
         const currentSession = getSession(route.sessionChatId) || getSession(chatId);
         const excludeId = currentSession?.id;
-        const recent = listRecentSessions(10, null, getCurrentEngine(chatId));
-        const filtered = excludeId ? recent.filter(s => s.sessionId !== excludeId) : recent;
-
         // For bound chats, prefer sessions from the same project to avoid
         // the bound-chat guard (handleCommand) immediately overwriting with a new session.
         const boundCwd = getBoundCwd(chatId);
+        const target = resolveAttachableSession(getCurrentEngine(chatId), boundCwd, {
+          allowGlobalFallback: true,
+          excludeSessionId: excludeId,
+        });
 
-        let candidates = filtered;
-        if (boundCwd) {
-          const boundFiltered = filtered.filter(s => s.projectPath && normalizeCwd(s.projectPath) === boundCwd);
-          if (boundFiltered.length > 0) candidates = boundFiltered;
-        }
-
-        if (candidates.length > 0 && candidates[0].projectPath) {
-          const target = candidates[0];
-          // Switch to that session (like /resume) AND its directory
+        if (target && target.projectPath) {
           const state2 = loadState();
           const cfgForEngine = loadConfig();
-          const engineByCwd = inferEngineByCwd(cfgForEngine, target.projectPath) || getDefaultEngine();
-          attachEngineSession(state2, chatId, engineByCwd, target.sessionId, target.projectPath);
+          const engineByCwd = normalizeEngineName(target.engine) || inferEngineByCwd(cfgForEngine, target.projectPath) || getDefaultEngine();
+          const attached = attachResolvedTarget(state2, chatId, engineByCwd, target, target.projectPath);
           saveState(state2);
+          if (attached.pendingState) {
+            await bot.sendMessage(chatId, `🔄 Synced pending context\n📁 ${path.basename(attached.cwd || HOME)}`);
+            return true;
+          }
           const name = target.customTitle || target.summary || '';
           const label = name ? name.slice(0, 40) : target.sessionId.slice(0, 8);
           await bot.sendMessage(chatId, `🔄 Synced to: ${label}\n📁 ${path.basename(target.projectPath)}`);