@wu529778790/open-im 1.11.1-beta.5 → 1.11.1-beta.7

package/README.md

@@ -48,10 +48,10 @@ After `start`, the CLI prints the dashboard URL (default **`http://127.0.0.1:392
 | --- | --- |
 | `/help` | Help |
 | `/new` | New AI session |
-| `/sessions` | Session history |
-| `/resume <N>` | Resume by list number |
+| `/sessions` | Session history with preview |
+| `/resume [N]` | Resume session (no arg = most recent) |
 | `/status` | AI + session info |
-| `/cd` / `/pwd` | Working directory |
+| `/cd` / `/pwd` | Switch work dir (auto-resumes that dir's session) |
 | `/allow` / `/y`, `/deny` / `/n` | Permission prompts |
 
 ## Session continuity

package/README.zh-CN.md

@@ -48,10 +48,10 @@ npx @wu529778790/open-im start
 | --- | --- |
 | `/help` | 帮助 |
 | `/new` | 新 AI 会话 |
-| `/sessions` | 历史会话 |
-| `/resume <序号>` | 按列表序号恢复 |
+| `/sessions` | 历史会话（含摘要预览） |
+| `/resume [序号]` | 恢复会话（无参数恢复最近一条） |
 | `/status` | AI 与会话信息 |
-| `/cd` / `/pwd` | 工作目录 |
+| `/cd` / `/pwd` | 切换工作目录（自动恢复该目录的历史会话） |
 | `/allow` / `/y`、`/deny` / `/n` | 权限确认 |
 
 ## 会话接力

package/dist/adapters/claude-sdk-adapter.d.ts

@@ -8,6 +8,7 @@
  *
  * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
  */
+import type { SDKSessionInfo } from '@anthropic-ai/claude-agent-sdk';
 import type { ToolAdapter, RunCallbacks, RunOptions, RunHandle } from './tool-adapter.interface.js';
 interface ClaudeSessionMeta {
     sessionId: string;
@@ -16,11 +17,10 @@ interface ClaudeSessionMeta {
     size: number;
 }
 /**
- * 扫描 ~/.claude/projects/<encoded-path>/ 找到最新的 CLI session。
- * 只返回 JSONL 文件（排除子目录如 subagents/），按修改时间倒序。
- * @param homeOverride 测试用：覆盖 homedir() 的返回值
+ * Find the latest CLI session for a work directory using the SDK's listSessions.
+ * Falls back to undefined if no sessions found.
  */
-export declare function findLatestClaudeSession(workDir: string, homeOverride?: string): ClaudeSessionMeta | undefined;
+export declare function findLatestClaudeSession(workDir: string): Promise<ClaudeSessionMeta | undefined>;
 /**
  * 由 initAdapters 根据配置调用。ttlMinutes≤0 时关闭空闲回收（仍受 MAX_ACTIVE_SESSIONS 限制）。
  */
@@ -36,6 +36,11 @@ export declare class ClaudeSDKAdapter implements ToolAdapter {
      * Useful when the caller knows a session is corrupted.
      */
     static removeSession(sessionId: string): void;
+    /**
+     * List sessions for a directory using the SDK's listSessions API.
+     * Replaces the custom file-scanning logic in findLatestClaudeSession.
+     */
+    static listSessionsForDir(workDir: string, limit?: number): Promise<SDKSessionInfo[]>;
     run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
 }
 export {};

package/dist/adapters/claude-sdk-adapter.js

@@ -8,8 +8,8 @@
  *
  * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
  */
-import { unstable_v2_createSession, unstable_v2_resumeSession } from '@anthropic-ai/claude-agent-sdk';
-import { existsSync, readFileSync, readdirSync, statSync, openSync, readSync, closeSync } from 'fs';
+import { unstable_v2_createSession, unstable_v2_resumeSession, listSessions } from '@anthropic-ai/claude-agent-sdk';
+import { existsSync, readFileSync, statSync, openSync, readSync, closeSync } from 'fs';
 import { execSync } from 'child_process';
 import { homedir } from 'os';
 import { join } from 'path';
@@ -99,51 +99,30 @@ function isCliSessionActive(sessionId, sessionFilePath) {
     }
 }
 /**
- * 扫描 ~/.claude/projects/<encoded-path>/ 找到最新的 CLI session。
- * 只返回 JSONL 文件（排除子目录如 subagents/），按修改时间倒序。
- * @param homeOverride 测试用：覆盖 homedir() 的返回值
+ * Find the latest CLI session for a work directory using the SDK's listSessions.
+ * Falls back to undefined if no sessions found.
  */
-export function findLatestClaudeSession(workDir, homeOverride) {
-    const projectDir = join(homeOverride ?? homedir(), '.claude', 'projects', workDirToProjectPath(workDir));
-    if (!existsSync(projectDir)) {
-        log.info(`No Claude Code project dir found: ${projectDir}`);
-        return undefined;
-    }
+export async function findLatestClaudeSession(workDir) {
     try {
-        const entries = readdirSync(projectDir, { withFileTypes: true });
-        const sessions = [];
-        for (const entry of entries) {
-            // 只处理 .jsonl 文件，跳过子目录（如 subagents/）和 memory 目录
-            if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
-                continue;
-            const sessionId = entry.name.replace('.jsonl', '');
-            // 校验 UUID 格式
-            if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(sessionId))
-                continue;
-            const filePath = join(projectDir, entry.name);
-            try {
-                const stat = statSync(filePath);
-                // 跳过空文件
-                if (stat.size === 0)
-                    continue;
-                sessions.push({ sessionId, mtime: stat.mtimeMs, filePath, size: stat.size });
-            }
-            catch {
-                continue;
-            }
-        }
+        const sessions = await listSessions({ dir: workDir, limit: 1 });
         if (sessions.length === 0) {
-            log.info(`No session files found in ${projectDir}`);
+            log.info(`No sessions found for ${workDir}`);
             return undefined;
         }
-        // 按修改时间倒序，最新的在前
-        sessions.sort((a, b) => b.mtime - a.mtime);
         const latest = sessions[0];
-        log.info(`Found latest Claude Code session: ${latest.sessionId} (mtime: ${new Date(latest.mtime).toISOString()}, size: ${latest.size})`);
-        return latest;
+        // filePath is needed for isCliSessionActive check — derive from standard path
+        const projectDir = join(homedir(), '.claude', 'projects', workDirToProjectPath(workDir));
+        const filePath = join(projectDir, `${latest.sessionId}.jsonl`);
+        log.info(`Found latest session via SDK: ${latest.sessionId} (lastModified: ${new Date(latest.lastModified).toISOString()})`);
+        return {
+            sessionId: latest.sessionId,
+            mtime: latest.lastModified,
+            filePath,
+            size: latest.fileSize ?? 0,
+        };
     }
     catch (err) {
-        log.warn(`Failed to scan Claude Code project dir: ${err}`);
+        log.warn(`Failed to list sessions via SDK: ${err}`);
         return undefined;
     }
 }
@@ -345,7 +324,7 @@ async function getOrCreateSession(sessionId, workDir, model, permissionMode, onS
     // NOTE: process.chdir() 是进程级全局副作用，在并发服务器中不理想。
     // 但 SDK 的 createSession/resumeSession 不接受 cwd 参数，且这些调用是同步的，
     // 所以 mutex + try/finally 已是最优方案。如果 SDK 未来支持 cwd 选项，应移除 chdir。
-    return withChdirMutex(() => {
+    return withChdirMutex(async () => {
         let session;
         const originalCwd = process.cwd();
         try {
@@ -380,7 +359,7 @@ async function getOrCreateSession(sessionId, workDir, model, permissionMode, onS
             // 没有指定 sessionId 时，尝试自动恢复 Claude Code CLI 的最新 session
             // 实现手机/电脑无缝切换：同目录下默认共享同一个对话
             if (!sessionId) {
-                const latest = findLatestClaudeSession(workDir);
+                const latest = await findLatestClaudeSession(workDir);
                 if (latest) {
                     // 检测 CLI 是否正在使用该 session（用于日志，不阻止 resume）
                     const cliActive = isCliSessionActive(latest.sessionId, latest.filePath);
@@ -472,6 +451,19 @@ export class ClaudeSDKAdapter {
             log.info(`Explicitly removed session: ${sessionId}`);
         }
     }
+    /**
+     * List sessions for a directory using the SDK's listSessions API.
+     * Replaces the custom file-scanning logic in findLatestClaudeSession.
+     */
+    static async listSessionsForDir(workDir, limit = 20) {
+        try {
+            return await listSessions({ dir: workDir, limit });
+        }
+        catch (err) {
+            log.warn(`Failed to list sessions for ${workDir}: ${err}`);
+            return [];
+        }
+    }
     run(prompt, sessionId, workDir, callbacks, options) {
         log.info(`[V2] run() entry model=${String(options?.model ?? '')} baseUrl=${process.env.ANTHROPIC_BASE_URL ?? '(default)'}`);
         const abortController = new AbortController();

package/dist/commands/handler.js

@@ -2,7 +2,30 @@ import { resolvePlatformAiCommand } from '../config.js';
 import { escapePathForMarkdown } from '../shared/utils.js';
 import { TERMINAL_ONLY_COMMANDS } from '../constants.js';
 import { createLogger } from '../logger.js';
+import { ClaudeSDKAdapter } from '../adapters/claude-sdk-adapter.js';
 const log = createLogger('Commands');
+function formatRelativeTime(ts) {
+    const sec = Math.floor((Date.now() - ts) / 1000);
+    if (sec < 60)
+        return '刚刚';
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return `${min}分钟前`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr}小时前`;
+    const day = Math.floor(hr / 24);
+    if (day === 1)
+        return '昨天';
+    if (day < 30)
+        return `${day}天前`;
+    return new Date(ts).toLocaleDateString('zh-CN');
+}
+function truncateSummary(session, maxLen = 30) {
+    const text = session.customTitle || session.summary || session.firstPrompt || '新会话';
+    const firstLine = text.split('\n')[0].trim();
+    return firstLine.length > maxLen ? firstLine.slice(0, maxLen) + '...' : firstLine;
+}
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { execFile } from 'node:child_process';
 import { readdirSync } from 'node:fs';
