chatccc 0.2.259 → 0.2.260

package/README.md

@@ -1,8 +1,8 @@
 # ChatCCC
 
-**用飞书或微信聊天控制 Claude Code / Cursor / Codex / CCC Agent。**
+**用飞书或微信聊天控制 Claude Code / Cursor / Codex / CCC Agent / DeepSeek Harness。**
 
-ChatCCC 把本地 AI 编程工具接入即时通讯软件。你可以在手机上发消息，让 Claude Code、Cursor Agent、Codex 或内置 CCC Agent 继续写代码、查问题、跑命令；不用一直守在电脑前。
+ChatCCC 把本地 AI 编程工具接入即时通讯软件。你可以在手机上发消息，让 Claude Code、Cursor Agent、Codex、内置 CCC Agent 或 DeepSeek Harness 继续写代码、查问题、跑命令；不用一直守在电脑前。
 
 飞书是推荐入口：直接私聊机器人即可持续使用同一个专属会话，需要并行任务时再用 `/new` 创建独立会话群；卡片能流式更新，体验完整。微信 iLink 更适合快速试用或临时使用：扫码即可接入，但只能走私聊文本模式。
 
@@ -21,7 +21,7 @@ ChatCCC 把本地 AI 编程工具接入即时通讯软件。你可以在手机
 - **手机上也能用 AI 编程工具**：在飞书或微信发消息，就像在终端给 Agent 下指令。
 - **飞书体验更完整**：私聊可持续对话，`/new` 创建的一群一会话支持多任务并行，CardKit 卡片可流式更新。
 - **微信接入更轻**：不用创建飞书应用，启动后扫码即可在微信私聊里使用。
-- **多 Agent 切换**：`/new` 使用默认 Agent，也可以用 `/new claude`、`/new cursor`、`/new codex`、`/new ccc` 指定工具。
+- **多 Agent 切换**：`/new` 使用默认 Agent，也可以用 `/new claude`、`/new cursor`、`/new codex`、`/new ccc`、`/new dsh` 指定工具。
 - **群里能跑 git**：`/git status`、`/git pull`、`/git log` 会在当前会话工作目录执行，并把输出发回聊天窗口。
 
 ## 飞书和微信的差异
@@ -216,7 +216,7 @@ chatccc
 
 ### 3. AI 工具配置
 
-Claude Code、Cursor 和 Codex 需要对应的本地工具；CCC Agent 内置于 ChatCCC，开箱即用，**模型接入不限于 DeepSeek**——它支持 OpenAI-compatible 和 Anthropic Messages 两种协议（详见下文 CCC Agent）。
+Claude Code、Cursor 和 Codex 需要对应的本地工具；CCC Agent 内置于 ChatCCC，开箱即用，**模型接入不限于 DeepSeek**——它支持 OpenAI-compatible 和 Anthropic Messages 两种协议（详见下文 CCC Agent）。DeepSeek Harness（DSH）采用按需安装，不计入 ChatCCC 主包生产依赖。
 
 #### CCC Agent
 
@@ -242,9 +242,15 @@ ChatCCC 会把 `ccc.DEEPSEEK_API_KEY`、`ccc.DEEPSEEK_BASE_URL`、模型和 effo
 
 #### Claude Code
 
-ChatCCC 通过 Anthropic Claude Agent SDK 调用 Claude Code 能力。SDK 引擎（含 Claude Code CLI 原生二进制，约 220MB）**按需下载**：在首次配置向导或 Web 管理页的「Claude Code」卡片点「安装 Claude Code SDK」（开关从关闭切到打开时也会弹出安装确认），页面会显示下载进度条，完成后即可使用。**只有启用 Claude Code 的用户才需要下载**，不使用 Claude Code 的安装不包含该引擎，chatccc 主包体积保持精简。
+ChatCCC 通过 Anthropic Claude Agent SDK 调用 Claude Code 能力。SDK 引擎（含 Claude Code CLI 原生二进制，约 220MB）**按需下载**：在首次配置向导或 Web 管理页打开 Claude Code 开关，或点击一次安装按钮，页面会连续显示环境检查、下载、校验、Runtime 验证、原子切换和清理进度，不需要逐步确认。**只有启用 Claude Code 的用户才需要下载**，不使用 Claude Code 的安装不包含该引擎，chatccc 主包体积保持精简。
 
