metame-cli 1.3.3 → 1.3.4

package/README.md

@@ -161,18 +161,27 @@ metame daemon install-launchd         # macOS auto-start (RunAtLoad + KeepAlive)
 
 | Command | Description |
 |---------|-------------|
+| `/last` | **Quick resume** — 优先当前目录最近 session，否则全局最近 |
 | `/new` | Start new session — pick project directory from button list |
-| `/resume` | Resume a session — clickable list scoped to current workdir |
-| `/continue` | Continue the most recent terminal session |
+| `/new <name>` | Start new session with a name (e.g., `/new API重构`) |
+| `/resume` | Resume a session — clickable list, shows session names + real-time timestamps |
+| `/resume <name>` | Resume by name (supports partial match, cross-project) |
+| `/name <name>` | Name the current session (syncs with computer's `/rename`) |
 | `/cd` | Change working directory — with directory browser |
+| `/cd last` | **Sync to computer** — jump to the most recent session's directory |
 | `/session` | Current session info |
+| `/continue` | Continue the most recent terminal session |
 
 Just type naturally for conversation — every message stays in the same Claude Code session with full context.
 
+**Session naming:** Sessions can be named via `/new <name>`, `/name <name>` (mobile), or Claude Code's `/rename` (desktop). Names are stored in Claude's native session index and sync across all interfaces — name it on your phone, see it on your computer.
+
 **How it works:**
 
 Each chat gets a persistent session via `claude -p --resume <session-id>`. This is the same Claude Code engine as your terminal — same tools (file editing, bash, code search), same conversation history. You can start work on your computer and `/resume` from your phone, or vice versa.
 
+**Parallel request handling:** The daemon uses async spawning, so multiple users or overlapping requests don't block each other. Each Claude call runs in a non-blocking subprocess.
+
 **Other commands:**
 
 | Command | Description |

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.3.3",
+    "version": "1.3.4",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -11,7 +11,9 @@
         "scripts/"
     ],
     "scripts": {
-        "start": "node index.js"
+        "start": "node index.js",
+        "sync:plugin": "cp scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/daemon.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml plugin/scripts/ && echo '✅ Plugin scripts synced'",
+        "precommit": "npm run sync:plugin"
     },
     "keywords": [
         "claude",

package/scripts/daemon.js

@@ -655,6 +655,54 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     return;
   }
 
