metame-cli 1.5.3 → 1.5.5

package/scripts/daemon-exec-commands.js

@@ -2,6 +2,7 @@
 
 const { classifyTaskUsage } = require('./usage-classifier');
 const { normalizeModel } = require('./daemon-task-scheduler');
+const { createCommandSessionResolver } = require('./daemon-command-session-route');
 
 function createExecCommandHandler(deps) {
   const {
@@ -20,12 +21,23 @@ function createExecCommandHandler(deps) {
     loadState,
     saveState,
     getSession,
+    getSessionForEngine,
     getSessionName,
     createSession,
     findSessionFile,
+    findCodexSessionFile = null,
     loadConfig,
     getDistillModel,
+    getDefaultEngine = () => 'claude',
   } = deps;
+  const { getActiveSession } = createCommandSessionResolver({
+    path,
+    loadConfig,
+    loadState,
+    getSession,
+    getSessionForEngine,
+    getDefaultEngine,
+  });
 
   function truncateOutput(output, maxLen = 4000) {
     const text = (output || '').trim() || '(no output)';
@@ -234,7 +246,7 @@ function createExecCommandHandler(deps) {
         const signal = proc.killSignal || 'SIGTERM';
         try { process.kill(-proc.child.pid, signal); } catch { try { proc.child.kill(signal); } catch { /* */ } }
       }
-      const session = getSession(chatId);
+      const { session } = getActiveSession(chatId);
       const name = session ? getSessionName(session.id) : null;
       const label = name || (session ? session.id.slice(0, 8) : 'none');
       await bot.sendMessage(chatId, `🔄 Session restarted. MCP/config reloaded.\n📁 ${session ? path.basename(session.cwd) : '~'} [${label}]`);
@@ -243,50 +255,84 @@ function createExecCommandHandler(deps) {
 
     // /compact — compress current session context to save tokens
     if (text === '/compact') {
-      const session = getSession(chatId);
-      if (!session || !session.started) {
+      const { sessionKey, engine, session } = getActiveSession(chatId);
+      if (!session || !session.id || !session.started) {
         await bot.sendMessage(chatId, '❌ No active session to compact.');
         return true;
       }
-      if (String(session.engine || '').toLowerCase() === 'codex') {
-        await bot.sendMessage(chatId, '⚠️ Codex 会话暂不支持 /compact，请继续在同一会话里对话。');
-        return true;
-      }
       await bot.sendMessage(chatId, '🗜 Compacting session...');
 
-      // Step 1: Read conversation from JSONL (fast, no Claude needed)
-      const jsonlPath = findSessionFile(session.id);
-      if (!jsonlPath) {
-        await bot.sendMessage(chatId, '❌ Session file not found.');
-        return true;
-      }
+      // Step 1: Read conversation (JSONL for Claude, rollout JSONL for Codex)
+      const isCodex = String(engine).toLowerCase() === 'codex';
       const messages = [];
-      try {
-        const lines = fs.readFileSync(jsonlPath, 'utf8').split('\n').filter(Boolean);
-        for (const line of lines) {
-          try {
-            const obj = JSON.parse(line);
-            if (obj.type === 'user' || obj.type === 'assistant') {
-              const msg = obj.message || {};
-              const content = msg.content;
+      if (isCodex) {
+        const codexFile = findCodexSessionFile && findCodexSessionFile(session.id);
+        if (!codexFile) {
+          await bot.sendMessage(chatId, '❌ Codex session file not found.');
+          return true;
+        }
+        try {
+          const lines = fs.readFileSync(codexFile, 'utf8').split('\n').filter(Boolean);
+          for (const line of lines) {
+            try {
+              const obj = JSON.parse(line);
+              if (obj.type !== 'response_item') continue;
+              const p = obj.payload;
+              if (!p || p.type !== 'message') continue;
+              const role = String(p.role || '').toLowerCase();
+              if (role !== 'user' && role !== 'assistant') continue;
+              const content = p.content || p;
               let textContent = '';
               if (typeof content === 'string') {
                 textContent = content;
               } else if (Array.isArray(content)) {
-                textContent = content
-                  .filter(c => c.type === 'text')
-                  .map(c => c.text || '')
-                  .join(' ');
+                textContent = content.map(c => {
+                  if (typeof c === 'string') return c;
+                  if (c && typeof c.text === 'string') return c.text;
+                  return '';
+                }).filter(Boolean).join(' ');
               }
-              if (textContent.trim()) {
-                messages.push({ role: obj.type, text: textContent.trim() });
+              textContent = textContent.trim();
+              if (textContent) messages.push({ role, text: textContent });
+            } catch { /* skip malformed lines */ }
+          }
+        } catch (e) {
+          await bot.sendMessage(chatId, `❌ Cannot read Codex session: ${e.message}`);
+          return true;
+        }
+      } else {
+        const jsonlPath = findSessionFile(session.id);
+        if (!jsonlPath) {
+          await bot.sendMessage(chatId, '❌ Session file not found.');
+          return true;
+        }
+        try {
+          const lines = fs.readFileSync(jsonlPath, 'utf8').split('\n').filter(Boolean);
+          for (const line of lines) {
+            try {
+              const obj = JSON.parse(line);
+              if (obj.type === 'user' || obj.type === 'assistant') {
+                const msg = obj.message || {};
+                const content = msg.content;
+                let textContent = '';
+                if (typeof content === 'string') {
+                  textContent = content;
+                } else if (Array.isArray(content)) {
+                  textContent = content
+                    .filter(c => c.type === 'text')
+                    .map(c => c.text || '')
+                    .join(' ');
+                }
+                if (textContent.trim()) {
+                  messages.push({ role: obj.type, text: textContent.trim() });
+                }
               }
-            }
-          } catch { /* skip malformed lines */ }
+            } catch { /* skip malformed lines */ }
+          }
+        } catch (e) {
+          await bot.sendMessage(chatId, `❌ Cannot read session: ${e.message}`);
+          return true;
         }
-      } catch (e) {
-        await bot.sendMessage(chatId, `❌ Cannot read session: ${e.message}`);
-        return true;
       }
 
       if (messages.length === 0) {
@@ -322,23 +368,36 @@ function createExecCommandHandler(deps) {
       }
 
       // Step 4: Create new session with the summary
-      const model = daemonCfg.model || 'opus';
       const oldName = getSessionName(session.id);
-      const newSession = createSession(chatId, session.cwd, oldName ? oldName + ' (compacted)' : '', session.engine || 'claude');
-      const initArgs = ['-p', '--session-id', newSession.id, '--model', model];
-      if (daemonCfg.dangerously_skip_permissions) initArgs.push('--dangerously-skip-permissions');
-      const preamble = buildProfilePreamble();
-      const initPrompt = preamble + `Here is the context from our previous session (compacted):\n\n${output}\n\nContext loaded. Ready to continue.`;
-      const { error: initErr } = await spawnClaudeAsync(initArgs, initPrompt, session.cwd, 60000);
-      if (initErr) {
-        await bot.sendMessage(chatId, `⚠️ Summary saved but new session init failed: ${initErr}`);
-        return true;
-      }
-      // Mark as started
-      const state2 = loadState();
-      if (state2.sessions[chatId]) {
-        state2.sessions[chatId].started = true;
+      const newSession = createSession(sessionKey, session.cwd, oldName ? oldName + ' (compacted)' : '', engine);
+      if (isCodex) {
+        // Codex doesn't support --session-id init; store context for first-message injection in engine
+        const state2 = loadState();
+        if (!state2.sessions[sessionKey]) state2.sessions[sessionKey] = {};
+        if (!state2.sessions[sessionKey].engines) state2.sessions[sessionKey].engines = {};
+        if (!state2.sessions[sessionKey].engines[engine]) state2.sessions[sessionKey].engines[engine] = {};
+        state2.sessions[sessionKey].engines[engine].compactContext = output;
         saveState(state2);
+      } else {
+        // Claude: warm up the new session immediately via --session-id
+        const model = daemonCfg.model || 'opus';
+        const initArgs = ['-p', '--session-id', newSession.id, '--model', model];
+        if (daemonCfg.dangerously_skip_permissions) initArgs.push('--dangerously-skip-permissions');
+        const preamble = buildProfilePreamble();
+        const initPrompt = preamble + `Here is the context from our previous session (compacted):\n\n${output}\n\nContext loaded. Ready to continue.`;
+        const { error: initErr } = await spawnClaudeAsync(initArgs, initPrompt, session.cwd, 60000);
+        if (initErr) {
+          await bot.sendMessage(chatId, `⚠️ Summary saved but new session init failed: ${initErr}`);
+          return true;
+        }
+        const state2 = loadState();
+        if (state2.sessions[sessionKey]) {
+          state2.sessions[sessionKey].started = true;
+          if (state2.sessions[sessionKey].engines && state2.sessions[sessionKey].engines[engine]) {
+            state2.sessions[sessionKey].engines[engine].started = true;
+          }
+          saveState(state2);
+        }
       }
       const tokenEst = Math.round(output.length / 3.5);
       await bot.sendMessage(chatId, `✅ Compacted! ~${tokenEst} tokens of context carried over.\nNew session: ${newSession.id.slice(0, 8)}`);
@@ -352,8 +411,8 @@ function createExecCommandHandler(deps) {
         await bot.sendMessage(chatId, '用法: /publish 123456');
         return true;
       }
-      const session = getSession(chatId);
-      const cwd = session?.cwd || HOME;
+      const { route, session } = getActiveSession(chatId);
+      const cwd = session?.cwd || route.cwd || HOME;
       await bot.sendMessage(chatId, `📦 npm publish --otp=${otp} ...`);
       try {
         const result = await runCommand('npm', ['publish', `--otp=${otp}`], { cwd, timeout: 60000 });

package/scripts/daemon-file-browser.js

@@ -58,15 +58,71 @@ function createFileBrowser(deps) {
     return entry.path;
   }
 
+  function appendDebugLog(message) {
+    try {
+      fs.appendFileSync(path.join(HOME, '.metame', 'daemon.log'), `[${new Date().toISOString()}] [INFO] [file-browser] ${message}\n`);
+    } catch {}
+  }
+
   async function sendFileButtons(bot, chatId, files) {
-    if (!bot.sendButtons || files.size === 0) return;
+    if (files.size === 0) return;
     const validFiles = [...files].filter(f => fs.existsSync(f));
-    if (validFiles.length === 0) return;
-    const buttons = validFiles.map(filePath => {
-      const shortId = cacheFile(filePath);
-      return [{ text: `📎 ${path.basename(filePath)}`, callback_data: `/file ${shortId}` }];
-    });
-    await bot.sendButtons(chatId, '📂 文件:', buttons);
+    if (validFiles.length === 0) return [];
+    const fallbackText = `📂 文件已生成：\n${validFiles.map(filePath => `- ${filePath}`).join('\n')}`;
+    const sentMessages = [];
+    appendDebugLog(`sendFileButtons chat=${chatId} hasSendFile=${typeof bot.sendFile === 'function'} hasSendButtons=${typeof bot.sendButtons === 'function'} hasEditMessage=${typeof bot.editMessage === 'function'} hasSendCard=${typeof bot.sendCard === 'function'} files=${validFiles.map(filePath => path.basename(filePath)).join(',')}`);
+
+    // Prefer direct file delivery when the adapter supports it.
+    // This matches the user's expectation on mobile and avoids brittle
+    // button-card transport on platforms like Feishu.
+    if (bot.sendFile) {
+      try {
+        appendDebugLog(`attempting direct sendFile chat=${chatId}`);
+        for (const filePath of validFiles) {
+          const msg = await bot.sendFile(chatId, filePath);
+          if (msg && msg.message_id) sentMessages.push(msg);
+        }
+        appendDebugLog(`direct sendFile success chat=${chatId} count=${sentMessages.length}`);
+        return sentMessages;
+      } catch (err) {
+        const detail = err && err.stack ? err.stack : String(err && err.message ? err.message : err);
+        appendDebugLog(`sendFile failed chat=${chatId} err=${detail.split('\n')[0]}`);
+        if (bot.sendMessage) {
+          const msg = await bot.sendMessage(chatId, fallbackText);
+          if (msg && msg.message_id) sentMessages.push(msg);
+        }
+        appendDebugLog(`sendFile fallback text chat=${chatId} count=${sentMessages.length}`);
+        return sentMessages;
+      }
+    }
+
+    const isStreamCardBot = typeof bot.editMessage === 'function' || typeof bot.sendCard === 'function';
+    if (!bot.sendButtons || isStreamCardBot) {
+      appendDebugLog(`button fallback skipped chat=${chatId} hasSendButtons=${typeof bot.sendButtons === 'function'} isStreamCardBot=${isStreamCardBot}`);
+      if (bot.sendMessage) {
+        const msg = await bot.sendMessage(chatId, fallbackText);
+        if (msg && msg.message_id) sentMessages.push(msg);
+      }
+      return sentMessages;
+    }
+
+    try {
+      appendDebugLog(`attempting sendButtons chat=${chatId}`);
+      const buttons = validFiles.map(filePath => {
+        const shortId = cacheFile(filePath);
+        return [{ text: `📎 ${path.basename(filePath)}`, callback_data: `/file ${shortId}` }];
+      });
+      const msg = await bot.sendButtons(chatId, '📂 文件:', buttons);
+      if (msg && msg.message_id) sentMessages.push(msg);
+      appendDebugLog(`sendButtons success chat=${chatId}`);
+    } catch {
+      appendDebugLog(`sendButtons failed chat=${chatId}`);
+      if (bot.sendMessage) {
+        const msg = await bot.sendMessage(chatId, fallbackText);
+        if (msg && msg.message_id) sentMessages.push(msg);
+      }
+    }
+    return sentMessages;
   }
 
   async function sendDirPicker(bot, chatId, mode, title) {
@@ -87,6 +143,7 @@ function createFileBrowser(deps) {
       const cmd = mode === 'new' ? '/new'
         : mode === 'bind' ? '/agent-bind-dir'
         : mode === 'agent-new' ? '/agent-dir'
+        : mode === 'team-new' ? '/agent-team-dir'
         : '/cd';
 
       const PAGE_SIZE = 10;

package/scripts/daemon-notify.js

@@ -1,5 +1,12 @@
 'use strict';
 
+function resolveAdminChatId(adapterConfig = {}) {
+  const explicitId = String(adapterConfig.admin_chat_id || '').trim();
+  if (explicitId) return explicitId;
+  const ids = Array.isArray(adapterConfig.allowed_chat_ids) ? adapterConfig.allowed_chat_ids : [];
+  return ids[0] || null;
+}
+
 function createNotifier(deps) {
   const { log, getConfig, getBridges } = deps;
 
@@ -46,16 +53,23 @@ function createNotifier(deps) {
 
   async function notifyAdmin(message) {
     const config = getConfig();
-    const { feishuBridge } = getBridges();
+    const { feishuBridge, telegramBridge } = getBridges();
     if (feishuBridge && feishuBridge.bot) {
-      const fsIds = (config.feishu && config.feishu.allowed_chat_ids) || [];
-      const adminId = fsIds[0];
+      const adminId = resolveAdminChatId(config.feishu || {});
       if (adminId) {
         try { await feishuBridge.bot.sendMessage(adminId, message); } catch (e) {
           log('ERROR', `Feishu admin notify failed ${adminId}: ${e.message}`);
         }
       }
     }
+    if (telegramBridge && telegramBridge.bot) {
+      const adminId = resolveAdminChatId(config.telegram || {});
+      if (adminId) {
+        try { await telegramBridge.bot.sendMarkdown(adminId, message); } catch (e) {
+          log('ERROR', `Telegram admin notify failed ${adminId}: ${e.message}`);
+        }
+      }
+    }
   }
 
   /**
@@ -97,4 +111,4 @@ function createNotifier(deps) {
   return { notify, notifyAdmin, notifyPersonal };
 }
 
-module.exports = { createNotifier };
+module.exports = { createNotifier, resolveAdminChatId };

package/scripts/daemon-ops-commands.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { createCommandSessionResolver } = require('./daemon-command-session-route');
+
 function createOpsCommandHandler(deps) {
   const {
     fs,
@@ -7,9 +9,12 @@ function createOpsCommandHandler(deps) {
     spawn,
     execSync,
     log,
+    loadConfig,
+    loadState,
     messageQueue,
     activeProcesses,
     getSession,
+    getSessionForEngine,
     listCheckpoints,
     cpDisplayLabel,
     truncateSessionToCheckpoint,
@@ -20,7 +25,16 @@ function createOpsCommandHandler(deps) {
     cleanupCheckpoints,
     getNoSleepProcess,
     setNoSleepProcess,
+    getDefaultEngine = () => 'claude',
   } = deps;
+  const { getActiveSession } = createCommandSessionResolver({
+    path,
+    loadConfig,
+    loadState,
+    getSession,
+    getSessionForEngine,
+    getDefaultEngine,
+  });
 
   function clearMessageQueue(chatId) {
     if (messageQueue.has(chatId)) {
@@ -45,7 +59,7 @@ function createOpsCommandHandler(deps) {
       clearMessageQueue(chatId);
       interruptActiveProcess(chatId);
 
-      const session = getSession(chatId);
+      const { session } = getActiveSession(chatId);
       if (!session || !session.id) {
         await bot.sendMessage(chatId, 'No active session to undo.');
         return true;
@@ -168,7 +182,7 @@ function createOpsCommandHandler(deps) {
       clearMessageQueue(chatId);
       interruptActiveProcess(chatId);
 
-      const session2 = getSession(chatId);
+      const { session: session2 } = getActiveSession(chatId);
       if (!session2 || !session2.id) {
         await bot.sendMessage(chatId, 'No active session.');
         return true;

package/scripts/daemon-remote-dispatch.js

@@ -46,10 +46,58 @@ function decodePacket(text) {
 }
 
 function verifyPacket(packet, secret) {
-  if (!packet || typeof packet !== 'object' || !packet.sig) return false;
+  if (!packet || typeof packet !== 'object' || !packet.sig || !secret) return false;
   return signPacket(packet, secret) === packet.sig;
 }
 
+function isValidPairCode(code) {
+  return /^\d{6}$/.test(String(code || '').trim());
+}
+
+function generatePairCode() {
+  return String(Math.floor(Math.random() * 1000000)).padStart(6, '0');
+}
+
+function deriveSecretFromPairCode(code, chatId) {
+  const normalizedCode = String(code || '').trim();
+  const normalizedChatId = String(chatId || '').trim();
+  if (!isValidPairCode(normalizedCode) || !normalizedChatId) return null;
+  return crypto
+    .createHash('sha256')
+    .update(`metame-remote-dispatch|${normalizedChatId}|${normalizedCode}`)
+    .digest('hex');
+}
+
+function getRemoteDispatchStatus(config) {
+  const rd = normalizeRemoteDispatchConfig(config);
+  if (!rd) return null;
+  return {
+    selfPeer: rd.selfPeer,
+    chatId: rd.chatId,
+    mode: 'pair-code',
+    hasSecret: !!rd.secret,
+  };
+}
+
+// TTL dedup map — prevents replayed packets (5 min window)
+const _seenPackets = new Map();
+const DEDUP_TTL_MS = 5 * 60 * 1000;
+
+function isDuplicate(packetId) {
+  if (!packetId) return false;
+  const now = Date.now();
+  for (const [id, ts] of _seenPackets) {
+    if (now - ts > DEDUP_TTL_MS) _seenPackets.delete(id);
+  }
+  if (_seenPackets.has(packetId)) return true;
+  _seenPackets.set(packetId, now);
+  return false;
+}
+
+function isRemoteMember(member) {
+  return !!(member && member.peer);
+}
+
 module.exports = {
   REMOTE_DISPATCH_PREFIX,
   normalizeRemoteDispatchConfig,
@@ -57,4 +105,10 @@ module.exports = {
   encodePacket,
   decodePacket,
   verifyPacket,
+  isValidPairCode,
+  generatePairCode,
+  deriveSecretFromPairCode,
+  getRemoteDispatchStatus,
+  isDuplicate,
+  isRemoteMember,
 };

package/scripts/daemon-runtime-lifecycle.js

@@ -58,9 +58,92 @@ function setupRuntimeWatchers(deps) {
     getHeartbeatTimer,
     setHeartbeatTimer,
     onRestartRequested,
+    // Agent soul layer auto-repair — optional, gracefully skipped if absent
+    repairAgentLayer,
+    writeConfigSafe,
+    expandPath,
+    HOME,
   } = deps;
 
+  /**
+   * After every config reload: ensure all project agent soul layers are healthy.
+   *
+   * For each project:
+   *   1. If cwd changed vs oldConfig → remove stale SOUL.md/MEMORY.md symlinks from old dir
+   *   2. Call repairAgentLayer (idempotent)
+   *   3. Persist missing agent_id back to daemon.yaml
+   */
+  function autoRepairAgentLayers(oldConfig, newConfig) {
+    if (typeof repairAgentLayer !== 'function') return;
+    const projects = newConfig && newConfig.projects;
+    if (!projects || typeof projects !== 'object') return;
+
+    const normCwd = (raw) => {
+      if (!raw) return null;
+      try {
+        const expanded = typeof expandPath === 'function'
+          ? expandPath(String(raw))
+          : String(raw).replace(/^~/, HOME || require('os').homedir());
+        return path.resolve(expanded);
+      } catch { return null; }
+    };
+
+    let repaired = 0;
+    let agentIdFixed = 0;
+    let needsWrite = false;
+
+    for (const [projectKey, project] of Object.entries(projects)) {
+      if (!project || !project.cwd) continue;
+      const newCwd = normCwd(project.cwd);
+      if (!newCwd) continue;
+
+      // Clean stale symlinks when cwd changed
+      const oldProject = oldConfig && oldConfig.projects && oldConfig.projects[projectKey];
+      if (oldProject && oldProject.cwd) {
+        const oldCwd = normCwd(oldProject.cwd);
+        if (oldCwd && oldCwd !== newCwd) {
+          for (const fname of ['SOUL.md', 'MEMORY.md']) {
+            const stale = path.join(oldCwd, fname);
+            try {
+              if (fs.existsSync(stale) && fs.lstatSync(stale).isSymbolicLink()) {
+                fs.unlinkSync(stale);
+                log('INFO', `[agent-repair] Removed stale ${fname} from ${oldCwd}`);
+              }
+            } catch { /* non-critical */ }
+          }
+        }
+      }
+
+      // Repair soul layer (idempotent — safe every reload)
+      try {
+        const ensured = repairAgentLayer(projectKey, project, HOME);
+        if (ensured) {
+          repaired++;
+          if (!project.agent_id && ensured.agentId) {
+            newConfig.projects[projectKey] = { ...project, agent_id: ensured.agentId };
+            needsWrite = true;
+            agentIdFixed++;
+          }
+        }
+      } catch (e) {
+        log('WARN', `[agent-repair] ${projectKey}: ${e.message}`);
+      }
+    }
+
+    if (needsWrite && typeof writeConfigSafe === 'function') {
+      try {
+        writeConfigSafe(newConfig);
+        log('INFO', `[agent-repair] Persisted ${agentIdFixed} agent_id(s) to daemon.yaml`);
+      } catch (e) {
+        log('WARN', `[agent-repair] writeConfigSafe failed: ${e.message}`);
+      }
+    }
+
+    if (repaired > 0) log('INFO', `[agent-repair] ${repaired} layer(s) ensured${agentIdFixed ? `, ${agentIdFixed} agent_id(s) added` : ''}`);
+  }
+
   function reloadConfig() {
+    const oldConfig = typeof getConfig === 'function' ? getConfig() : null;
     const strict = typeof loadConfigStrict === 'function'
       ? loadConfigStrict()
       : { ok: true, config: loadConfig() };
@@ -74,6 +157,10 @@ function setupRuntimeWatchers(deps) {
     const { general, project } = getAllTasks(newConfig);
     const totalCount = general.length + project.length;
     log('INFO', `Config reloaded: ${totalCount} tasks (${project.length} in projects)`);
+    // Auto-repair agent soul layers on every config change (idempotent, fire-and-forget)
+    try { autoRepairAgentLayers(oldConfig, newConfig); } catch (e) {
+      log('WARN', `[agent-repair] Unexpected error: ${e.message}`);
+    }
     return { success: true, tasks: totalCount };
   }