-SDK 始终使用其内置的 Claude Code CLI（档位 b），不依赖用户自行安装的 `claude` 命令。本机完成 Claude Code 登录后即可使用（SDK 复用 `~/.claude` 登录态）；同时支持官方和第三方 Anthropic 兼容 API：使用官方服务无需额外配置，使用第三方 API 则填写 `claude.apiKey` 和 `claude.baseUrl`。`claude.model`、`claude.subagentModel`、`claude.effort`、`claude.apiKey`、`claude.baseUrl` 均为选填；`claude.maxTurn` 控制每次对话的最大轮数（默认 0，即无限制）。填写后会把对应配置传给 Claude Agent SDK；留空则以 `~/.claude/settings.json` 为准。
+SDK 始终使用其内置的 Claude Code CLI（档位 b），不依赖用户自行安装的 `claude` 命令。本机完成 Claude Code 登录后即可使用（SDK 复用 `~/.claude` 登录态）；同时支持官方和第三方 Anthropic 兼容 API：使用官方服务无需额外配置，使用第三方 API 则填写 `claude.apiKey` 和 `claude.baseUrl`。`claude.model`、`claude.subagentModel`、`claude.effort`、`claude.apiKey`、`claude.baseUrl` 均为选填；`claude.maxTurn` 控制每次对话的最大轮数（默认 0，即无限制）。填写后会把对应配置传给 Claude Agent SDK；留空则以 `~/.claude/settings.json` 为准。
+
+#### DeepSeek Harness
+
+DeepSeek Harness 是可选 Agent。在首次配置向导或 Web 管理页打开 DSH 开关，ChatCCC 会一次点击完成环境检查、临时目录准备、精确版本下载、包校验、Runtime 握手、原子切换和旧版本清理，并在页面逐步显示进度。安装失败时不会替换当前可用版本；刷新页面后仍可恢复安装进度。当前固定安装 `0.1.0-rc.6`，要求 Node.js >= 22.19.0。
+
+DSH 引擎安装在 `~/.chatccc/engines/dsh/`，不加入 ChatCCC 的 `dependencies`。配置 `dsh.apiKey`、`dsh.baseUrl`、`dsh.model`、`dsh.provider` 和 `dsh.maxTokens` 后，可设为默认 Agent 或使用 `/new dsh` 新建会话。安装验证只做本地 JSON-RPC Runtime 握手，不会调用付费模型。
 
 #### Cursor Agent CLI
 
@@ -374,13 +380,15 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `ccc.model` | CCC Agent 默认模型 |
 | `ccc.subModel` | CCC Agent 子模型（选填）：用于内部轻量环节（压缩摘要生成、task 子代理任务）；留空跟随主模型 |
 | `ccc.compactionTimeoutMs` | CCC Agent 上下文压缩单轮超时（毫秒），默认 300000（5 分钟）；压缩超时会让整轮对话失败，建议保持默认或调大 |
-| `ccc.contextWindow` | CCC Agent 模型上下文窗口（token），默认 1048576（1M，DeepSeek V4 Pro/Flash 原生规格）；压缩阈值自动 = 窗口 × 80%；超过模型/服务端实际上限会被 API 拒绝，可在 Web UI 下拉选择或自定义（单位 k） |
+| `ccc.contextWindow` | CCC Agent 模型上下文窗口（token），默认 1048576（1M，DeepSeek V4 Pro/Flash 原生规格）；压缩阈值自动 = 窗口 × 80%；超过模型/服务端实际上限会被 API 拒绝，可在 Web UI 下拉选择或自定义（单位 k） |
+| `dsh.apiKey` / `dsh.baseUrl` | DeepSeek Harness 的 API Key 和官方 DeepSeek 服务地址 |
+| `dsh.model` / `dsh.provider` / `dsh.maxTokens` | DSH 默认模型、Runtime provider 和最大 token 数 |
 
 > **权限控制**：普通消息以 `bypassPermissions` 模式运行，跳过 Agent 操作确认。使用 `/plan` 或 `/ask` 前缀时，ChatCCC 自动切换为只读模式：Claude SDK 仅放行 Read + stop-stuck-loop 网络请求，Codex 使用 `--sandbox read-only`，Cursor 使用 `--mode plan/ask`。请只在可信环境中使用。
 
 ### 5. 开始使用
 
-**飞书：** 找到机器人后直接发送普通消息，即可在当前私聊中创建并持续使用专属 AI 会话；私聊工作目录固定为运行 ChatCCC 的系统账号用户目录。默认 Agent 发生变化后，下一条私聊普通消息会触发切换并创建新的空会话；若旧 Agent 正在生成，该消息会先排队，待当前回复完成后再切换。命令不会触发自动切换。需要独立任务时，发送 `/new`、`/new claude`、`/new cursor`、`/new codex` 或 `/new ccc`，机器人会另外创建会话群。
+**飞书：** 找到机器人后直接发送普通消息，即可在当前私聊中创建并持续使用专属 AI 会话；私聊工作目录固定为运行 ChatCCC 的系统账号用户目录。默认 Agent 发生变化后，下一条私聊普通消息会触发切换并创建新的空会话；若旧 Agent 正在生成，该消息会先排队，待当前回复完成后再切换。命令不会触发自动切换。需要独立任务时，发送 `/new`、`/new claude`、`/new cursor`、`/new codex`、`/new ccc` 或 `/new dsh`，机器人会另外创建会话群。
 
 **微信：** 扫码登录后，在机器人私聊里发送 `/new` 或指定 Agent 的 `/new ...` 命令即可开始。功能与飞书基本一致，但展示为纯文本。
 