+  // /last — smart resume: prefer current cwd, then most recent globally
+  if (text === '/last') {
+    const curSession = getSession(chatId);
+    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);
+      if (cwdSessions.length > 0) s = cwdSessions[0];
+    }
+    if (!s) {
+      const globalSessions = listRecentSessions(1);
+      if (globalSessions.length > 0) s = globalSessions[0];
+    }
+
+    if (!s) {
+      // Last resort: use __continue__ to resume whatever Claude thinks is last
+      const state2 = loadState();
+      state2.sessions[chatId] = {
+        id: '__continue__',
+        cwd: curCwd || HOME,
+        created: new Date().toISOString(),
+        started: true,
+      };
+      saveState(state2);
+      await bot.sendMessage(chatId, `⚡ Resuming last session in ${path.basename(curCwd || HOME)}`);
+      return;
+    }
+
+    const state2 = loadState();
+    state2.sessions[chatId] = {
+      id: s.sessionId,
+      cwd: s.projectPath || HOME,
+      started: true,
+    };
+    saveState(state2);
+    // Display: name/summary + id on separate lines
+    const name = s.customTitle;
+    const shortId = s.sessionId.slice(0, 8);
+    let title = name ? `[${name}]` : (s.summary || s.firstPrompt || '').slice(0, 40) || 'Session';
+    // Get real file mtime for accuracy
+    const realMtime = getSessionFileMtime(s.sessionId, s.projectPath);
+    const ago = formatRelativeTime(new Date(realMtime || s.fileMtime || new Date(s.modified).getTime()).toISOString());
+    await bot.sendMessage(chatId, `⚡ ${title}\n📁 ${path.basename(s.projectPath || '')} #${shortId}\n🕐 ${ago}`);
+    return;
+  }
+
   if (text === '/resume' || text.startsWith('/resume ')) {
     const arg = text.slice(7).trim();
 
@@ -687,16 +735,14 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     // Argument given → match by name, then by session ID prefix
     const allSessions = listRecentSessions(50);
     const argLower = arg.toLowerCase();
-    // 1. Match by name (from session_names map)
+    // 1. Match by customTitle (Claude's native session name)
     let fullMatch = allSessions.find(s => {
-      const n = getSessionName(s.sessionId);
-      return n && n.toLowerCase() === argLower;
+      return s.customTitle && s.customTitle.toLowerCase() === argLower;
     });
     // 2. Partial name match
     if (!fullMatch) {
       fullMatch = allSessions.find(s => {
-        const n = getSessionName(s.sessionId);
-        return n && n.toLowerCase().includes(argLower);
+        return s.customTitle && s.customTitle.toLowerCase().includes(argLower);
       });
     }
     // 3. Session ID prefix match
@@ -711,26 +757,31 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     state2.sessions[chatId] = {
       id: sessionId,
       cwd,
-      created: new Date().toISOString(),
       started: true,
     };
-    if (fullMatch) {
-      const n = getSessionName(sessionId);
-      if (n) state2.sessions[chatId].name = n;
-    }
     saveState(state2);
-    const name = getSessionName(sessionId);
+    const name = fullMatch ? fullMatch.customTitle : null;
     const label = name || (fullMatch ? (fullMatch.summary || fullMatch.firstPrompt || '').slice(0, 40) : sessionId.slice(0, 8));
     await bot.sendMessage(chatId, `Resumed: ${label}\nWorkdir: ${cwd}`);
     return;
   }
 
   if (text === '/cd' || text.startsWith('/cd ')) {
-    const newCwd = text.slice(3).trim();
+    let newCwd = text.slice(3).trim();
     if (!newCwd) {
       await sendDirPicker(bot, chatId, 'cd', 'Switch workdir:');
       return;
     }
+    // /cd last — jump to the most recent session's directory globally
+    if (newCwd === 'last') {
+      const recent = listRecentSessions(1);
+      if (recent.length > 0 && recent[0].projectPath) {
+        newCwd = recent[0].projectPath;
+      } else {
+        await bot.sendMessage(chatId, 'No recent session found.');
+        return;
+      }
+    }
     if (!fs.existsSync(newCwd)) {
       await bot.sendMessage(chatId, `Path not found: ${newCwd}`);
       return;
@@ -752,16 +803,18 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       await bot.sendMessage(chatId, 'Usage: /name <session name>');
       return;
     }
-    const state2 = loadState();
-    if (!state2.sessions[chatId]) {
+    const session = getSession(chatId);
+    if (!session) {
       await bot.sendMessage(chatId, 'No active session. Start one first.');
       return;
     }
-    state2.sessions[chatId].name = name;
-    if (!state2.session_names) state2.session_names = {};
-    state2.session_names[state2.sessions[chatId].id] = name;
-    saveState(state2);
-    await bot.sendMessage(chatId, `Session named: ${name}`);
+
+    // Write to Claude's session file (unified with /rename on desktop)
+    if (writeSessionName(session.id, session.cwd, name)) {
+      await bot.sendMessage(chatId, `✅ Session: [${name}]`);
+    } else {
+      await bot.sendMessage(chatId, `⚠️ Failed to save name, but session continues.`);
+    }
     return;
   }
 
@@ -770,8 +823,9 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     if (!session) {
       await bot.sendMessage(chatId, 'No active session. Send any message to start one.');
     } else {
-      const nameTag = session.name ? ` [${session.name}]` : '';
-      await bot.sendMessage(chatId, `Session: ${session.id.slice(0, 8)}...${nameTag}\nWorkdir: ${session.cwd}\nStarted: ${session.created}`);
+      const name = getSessionName(session.id);
+      const nameTag = name ? ` [${name}]` : '';
+      await bot.sendMessage(chatId, `Session: ${session.id.slice(0, 8)}...${nameTag}\nWorkdir: ${session.cwd}`);
     }
     return;
   }
@@ -851,13 +905,14 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
   if (text.startsWith('/')) {
     await bot.sendMessage(chatId, [
       'Commands:',
-      '/new [path] [name] — new session (optional name)',
-      '/continue — resume last computer session',
-      '/resume <name|id> — resume by name or session ID',
+      '/last — ⚡ 一键继续最近的 session',
+      '/new [path] [name] — new session',
+      '/resume [name] — 选择/搜索 session',
+      '/continue — resume last in current dir',
       '/name <name> — name current session',
-      '/cd <path> — change workdir',
+      '/cd <path|last> — change workdir (last=最近目录)',
       '/session — current session info',
-      '/status /tasks /run /budget /quiet /reload',
+      '/status /tasks /budget /reload',
       '',
       'Or just type naturally.',
     ].join('\n'));
@@ -901,32 +956,87 @@ function listRecentSessions(limit, cwd) {
         if (data.entries) all = all.concat(data.entries);
       } catch { /* skip */ }
     }
