@wu529778790/open-im 1.7.1-beta.0 → 1.7.1-beta.2

package/README.md

@@ -57,9 +57,11 @@ The config file is stored at `~/.open-im/config.json` by default.
 | `open-im stop` | Stop the background service |
 | `open-im dev` | Run in the foreground for development/debugging |
 
-## Graphical Config Page
+## Server Deployment & Config Page
 
-Open the config page at **http://127.0.0.1:39282** (or the URL shown after `open-im start`). The page includes:
+### Local (with browser)
+
+Open the config page at [`http://127.0.0.1:39282`](http://127.0.0.1:39282) (or the URL shown after `open-im start`). The page includes:
 
 - **Dashboard** – Configured / Enabled platform count and service status (Idle or Running)
 - **Platforms** – Enable and configure Telegram, Feishu, QQ, WeCom, and DingTalk (credentials, proxy, per-platform AI tool, allowed user IDs). Each platform has a “Test Configuration” button.
@@ -68,10 +70,102 @@ Open the config page at **http://127.0.0.1:39282** (or the URL shown after `open
 
 WeChat is not in the web UI; configure it in `~/.open-im/config.json` or via `open-im init` if needed.
 
-- `open-im start` serves the config page and the bridge.
+- `open-im start` serves both the config page and the bridge.
 - `open-im dev` opens the page automatically only when setup is incomplete.
 - To open the page when config already exists, run `open-im start` and visit the URL above.
 
+### On a headless server (no GUI)
+
+Many servers do not have a desktop environment or browser. In that case, trying to auto-launch a browser (`xdg-open`, `open`, `start`) is unnecessary and may even fail. Use these patterns instead.
+
+#### 1) Disable automatic browser launch
+
+On the server:
+
+```bash
+export OPEN_IM_NO_BROWSER=1
+open-im start
+```
+
+This starts the bridge and the config web server in the background without attempting to open a browser.
+
+#### 2) Verify that the config page is listening on the server
+
+On the server:
+
+```bash
+ss -lntp | grep 39282        # or: netstat -lntp | grep 39282
+curl -v http://127.0.0.1:39282/
+```
+
+If you see a `LISTEN` line for `127.0.0.1:39282` and `curl` returns HTML, the config UI is running.
+
+#### 3) Safest option: SSH tunnel to local browser
+
+Instead of exposing port 39282 to the public internet, use SSH port forwarding:
+
+```bash
+# On your local machine:
+ssh -L 39282:127.0.0.1:39282 user@your-server-ip
+```
+
+Then open in your local browser:
+
+```text
+http://127.0.0.1:39282/
+```
+
+This safely tunnels the config page from the server to your local browser.
+
+#### 4) Optional: Remote access with one-time login link
+
+If you want to open the config UI directly from another device without SSH tunneling, you can bind the web config server to all interfaces and use a one-time login URL:
+
+- **Bind to all interfaces and keep the browser closed on the server:**
+
+  ```bash
+  export OPEN_IM_NO_BROWSER=1
+  export OPEN_IM_WEB_HOST=0.0.0.0
+  open-im start
+  ```
+
+  - By default, `OPEN_IM_WEB_HOST` is `127.0.0.1` (local only).
+  - Setting it to `0.0.0.0` makes the config page listen on all interfaces.
+
+- **On startup, open-im will log a one-time login URL**, for example:
+
+  ```text
+  ━━━━━━━━ Web Config Login ━━━━━━━━
+  Host binding : 0.0.0.0
+  Login URL    : http://127.0.0.1:39282/?login_token=xxxx
+  Note: replace 127.0.0.1 with your server IP or hostname when opening from another device.
+  This login link is valid for approximately 15 minutes and can be used only once.
+  After login, subsequent requests will use a short-lived session cookie.
+  ```
+
+- **From your laptop/phone**, replace `127.0.0.1` with the server IP or hostname and open the URL in a browser:
+
+  ```text
+  http://your-server-ip:39282/?login_token=xxxx
+  ```
+
+  The first successful visit:
+
+  - Consumes the one-time `login_token` (subsequent uses will fail with 401);
+  - Creates a short-lived session and sets a `openim_session` cookie in your browser;
+  - Redirects you to the config page without query parameters.
+
+  After that, as long as the `openim_session` cookie is valid and the process is still running, you can continue visiting:
+
+  ```text
+  http://your-server-ip:39282/
+  ```
+
+> Security notes:
+>
+> - Binding `OPEN_IM_WEB_HOST=0.0.0.0` exposes the config port on all interfaces. Always combine this with firewall rules / security groups and consider fronting the port with HTTPS + auth via a reverse proxy.
+> - When in doubt, prefer SSH tunneling (step 3) over direct exposure.
+
 ## Session Behavior
 
 Session context is stored locally in `~/.open-im/data/sessions.json` and is separate from the IM chat history itself. Each user has an independent session directory and session metadata. Sending `/new` resets the current AI session.

package/README.zh-CN.md

@@ -57,9 +57,17 @@ open-im start
 | `open-im stop` | 停止后台服务 |
 | `open-im dev` | 前台运行（调试模式） |
 
-## 图形化配置页面
+## 服务器部署与图形化配置
 
-在浏览器中打开 **http://127.0.0.1:39282**（或执行 `open-im start` 后提示的地址），页面结构如下：
+### 本机（带浏览器）使用
+
+在本机直接运行：
+
+```bash
+open-im start
+```
+
+然后在浏览器中打开 [`http://127.0.0.1:39282`](http://127.0.0.1:39282)（或命令行里提示的地址），页面结构如下：
 
 - **概览** – 已配置/已启用平台数量、服务状态（未启动或运行中）
 - **平台配置** – 启用并填写 Telegram、飞书、QQ、企业微信、钉钉的凭证（Bot Token/App ID/Secret、代理、该平台使用的 AI 工具、白名单用户 ID）。每个平台提供「校验配置」按钮
@@ -72,6 +80,98 @@ open-im start
 - `open-im dev` 仅在未完成配置时自动打开页面
 - 已有配置但想手动打开时，执行 `open-im start` 后访问上述地址即可
 
+### 在服务器上部署（无图形界面）
+
+很多服务器没有桌面环境和浏览器，此时「自动打开浏览器」既没意义，还可能因为缺少 `xdg-open` 报错。推荐如下用法：
+
+#### 1）关闭自动打开浏览器
+
+在服务器上设置环境变量，然后启动：
+
+```bash
+export OPEN_IM_NO_BROWSER=1
+open-im start
+```
+
+这样只会在后台启动服务与配置页面，不会尝试执行 `xdg-open` / `open` / `start`。
+
+#### 2）检查配置页面是否已在服务器本机监听
+
+在服务器上执行：
+
+```bash
+ss -lntp | grep 39282        # 或 netstat -lntp | grep 39282
+curl -v http://127.0.0.1:39282/
+```
+
+若看到 `LISTEN 0 ... 127.0.0.1:39282` 且 `curl` 返回 HTML，则说明 Web 配置页已正常启动。
+
+#### 3）推荐方式：通过 SSH 隧道在本地浏览器访问
+
+不建议直接对外开放 39282 端口，而是使用 SSH 端口转发：
+
+```bash
+# 在本地电脑执行，将本地 39282 转发到服务器 127.0.0.1:39282
+ssh -L 39282:127.0.0.1:39282 user@your-server-ip
+```
+
+然后在本地浏览器访问：
+
+```text
+http://127.0.0.1:39282/
+```
+
+即可打开服务器上的配置页面。
+
+#### 4）可选：在服务器上直接访问的一次性登录链接
+
+如果你确实希望在服务器上绑定到公网 IP，从其他设备直接访问配置页面，可以：
+
+- **将 Web 配置服务绑定到所有网卡：**
+
+  ```bash
+  export OPEN_IM_NO_BROWSER=1
+  export OPEN_IM_WEB_HOST=0.0.0.0
+  open-im start
+  ```
+
+  - 默认情况下，`OPEN_IM_WEB_HOST` 为 `127.0.0.1`（仅本机访问）。
+  - 设置为 `0.0.0.0` 后，配置页面会监听在所有网卡上。
+
+- **启动后，open-im 会在日志中输出一次性登录链接**，类似：
+
+  ```text
+  ━━━━━━━━ Web Config Login ━━━━━━━━
+  Host binding : 0.0.0.0
+  Login URL    : http://127.0.0.1:39282/?login_token=xxxx
+  Note: replace 127.0.0.1 with your server IP or hostname when opening from another device.
+  This login link is valid for approximately 15 minutes and can be used only once.
+  After login, subsequent requests will use a short-lived session cookie.
+  ```
+
+- **在本地电脑或手机浏览器中**，将 `127.0.0.1` 换成服务器 IP 或域名，打开该链接：
+
+  ```text
+  http://your-server-ip:39282/?login_token=xxxx
+  ```
+
+  第一次成功访问会：
+
+  - 消费掉这枚一次性 `login_token`（后续再访问同一链接会 401）；
+  - 在浏览器中创建一个短期会话，设置 `openim_session` Cookie；
+  - 自动重定向到不带参数的配置页。
+
+  之后，只要 `openim_session` Cookie 仍然有效、进程仍在运行，就可以直接访问：
+
+  ```text
+  http://your-server-ip:39282/
+  ```
+
+> 安全提示：
+>
+> - 将 `OPEN_IM_WEB_HOST=0.0.0.0` 意味着该端口会对所有网卡开放，请务必结合防火墙/安全组、尽量配合 HTTPS + 反向代理（例如 Nginx/Caddy 的 Basic Auth 或 OIDC 登录）一起使用。
+> - 如无把握，优先使用上面的 SSH 隧道方案（第 3 步），安全性更高。
+
 ## 会话说明
 
 会话上下文保存在本地 `~/.open-im/data/sessions.json`，与 IM 聊天记录本身无关。每个用户有独立会话目录和 session 信息，发送 `/new` 会重置当前 AI 会话。

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

@@ -1,18 +1,18 @@
 /**
- * Claude SDK Adapter - 使用 Agent SDK 实现持久会话，无需每次 spawn 进程
+ * Claude SDK Adapter - 使用 Agent SDK V2 Session API 实现真正的多轮对话
  *
- * 优势：
- * 1. 进程内执行 - 无 fork/exec 开销，响应更快
- * 2. 会话复用 - resume 保留上下文，无需重新加载历史
- * 3. 流式输出 - includePartialMessages 支持 text_delta、thinking_delta
+ * V2 API 优势：
+ * 1. 进程内执行 - 无 fork/exec 开销
+ * 2. 持久会话 - SDKSession 对象保持会话状态，支持真正的多轮对话
+ * 3. 流式输出 - 支持实时增量更新
  *
- * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN（claude setup-token）
+ * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
  */
 import type { ToolAdapter, RunCallbacks, RunOptions, RunHandle } from './tool-adapter.interface.js';
 export declare class ClaudeSDKAdapter implements ToolAdapter {
     readonly toolId = "claude-sdk";
     /**
-     * 清理所有活跃的 SDK 查询
+     * 清理所有活跃的 SDK 会话和流
      */
     static destroy(): void;
     run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;

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

@@ -1,18 +1,21 @@
 /**
- * Claude SDK Adapter - 使用 Agent SDK 实现持久会话，无需每次 spawn 进程
+ * Claude SDK Adapter - 使用 Agent SDK V2 Session API 实现真正的多轮对话
  *
- * 优势：
- * 1. 进程内执行 - 无 fork/exec 开销，响应更快
- * 2. 会话复用 - resume 保留上下文，无需重新加载历史
- * 3. 流式输出 - includePartialMessages 支持 text_delta、thinking_delta
+ * V2 API 优势：
+ * 1. 进程内执行 - 无 fork/exec 开销
+ * 2. 持久会话 - SDKSession 对象保持会话状态，支持真正的多轮对话
+ * 3. 流式输出 - 支持实时增量更新
  *
- * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN（claude setup-token）
+ * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
  */
-import { query } from '@anthropic-ai/claude-agent-sdk';
+import { unstable_v2_createSession, unstable_v2_resumeSession } from '@anthropic-ai/claude-agent-sdk';
 import { createLogger } from '../logger.js';
 const log = createLogger('ClaudeSDK');
-// 存储所有活跃的查询，用于清理
-const activeQueries = new Set();
+// 存储所有活跃的 SDKSession 对象，key 为 sessionId
+// 使用 Map 而不是 Set，因为我们需要通过 sessionId 获取 session
+const activeSessions = new Map();
+// 存储正在进行的流式迭代器，用于中断
+const activeStreams = new Set();
 function isStreamEvent(msg) {
     return msg.type === 'stream_event';
 }
@@ -20,33 +23,82 @@ function isSystemInit(msg) {
     const m = msg;
     return m.type === 'system' && m.subtype === 'init';
 }
+function isAssistant(msg) {
+    return msg.type === 'assistant';
+}
 function isResult(msg) {
     return msg.type === 'result';
 }
-function isAssistant(msg) {
-    return msg.type === 'assistant';
+/**
+ * 获取或创建 SDKSession
+ * @param sessionId 已有的 sessionId，如果为 undefined 则创建新会话
+ * @param workDir 工作目录
+ * @param model 模型名称
+ * @param permissionMode 权限模式
+ * @returns SDKSession 对象和实际的 sessionId
+ */
+async function getOrCreateSession(sessionId, _workDir, // 保留参数以备将来使用
+model, permissionMode) {
+    const sessionOptions = {
+        model: model || 'claude-opus-4-5',
+        permissionMode,
+        // 可以添加其他选项，如 hooks, allowedTools 等
+    };
+    let session;
+    if (sessionId) {
+        // 尝试恢复已有会话
+        try {
+            log.info(`Attempting to resume session: ${sessionId}`);
+            session = unstable_v2_resumeSession(sessionId, sessionOptions);
+            activeSessions.set(sessionId, session);
+            log.info(`Successfully resumed session: ${sessionId}`);
+            return { session, sessionId };
+        }
+        catch (err) {
+            log.warn(`Failed to resume session ${sessionId}, creating new one: ${err}`);
+            // 恢复失败，创建新会话
+        }
+    }
+    // 创建新会话
+    session = unstable_v2_createSession(sessionOptions);
+    // 新会话的 sessionId 需要从第一个消息中获取
+    // 暂时返回 undefined，稍后在 init 消息中获取
+    const tempId = `pending-${Date.now()}`;
+    activeSessions.set(tempId, session);
+    log.info(`Created new session (tempId: ${tempId})`);
+    return { session, sessionId: tempId };
 }
 export class ClaudeSDKAdapter {
     toolId = 'claude-sdk';
     /**
-     * 清理所有活跃的 SDK 查询
+     * 清理所有活跃的 SDK 会话和流
      */
     static destroy() {
-        for (const q of activeQueries) {
+        for (const stream of activeStreams) {
             try {
-                if (q && typeof q.return === 'function') {
-                    q.return();
+                if (stream && typeof stream.return === 'function') {
+                    stream.return();
                 }
             }
             catch {
                 /* ignore */
             }
         }
-        activeQueries.clear();
+        activeStreams.clear();
+        for (const session of activeSessions.values()) {
+            try {
+                session.close();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        activeSessions.clear();
     }
     run(prompt, sessionId, workDir, callbacks, options) {
         const abortController = new AbortController();
-        let queryClosed = false;
+        let streamClosed = false;
+        let actualSessionId;
         const permissionMode = options?.skipPermissions
             ? 'bypassPermissions'
             : options?.permissionMode === 'acceptEdits'
@@ -54,65 +106,47 @@ export class ClaudeSDKAdapter {
                 : options?.permissionMode === 'plan'
                     ? 'plan'
                     : 'default';
-        const runQuery = async () => {
+        const runSession = async () => {
             try {
-                // 调试：检查关键环境变量
+                // 检查环境变量
                 const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
                 const hasAuthToken = !!process.env.ANTHROPIC_AUTH_TOKEN;
-                const hasBaseUrl = !!process.env.ANTHROPIC_BASE_URL;
-                if (!hasApiKey && !hasAuthToken && !hasBaseUrl) {
+                if (!hasApiKey && !hasAuthToken) {
                     log.warn('Claude SDK: No API credentials found in environment variables');
                 }
-                const opts = {
-                    cwd: workDir,
-                    resume: sessionId,
-                    includePartialMessages: true,
-                    permissionMode,
-                    model: options?.model,
-                    abortController,
-                    allowDangerouslySkipPermissions: permissionMode === 'bypassPermissions',
-                };
-                log.info(`[ClaudeSDK] Starting query: prompt="${prompt.slice(0, 50)}...", sessionId=${sessionId ?? 'new'}, cwd=${workDir}`);
-                let q;
-                try {
-                    q = query({
-                        prompt,
-                        options: opts,
-                    });
-                }
-                catch (queryInitErr) {
-                    log.error(`[ClaudeSDK] Query initialization failed:`, queryInitErr);
-                    // 如果是会话文件问题，尝试作为新会话
-                    if (sessionId && (queryInitErr.code === 'ENOENT' ||
-                        queryInitErr.message.includes('ENOENT') ||
-                        queryInitErr.message.includes('not found'))) {
-                        log.warn(`[ClaudeSDK] Session file not found, starting new session`);
-                        callbacks.onSessionInvalid?.();
-                        // 重新创建查询，不带 resume
-                        const newOpts = { ...opts, resume: undefined };
-                        q = query({
-                            prompt,
-                            options: newOpts,
-                        });
-                    }
-                    else {
-                        callbacks.onError(`查询初始化失败: ${queryInitErr.message}`);
-                        return;
-                    }
-                }
-                // 将查询添加到活跃列表
-                activeQueries.add(q);
+                log.info(`[V2] Session: ${sessionId ?? 'new'}, prompt="${prompt.slice(0, 50)}..."`);
+                // 获取或创建会话
+                const { session } = await getOrCreateSession(sessionId, workDir, options?.model, permissionMode);
+                // 发送用户消息
+                await session.send(prompt);
+                // 获取响应流
+                const stream = session.stream();
+                activeStreams.add(stream);
                 let accumulated = '';
                 let accumulatedThinking = '';
                 const toolStats = {};
                 try {
-                    for await (const msg of q) {
-                        if (abortController.signal.aborted)
+                    for await (const msg of stream) {
+                        if (abortController.signal.aborted) {
+                            log.info('Stream aborted by user');
                             break;
+                        }
+                        // 获取实际的 sessionId（从 init 消息中）
                         if (isSystemInit(msg)) {
-                            callbacks.onSessionId?.(msg.session_id);
+                            const newSessionId = msg.session_id;
+                            if (newSessionId && newSessionId !== actualSessionId) {
+                                // 更新 sessionId 映射
+                                if (actualSessionId && actualSessionId.startsWith('pending-')) {
+                                    activeSessions.delete(actualSessionId);
+                                }
+                                activeSessions.set(newSessionId, session);
+                                actualSessionId = newSessionId;
+                                log.info(`[V2] Got actual sessionId: ${newSessionId}`);
+                                callbacks.onSessionId?.(newSessionId);
+                            }
                             continue;
                         }
+                        // 处理流式事件
                         if (isStreamEvent(msg)) {
                             const ev = msg.event;
                             if (ev?.type === 'content_block_delta' && ev.delta) {
@@ -127,6 +161,7 @@ export class ClaudeSDKAdapter {
                             }
                             continue;
                         }
+                        // 处理助手消息（工具调用）
                         if (isAssistant(msg)) {
                             const content = msg.message?.content;
                             for (const block of content ?? []) {
@@ -137,16 +172,22 @@ export class ClaudeSDKAdapter {
                             }
                             continue;
                         }
+                        // 处理结果消息
                         if (isResult(msg)) {
-                            queryClosed = true;
+                            streamClosed = true;
                             const m = msg;
                             const success = m.subtype === 'success';
                             const errs = m.errors ?? [];
-                            const noConvErr = errs.find((e) => e.includes('No conversation found with session ID'));
-                            if (!success && noConvErr) {
-                                log.warn(`SDK session invalid: ${noConvErr}`);
-                                callbacks.onSessionInvalid?.();
-                                callbacks.onError('会话已过期，请发送 /new 开始新会话');
+                            log.info(`[V2] Result: subtype=${m.subtype}, num_turns=${m.num_turns}, sessionId=${actualSessionId ?? 'unknown'}`);
+                            // 检查会话错误
+                            if (!success) {
+                                const noConvErr = errs.find((e) => e.includes('No conversation found') || e.includes('session not found'));
+                                if (noConvErr) {
+                                    log.warn(`Session ${actualSessionId} not found, may need to create new one`);
+                                    callbacks.onSessionInvalid?.();
+                                }
+                                const errMsg = errs[0] || '未知错误';
+                                callbacks.onError(errMsg);
                                 return;
                             }
                             const resultText = m.result ?? '';
@@ -159,71 +200,55 @@ export class ClaudeSDKAdapter {
                                 numTurns: m.num_turns ?? 0,
                                 toolStats,
                             };
-                            if (!result.accumulated && result.result)
+                            if (!result.accumulated && result.result) {
                                 result.accumulated = result.result;
+                            }
                             if (!result.accumulated && !result.result && accumulated) {
-                                log.debug(`Result event had no text but accumulated=${accumulated.length} chars, using accumulated`);
                                 result.accumulated = accumulated;
                                 result.result = accumulated;
                             }
-                            if (!result.accumulated && !result.result) {
-                                const errMsg = errs[0] ?? '未知错误';
-                                log.warn(`SDK result empty: subtype=${m.subtype}, errors=${JSON.stringify(errs)}`);
-                                callbacks.onError(errMsg);
-                                return;
-                            }
                             callbacks.onComplete(result);
                             return;
                         }
                     }
-                    if (!queryClosed) {
+                    // 如果流正常结束但没有收到 result 消息
+                    if (!streamClosed && accumulated) {
+                        log.info('Stream ended without result message, using accumulated text');
                         callbacks.onComplete({
                             success: true,
                             result: accumulated,
                             accumulated,
                             cost: 0,
                             durationMs: 0,
-                            numTurns: 0,
+                            numTurns: 1,
                             toolStats,
                         });
                     }
                 }
                 finally {
-                    q.close();
-                    // 从活跃列表中移除
-                    activeQueries.delete(q);
+                    // 从活跃列表中移除流
+                    activeStreams.delete(stream);
                 }
             }
             catch (err) {
                 if (abortController.signal.aborted) {
-                    log.info('Query aborted by user');
+                    log.info('Session run aborted');
                     return;
                 }
                 const errorObj = err;
                 const msg = errorObj.message || String(err);
-                const stack = errorObj.stack || '';
-                // 输出详细的错误信息用于调试
-                log.error(`Claude SDK error: ${msg}`);
-                if (stack) {
-                    log.error(`Error stack: ${stack}`);
-                }
-                // 特别处理会话文件不存在的情况
-                if (errorObj.code === 'ENOENT' ||
-                    errorObj.syscall === 'lstat' ||
-                    msg.includes('ENOENT') ||
-                    msg.includes('session')) {
-                    log.warn(`Session file access error, likely session is corrupted or missing`);
-                    callbacks.onSessionInvalid?.();
-                    callbacks.onError('会话文件不存在或已损坏，请发送 /new 开始新会话');
-                }
-                else {
-                    callbacks.onError(msg);
+                log.error(`Claude SDK V2 error: ${msg}`);
+                if (errorObj.stack) {
+                    log.error(`Error stack: ${errorObj.stack}`);
                 }
+                callbacks.onError(msg);
             }
         };
-        runQuery();
+        // 启动会话（不等待）
+        runSession();
         return {
             abort: () => {
+                log.info('Aborting session run');
                 abortController.abort();
             },
         };

package/dist/adapters/registry.js

@@ -1,5 +1,4 @@
 import { getConfiguredAiCommands } from '../config.js';
-import { ClaudeAdapter } from './claude-adapter.js';
 import { ClaudeSDKAdapter } from './claude-sdk-adapter.js';
 import { CodexAdapter } from './codex-adapter.js';
 import { CodeBuddyAdapter } from './codebuddy-adapter.js';
@@ -10,17 +9,8 @@ export function initAdapters(config) {
     adapters.clear();
     for (const aiCommand of getConfiguredAiCommands(config)) {
         if (aiCommand === 'claude') {
-            if (config.useSdkMode) {
-                log.info('Claude Agent SDK adapter enabled');
-                adapters.set('claude', new ClaudeSDKAdapter());
-            }
-            else {
-                log.info('Claude CLI adapter enabled');
-                adapters.set('claude', new ClaudeAdapter(config.claudeCliPath, {
-                    useProcessPool: true,
-                    idleTimeoutMs: 2 * 60 * 1000,
-                }));
-            }
+            log.info('Claude Agent SDK adapter enabled');
+            adapters.set('claude', new ClaudeSDKAdapter());
             continue;
         }
         if (aiCommand === 'codex') {
@@ -38,7 +28,6 @@ export function getAdapter(aiCommand) {
     return adapters.get(aiCommand);
 }
 export function cleanupAdapters() {
-    ClaudeAdapter.destroy();
     ClaudeSDKAdapter.destroy();
     adapters.clear();
 }

package/dist/commands/handler.d.ts

@@ -1,14 +1,11 @@
 import { type Config } from '../config.js';
 import type { SessionManager } from '../session/session-manager.js';
 import type { RequestQueue } from '../queue/request-queue.js';
-import { type PermissionMode } from '../permission-mode/types.js';
 import type { ThreadContext } from '../shared/types.js';
 export type { ThreadContext };
 export interface MessageSender {
     sendTextReply(chatId: string, text: string, threadCtx?: ThreadContext): Promise<void>;
     sendDirectorySelection?(chatId: string, currentDir: string, userId: string): Promise<void>;
-    sendModeCard?(chatId: string, userId: string, currentMode: PermissionMode): Promise<void>;
-    sendModeKeyboard?(chatId: string, userId: string, currentMode: PermissionMode): Promise<void>;
 }
 export interface CommandHandlerDeps {
     config: Config;
@@ -22,15 +19,12 @@ export declare class CommandHandler {
     private deps;
     constructor(deps: CommandHandlerDeps);
     dispatch(text: string, chatId: string, userId: string, platform: 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework', handleClaudeRequest: ClaudeRequestHandler): Promise<boolean>;
-    private handleMode;
     private getClearHistoryHint;
     private handleHelp;
     private handleNew;
     private handlePwd;
     private handleStatus;
     private handleCd;
-    private handleAllow;
-    private handleDeny;
     private getAiVersion;
 }
 /**