@@ -396,7 +404,8 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `/new claude` | 创建 Claude Code 会话；飞书中会创建新群 |
 | `/new cursor` | 创建 Cursor 会话；飞书中会创建新群 |
 | `/new codex` | 创建 Codex 会话；飞书中会创建新群 |
-| `/new ccc` | 创建内置 CCC Agent 会话；飞书中会创建新群 |
+| `/new ccc` | 创建内置 CCC Agent 会话；飞书中会创建新群 |
+| `/new dsh` | 创建 DeepSeek Harness 会话；飞书中会创建新群 |
 | `/forget` | 在当前聊天原地重置会话（忘掉上下文）；群聊保留工作目录，飞书私聊固定使用系统用户目录 |
 | `/model` | 查看或切换当前会话的模型 |
 | `/fast` | 查看当前 Codex 会话的 Fast 模式；使用 `/fast on` 或 `/fast off` 切换 |
@@ -406,7 +415,7 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `/cd` | 查看或设置后续新建会话的默认工作目录，不改变当前会话；飞书私聊自身始终使用系统用户目录 |
 | `/sessions` | 查看所有会话状态 |
 | `/session <数字>` | 将当前群聊切换到 `/sessions` 列表中的指定会话；飞书私聊不支持切换 |
-| `/usage` | 查看当前会话对应 Agent 的用量；Codex 显示 5h/7天窗口，Cursor 显示当前周期用量，CCC Agent 仅在官方 DeepSeek 端点时显示账户余额（其他兼容端点自动跳过） |
+| `/usage` | 查看当前会话对应 Agent 的用量；Codex 显示 5h/7天窗口，Cursor 显示当前周期用量，CCC Agent 和 DSH 仅在官方 DeepSeek 端点时显示账户余额（其他兼容端点自动跳过） |
 | `/git <子命令>` | 在当前会话工作目录执行 `git ...` 并回传输出 |
 | `/abd<内容>` | 去掉 `/abd` 前缀后把内容发给 Agent，并在消息末尾追加第一性原理需求澄清提示 |
 | `/plan <内容>` | 只读计划模式：仅允许读文件和 stop-stuck-loop 请求，不执行任何写操作 |
@@ -425,4 +434,4 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 
 ## 技术栈
 
-TypeScript（发布前编译为 JavaScript，tsx 仅用于开发）/ Node.js >= 20 / AI SDK / Anthropic Claude Agent SDK（按需下载，仅启用 Claude Code 时安装）/ Cursor Agent CLI / Codex CLI / 飞书 WebSocket API / CardKit / 微信 iLink
+TypeScript（发布前编译为 JavaScript，tsx 仅用于开发）/ Node.js >= 20 / AI SDK / Anthropic Claude Agent SDK（按需下载）/ DeepSeek Harness SDK + JSON-RPC Runtime（按需下载，要求 Node.js >= 22.19.0）/ Cursor Agent CLI / Codex CLI / 飞书 WebSocket API / CardKit / 微信 iLink

package/config.sample.json

@@ -37,14 +37,20 @@
       "retentionDays": 7,
       "keepCompleted": false
     },
-    "ccc": {
-      "enabled": false,
-      "maxBytesPerTurn": 52428800,
-      "retentionDays": 7,
-      "keepCompleted": false
+    "ccc": {
+      "enabled": false,
+      "maxBytesPerTurn": 52428800,
+      "retentionDays": 7,
+      "keepCompleted": false
+    },
+    "dsh": {
+      "enabled": false,
+      "maxBytesPerTurn": 52428800,
+      "retentionDays": 7,
+      "keepCompleted": false
     }
   },
