oh-my-im 0.1.14 → 0.1.17

package/README.md

@@ -1,6 +1,6 @@
 # oh-my-im
 
-`oh-my-im` 是一个运行在本机的钉钉 AI Agent 桥接器。它接收钉钉单聊和配置群中的消息，调用本机的 [Codex CLI](https://github.com/openai/codex) 或 [Pi](https://github.com/badlogic/pi-mono)，再通过钉钉文本或互动卡片返回结果。
+`oh-my-im` 是一个运行在本机的钉钉 AI Agent 桥接器。它接收钉钉单聊和配置群中的消息，调用本机的 [Codex CLI](https://github.com/openai/codex)、[Pi](https://github.com/badlogic/pi-mono) 或 [OpenCode](https://opencode.ai/)，再通过钉钉文本或互动卡片返回结果。
 
 项目是一个 TypeScript/Node.js 应用，不使用数据库、Redis 或 Docker。配置、运行状态、日志和回复历史默认保存在当前用户的 `~/.oh-my-im/` 目录。
 
@@ -8,8 +8,8 @@
 
 - 单聊机器人：按用户白名单接收钉钉单聊，支持文本、图片、文件、语音等可解析消息。
 - 群消息监听：消费 DWS 全群消息事件，再按“群 + 发送人”规则做本地过滤。
-- Agent 切换：在管理页选择 Codex 或 Pi，也可以在会话中使用已配置的关键词切换。
-- Agent 模型：在管理页分别配置 Codex 和 Pi 的默认模型；同一 Agent 的群聊和单聊共用该模型。
+- Agent 切换：在管理页选择 Codex、Pi 或 OpenCode，也可以在会话中使用已配置的关键词切换。
+- Agent 模型：管理页可分别配置 Pi 和 OpenCode 模型；Codex 始终使用系统 Codex CLI 已设置的默认模型。
 - 回复方式：在管理页选择互动卡片或普通文本；该设置同时作用于群聊和私聊。普通文本模式只发送 Agent 最终结果。
 - 互动卡片：显示处理中、工具调用和最终回复；群聊支持 Markdown 或纯文本格式。
 - Session 管理：单聊用户只能查看和切换自己工作目录下的 Session；超级管理员可管理其他工作目录。
@@ -86,7 +86,7 @@ http://127.0.0.1:12525
 1. 在“钉钉应用”区域填写 Client ID、Client Secret、机器人名称和机器人 ID。
 2. 在 DWS 区域完成登录；管理页可发起 Device Flow 登录并查看状态。
 3. 搜索群并选择群成员，保存群监听规则。每条规则的唯一键是 `groupId + senderId`。
-4. 选择默认 Agent，必要时填写 Agent 模型名和群提示词前缀。
+4. 选择默认 Agent，必要时填写 Agent 模型名和群提示词后缀。
 5. 如需单聊，打开单聊开关并添加单聊授权人员；可另外配置 Session 超级管理员。
 6. 点击“保存并生效”，然后从钉钉发送一条测试消息。
 
@@ -94,14 +94,14 @@ http://127.0.0.1:12525
 
 ### Agent 模型
 
-管理页会分别展示 Codex 和 Pi 的模型选择。两个配置彼此独立：
+管理页展示 Pi 和 OpenCode 的模型选择：
 
 ```text
-Codex 默认模型 -> 所有使用 Codex 的群聊和单聊
 Pi 默认模型   -> 所有使用 Pi 的群聊和单聊
+OpenCode 默认模型 -> 所有使用 OpenCode 的群聊和单聊
 ```
 
-选择“使用 CLI 默认模型”时不会传递 `--model`，由对应 Agent CLI 决定默认模型。模型列表分别通过 `codex --list-models` 和 `pi --list-models` 获取；如果某个 CLI 暂不可用，可以先完成 CLI 登录或直接保留默认模型。
+Codex 始终不会传递 `--model`，也不读取 Web 后台或系统变量中的模型值，由 Codex CLI 自己决定默认模型。Pi 的模型列表通过 `pi --list-models` 获取，OpenCode 的模型列表通过 `opencode models` 获取；如果对应 CLI 暂不可用，可以先完成 CLI 登录或直接保留默认模型。
 
 ## `omi` 命令
 
@@ -139,8 +139,10 @@ omi
 - 钉钉应用凭证、机器人名称、机器人发送者 ID。
 - 单聊开关、单聊授权人员和 Session 超级管理员。
 - 群监听规则：群、群成员和每次个人历史消息拉取参数。
-- 群提示词前缀、互动卡片格式、卡片更新间隔和是否显示耗时。
+- 群提示词后缀、互动卡片格式、卡片更新间隔和是否显示耗时。
+- 提示词后缀会追加在用户消息事件 JSON 的最下方。
 - Agent 回复方式：互动卡片模式会创建并更新卡片；普通文本模式只在 Agent 完成后发送最终结果。
+- 处理详情：默认不显示，可在卡片设置中开启；开启后展示消息数和工具调用数。
 - 卡片更新间隔设为正数时按间隔更新处理中内容；设为 `0` 或负数时关闭处理中更新，仅在 Agent 完成后发送最终结果。
 - 暂停、开启/关闭监听、切换 Agent 的关键词。多个关键词用 `|` 分隔。
 - 可选的 Webhook，用于 Agent 处理失败时向群发送文本通知。
@@ -154,18 +156,18 @@ omi
 ```text
 /help
 /status
-/sessions [pi|codex]
-/use <pi|codex> <编号或 sessionId>
+/sessions [pi|codex|opencode]
+/use <pi|codex|opencode> <编号或 sessionId>
 /current
-/new
+/new                       # 清空当前会话的 Agent session，下一条消息使用新会话
 ```
 
 Session 超级管理员额外拥有：
 
 ```text
-/admin-sessions [pi|codex]
+/admin-sessions [pi|codex|opencode]
 /admin-cd <目录编号或路径>
-/admin-use <pi|codex> <编号或 sessionId>
+/admin-use <pi|codex|opencode> <编号或 sessionId>
 /admin-current
 /admin-reset
 ```
@@ -189,14 +191,15 @@ Session 超级管理员额外拥有：
 | `DWS_CLI_PATH` | `dws` | DWS CLI 路径 |
 | `CODEX_CLI_PATH` | `codex` | 群侧 Codex CLI 路径 |
 | `PI_CLI_PATH` | `pi` | Pi CLI 路径 |
-| `DWS_CODEX_MODEL` | 不使用 | 已废弃；模型统一从 Web 的 Codex 配置读取 |
+| `OPENCODE_CLI_PATH` | `opencode` | OpenCode CLI 路径 |
+| `DWS_CODEX_MODEL` | 不使用 | 不读取；Codex 使用系统 CLI 默认模型 |
 | `DWS_CODEX_TIMEOUT_MS` | `300000` | 群侧 Codex 超时，单位毫秒 |
 | `CODEX_PROXY` | 未设置 | 传给 Agent 的代理配置 |
 | `CODEX_HOME` | `~/.codex` | Codex Session 根目录 |
 | `PI_CODING_AGENT_SESSION_DIR` | `~/.pi/agent/sessions` | Pi Session 根目录 |
 | `OHMIM_DATA_DIR` | `~/.oh-my-im` | 回复历史目录使用的数据根目录 |
 
-模型来源统一为 Web 中的 Agent 配置；Codex 未配置模型时使用 Codex CLI 默认模型，Pi 未配置模型时使用 Pi CLI 默认模型。
+模型来源：Codex 使用系统 CLI 默认模型，Pi 和 OpenCode 使用 Web 中各自的模型配置；未配置时分别使用对应 CLI 默认模型。OpenCode 模型列表来自 `opencode models`，保存值格式为 `provider/model`。
 
 当前实现默认以 bypass/full approval 方式运行 Agent。请只在可信的本地工作目录中使用，并确保 Agent 运行账号拥有合适的文件权限。
 
@@ -214,6 +217,8 @@ Session 超级管理员额外拥有：
 ├── group-worker.lock           # 群 worker 锁
 ├── omi-bot-status.json         # 单聊连接状态
 ├── dws-cards.json              # 群卡片状态
+├── group-sessions.json         # 群聊 Agent Session 绑定
+├── private-sessions.json       # 私聊 Agent Session 绑定
 ├── dws-history-cursor.json     # 个人群历史轮询时间游标和消息去重键
 └── replies/YYYY-MM-DD.json     # 单聊和群聊回复历史
 ```
@@ -291,7 +296,7 @@ src/
 ├── dingtalk.ts            # Stream 单聊消息解析与发送
 ├── dingtalk-card.ts       # StandardCard 创建和更新
 ├── dingtalk-robot.ts      # 钉钉机器人 OpenAPI/Webhook
-├── agents/                # Codex/Pi 进程适配
+├── agents/                # Codex/Pi/OpenCode 进程适配
 └── conversation-log.ts    # 回复历史持久化
 ```
 

package/dist/agents/codex-agent.js

@@ -179,16 +179,20 @@ function buildArgs(prompt, workDir, sessionId, config) {
     else {
         common.push("--full-auto");
     }
-    const modelOptions = config.agentModel ? ["--model", config.agentModel] : config.codexModel ? ["--model", config.codexModel] : [];
     return sessionId
-        ? ["exec", "resume", ...common, ...modelOptions, sessionId, "-"]
-        : ["exec", ...common, ...modelOptions, "--cd", workDir, "-"];
+        ? ["exec", "resume", ...common, sessionId, "-"]
+        : ["exec", ...common, "--cd", workDir, "-"];
 }
 export function runCodex(prompt, sessionId, config, callbacks = {}) {
     return new Promise((resolve, reject) => {
         const start = Date.now();
         const args = buildArgs(prompt, config.codexWorkDir, sessionId, config);
         const env = createAgentEnv(config.codexProxy);
+        // Codex model selection belongs exclusively to the CLI config. Do not
+        // let legacy application or model environment variables override it.
+        delete env.DWS_CODEX_MODEL;
+        delete env.CODEX_MODEL;
+        delete env.OPENAI_MODEL;
         log.info(`spawn ${config.codexCliPath} ${args.join(" ")}`);
         const child = spawn(config.codexCliPath, args, {
             cwd: config.codexWorkDir,

package/dist/agents/index.js

@@ -1,7 +1,8 @@
 import { listCodexSessions, runCodex } from "./codex-agent.js";
 import { listPiSessions, runPi } from "./pi-agent.js";
+import { listOpenCodeSessions, runOpenCode } from "./opencode-agent.js";
 export function agentLabel(agent) {
-    return agent === "pi" ? "Pi" : "Codex";
+    return agent === "pi" ? "Pi" : agent === "opencode" ? "OpenCode" : "Codex";
 }
 export function agentSwitchMessage(agent) {
     const label = `${agentLabel(agent)} Agent`;
@@ -11,12 +12,12 @@ export function agentSwitchMessage(agent) {
     ].join("\n");
 }
 export function listAgentSessions(agent, config) {
-    return agent === "pi"
-        ? listPiSessions(config)
-        : listCodexSessions(config);
+    return agent === "pi" ? listPiSessions(config) : agent === "opencode" ? listOpenCodeSessions(config) : listCodexSessions(config);
 }
 export function runAgent(agent, prompt, sessionId, config, callbacks = {}) {
     return agent === "pi"
         ? runPi(prompt, sessionId, config, callbacks)
-        : runCodex(prompt, sessionId, config, callbacks);
+        : agent === "opencode"
+            ? runOpenCode(prompt, sessionId, config, callbacks)
+            : runCodex(prompt, sessionId, config, callbacks);
 }

package/dist/agents/opencode-agent.js

@@ -0,0 +1,156 @@
+import { spawn } from "node:child_process";
+import { createLogger } from "../logger.js";
+import { asObject, attachJsonlReader, createOpenCodeEnv } from "./process-utils.js";
+const log = createLogger("OpenCode");
+function asTimestamp(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value !== "number")
+        return undefined;
+    return new Date(value).toISOString();
+}
+export function listOpenCodeSessions(config) {
+    return new Promise((resolve) => {
+        const cliPath = config.opencodeCliPath || "opencode";
+        const child = spawn(cliPath, ["session", "list", "--format", "json", "-n", "500"], {
+            cwd: config.codexWorkDir,
+            env: createOpenCodeEnv(config.codexProxy),
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        child.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+        child.on("error", () => resolve([]));
+        child.on("close", (code) => {
+            if (code !== 0)
+                return resolve([]);
+            try {
+                const value = JSON.parse(stdout);
+                resolve(value.flatMap((item) => {
+                    const cwd = typeof item.directory === "string" ? item.directory : undefined;
+                    const id = typeof item.id === "string" ? item.id : undefined;
+                    if (!id)
+                        return [];
+                    return [{
+                            id,
+                            title: typeof item.title === "string" ? item.title : undefined,
+                            createdAt: asTimestamp(item.created),
+                            updatedAt: asTimestamp(item.updated),
+                            cwd,
+                        }];
+                }));
+            }
+            catch {
+                resolve([]);
+            }
+        });
+    });
+}
+function textFromEvent(event) {
+    const part = asObject(event.part);
+    const text = part?.text ?? event.text;
+    return typeof text === "string" && text ? text : undefined;
+}
+function eventSessionId(event) {
+    for (const value of [event.sessionID, event.sessionId, event.session_id, asObject(event.part)?.sessionID]) {
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function toolFromEvent(event) {
+    if (event.type !== "tool_use" && event.type !== "tool")
+        return undefined;
+    const part = asObject(event.part);
+    const name = [part?.tool, event.tool, event.name].find((value) => typeof value === "string" && Boolean(value.trim()));
+    if (!name)
+        return undefined;
+    const id = [part?.callID, part?.callId, event.callID, event.callId].find((value) => typeof value === "string" && Boolean(value.trim()));
+    return { name, id };
+}
+export function runOpenCode(prompt, sessionId, config, callbacks = {}) {
+    return new Promise((resolve, reject) => {
+        const start = Date.now();
+        const args = ["run", "--format", "json", "--dir", config.codexWorkDir, "--auto"];
+        if (config.agentModel)
+            args.push("--model", config.agentModel);
+        if (sessionId)
+            args.push("--session", sessionId);
+        args.push(prompt);
+        const child = spawn(config.opencodeCliPath || "opencode", args, {
+            cwd: config.codexWorkDir,
+            env: createOpenCodeEnv(config.codexProxy),
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let completed = false;
+        let latestText = "";
+        let stderr = "";
+        let nextSessionId = sessionId;
+        const toolStats = {};
+        const seenTools = new Set();
+        const timeout = setTimeout(() => finishError(`OpenCode timeout after ${Math.round(config.cliTimeoutMs / 1000)}s`), config.cliTimeoutMs);
+        timeout.unref();
+        const finish = () => {
+            if (completed)
+                return;
+            completed = true;
+            clearTimeout(timeout);
+            resolve({ sessionId: nextSessionId, text: latestText.trim() || "(无输出)", toolStats, durationMs: Date.now() - start });
+        };
+        function finishError(message) {
+            if (completed)
+                return;
+            completed = true;
+            clearTimeout(timeout);
+            child.kill("SIGTERM");
+            reject(new Error(message));
+        }
+        callbacks.onAbortReady?.(() => {
+            if (!completed) {
+                child.kill("SIGTERM");
+                setTimeout(() => { if (!completed)
+                    child.kill("SIGKILL"); }, 1_000).unref();
+            }
+        });
+        child.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
+        attachJsonlReader(child.stdout, (line) => {
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            nextSessionId = eventSessionId(event) || nextSessionId;
+            if (event.type === "error") {
+                const error = asObject(event.error);
+                finishError(typeof error?.message === "string" ? error.message : typeof event.message === "string" ? event.message : "OpenCode failed");
+                return;
+            }
+            const tool = toolFromEvent(event);
+            if (tool) {
+                const key = tool.id || `${tool.name}:${seenTools.size}`;
+                if (!seenTools.has(key)) {
+                    seenTools.add(key);
+                    toolStats[tool.name] = (toolStats[tool.name] ?? 0) + 1;
+                    callbacks.onToolUse?.(tool.name, { ...toolStats });
+                }
+            }
+            if (event.type === "text" || event.type === "message") {
+                const text = textFromEvent(event);
+                if (text) {
+                    latestText = text.startsWith(latestText) ? text : latestText.startsWith(text) ? latestText : latestText + text;
+                    callbacks.onText?.(latestText);
+                }
+            }
+        });
+        child.on("error", (error) => finishError(error.message));
+        child.on("close", (code) => {
+            if (completed)
+                return;
+            if (code && code !== 0)
+                return finishError(stderr.trim() || `OpenCode exited with code ${code}`);
+            finish();
+        });
+        log.info(`spawn ${config.opencodeCliPath || "opencode"} ${args.join(" ")}`);
+    });
+}

package/dist/agents/pi-agent.js

@@ -79,10 +79,10 @@ function extractAssistantText(message) {
     const text = value.content.flatMap((part) => {
         const item = asObject(part);
         return item?.type === "text" && typeof item.text === "string" ? [item.text] : [];
-    }).join("\n");
+    }).join("");
     return text || undefined;
 }
-export function runPi(prompt, sessionId, config, callbacks = {}) {
+function runPiOnce(prompt, sessionId, config, callbacks = {}) {
     return new Promise((resolve, reject) => {
         const start = Date.now();
         const args = ["--mode", "rpc", "--approve"];
@@ -209,6 +209,10 @@ export function runPi(prompt, sessionId, config, callbacks = {}) {
         child.on("close", (code) => {
             if (completed)
                 return;
+            if (stderr && /Session found in different project|Fork this session\?/i.test(stderr)) {
+                fail(stderr.trim());
+                return;
+            }
             if (code && code !== 0) {
                 fail(stderr.trim() || `Pi Agent exited with code ${code}`);
                 return;
@@ -218,3 +222,20 @@ export function runPi(prompt, sessionId, config, callbacks = {}) {
         child.stdin.write(`${JSON.stringify({ id: "state", type: "get_state" })}\n`);
     });
 }
+function isMissingSessionError(error) {
+    return error instanceof Error && /No session found matching ['"]?[^'"\s]+['"]?/i.test(error.message);
+}
+function isDifferentProjectError(error) {
+    return error instanceof Error && /Session found in different project|Fork this session\?/i.test(error.message);
+}
+export async function runPi(prompt, sessionId, config, callbacks = {}) {
+    try {
+        return await runPiOnce(prompt, sessionId, config, callbacks);
+    }
+    catch (error) {
+        if (!sessionId || (!isMissingSessionError(error) && !isDifferentProjectError(error)))
+            throw error;
+        log.warn(`session=${sessionId} is unavailable for the current project; starting a new Pi session`);
+        return runPiOnce(prompt, undefined, config, callbacks);
+    }
+}

package/dist/agents/process-utils.js

@@ -14,6 +14,15 @@ export function createAgentEnv(proxy) {
     env.all_proxy = proxy;
     return env;
 }
+export function createOpenCodeEnv(proxy) {
+    const env = createAgentEnv(proxy);
+    // A parent npm/pnpm process can put a broken opencode shim from an
+    // unrelated node_modules/.bin directory ahead of the working CLI.
+    if (env.PATH) {
+        env.PATH = env.PATH.split(":").filter((entry) => !entry.endsWith("/node_modules/.bin")).join(":");
+    }
+    return env;
+}
 /** Read strict LF-delimited JSONL without treating Unicode separators as records. */
 export function attachJsonlReader(stream, onLine) {
     const decoder = new StringDecoder("utf8");