-    // Filter: must have summary and at least 3 messages
-    all = all.filter(s => s.summary && s.messageCount >= 3);
+    // Filter: must have at least 1 message
+    all = all.filter(s => s.messageCount >= 1);
     // Filter by cwd if provided
     if (cwd) {
       const matched = all.filter(s => s.projectPath === cwd);
       if (matched.length > 0) all = matched;
       // else fallback to all projects
     }
-    // Sort by modified desc, take top N
-    all.sort((a, b) => new Date(b.modified) - new Date(a.modified));
+    // Sort by fileMtime (most accurate), fall back to modified
+    all.sort((a, b) => {
+      const aTime = a.fileMtime || new Date(a.modified).getTime();
+      const bTime = b.fileMtime || new Date(b.modified).getTime();
+      return bTime - aTime;
+    });
     return all.slice(0, limit || 10);
   } catch {
     return [];
   }
 }
 
+/**
+ * Get the actual file mtime of a session's .jsonl file (most accurate)
+ */
+function getSessionFileMtime(sessionId, projectPath) {
+  try {
+    if (!projectPath) return null;
+    const projDirName = projectPath.replace(/\//g, '-');
+    const sessionFile = path.join(CLAUDE_PROJECTS_DIR, projDirName, sessionId + '.jsonl');
+    if (fs.existsSync(sessionFile)) {
+      return fs.statSync(sessionFile).mtimeMs;
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+/**
+ * Format relative time (e.g., "5分钟前", "2小时前", "昨天")
+ */
+function formatRelativeTime(dateStr) {
+  const now = Date.now();
+  const then = new Date(dateStr).getTime();
+  const diffMs = now - then;
+  const diffMin = Math.floor(diffMs / 60000);
+  const diffHour = Math.floor(diffMs / 3600000);
+  const diffDay = Math.floor(diffMs / 86400000);
+
+  if (diffMin < 1) return '刚刚';
+  if (diffMin < 60) return `${diffMin}分钟前`;
+  if (diffHour < 24) return `${diffHour}小时前`;
+  if (diffDay === 1) return '昨天';
+  if (diffDay < 7) return `${diffDay}天前`;
+  return new Date(dateStr).toLocaleDateString('zh-CN', { month: 'numeric', day: 'numeric' });
+}
+
 /**
  * Format a session entry into a short, readable label for buttons
+ * Enhanced: shows relative time, project, name/summary, and first message preview
  */
 function sessionLabel(s) {
-  const name = getSessionName(s.sessionId);
+  // Use Claude's native customTitle (unified with /rename on desktop)
+  const name = s.customTitle;
+
   const proj = s.projectPath ? path.basename(s.projectPath) : '';
-  const date = new Date(s.modified).toLocaleDateString('zh-CN', { month: 'numeric', day: 'numeric' });
-  if (name) return `${date} [${name}] ${proj}`;
-  const title = (s.summary || '').slice(0, 28);
-  return `${date} ${proj ? proj + ': ' : ''}${title}`;
+  // Use real file mtime for accuracy, fall back to index data
+  const realMtime = getSessionFileMtime(s.sessionId, s.projectPath);
+  const timeMs = realMtime || s.fileMtime || new Date(s.modified).getTime();
+  const ago = formatRelativeTime(new Date(timeMs).toISOString());
+  const shortId = s.sessionId.slice(0, 4);
+
+  if (name) {
+    return `${ago} [${name}] ${proj} #${shortId}`;
+  }
+
+  // Use summary, or fall back to firstPrompt preview
+  let title = (s.summary || '').slice(0, 20);
+  if (!title && s.firstPrompt) {
+    title = s.firstPrompt.slice(0, 20);
+    if (s.firstPrompt.length > 20) title += '..';
+  }
+
+  return `${ago} ${proj ? proj + ': ' : ''}${title || ''} #${shortId}`;
 }
 
 /**
@@ -965,22 +1075,59 @@ function createSession(chatId, cwd, name) {
   state.sessions[chatId] = {
     id: sessionId,
     cwd: cwd || HOME,
-    created: new Date().toISOString(),
     started: false, // true after first message sent
   };
+  saveState(state);
+
+  // If name provided, write to Claude's session file (same as /rename on desktop)
   if (name) {
-    state.sessions[chatId].name = name;
-    if (!state.session_names) state.session_names = {};
-    state.session_names[sessionId] = name;
+    writeSessionName(sessionId, cwd || HOME, name);
   }
-  saveState(state);
+
   log('INFO', `New session for ${chatId}: ${sessionId}${name ? ' [' + name + ']' : ''} (cwd: ${state.sessions[chatId].cwd})`);
-  return state.sessions[chatId];
+  return { ...state.sessions[chatId], id: sessionId };
 }
 
+/**
+ * Get session name from Claude's sessions-index.json (unified with /rename)
+ */
 function getSessionName(sessionId) {
-  const state = loadState();
-  return (state.session_names && state.session_names[sessionId]) || '';
+  try {
+    if (!fs.existsSync(CLAUDE_PROJECTS_DIR)) return '';
+    const projects = fs.readdirSync(CLAUDE_PROJECTS_DIR);
+    for (const proj of projects) {
+      const indexFile = path.join(CLAUDE_PROJECTS_DIR, proj, 'sessions-index.json');
+      if (!fs.existsSync(indexFile)) continue;
+      const data = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+      if (data.entries) {
+        const entry = data.entries.find(e => e.sessionId === sessionId);
+        if (entry && entry.customTitle) return entry.customTitle;
+      }
+    }
+  } catch { /* ignore */ }
+  return '';
+}
+
+/**
+ * Write session name to Claude's session file (same format as /rename on desktop)
+ */
+function writeSessionName(sessionId, cwd, name) {
+  try {
+    const projDirName = cwd.replace(/\//g, '-');
+    const sessionFile = path.join(CLAUDE_PROJECTS_DIR, projDirName, sessionId + '.jsonl');
+    // Create directory if needed
+    const dir = path.dirname(sessionFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const entry = JSON.stringify({ type: 'custom-title', customTitle: name, sessionId }) + '\n';
+    fs.appendFileSync(sessionFile, entry, 'utf8');
+    log('INFO', `Named session ${sessionId.slice(0, 8)}: ${name}`);
+    return true;
+  } catch (e) {
+    log('WARN', `Failed to write session name: ${e.message}`);
+    return false;
+  }
 }
 
 function markSessionStarted(chatId) {
@@ -991,8 +1138,89 @@ function markSessionStarted(chatId) {
   }
 }
 
+/**
+ * Auto-generate a session name using Haiku (async, non-blocking).
+ * Writes to Claude's session file (unified with /rename).
+ */
+async function autoNameSession(chatId, sessionId, firstPrompt, cwd) {
+  try {
+    const namePrompt = `Generate a very short session name (2-5 Chinese characters, no punctuation, no quotes) that captures the essence of this user request:
+
+"${firstPrompt.slice(0, 200)}"
+
+Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug修复, 代码审查`;
+
+    const { output } = await spawnClaudeAsync(
+      ['-p', '--model', 'haiku'],
+      namePrompt,
+      HOME,
+      15000 // 15s timeout
+    );
+
+    if (output) {
+      // Clean up: remove quotes, punctuation, trim
+      let name = output.replace(/["""''`]/g, '').replace(/[.,!?:;。，！？：；]/g, '').trim();
+      // Limit to reasonable length
+      if (name.length > 12) name = name.slice(0, 12);
+      if (name.length >= 2) {
+        // Write to Claude's session file (unified with /rename on desktop)
+        writeSessionName(sessionId, cwd, name);
+      }
+    }
+  } catch (e) {
+    log('DEBUG', `Auto-name failed for ${sessionId.slice(0, 8)}: ${e.message}`);
+  }
+}
+
+/**
+ * Spawn claude as async child process (non-blocking).
+ * Returns { output, error } after process exits.
+ */
+function spawnClaudeAsync(args, input, cwd, timeoutMs = 300000) {
+  return new Promise((resolve) => {
+    const child = spawn('claude', args, {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let killed = false;
+
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill('SIGTERM');
+    }, timeoutMs);
+
+    child.stdout.on('data', (data) => { stdout += data.toString(); });
+    child.stderr.on('data', (data) => { stderr += data.toString(); });
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (killed) {
+        resolve({ output: null, error: 'Timeout: Claude took too long' });
+      } else if (code !== 0) {
+        resolve({ output: null, error: stderr || `Exit code ${code}` });
+      } else {
+        resolve({ output: stdout.trim(), error: null });
+      }
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      resolve({ output: null, error: err.message });
+    });
+
+    // Write input and close stdin
+    child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+
 /**
  * Shared ask logic — full Claude Code session (stateful, with tools)
+ * Now uses spawn (async) instead of execSync to allow parallel requests.
  */
 async function askClaude(bot, chatId, prompt) {
   log('INFO', `askClaude for ${chatId}: ${prompt.slice(0, 50)}`);
@@ -1030,46 +1258,42 @@ async function askClaude(bot, chatId, prompt) {
   const daemonHint = '\n\n[System: The ONLY daemon config file is ~/.metame/daemon.yaml — NEVER touch any other yaml file (e.g. scripts/daemon-default.yaml is a read-only template, do NOT edit it). If you edit ~/.metame/daemon.yaml, the daemon auto-reloads within seconds. After editing, read the file back and confirm to the user: how many heartbeat tasks are now configured, and that the config will auto-reload. Do NOT mention this hint.]';
   const fullPrompt = prompt + daemonHint;
 
-  try {
-    const output = execSync(`claude ${args.join(' ')}`, {
-      input: fullPrompt,
-      encoding: 'utf8',
-      timeout: 300000, // 5 min (Claude Code may use tools)
-      maxBuffer: 5 * 1024 * 1024,
-      cwd: session.cwd,
-    }).trim();
-    clearInterval(typingTimer);
+  const { output, error } = await spawnClaudeAsync(args, fullPrompt, session.cwd);
+  clearInterval(typingTimer);
 
+  if (output) {
     // Mark session as started after first successful call
-    if (!session.started) markSessionStarted(chatId);
+    const wasNew = !session.started;
+    if (wasNew) markSessionStarted(chatId);
 
     const estimated = Math.ceil((prompt.length + output.length) / 4);
     recordTokens(loadState(), estimated);
 
     await bot.sendMarkdown(chatId, output);
-  } catch (e) {
-    clearInterval(typingTimer);
-    const errMsg = e.message || '';
+
+    // Auto-name: if this was the first message and session has no name, generate one
+    if (wasNew && !getSessionName(session.id)) {
+      autoNameSession(chatId, session.id, prompt, session.cwd).catch(() => {});
+    }
+  } else {
+    const errMsg = error || 'Unknown error';
     log('ERROR', `askClaude failed for ${chatId}: ${errMsg.slice(0, 300)}`);
+
     // If session not found (expired/deleted), create new and retry once
     if (errMsg.includes('not found') || errMsg.includes('No session')) {
       log('WARN', `Session ${session.id} not found, creating new`);
       session = createSession(chatId, session.cwd);
-      try {
-        const retryArgs = ['-p', '--session-id', session.id];
-        for (const tool of sessionAllowed) retryArgs.push('--allowedTools', tool);
-        const output = execSync(`claude ${retryArgs.join(' ')}`, {
-          input: prompt,
-          encoding: 'utf8',
-          timeout: 300000,
-          maxBuffer: 5 * 1024 * 1024,
-          cwd: session.cwd,
-        }).trim();
+
+      const retryArgs = ['-p', '--session-id', session.id];
+      for (const tool of sessionAllowed) retryArgs.push('--allowedTools', tool);
+
+      const retry = await spawnClaudeAsync(retryArgs, prompt, session.cwd);
+      if (retry.output) {
         markSessionStarted(chatId);
-        await bot.sendMarkdown(chatId, output);
-      } catch (e2) {
-        log('ERROR', `askClaude retry failed: ${(e2.message || '').slice(0, 200)}`);
-        try { await bot.sendMessage(chatId, `Error: ${(e2.message || '').slice(0, 200)}`); } catch { /* */ }
+        await bot.sendMarkdown(chatId, retry.output);
+      } else {
+        log('ERROR', `askClaude retry failed: ${(retry.error || '').slice(0, 200)}`);
+        try { await bot.sendMessage(chatId, `Error: ${(retry.error || '').slice(0, 200)}`); } catch { /* */ }
       }
     } else {
       try { await bot.sendMessage(chatId, `Error: ${errMsg.slice(0, 200)}`); } catch { /* */ }
@@ -1114,6 +1338,24 @@ async function startFeishuBridge(config, executeTaskByName) {
 // ---------------------------------------------------------
 // PID MANAGEMENT
 // ---------------------------------------------------------
+
+// Kill any existing daemon before starting (takeover strategy)
+function killExistingDaemon() {
+  if (!fs.existsSync(PID_FILE)) return;
+  try {
+    const oldPid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+    if (oldPid && oldPid !== process.pid) {
+      process.kill(oldPid, 'SIGTERM');
+      log('INFO', `Killed existing daemon (PID: ${oldPid})`);
+      // Brief pause to let it clean up
+      require('child_process').execSync('sleep 1', { stdio: 'ignore' });
+    }
+  } catch {
+    // Process doesn't exist or already dead
+  }
+  try { fs.unlinkSync(PID_FILE); } catch {}
+}
+
 function writePid() {
   fs.writeFileSync(PID_FILE, String(process.pid), 'utf8');
 }
@@ -1141,6 +1383,8 @@ async function main() {
     process.exit(1);
   }
 
+  // Takeover: kill any existing daemon
+  killExistingDaemon();
   writePid();
   const state = loadState();
   state.pid = process.pid;