-  "ccc": {
+  "ccc": {
     "enabled": false,
     "defaultAgent": false,
     "DEEPSEEK_API_KEY": "",
@@ -55,8 +61,17 @@
     "effort": "",
     "provider": "",
     "compactionTimeoutMs": 300000,
-    "contextWindow": 1048576
-  },
+    "contextWindow": 1048576
+  },
+  "dsh": {
+    "enabled": false,
+    "defaultAgent": false,
+    "apiKey": "",
+    "baseUrl": "https://api.deepseek.com/v1",
+    "model": "deepseek-v4-flash",
+    "provider": "deepseek-official",
+    "maxTokens": 49152
+  },
   "claude": {
     "enabled": false,
     "defaultAgent": true,

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

@@ -14,7 +14,7 @@ import { parseUserCommand } from "./adapter-interface.js";
 import { CHATCCC_PORT, config, PROJECT_ROOT, RAW_STREAM_LOGS_DIR } from "../config.js";
 import { defaultClaudeSessionMetaStore, } from "./claude-session-meta-store.js";
 import { createRawStreamLog, } from "./raw-stream-log.js";
-import { getClaudeSdkEntryPath } from "../claude-sdk-installer.js";
+import { engineManager } from "../engines/engine-specs.js";
 const CLAUDE_SPECIFIC_PROMPT_PATH = join(PROJECT_ROOT, "agent-prompts", "claude_specific.md");
 export function buildSdkEnv(subagentModel, apiKey, baseUrl) {
     const subagentModelTrim = (subagentModel ?? "").trim();
@@ -230,7 +230,8 @@ let sdkModulePromise = null;
  */
 export function loadClaudeSdkModule() {
     if (!sdkModulePromise) {
-        sdkModulePromise = import(__rewriteRelativeImportExtension(pathToFileURL(getClaudeSdkEntryPath()).href))
+        sdkModulePromise = engineManager.getEntryPath("claude")
+            .then((entryPath) => import(__rewriteRelativeImportExtension(pathToFileURL(entryPath).href)))
             .then((m) => m)
             .catch((err) => {
             sdkModulePromise = null;

package/dist/src/adapters/dsh-adapter.js

@@ -0,0 +1,230 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { engineManager } from "../engines/engine-specs.js";
+import { config, RAW_STREAM_LOGS_DIR } from "../config.js";
+import { createRawStreamLog } from "./raw-stream-log.js";
+let injectedSdk = null;
+const knownSessions = new Map();
+export function __setDshSdkModuleForTest(module) {
+    injectedSdk = module;
+}
+export function createDshAdapter(options = {}) {
+    return {
+        displayName: "DeepSeek Harness",
+        sessionDescPrefix: "DSH Session:",
+        responseStallDetectionEnabled: true,
+        async createSession(cwd) {
+            await engineManager.getEntryPath("dsh");
+            const sessionId = `dsh-${randomUUID()}`;
+            knownSessions.set(sessionId, { sessionId, cwd, lastModified: Date.now(), model: options.model ?? "deepseek-v4-flash" });
+            return { sessionId };
+        },
+        async *prompt(sessionId, userText, cwd, signal, promptOptions) {
+            const entryPath = await engineManager.getEntryPath("dsh");
+            const installationDir = resolve(dirname(entryPath), "../../../..");
+            const sdk = injectedSdk ?? await import(__rewriteRelativeImportExtension(pathToFileURL(entryPath).href));
+            const sessionRoot = join(homedir(), ".chatccc", "dsh-sessions");
+            await mkdir(sessionRoot, { recursive: true });
+            const runtime = new sdk.DeepSeekHarness({
+                launch: {
+                    command: process.execPath,
+                    args: [
+                        join(installationDir, "node_modules", "@deepseek-ai", "dsh-sdk-jsonrpc-demo", "lib", "bin.js"),
+                        join(installationDir, "dsh-runtime.cordis.yml"),
+                    ],
+                    cwd,
+                    env: {
+                        ...process.env,
+                        DSH_CWD: cwd,
+                        DSH_SESSION_ROOT: sessionRoot,
+                        ...(options.apiKey ? { DEEPSEEK_API_KEY: options.apiKey } : {}),
+                        ...(options.baseUrl ? { DEEPSEEK_BASE_URL: options.baseUrl } : {}),
+                    },
+                },
+                cwd,
+                provider: options.provider ?? "deepseek-official",
+                model: options.model ?? "deepseek-v4-flash",
+                ...(options.maxTokens ? { maxTokens: options.maxTokens } : {}),
+            });
+            const queue = new AsyncMessageQueue();
+            const rawLogConfig = config.rawStreamLogs.dsh;
+            let rawLog = null;
+            try {
+                rawLog = await createRawStreamLog({
+                    enabled: rawLogConfig.enabled,
+                    rootDir: RAW_STREAM_LOGS_DIR,
+                    tool: "dsh",
+                    sessionId,
+                    label: "prompt",
+                    maxBytesPerTurn: rawLogConfig.maxBytesPerTurn,
+                    retentionDays: rawLogConfig.retentionDays,
+                });
+            }
+            catch (error) {
+                console.error(`[DSH raw stream log] create failed: ${error.message}`);
+            }
+            let closed = false;
+            let completed = false;
+            const closeRuntime = () => {
+                if (closed)
+                    return;
+                closed = true;
+                void runtime.close();
+            };
+            promptOptions?.onSessionCreated?.(closeRuntime);
+            const onAbort = () => closeRuntime();
+            signal?.addEventListener("abort", onAbort, { once: true });
+            const task = (async () => {
+                try {
+                    await runtime.start();
+                    const result = await runtime.run(userText, {
+                        sessionId,
+                        onNotification: (notification) => {
+                            rawLog?.writeLine(JSON.stringify(notification));
+                            const message = notificationToMessage(notification);
+                            if (message)
+                                queue.push(message);
+                        },
+                    });
+                    if (result.finalResponse) {
+                        rawLog?.writeLine(JSON.stringify({ type: "run.result", result }));
+                        queue.push({ type: "assistant", blocks: [{ type: "text_final", text: result.finalResponse }], isFinalResponse: true });
+                    }
+                    completed = true;
+                    knownSessions.set(sessionId, { sessionId, cwd, lastModified: Date.now(), model: options.model ?? "deepseek-v4-flash" });
+                    queue.end();
+                }
+                catch (error) {
+                    queue.fail(error instanceof Error ? error : new Error(String(error)));
+                }
+                finally {
+                    signal?.removeEventListener("abort", onAbort);
+                    await runtime.close().catch(() => { });
+                    await rawLog?.close({ keep: rawLogConfig.keepCompleted || signal?.aborted === true || !completed });
+                    closed = true;
+                }
+            })();
+            try {
+                for await (const message of queue)
+                    yield message;
+                await task;
+            }
+            finally {
+                closeRuntime();
+            }
+        },
+        async getSessionInfo(sessionId) {
+            return knownSessions.get(sessionId) ?? { sessionId };
+        },
+        async closeSession() {
+            // Each prompt owns and closes its runtime. Durable state lives under ~/.chatccc/dsh-sessions.
+        },
+    };
+}
+function notificationToMessage(notification) {
+    if (notification.method === "session.status") {
+        return notification.params.status === "running"
+            ? { type: "system", blocks: [{ type: "agent_status", status: "responding" }] }
+            : null;
+    }
+    if (notification.method === "subagent.started") {
+        return { type: "system", blocks: [{ type: "agent_progress", phase: "reasoning" }] };
+    }
+    if (notification.method !== "session.event")
+        return null;
+    const event = asRecord(notification.params.event);
+    if (!event)
+        return null;
+    const data = asRecord(event.data);
+    if (!data)
+        return null;
+    const blocks = [];
+    if (event.type === "assistant/chunk") {
+        const chunk = asRecord(data.chunk);
+        if (chunk?.type === "text-delta" && typeof chunk.text === "string" && chunk.text) {
+            blocks.push({ type: "text", text: chunk.text });
+        }
+    }
+    else if (event.type === "tool/call") {
+        const raw = typeof data.arguments === "string" ? data.arguments : "{}";
+        let input = raw;
+        try {
+            input = JSON.parse(raw);
+        }
+        catch { /* retain raw provider arguments */ }
+        blocks.push({
+            type: "tool_use",
+            ...(typeof data.callId === "string" ? { id: data.callId } : {}),
+            name: typeof data.name === "string" ? data.name : "tool",
+            input,
+        });
+    }
+    else if (event.type === "tool/result") {
+        const message = asRecord(data.message);
+        const callId = typeof message?.toolCallId === "string"
+            ? message.toolCallId
+            : typeof message?.callId === "string"
+                ? message.callId
+                : "";
+        blocks.push({
+            type: "tool_result",
+            tool_use_id: callId,
+            content: message?.content ?? data.message,
+            ...(data.error ? { is_error: true } : {}),
+        });
+    }
+    else if (event.type === "turn/start" || event.type === "step/start") {
+        blocks.push({ type: "agent_progress", phase: "reasoning" });
+    }
+    return blocks.length ? { type: "assistant", blocks } : null;
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+class AsyncMessageQueue {
+    values = [];
+    waiters = [];
+    done = false;
+    error = null;
+    push(value) {
+        if (this.done)
+            return;
+        this.values.push(value);
+        this.waiters.shift()?.();
+    }
+    end() {
+        this.done = true;
+        while (this.waiters.length)
+            this.waiters.shift()?.();
+    }
+    fail(error) {
+        this.error = error;
+        this.end();
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.values.length) {
+                yield this.values.shift();
+                continue;
+            }
+            if (this.error)
+                throw this.error;
+            if (this.done)
+                return;
+            await new Promise((resolvePromise) => this.waiters.push(resolvePromise));
+        }
+    }
+}

package/dist/src/agent-tool.js

@@ -1,9 +1,10 @@
-export const AGENT_TOOLS = ["claude", "cursor", "codex", "ccc"];
+export const AGENT_TOOLS = ["claude", "cursor", "codex", "ccc", "dsh"];
 export const AGENT_TOOL_OPTIONS = [
     { id: "ccc", label: "CCC" },
     { id: "claude", label: "Claude" },
     { id: "cursor", label: "Cursor" },
     { id: "codex", label: "Codex" },
+    { id: "dsh", label: "DeepSeek Harness" },
 ];
 export function isAgentTool(value) {
     return typeof value === "string" && AGENT_TOOLS.includes(value);

package/dist/src/card-action-parser.js

@@ -16,6 +16,7 @@ export const CARD_ACTION_CMD_MAP = {
     "new cursor": "/new cursor",
     "new codex": "/new codex",
     "new ccc": "/new ccc",
+    "new dsh": "/new dsh",
     restart: "/restart",
     update: "/update",
     state: "/state",

package/dist/src/cards.js

@@ -137,6 +137,7 @@ export function buildHelpCard(userText, opts = {}) {
         "发送 **/new cursor** 创建新 Cursor 会话",
         "发送 **/new codex** 创建新 Codex 会话",
         "发送 **/new ccc** 创建新 CCC Agent 会话",
+        "发送 **/new dsh** 创建新 DeepSeek Harness 会话",
         "发送 **/forget** 重置当前会话（忘掉上下文，沿用当前工作目录，不切换）",
         "发送 **/plan** 以规划模式提问（只读，不执行写操作）",
         "发送 **/ask** 以问答模式提问（只读，不执行写操作）",
@@ -157,6 +158,7 @@ export function buildHelpCard(userText, opts = {}) {
                 { text: "新建 Cursor 会话（/new cursor）", value: JSON.stringify({ cmd: "new cursor" }), type: "primary" },
                 { text: "新建 Codex 会话（/new codex）", value: JSON.stringify({ cmd: "new codex" }), type: "primary" },
                 { text: "新建 CCC Agent 会话（/new ccc）", value: JSON.stringify({ cmd: "new ccc" }), type: "primary" },
+                { text: "新建 DeepSeek Harness 会话（/new dsh）", value: JSON.stringify({ cmd: "new dsh" }), type: "primary" },
                 { text: "重启 ChatCCC（/restart）", value: JSON.stringify({ cmd: "restart" }), type: "danger" },
                 { text: "更新并重启（/update）", value: JSON.stringify({ cmd: "update" }), type: "danger" },
                 { text: "切换工作路径（/cd）", value: JSON.stringify({ cmd: "cd" }), type: "default" },
@@ -253,6 +255,8 @@ function sessionToolLabel(tool) {
         return "Codex";
     if (tool === "ccc")
         return "CCC Agent";
+    if (tool === "dsh")
+        return "DeepSeek Harness";
     return "Claude Code";
 }
 function pushSessionGroup(lines, title, sessions, formatSession, index) {
@@ -271,22 +275,24 @@ export function buildSessionsCard(sessions, opts = {}) {
     const defaultToolLabel = opts.defaultToolLabel ?? "Claude Code";
     const fixedPrivateSession = opts.fixedPrivateSession ?? false;
     // 按 tool 分组排序：Claude Code 在前，Cursor 其次，Codex 最后
-    const claudeCodeSessions = sessions.filter(s => s.tool !== "cursor" && s.tool !== "codex" && s.tool !== "ccc");
+    const claudeCodeSessions = sessions.filter(s => s.tool === "claude");
     const cursorSessions = sessions.filter(s => s.tool === "cursor");
     const codexSessions = sessions.filter(s => s.tool === "codex");
     const cccSessions = sessions.filter(s => s.tool === "ccc");
+    const dshSessions = sessions.filter(s => s.tool === "dsh");
     const hasClaudeCode = claudeCodeSessions.length > 0;
     const hasCursor = cursorSessions.length > 0;
     const hasCodex = codexSessions.length > 0;
     const hasCcc = cccSessions.length > 0;
+    const hasDsh = dshSessions.length > 0;
     if (sessions.length === 0) {
         return JSON.stringify({
             config: { wide_screen_mode: true },
             header: { template: "blue", title: { content: "所有会话", tag: "plain_text" } },
             elements: [
                 { tag: "div", text: { tag: "lark_md", content: fixedPrivateSession
-                            ? `当前没有会话记录。\n\n直接发送普通消息即可创建飞书私聊专属 ${defaultToolLabel} 会话；默认 Agent 变化后，下一条普通消息会创建对应 Agent 的新空会话。发送 **/new**、**/new claude**、**/new cursor**、**/new codex** 或 **/new ccc** 会另外创建会话群。`
-                            : `当前没有会话记录。\n\n使用 **/new**（默认 ${defaultToolLabel}）、**/new claude**、**/new cursor**、**/new codex** 或 **/new ccc** 创建新会话。\n创建后可在任意会话群内发送 **/sessions** 查看列表，用 **/session 数字** 切换会话。` } },
+                            ? `当前没有会话记录。\n\n直接发送普通消息即可创建飞书私聊专属 ${defaultToolLabel} 会话；默认 Agent 变化后，下一条普通消息会创建对应 Agent 的新空会话。发送 **/new**、**/new claude**、**/new cursor**、**/new codex**、**/new ccc** 或 **/new dsh** 会另外创建会话群。`
+                            : `当前没有会话记录。\n\n使用 **/new**（默认 ${defaultToolLabel}）、**/new claude**、**/new cursor**、**/new codex**、**/new ccc** 或 **/new dsh** 创建新会话。\n创建后可在任意会话群内发送 **/sessions** 查看列表，用 **/session 数字** 切换会话。` } },
                 { tag: "hr" },
                 { tag: "action", actions: [{ tag: "button", text: { tag: "plain_text", content: "收起" }, type: "default", value: { action: "close" } }] },
             ],
@@ -322,6 +328,8 @@ export function buildSessionsCard(sessions, opts = {}) {
         pushSessionGroup(lines, "Codex 会话", codexSessions, formatSession, idx);
     if (hasCcc)
         pushSessionGroup(lines, "CCC Agent 会话", cccSessions, formatSession, idx);
+    if (hasDsh)
+        pushSessionGroup(lines, "DeepSeek Harness 会话", dshSessions, formatSession, idx);
     return JSON.stringify({
         config: { wide_screen_mode: true },
         header: { template: "blue", title: { content: "所有会话", tag: "plain_text" } },

package/dist/src/config.js

@@ -58,6 +58,9 @@ export function getAllModelsForTool(tool, cfg = config) {
         collect(cfg.ccc.model);
         collect(cfg.ccc.alternativeModel);
     }
+    else if (tool === "dsh") {
+        collect(cfg.dsh.model);
+    }
     return Array.from(seen).slice(0, 100);
 }
 export const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
@@ -291,6 +294,7 @@ function loadConfig() {
             cursor: { enabled: false, maxBytesPerTurn: 50 * 1024 * 1024, retentionDays: 7, keepCompleted: false },
             codex: { enabled: false, maxBytesPerTurn: 50 * 1024 * 1024, retentionDays: 7, keepCompleted: false },
             ccc: { enabled: false, maxBytesPerTurn: 50 * 1024 * 1024, retentionDays: 7, keepCompleted: false },
+            dsh: { enabled: false, maxBytesPerTurn: 50 * 1024 * 1024, retentionDays: 7, keepCompleted: false },
         },
         claude: { enabled: false, defaultAgent: true, model: "", subagentModel: "", effort: "", apiKey: "", baseUrl: "", maxTurn: 0 },
         cursor: {
@@ -316,6 +320,15 @@ function loadConfig() {
             compactionTimeoutMs: DEFAULT_CCC_COMPACTION_TIMEOUT_MS,
             contextWindow: DEFAULT_CCC_CONTEXT_WINDOW_TOKENS,
         },
+        dsh: {
+            enabled: false,
+            defaultAgent: false,
+            apiKey: "",
+            baseUrl: DEFAULT_CCC_DEEPSEEK_BASE_URL,
+            model: "deepseek-v4-flash",
+            provider: "deepseek-official",
+            maxTokens: 49152,
+        },
     };
     if (!IS_TEST_ENV) {
         migrateLegacyData();
@@ -368,6 +381,7 @@ function loadConfig() {
     const cursorRaw = (parsed.cursor ?? {});
     const codexRaw = (parsed.codex ?? {});
     const cccRaw = (parsed.ccc ?? {});
+    const dshRaw = (parsed.dsh ?? {});
     const webUiRaw = (parsed.webUi ?? {});
     const chromeDevtoolsRaw = (parsed.chromeDevtools ?? {});
     const rawStreamLogsRaw = typeof parsed.rawStreamLogs === "object" && parsed.rawStreamLogs !== null
@@ -408,17 +422,20 @@ function loadConfig() {
     const cursorEnabled = resolveEnabled(cursorRaw.enabled, cursorNonEmpty);
     const codexEnabled = resolveEnabled(codexRaw.enabled, codexNonEmpty);
     const cccEnabled = resolveCccEnabled(cccRaw.enabled, cccRaw.DEEPSEEK_API_KEY);
+    const dshEnabled = resolveEnabled(dshRaw.enabled, () => Boolean(typeof dshRaw.apiKey === "string" && dshRaw.apiKey.trim()));
     const chromeDevtoolsPort = Number(chromeDevtoolsRaw.port);
     const explicitDefaultTool = typeof claude.defaultAgent === "boolean" && claude.defaultAgent && claudeEnabled ? "claude" :
         typeof cursorRaw.defaultAgent === "boolean" && cursorRaw.defaultAgent && cursorEnabled ? "cursor" :
             typeof codexRaw.defaultAgent === "boolean" && codexRaw.defaultAgent && codexEnabled ? "codex" :
                 typeof cccRaw.defaultAgent === "boolean" && cccRaw.defaultAgent && cccEnabled ? "ccc" :
-                    null;
+                    typeof dshRaw.defaultAgent === "boolean" && dshRaw.defaultAgent && dshEnabled ? "dsh" :
+                        null;
     const fallbackDefaultTool = claudeEnabled ? "claude" :
         cursorEnabled ? "cursor" :
             codexEnabled ? "codex" :
                 cccEnabled ? "ccc" :
-                    "claude";
+                    dshEnabled ? "dsh" :
+                        "claude";
     const defaultTool = explicitDefaultTool ?? fallbackDefaultTool;
     return {
         feishu: {
@@ -462,6 +479,7 @@ function loadConfig() {
             cursor: normalizeRawStreamAgentLogConfig(rawStreamLogsRaw.cursor),
             codex: normalizeRawStreamAgentLogConfig(rawStreamLogsRaw.codex),
             ccc: normalizeRawStreamAgentLogConfig(rawStreamLogsRaw.ccc),
+            dsh: normalizeRawStreamAgentLogConfig(rawStreamLogsRaw.dsh),
         },
         claude: {
             enabled: claudeEnabled,
@@ -509,6 +527,15 @@ function loadConfig() {
             compactionTimeoutMs: normalizePositiveInteger(cccRaw.compactionTimeoutMs, DEFAULT_CCC_COMPACTION_TIMEOUT_MS),
             contextWindow: normalizePositiveInteger(cccRaw.contextWindow, DEFAULT_CCC_CONTEXT_WINDOW_TOKENS),
         },
+        dsh: {
+            enabled: dshEnabled,
+            defaultAgent: defaultTool === "dsh",
+            apiKey: normalizeOptionalConfigField(dshRaw.apiKey, { label: "dsh.apiKey" }),
+            baseUrl: normalizeOptionalConfigField(dshRaw.baseUrl, { label: "dsh.baseUrl", fallback: DEFAULT_CCC_DEEPSEEK_BASE_URL }),
+            model: normalizeOptionalConfigField(dshRaw.model, { label: "dsh.model", fallback: "deepseek-v4-flash" }),
+            provider: normalizeOptionalConfigField(dshRaw.provider, { label: "dsh.provider", fallback: "deepseek-official" }),
+            maxTokens: normalizePositiveInteger(dshRaw.maxTokens, 49152),
+        },
     };
 }
 /**
@@ -781,6 +808,7 @@ export const CURSOR_SESSION_PREFIX = "Cursor Session:";
 export const CODEX_SESSION_PREFIX = "Codex Session:";
 /** 群描述中用于识别 CCC Agent 会话的前缀 */
 export const CCC_SESSION_PREFIX = "CCC Session:";
+export const DSH_SESSION_PREFIX = "DSH Session:";
 /** 根据 tool 名称返回对应的群描述前缀 */
 export function sessionPrefixForTool(tool) {
     if (tool === "cursor")
@@ -789,6 +817,8 @@ export function sessionPrefixForTool(tool) {
         return CODEX_SESSION_PREFIX;
     if (tool === "ccc")
         return CCC_SESSION_PREFIX;
+    if (tool === "dsh")
+        return DSH_SESSION_PREFIX;
     return CLAUDE_SESSION_PREFIX;
 }
 /** 根据 tool 名称返回用于状态展示的标签 */
@@ -799,6 +829,8 @@ export function toolDisplayName(tool) {
         return "Codex";
     if (tool === "ccc")
         return "CCC Agent";
+    if (tool === "dsh")
+        return "DeepSeek Harness";
     return "Claude Code";
 }
 /** 解析 /new 未指定工具时使用的默认 Agent。旧配置缺省 defaultAgent 时保持 Claude 优先。 */