@@ -84,7 +107,7 @@ export class CommandHandler {
             '/help - 显示帮助',
             '/new - 开始新会话（AI 上下文重置）',
             '/sessions - 查看历史会话',
-            '/resume <序号> - 恢复历史会话',
+            '/resume [序号] - 恢复历史会话（无参数恢复最近一条）',
             '/status - 显示状态',
             '/cd <路径> - 切换工作目录',
             '/pwd - 当前工作目录',
@@ -93,44 +116,52 @@ export class CommandHandler {
         return true;
     }
     async handleSessions(chatId, userId, _platform) {
-        const history = this.deps.sessionManager.listConvHistory(userId);
-        const active = this.deps.sessionManager.getActiveConvInfo(userId);
-        if (history.length === 0 && !active) {
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        const sessions = await ClaudeSDKAdapter.listSessionsForDir(workDir);
+        if (sessions.length === 0) {
             await this.replySender().sendTextReply(chatId, '📋 暂无会话记录。');
             return true;
         }
         const lines = ['📋 会话列表:', ''];
-        history.forEach((entry, i) => {
-            lines.push(`${i + 1}. ${entry.convId} · ${entry.totalTurns}轮`);
+        sessions.forEach((session, i) => {
+            const preview = truncateSummary(session);
+            const time = session.lastModified ? ` · ${formatRelativeTime(session.lastModified)}` : '';
+            lines.push(`${i + 1}. ${preview}${time}`);
         });
-        if (active) {
-            const num = history.length + 1;
-            lines.push(`▸ ${num}. ${active.convId} · ${active.totalTurns}轮（当前）`);
-        }
-        lines.push('', '使用 /resume <序号> 恢复历史会话');
+        lines.push('', '使用 /resume <序号> 恢复，或 /resume 恢复最近一条');
         await this.replySender().sendTextReply(chatId, lines.join('\n'));
         return true;
     }
     async handleResume(chatId, userId, arg, _platform) {
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        const sessions = await ClaudeSDKAdapter.listSessionsForDir(workDir);
+        // /resume (no arg) — resume the most recent session
+        if (!arg) {
+            if (sessions.length === 0) {
+                await this.replySender().sendTextReply(chatId, '没有可恢复的历史会话。');
+                return true;
+            }
+            const session = sessions[0];
+            this.deps.requestQueue.cancelUser(userId);
+            this.deps.sessionManager.setActiveSessionId(userId, session.sessionId);
+            const preview = truncateSummary(session);
+            await this.replySender().sendTextReply(chatId, `✅ 已恢复最近会话: ${preview}\n继续发消息即可。`);
+            return true;
+        }
         const index = parseInt(arg, 10);
         if (isNaN(index) || index < 1) {
-            await this.replySender().sendTextReply(chatId, '用法: /resume <序号>\n\n使用 /sessions 查看会话列表。');
+            await this.replySender().sendTextReply(chatId, '用法: /resume [序号]\n\n不带序号则恢复最近一条会话。');
             return true;
         }
-        const history = this.deps.sessionManager.listConvHistory(userId);
-        if (index > history.length) {
-            await this.replySender().sendTextReply(chatId, `序号 ${index} 无效，共 ${history.length} 个历史会话。`);
+        if (index > sessions.length) {
+            await this.replySender().sendTextReply(chatId, `序号 ${index} 无效，共 ${sessions.length} 个历史会话。`);
             return true;
         }
-        const entry = history[index - 1];
+        const session = sessions[index - 1];
         this.deps.requestQueue.cancelUser(userId);
-        const ok = this.deps.sessionManager.resumeConv(userId, entry.convId);
-        if (ok) {
-            await this.replySender().sendTextReply(chatId, `✅ 已恢复会话 ${index} (${entry.convId})，共 ${entry.totalTurns}轮对话。\n继续发消息即可。`);
-        }
-        else {
-            await this.replySender().sendTextReply(chatId, '❌ 恢复会话失败，请重试。');
-        }
+        this.deps.sessionManager.setActiveSessionId(userId, session.sessionId);
+        const preview = truncateSummary(session);
+        await this.replySender().sendTextReply(chatId, `✅ 已恢复会话: ${preview}\n继续发消息即可。`);
         return true;
     }
     async handleNew(chatId, userId) {
@@ -179,10 +210,7 @@ export class CommandHandler {
         try {
             this.deps.requestQueue.cancelUser(userId);
             const result = await this.deps.sessionManager.setWorkDir(userId, dir);
-            const msg = result.resumed
-                ? `📁 工作目录已切换到: ${escapePathForMarkdown(result.path)}\n\n🔄 已恢复该目录的最近会话，继续之前的上下文。`
-                : `📁 工作目录已切换到: ${escapePathForMarkdown(result.path)}\n\n🆕 该目录暂无历史会话，已创建全新上下文。`;
-            await this.replySender().sendTextReply(chatId, msg);
+            await this.replySender().sendTextReply(chatId, `📁 工作目录已切换到: ${escapePathForMarkdown(result.path)}\n\n下一条消息将自动查找该目录的最近会话。`);
         }
         catch (err) {
             await this.replySender().sendTextReply(chatId, err instanceof Error ? err.message : String(err));

package/dist/session/session-manager.d.ts

@@ -1,10 +1,4 @@
 type ToolId = 'claude' | 'codex' | 'codebuddy' | 'opencode';
-interface ConvHistoryEntry {
-    convId: string;
-    totalTurns: number;
-    createdAt: number;
-    workDir?: string;
-}
 export declare function resolveWorkDirInput(baseDir: string, targetDir: string): string;
 export declare class SessionManager {
     private sessions;
@@ -30,13 +24,12 @@ export declare class SessionManager {
         resumed: boolean;
     }>;
     newSession(userId: string): boolean;
+    /**
+     * Set the active session to a specific SDK session (used by /resume).
+     * Bridges the SDK sessionId to our internal activeConvId tracking.
+     */
+    setActiveSessionId(userId: string, sessionId: string): void;
     clearActiveToolSession(userId: string, toolId: ToolId): boolean;
-    listConvHistory(userId: string): ConvHistoryEntry[];
-    getActiveConvInfo(userId: string): {
-        convId: string;
-        totalTurns: number;
-    } | undefined;
-    resumeConv(userId: string, convId: string): boolean;
     addTurns(userId: string, turns: number): number;
     addTurnsForThread(userId: string, threadId: string, turns: number): number;
     getModel(userId: string, threadId?: string): string | undefined;

package/dist/session/session-manager.js

@@ -107,52 +107,16 @@ export class SessionManager {
         const currentDir = this.getWorkDir(userId);
         const realPath = await this.resolveAndValidate(currentDir, workDir);
         const s = this.sessions.get(userId);
-        let oldConvId;
-        let resumed = false;
         if (s) {
             // Same directory — no-op
             if (realPath === currentDir) {
                 return { path: realPath, resumed: false };
             }
-            oldConvId = s.activeConvId;
             this.persistActiveConvSessions(userId, s);
-            // Archive current conversation with its workDir
-            if (oldConvId) {
-                if (!s.convHistory)
-                    s.convHistory = [];
-                s.convHistory.push({
-                    convId: oldConvId,
-                    totalTurns: s.totalTurns ?? 0,
-                    createdAt: Date.now(),
-                    workDir: currentDir,
-                });
-                if (s.convHistory.length > 10)
-                    s.convHistory = s.convHistory.slice(-10);
-            }
-            // Look for a previous conversation in the target directory
-            if (!s.convHistory)
-                s.convHistory = [];
-            const matchIdx = s.convHistory.findIndex((e) => e.workDir === realPath);
-            if (matchIdx !== -1) {
-                const [entry] = s.convHistory.splice(matchIdx, 1);
-                s.activeConvId = entry.convId;
-                s.totalTurns = entry.totalTurns;
-                s.sessionIds = {};
-                for (const toolId of ['claude', 'codex', 'codebuddy', 'opencode']) {
-                    const sessionId = this.convSessionMap.get(this.getConvSessionKey(userId, entry.convId, toolId));
-                    if (sessionId) {
-                        if (!s.sessionIds)
-                            s.sessionIds = {};
-                        s.sessionIds[toolId] = sessionId;
-                    }
-                }
-                resumed = true;
-                log.info(`Resumed session for user ${userId}: convId=${entry.convId}, workDir=${realPath}, turns=${entry.totalTurns}`);
-            }
-            else {
-                s.sessionIds = {};
-                s.activeConvId = randomBytes(4).toString('hex');
-            }
+            // Clear active session IDs; SDK adapter will auto-resume latest CLI session for new dir
+            s.sessionIds = {};
+            s.activeConvId = randomBytes(4).toString('hex');
+            s.totalTurns = 0;
             s.workDir = realPath;
         }
         else {
@@ -162,8 +126,8 @@ export class SessionManager {
             });
         }
         this.flushSync();
-        log.info(`WorkDir changed for user ${userId}: ${realPath}, oldConvId=${oldConvId}, resumed=${resumed}`);
-        return { path: realPath, resumed };
+        log.info(`WorkDir changed for user ${userId}: ${realPath}`);
+        return { path: realPath, resumed: false };
     }
     newSession(userId) {
         const s = this.sessions.get(userId);
@@ -171,20 +135,6 @@ export class SessionManager {
             const oldSessionIds = { ...(s.sessionIds ?? {}) };
             const oldConvId = s.activeConvId;
             this.persistActiveConvSessions(userId, s);
-            // Archive old conversation to history (keep convSessionMap entries for resume)
-            if (oldConvId) {
-                if (!s.convHistory)
-                    s.convHistory = [];
-                s.convHistory.push({
-                    convId: oldConvId,
-                    totalTurns: s.totalTurns ?? 0,
-                    createdAt: Date.now(),
-                    workDir: s.workDir,
-                });
-                // Keep last 10 entries
-                if (s.convHistory.length > 10)
-                    s.convHistory = s.convHistory.slice(-10);
-            }
             s.sessionIds = {};
             s.activeConvId = randomBytes(4).toString('hex');
             s.totalTurns = 0;
@@ -194,6 +144,25 @@ export class SessionManager {
         }
         return false;
     }
+    /**
+     * Set the active session to a specific SDK session (used by /resume).
+     * Bridges the SDK sessionId to our internal activeConvId tracking.
+     */
+    setActiveSessionId(userId, sessionId) {
+        let s = this.sessions.get(userId);
+        if (!s) {
+            s = { workDir: this.defaultWorkDir };
+            this.sessions.set(userId, s);
+        }
+        this.persistActiveConvSessions(userId, s);
+        s.activeConvId = randomBytes(4).toString('hex');
+        s.totalTurns = 0;
+        if (!s.sessionIds)
+            s.sessionIds = {};
+        s.sessionIds.claude = sessionId;
+        this.flushSync();
+        log.info(`Set active session for user ${userId}: sessionId=${sessionId}, convId=${s.activeConvId}`);
+    }
     clearActiveToolSession(userId, toolId) {
         const s = this.sessions.get(userId);
         if (!s)
@@ -208,57 +177,6 @@ export class SessionManager {
         log.info(`Cleared active ${toolId} session for user ${userId}, convId=${activeConvId ?? 'none'}`);
         return hadSession;
     }
-    listConvHistory(userId) {
-        const s = this.sessions.get(userId);
-        if (!s)
-            return [];
-        return s.convHistory ?? [];
-    }
-    getActiveConvInfo(userId) {
-        const s = this.sessions.get(userId);
-        if (!s?.activeConvId)
-            return undefined;
-        return { convId: s.activeConvId, totalTurns: s.totalTurns ?? 0 };
-    }
-    resumeConv(userId, convId) {
-        const s = this.sessions.get(userId);
-        if (!s)
-            return false;
-        // Find target in history
-        const idx = s.convHistory?.findIndex((e) => e.convId === convId) ?? -1;
-        if (idx === -1)
-            return false;
-        // Archive current active session
-        this.persistActiveConvSessions(userId, s);
-        if (s.activeConvId) {
-            if (!s.convHistory)
-                s.convHistory = [];
-            s.convHistory.push({
-                convId: s.activeConvId,
-                totalTurns: s.totalTurns ?? 0,
-                createdAt: Date.now(),
-                workDir: s.workDir,
-            });
-        }
-        // Remove target from history
-        const [entry] = s.convHistory.splice(idx, 1);
-        // Restore target as active
-        s.activeConvId = entry.convId;
-        s.totalTurns = entry.totalTurns;
-        s.sessionIds = {};
-        // Restore sessionIds from convSessionMap
-        for (const toolId of ['claude', 'codex', 'codebuddy']) {
-            const sessionId = this.convSessionMap.get(this.getConvSessionKey(userId, entry.convId, toolId));
-            if (sessionId) {
-                if (!s.sessionIds)
-                    s.sessionIds = {};
-                s.sessionIds[toolId] = sessionId;
-            }
-        }
-        this.flushSync();
-        log.info(`Resumed session for user ${userId}: convId=${entry.convId}, turns=${entry.totalTurns}`);
-        return true;
-    }
     addTurns(userId, turns) {
         const s = this.sessions.get(userId);
         if (!s)
@@ -345,6 +263,9 @@ export class SessionManager {
                         log.warn(`Legacy shared sessionId found for user ${k}; clearing it to avoid cross-tool resume conflicts`);
                     }
                     delete v.sessionId;
+                    // Clean up legacy fields
+                    delete v.firstMessage;
+                    delete v.convHistory;
                     if (v.threads) {
                         for (const thread of Object.values(v.threads)) {
                             if (!thread.sessionIds)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.11.1-beta.5",
+  "version": "1.11.1-beta.7",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",