opencode-chat-channel 1.0.0 → 1.2.0

package/README.md

@@ -1,6 +1,9 @@
 # opencode-chat-channel
 
-An [opencode](https://opencode.ai) plugin that connects your Feishu (Lark) bot to opencode via **WebSocket long connection** — no public IP required.
+An [opencode](https://opencode.ai) plugin that connects instant messaging bots to opencode AI via a unified multi-channel architecture.
+
+**Currently supported**: Feishu (Lark) via WebSocket long connection — no public IP required.  
+**Skeleton ready**: WeCom (企业微信) — see `src/channels/wecom/index.ts`.
 
 [中文说明](#中文说明) · [English](#english)
 
@@ -11,67 +14,65 @@ An [opencode](https://opencode.ai) plugin that connects your Feishu (Lark) bot t
 ### How It Works
 
 ```
-Feishu User sends message
-    ↓ WebSocket long connection
-Feishu Open Platform
-    ↓ @larksuiteoapi/node-sdk WSClient
+User sends message (Feishu / WeCom / ...)
+    ↓ Channel adapter (WebSocket / HTTP callback / ...)
 chat-channel plugin (this repo)
     ↓ client.session.prompt()
 opencode AI (Sisyphus)
     ↓ text reply
-Feishu User receives reply
+User receives reply
 ```
 
-- Each Feishu user (`open_id`) gets their own persistent opencode session
+- Each user (`open_id` / user ID) gets their own persistent opencode session
 - Sessions expire after 2 hours of inactivity (auto-cleanup)
-- Replies longer than 4000 characters are automatically split into multiple messages
+- Replies longer than 4000 characters are automatically split
 
 ---
 
-### Quick Install (Recommended)
+### Installation
 
-Run this single command in your terminal:
+Since this is an **opencode plugin**, opencode handles installation automatically via npm. No scripts needed.
 
-```bash
-curl -fsSL https://raw.githubusercontent.com/coneycode/opencode-chat-channel/main/install.sh | bash
-```
+#### Step 1: Add to `opencode.json`
 
-The installer will:
-1. Download the plugin to `~/.config/opencode/plugins/chat-channel.ts`
-2. Add `@larksuiteoapi/node-sdk` to `~/.config/opencode/package.json`
-3. Run `bun install` to install dependencies
-4. Prompt you for your Feishu **App ID** (saved to `.env`) and **App Secret** (saved to macOS Keychain)
+Edit `~/.config/opencode/opencode.json` and add the plugin:
 
-After installation, start opencode and you should see:
-```
-[chat-channel] 飞书机器人已启动（长连接模式），appId=cli_xxx***
+```json
+{
+  "plugin": [
+    "opencode-chat-channel@latest"
+  ]
+}
 ```
 
-> **Requirements**: `bun` and `curl` must be installed. macOS is required for Keychain-based secret storage.
-
----
+opencode will pull and install the package automatically on next startup.
 
-### Manual Installation
+#### Step 2: Select channels to enable
 
-1. **Copy the plugin file** to your opencode plugins directory:
+Add `CHAT_CHANNELS` to `~/.config/opencode/.env` to control which channels are active:
 
 ```bash
-cp src/index.ts ~/.config/opencode/plugins/chat-channel.ts
-```
+# ~/.config/opencode/.env
 
-2. **Add the dependency** to `~/.config/opencode/package.json`:
+# Enable Feishu only (recommended to start)
+CHAT_CHANNELS=feishu
 
-```json
-{
-  "dependencies": {
-    "@larksuiteoapi/node-sdk": "^1.37.0"
-  }
-}
+# Enable multiple channels at once
+# CHAT_CHANNELS=feishu,wecom
+
+# Leave unset or empty = auto mode: any channel with valid credentials starts automatically
+# CHAT_CHANNELS=
 ```
 
-Then run `bun install` in `~/.config/opencode/`.
+Then configure credentials for each enabled channel (see sections below).
+
+#### Step 3: Configure channel credentials
+
+See the [Feishu Configuration](#feishu-configuration) section below.
 
-### Configuration
+---
+
+### Feishu Configuration
 
 #### Step 1: Create a Feishu Self-Built App
 
@@ -98,13 +99,21 @@ FEISHU_APP_ID=cli_xxxxxxxxxxxxxxxx
 # OPENCODE_BASE_URL=http://localhost:4321
 ```
 
-**App Secret** (sensitive, store in macOS Keychain):
+**App Secret** — choose the method for your platform:
 
-```bash
-security add-generic-password -a chat-channel -s opencode-chat-channel -w <your-app-secret> -U
-```
+| Platform | Method | Command |
+|----------|--------|---------|
+| macOS | Keychain (recommended) | `security add-generic-password -a chat-channel -s opencode-chat-channel -w <secret> -U` |
+| Windows / Linux | `.env` file | Add `FEISHU_APP_SECRET=<secret>` to `~/.config/opencode/.env` |
+| All platforms | Environment variable | Set `FEISHU_APP_SECRET=<secret>` before launching opencode |
+
+> **Priority**: environment variable → macOS Keychain → `.env` file value (already loaded as env var).
+> The plugin tries each in order and uses the first one found.
 
-Verify:
+> ⚠️ If you store the secret in `.env`, ensure the file has restricted permissions:
+> `chmod 600 ~/.config/opencode/.env`
+
+**macOS Keychain** (verify):
 
 ```bash
 security find-generic-password -a chat-channel -s opencode-chat-channel -w
@@ -119,19 +128,47 @@ opencode
 You should see in the logs:
 
 ```
-[chat-channel] 飞书机器人已启动（长连接模式），appId=cli_xxx***
+[feishu] 飞书机器人已启动（长连接模式），appId=cli_xxx***
+chat-channel 已启动，活跃渠道: feishu
 ```
 
-### File Structure
+---
+
+### Adding a New Channel
+
+The plugin uses a `ChatChannel` interface. To add a new channel:
 
+1. Create `src/channels/<name>/index.ts` implementing `ChatChannel` and exporting a `ChannelFactory`
+2. Register the factory in `src/index.ts` → `CHANNEL_FACTORIES` array
+
+```typescript
+// src/channels/myapp/index.ts
+import type { ChatChannel, ChannelFactory } from "../../types.js";
+
+class MyAppChannel implements ChatChannel {
+  readonly name = "myapp";
+  async start(onMessage) { /* connect, call onMessage on each msg */ }
+  async send(target, text) { /* send reply */ }
+}
+
+export const myappChannelFactory: ChannelFactory = async (client) => {
+  // read credentials, return null if not configured
+  return new MyAppChannel(...);
+};
 ```
-~/.config/opencode/
-├── plugins/
-│   └── chat-channel.ts    # plugin file (copied from src/index.ts)
-├── package.json          # dependencies (add @larksuiteoapi/node-sdk)
-└── .env                  # FEISHU_APP_ID (App Secret in Keychain)
+
+```typescript
+// src/index.ts — add to CHANNEL_FACTORIES
+import { myappChannelFactory } from "./channels/myapp/index.js";
+
+const CHANNEL_FACTORIES: ChannelFactory[] = [
+  feishuChannelFactory,
+  myappChannelFactory, // ← add here
+];
 ```
 
+---
+
 ### FAQ
 
 **Q: Plugin starts but bot receives no messages**
@@ -154,68 +191,65 @@ You should see in the logs:
 ### 工作原理
 
 ```
-飞书用户发消息
-    ↓ WebSocket 长连接
-飞书开放平台
-    ↓ @larksuiteoapi/node-sdk WSClient
+用户发消息（飞书 / 企业微信 / ...）
+    ↓ 渠道适配器（WebSocket 长连接 / HTTP 回调 / ...）
 chat-channel 插件（本仓库）
     ↓ client.session.prompt()
 opencode AI (Sisyphus)
     ↓ 回复文本
-飞书用户
+用户收到回复
 ```
 
-- 每个飞书用户（`open_id`）独享一个 opencode session，**对话历史持久保留**
+- 每个用户独享一个 opencode session，**对话历史持久保留**
 - session 闲置 2 小时后自动回收，下次对话开新 session
 - AI 回复超过 4000 字时自动分段发送
 
 ---
 
-### 一键安装（推荐）
+### 安装
 
-在终端执行以下命令：
+本项目是 **opencode 插件**，opencode 通过 npm 自动管理安装，无需额外脚本。
 
-```bash
-curl -fsSL https://raw.githubusercontent.com/coneycode/opencode-chat-channel/main/install.sh | bash
-```
+#### 第一步：添加到 `opencode.json`
 
-安装程序会自动完成：
-1. 下载插件文件到 `~/.config/opencode/plugins/chat-channel.ts`
-2. 将 `@larksuiteoapi/node-sdk` 添加到 `~/.config/opencode/package.json`
-3. 执行 `bun install` 安装依赖
-4. 交互式询问你的 **App ID**（保存到 `.env`）和 **App Secret**（保存到 macOS 钥匙串）
+编辑 `~/.config/opencode/opencode.json`，在 `plugin` 数组中添加：
 
-安装完成后，启动 opencode 即可看到：
-```
-[chat-channel] 飞书机器人已启动（长连接模式），appId=cli_xxx***
+```json
+{
+  "plugin": [
+    "opencode-chat-channel@latest"
+  ]
+}
 ```
 
-> **前置条件**：需要已安装 `bun` 和 `curl`；App Secret 安全存储依赖 macOS 钥匙串。
+下次启动 opencode 时会自动拉取并安装。
 
----
+#### 第二步：选择要启用的渠道
 
-### 手动安装
-### 安装
-
-1. **复制插件文件** 到 opencode 插件目录：
+在 `~/.config/opencode/.env` 中配置 `CHAT_CHANNELS`，指定要开启哪些渠道：
 
 ```bash
-cp src/index.ts ~/.config/opencode/plugins/chat-channel.ts
-```
+# ~/.config/opencode/.env
 
-2. **添加依赖** 到 `~/.config/opencode/package.json`：
+# 只开启飞书（初始推荐）
+CHAT_CHANNELS=feishu
 
-```json
-{
-  "dependencies": {
-    "@larksuiteoapi/node-sdk": "^1.37.0"
-  }
-}
+# 同时开启多个渠道
+# CHAT_CHANNELS=feishu,wecom
+
+# 留空或不配置 = 自动模式：凭证存在的渠道自动启用
+# CHAT_CHANNELS=
 ```
 
-然后在 `~/.config/opencode/` 目录运行 `bun install`。
+然后配置对应渠道的凭证（见下方各渠道配置说明）。
+
+#### 第三步：配置渠道凭证
 
-### 配置步骤
+参见下方各渠道的配置说明。
+
+---
+
+### 飞书配置
 
 #### 第一步：创建飞书自建应用
 
@@ -238,17 +272,25 @@ cp src/index.ts ~/.config/opencode/plugins/chat-channel.ts
 # ~/.config/opencode/.env
 FEISHU_APP_ID=cli_xxxxxxxxxxxxxxxx
 
-# 可选：自定义 opencode API 地址（默认： http://localhost:4321）
+# 可选：自定义 opencode API 地址（默认：http://localhost:4321）
 # OPENCODE_BASE_URL=http://localhost:4321
 ```
 
-**App Secret**（敏感，存 macOS Keychain，不落盘明文）：
+**App Secret**—按使用的平台选择存储方式：
 
-```bash
-security add-generic-password -a chat-channel -s opencode-chat-channel -w <你的AppSecret> -U
-```
+| 平台 | 方式 | 命令 |
+|------|------|------|
+| macOS | 钒匙串（推荐，不落盘明文） | `security add-generic-password -a chat-channel -s opencode-chat-channel -w <secret> -U` |
+| Windows / Linux | 写入 `.env` 文件 | 在 `~/.config/opencode/.env` 中添加 `FEISHU_APP_SECRET=<secret>` |
+| 所有平台 | 环境变量 | 启动 opencode 前设置 `FEISHU_APP_SECRET=<secret>` |
 
-验证写入是否成功：
+> **读取优先级**：环境变量 → macOS 钒匙串 → `.env` 文件（已在插件启动时自动读入环境变量）。
+> 插件依次尝试，找到第一个有效值即停止。
+
+> ⚠️ 如果将 Secret 写入 `.env`，建议限制文件权限：
+> `chmod 600 ~/.config/opencode/.env`
+
+**macOS 钒匙串**验证：
 
 ```bash
 security find-generic-password -a chat-channel -s opencode-chat-channel -w
@@ -263,19 +305,39 @@ opencode
 启动后日志中会看到：
 
 ```
-[chat-channel] 飞书机器人已启动（长连接模式），appId=cli_xxx***
+[feishu] 飞书机器人已启动（长连接模式），appId=cli_xxx***
+chat-channel 已启动，活跃渠道: feishu
 ```
 
-### 文件位置
+---
+
+### 接入新渠道
+
+插件基于 `ChatChannel` 接口设计，新增渠道步骤：
+
+1. 新建 `src/channels/<渠道名>/index.ts`，实现 `ChatChannel` 接口并导出 `ChannelFactory`
+2. 在 `src/index.ts` 的 `CHANNEL_FACTORIES` 数组中注册工厂函数
+
+参见 `src/channels/wecom/index.ts` — 企业微信骨架，含详细的实现 TODO 注释。
+
+---
+
+### 项目结构
 
 ```
-~/.config/opencode/
-├── plugins/
-│   └── chat-channel.ts    # 插件主文件（从 src/index.ts 复制）
-├── package.json          # 依赖（含 @larksuiteoapi/node-sdk）
-└── .env                  # 环境变量（FEISHU_APP_ID；App Secret 存 Keychain）
+src/
+├── index.ts                    # 插件入口，注册所有渠道
+├── types.ts                    # ChatChannel 接口 & 公共类型
+├── session-manager.ts          # opencode session 管理 & 工具函数
+└── channels/
+    ├── feishu/
+    │   └── index.ts            # 飞书渠道实现（已完成）
+    └── wecom/
+        └── index.ts            # 企业微信渠道骨架（待实现）
 ```
 
+---
+
 ### 常见问题
 
 **Q: 插件启动后收不到消息**

package/dist/channels/feishu/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * opencode-chat-channel — 飞书渠道适配器
+ *
+ * 通过飞书长连接（WebSocket）接收消息，实现 ChatChannel 接口。
+ *
+ * 凭证读取优先级（FEISHU_APP_SECRET）：
+ *   1. 环境变量 FEISHU_APP_SECRET（所有平台，最高优先）
+ *   2. macOS Keychain（仅 macOS，自动尝试）
+ *      service=opencode-chat-channel，account=chat-channel
+ *      写入：security add-generic-password -a chat-channel -s opencode-chat-channel -w <secret> -U
+ *   3. ~/.config/opencode/.env 中的 FEISHU_APP_SECRET（Windows/Linux 推荐）
+ *
+ * FEISHU_APP_ID 始终从 .env 文件读取（非敏感）。
+ */
+import type { ChannelFactory } from "../../types.js";
+/**
+ * 飞书渠道工厂函数。
+ * 凭证不完整时记录警告日志并返回 null（插件跳过该渠道）。
+ */
+export declare const feishuChannelFactory: ChannelFactory;
+//# sourceMappingURL=index.d.ts.map

package/dist/channels/feishu/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/channels/feishu/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAAe,cAAc,EAAiC,MAAM,gBAAgB,CAAC;AAyKjG;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAuBlC,CAAC"}

package/dist/channels/wecom/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * opencode-chat-channel — 企业微信渠道适配器（骨架）
+ *
+ * 企业微信接入方式：
+ *   - 自建应用通过"企业微信回调"（HTTP Webhook）接收消息
+ *   - 或通过"接收消息" API（需要公网地址或内网穿透）
+ *
+ * 凭证配置（待实现时填充）：
+ *   WECOM_CORP_ID      企业 ID，存放在 ~/.config/opencode/.env
+ *   WECOM_AGENT_ID     应用 AgentId，存放在 ~/.config/opencode/.env
+ *   WECOM_SECRET       应用 Secret，存 macOS Keychain：
+ *     security add-generic-password -a chat-channel-wecom -s opencode-chat-channel -w <secret> -U
+ *   WECOM_TOKEN        企业微信回调 Token，存放在 ~/.config/opencode/.env
+ *   WECOM_ENCODING_AES_KEY  企业微信消息加解密 Key，存 macOS Keychain：
+ *     security add-generic-password -a chat-channel-wecom-aes -s opencode-chat-channel -w <key> -U
+ *
+ * TODO: 完整实现
+ *   1. 启动 HTTP 服务器接收企业微信回调（验证 Token、解密消息体）
+ *   2. 调用企业微信 API 发送文本消息
+ *   3. 支持消息加解密（EnterpriseWeChatCrypto）
+ *
+ * 参考文档：
+ *   https://developer.work.weixin.qq.com/document/path/90238
+ *   https://developer.work.weixin.qq.com/document/path/90236
+ */
+import type { ChannelFactory } from "../../types.js";
+/**
+ * 企业微信渠道工厂函数。
+ *
+ * 读取 WECOM_CORP_ID / WECOM_AGENT_ID 环境变量，
+ * 以及 Keychain 中的 WECOM_SECRET。
+ * 任意凭证缺失时返回 null，插件跳过该渠道。
+ *
+ * @todo 待企业微信实现完成后启用此工厂函数
+ */
+export declare const wecomChannelFactory: ChannelFactory;
+//# sourceMappingURL=index.d.ts.map

package/dist/channels/wecom/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/channels/wecom/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAe,cAAc,EAAiC,MAAM,gBAAgB,CAAC;AA4FjG;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAuBjC,CAAC"}

package/dist/index.d.ts

@@ -1,17 +1,21 @@
 /**
- * opencode-chat-channel — opencode 飞书机器人插件
+ * opencode-chat-channel — opencode 多渠道机器人插件
  *
- * 通过飞书长连接（WebSocket）接收消息，驱动 opencode AI 回复。
+ * 通过 .env 文件中的 CHAT_CHANNELS 配置项选择启用哪些渠道：
  *
- * 凭证存储方案（macOS Keychain）：
- *   FEISHU_APP_ID 存放在 ~/.config/opencode/.env（非敏感，可见）
- *   FEISHU_APP_SECRET 存放在系统钥匙串，service=opencode-chat-channel，account=chat-channel
- *   写入命令：
- *     security add-generic-password -a chat-channel -s opencode-chat-channel -w <secret> -U
+ *   CHAT_CHANNELS=feishu          # 只启用飞书
+ *   CHAT_CHANNELS=feishu,wecom    # 同时启用飞书和企业微信
+ *   CHAT_CHANNELS=                # 留空：自动探测（凭证存在即启用）
+ *   # 不配置此项：同留空，自动探测
  *
- * 每个飞书用户（open_id）独享一个 opencode session，对话历史保留。
+ * 其他配置项：
+ *   OPENCODE_BASE_URL   opencode API 地址（默认 http://localhost:4321）
+ *
+ * 各渠道的凭证配置详见 README。
  */
 import type { Plugin } from "@opencode-ai/plugin";
 export declare const ChatChannelPlugin: Plugin;
 export default ChatChannelPlugin;
+export type { ChatChannel, ChannelFactory, ChannelName, IncomingMessage, PluginClient } from "./types.js";
+export { SessionManager, extractResponseText, loadDotEnv } from "./session-manager.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAgDlD,eAAO,MAAM,iBAAiB,EAAE,MAsR/B,CAAC;AAEF,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAgIlD,eAAO,MAAM,iBAAiB,EAAE,MAyF/B,CAAC;AAEF,eAAe,iBAAiB,CAAC;AAGjC,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1G,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -1,8 +1,59 @@
 // src/index.ts
-import * as Lark from "@larksuiteoapi/node-sdk";
-import { execFileSync } from "child_process";
-import { readFileSync } from "fs";
 import { join } from "path";
+
+// src/session-manager.ts
+import { readFileSync } from "fs";
+var SESSION_TTL_MS = 2 * 60 * 60 * 1000;
+
+class SessionManager {
+  client;
+  channel;
+  titleFn;
+  constructor(client, channel, titleFn = (id) => `${channel} · ${id}`) {
+    this.client = client;
+    this.channel = channel;
+    this.titleFn = titleFn;
+  }
+  sessions = new Map;
+  async getOrCreate(userId) {
+    const existing = this.sessions.get(userId);
+    const now = Date.now();
+    if (existing && now - existing.lastActivity < SESSION_TTL_MS) {
+      existing.lastActivity = now;
+      return existing.sessionId;
+    }
+    const res = await this.client.session.create({
+      body: { title: this.titleFn(userId) }
+    });
+    const sessionId = res.data.id;
+    this.sessions.set(userId, { sessionId, lastActivity: now });
+    await this.client.app.log({
+      body: {
+        service: "chat-channel",
+        level: "info",
+        message: `[${this.channel}] 创建新 session: ${sessionId}`,
+        extra: { userId }
+      }
+    });
+    return sessionId;
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [userId, meta] of this.sessions.entries()) {
+      if (now - meta.lastActivity > SESSION_TTL_MS) {
+        this.sessions.delete(userId);
+      }
+    }
+  }
+  startAutoCleanup(intervalMs = 30 * 60 * 1000) {
+    return setInterval(() => this.cleanup(), intervalMs);
+  }
+}
+function extractResponseText(parts) {
+  if (!Array.isArray(parts))
+    return "";
+  return parts.filter((p) => p?.type === "text").map((p) => p?.text ?? "").join("").trim();
+}
 function loadDotEnv(envPath) {
   try {
     const content = readFileSync(envPath, "utf8");
@@ -22,95 +73,84 @@ function loadDotEnv(envPath) {
     }
   } catch {}
 }
-var SESSION_TTL_MS = 2 * 60 * 60 * 1000;
-var OPENCODE_BASE_URL = process.env["OPENCODE_BASE_URL"] ?? "http://localhost:4321";
-var ChatChannelPlugin = async ({ client }) => {
-  const configDir = join(process.env["HOME"] ?? "/Users/" + (process.env["USER"] ?? "unknown"), ".config", "opencode");
-  loadDotEnv(join(configDir, ".env"));
-  const appId = process.env["FEISHU_APP_ID"];
-  let appSecret;
-  try {
-    const stdout = execFileSync("security", [
-      "find-generic-password",
-      "-a",
-      "chat-channel",
-      "-s",
-      "opencode-chat-channel",
-      "-w"
-    ], { encoding: "utf8" });
-    appSecret = stdout.trim() || undefined;
-  } catch {
-    appSecret = undefined;
+
+// src/channels/feishu/index.ts
+import * as Lark from "@larksuiteoapi/node-sdk";
+import { execFileSync } from "child_process";
+var MAX_MSG_LEN = 4000;
+var MAX_PROCESSED = 500;
+function readAppSecret() {
+  if (process.env["FEISHU_APP_SECRET"]) {
+    return process.env["FEISHU_APP_SECRET"];
   }
-  if (!appId || !appSecret) {
-    await client.app.log({
-      body: {
-        service: "chat-channel",
-        level: "warn",
-        message: !appId ? "FEISHU_APP_ID 未设置（请在 .env 中添加），飞书机器人插件已跳过" : "FEISHU_APP_SECRET 未找到（请写入 Keychain），飞书机器人插件已跳过"
-      }
+  if (process.platform === "darwin") {
+    try {
+      const stdout = execFileSync("security", ["find-generic-password", "-a", "chat-channel", "-s", "opencode-chat-channel", "-w"], { encoding: "utf8" });
+      return stdout.trim() || undefined;
+    } catch {}
+  }
+  return;
+}
+
+class FeishuChannel {
+  appId;
+  appSecret;
+  client;
+  name = "feishu";
+  larkClient;
+  processedMessages = new Set;
+  constructor(appId, appSecret, client) {
+    this.appId = appId;
+    this.appSecret = appSecret;
+    this.client = client;
+    this.larkClient = new Lark.Client({
+      appId,
+      appSecret,
+      appType: Lark.AppType.SelfBuild,
+      domain: Lark.Domain.Feishu
     });
-    return {};
   }
-  const larkClient = new Lark.Client({
-    appId,
-    appSecret,
-    appType: Lark.AppType.SelfBuild,
-    domain: Lark.Domain.Feishu
-  });
-  const userSessions = new Map;
-  const processedMessages = new Set;
-  const MAX_PROCESSED = 500;
-  async function getOrCreateSession(openId) {
-    const existing = userSessions.get(openId);
-    const now = Date.now();
-    if (existing && now - existing.lastActivity < SESSION_TTL_MS) {
-      existing.lastActivity = now;
-      return existing.sessionId;
-    }
-    const res = await client.session.create({
-      body: { title: `飞书对话 · ${openId}` }
+  async start(onMessage) {
+    const wsClient = new Lark.WSClient({
+      appId: this.appId,
+      appSecret: this.appSecret,
+      loggerLevel: Lark.LoggerLevel.warn
     });
-    const sessionId = res.data.id;
-    userSessions.set(openId, { sessionId, lastActivity: now });
-    await client.app.log({
+    wsClient.start({
+      eventDispatcher: new Lark.EventDispatcher({}).register({
+        "im.message.receive_v1": async (data) => {
+          const parsed = this.parseEvent(data);
+          if (parsed)
+            await onMessage(parsed);
+        }
+      })
+    });
+    await this.client.app.log({
       body: {
         service: "chat-channel",
         level: "info",
-        message: `创建新 session: ${sessionId}`,
-        extra: { openId }
+        message: `[feishu] 飞书机器人已启动（长连接模式），appId=${this.appId.slice(0, 8)}***`
       }
     });
-    return sessionId;
   }
-  function cleanupExpiredSessions() {
-    const now = Date.now();
-    for (const [openId, meta] of userSessions.entries()) {
-      if (now - meta.lastActivity > SESSION_TTL_MS) {
-        userSessions.delete(openId);
-      }
-    }
-  }
-  setInterval(cleanupExpiredSessions, 30 * 60 * 1000);
-  async function replyToFeishu(chatId, text) {
-    const MAX_LEN = 4000;
+  async send(replyTarget, text) {
     const chunks = [];
-    for (let i = 0;i < text.length; i += MAX_LEN) {
-      chunks.push(text.slice(i, i + MAX_LEN));
+    for (let i = 0;i < text.length; i += MAX_MSG_LEN) {
+      chunks.push(text.slice(i, i + MAX_MSG_LEN));
     }
     for (const chunk of chunks) {
-      await larkClient.im.message.create({
+      await this.larkClient.im.message.create({
         params: { receive_id_type: "chat_id" },
         data: {
-          receive_id: chatId,
+          receive_id: replyTarget,
           content: JSON.stringify({ text: chunk }),
           msg_type: "text"
         }
       });
     }
   }
-  async function sendThinking(chatId) {
-    await larkClient.im.message.create({
+  async sendThinking(chatId) {
+    await this.larkClient.im.message.create({
       params: { receive_id_type: "chat_id" },
       data: {
         receive_id: chatId,
@@ -119,15 +159,12 @@ var ChatChannelPlugin = async ({ client }) => {
       }
     });
   }
-  function extractResponseText(parts) {
-    if (!Array.isArray(parts))
-      return "";
-    return parts.filter((p) => p?.type === "text").map((p) => p?.text ?? "").join("").trim();
-  }
-  async function handleMessage(data) {
-    const { message, sender } = data;
+  parseEvent(data) {
+    const { message, sender } = data ?? {};
+    if (!message || !sender)
+      return null;
     if (message.message_type !== "text") {
-      await larkClient.im.message.create({
+      this.larkClient.im.message.create({
         params: { receive_id_type: "chat_id" },
         data: {
           receive_id: message.chat_id,
@@ -135,48 +172,142 @@ var ChatChannelPlugin = async ({ client }) => {
           msg_type: "text"
         }
       });
-      return;
+      return null;
     }
     const msgId = message.message_id;
-    if (processedMessages.has(msgId)) {
+    if (this.processedMessages.has(msgId))
+      return null;
+    if (this.processedMessages.size >= MAX_PROCESSED)
+      this.processedMessages.clear();
+    this.processedMessages.add(msgId);
+    let text;
+    try {
+      text = JSON.parse(message.content).text?.trim();
+    } catch {
+      return null;
+    }
+    if (!text)
+      return null;
+    return {
+      messageId: msgId,
+      userId: sender.sender_id?.open_id ?? message.chat_id,
+      replyTarget: message.chat_id,
+      text
+    };
+  }
+}
+var feishuChannelFactory = async (client) => {
+  const appId = process.env["FEISHU_APP_ID"];
+  const appSecret = readAppSecret();
+  if (!appId || !appSecret) {
+    const isMac = process.platform === "darwin";
+    const secretHint = isMac ? `macOS: security add-generic-password -a chat-channel -s opencode-chat-channel -w <secret> -U
+` + "       或在 .env 中添加 FEISHU_APP_SECRET=<secret>" : ".env 中添加 FEISHU_APP_SECRET=<secret>";
+    await client.app.log({
+      body: {
+        service: "chat-channel",
+        level: "warn",
+        message: !appId ? "[feishu] FEISHU_APP_ID 未设置，请在 .env 中添加 FEISHU_APP_ID=cli_xxx，飞书渠道已跳过" : `[feishu] FEISHU_APP_SECRET 未找到，飞书渠道已跳过。请配置：${secretHint}`
+      }
+    });
+    return null;
+  }
+  return new FeishuChannel(appId, appSecret, client);
+};
+
+// src/channels/wecom/index.ts
+class WeComChannel {
+  corpId;
+  agentId;
+  secret;
+  client;
+  name = "wecom";
+  constructor(corpId, agentId, secret, client) {
+    this.corpId = corpId;
+    this.agentId = agentId;
+    this.secret = secret;
+    this.client = client;
+  }
+  async start(onMessage) {
+    await this.client.app.log({
+      body: {
+        service: "chat-channel",
+        level: "warn",
+        message: "[wecom] 企业微信渠道尚未实现，已跳过。如需接入，请参考 src/channels/wecom/index.ts 中的 TODO。"
+      }
+    });
+  }
+  async send(replyTarget, text) {
+    throw new Error("[wecom] WeComChannel.send() 尚未实现");
+  }
+}
+var wecomChannelFactory = async (client) => {
+  const corpId = process.env["WECOM_CORP_ID"];
+  const agentId = process.env["WECOM_AGENT_ID"];
+  const secret = undefined;
+  if (!corpId || !agentId || !secret) {
+    if (corpId || agentId) {
       await client.app.log({
         body: {
           service: "chat-channel",
-          level: "info",
-          message: `重复消息已忽略: ${msgId}`
+          level: "warn",
+          message: "[wecom] 企业微信凭证不完整（需要 WECOM_CORP_ID、WECOM_AGENT_ID、WECOM_SECRET），渠道已跳过"
         }
       });
-      return;
     }
-    if (processedMessages.size >= MAX_PROCESSED)
-      processedMessages.clear();
-    processedMessages.add(msgId);
-    let userText;
-    try {
-      userText = JSON.parse(message.content).text?.trim();
-    } catch {
-      return;
+    return null;
+  }
+  return new WeComChannel(corpId, agentId, secret, client);
+};
+
+// src/index.ts
+var CHANNEL_REGISTRY = {
+  feishu: feishuChannelFactory,
+  wecom: wecomChannelFactory
+};
+function resolveEnabledChannels(client) {
+  const raw = process.env["CHAT_CHANNELS"]?.trim();
+  if (!raw)
+    return null;
+  const requested = raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  const known = Object.keys(CHANNEL_REGISTRY);
+  const enabled = [];
+  for (const name of requested) {
+    if (known.includes(name)) {
+      enabled.push(name);
+    } else {
+      client.app.log({
+        body: {
+          service: "chat-channel",
+          level: "warn",
+          message: `[config] 未知渠道名 "${name}"，已忽略。可用渠道：${known.join(", ")}`
+        }
+      });
     }
-    if (!userText)
-      return;
-    const openId = sender.sender_id?.open_id ?? message.chat_id;
-    const chatId = message.chat_id;
+  }
+  return enabled;
+}
+function createMessageHandler(channel, sessionManager, client) {
+  return async (msg) => {
+    const { userId, replyTarget, text } = msg;
     await client.app.log({
       body: {
         service: "chat-channel",
         level: "info",
-        message: `收到消息: "${userText.slice(0, 80)}${userText.length > 80 ? "..." : ""}"`,
-        extra: { openId, chatId }
+        message: `[${channel.name}] 收到消息: "${text.slice(0, 80)}${text.length > 80 ? "..." : ""}"`,
+        extra: { userId, replyTarget }
       }
     });
-    await sendThinking(chatId);
+    if ("sendThinking" in channel && typeof channel.sendThinking === "function") {
+      await channel.sendThinking(replyTarget);
+    }
     let responseText = null;
     try {
-      const sessionId = await getOrCreateSession(openId);
+      const sessionId = await sessionManager.getOrCreate(userId);
       const result = await client.session.prompt({
         path: { id: sessionId },
         body: {
-          parts: [{ type: "text", text: userText }],
+          parts: [{ type: "text", text }],
           model: {
             providerID: "Mify-Anthropic",
             modelID: "ppio/pa/claude-sonnet-4-6"
@@ -190,34 +321,60 @@ var ChatChannelPlugin = async ({ client }) => {
         body: {
           service: "chat-channel",
           level: "error",
-          message: `处理消息失败: ${errorMsg}`,
-          extra: { openId }
+          message: `[${channel.name}] 处理消息失败: ${errorMsg}`,
+          extra: { userId }
         }
       });
-      await replyToFeishu(chatId, `⚠️ 出错了：${errorMsg}`);
+      await channel.send(replyTarget, `⚠️ 出错了：${errorMsg}`);
       return;
     }
-    if (responseText) {
-      await replyToFeishu(chatId, responseText);
-    } else {
-      await replyToFeishu(chatId, "（AI 没有返回文字回复）");
-    }
+    await channel.send(replyTarget, responseText || "（AI 没有返回文字回复）");
+  };
+}
+var ChatChannelPlugin = async ({ client }) => {
+  const configDir = join(process.env["HOME"] ?? `/Users/${process.env["USER"] ?? "unknown"}`, ".config", "opencode");
+  loadDotEnv(join(configDir, ".env"));
+  const enabledNames = resolveEnabledChannels(client);
+  const factories = enabledNames ? enabledNames.map((name) => [name, CHANNEL_REGISTRY[name]]) : Object.entries(CHANNEL_REGISTRY);
+  if (enabledNames) {
+    await client.app.log({
+      body: {
+        service: "chat-channel",
+        level: "info",
+        message: `[config] CHAT_CHANNELS="${process.env["CHAT_CHANNELS"]}"，将启用: ${enabledNames.join(", ") || "（无）"}`
+      }
+    });
+  }
+  const channels = [];
+  for (const [, factory] of factories) {
+    const channel = await factory(client);
+    if (channel)
+      channels.push(channel);
+  }
+  if (channels.length === 0) {
+    const hint = enabledNames ? `检查 CHAT_CHANNELS="${process.env["CHAT_CHANNELS"]}" 指定的渠道是否已配置凭证` : "请在 .env 中配置至少一个渠道的凭证，或设置 CHAT_CHANNELS=<渠道名> 明确指定";
+    await client.app.log({
+      body: {
+        service: "chat-channel",
+        level: "warn",
+        message: `所有渠道均未就绪，插件空启动。${hint}`
+      }
+    });
+    return {};
+  }
+  const cleanupTimers = [];
+  for (const channel of channels) {
+    const sessionManager = new SessionManager(client, channel.name, (userId) => `${channel.name} 对话 · ${userId}`);
+    const timer = sessionManager.startAutoCleanup();
+    cleanupTimers.push(timer);
+    const handleMessage = createMessageHandler(channel, sessionManager, client);
+    await channel.start(handleMessage);
   }
-  const wsClient = new Lark.WSClient({
-    appId,
-    appSecret,
-    loggerLevel: Lark.LoggerLevel.warn
-  });
-  wsClient.start({
-    eventDispatcher: new Lark.EventDispatcher({}).register({
-      "im.message.receive_v1": handleMessage
-    })
-  });
   await client.app.log({
     body: {
       service: "chat-channel",
       level: "info",
-      message: `飞书机器人已启动（长连接模式），appId=${appId.slice(0, 8)}***`
+      message: `chat-channel 已启动，活跃渠道: ${channels.map((c) => c.name).join(", ")}`
     }
   });
   return {
@@ -237,6 +394,9 @@ var ChatChannelPlugin = async ({ client }) => {
 };
 var src_default = ChatChannelPlugin;
 export {
+  loadDotEnv,
+  extractResponseText,
   src_default as default,
+  SessionManager,
   ChatChannelPlugin
 };

package/dist/session-manager.d.ts

@@ -0,0 +1,36 @@
+/**
+ * opencode-chat-channel — SessionManager
+ *
+ * 管理"渠道用户 ID → opencode session"的映射。
+ * 与具体渠道无关，所有 channel 实现共享同一套逻辑。
+ */
+import type { PluginClient } from "./types.js";
+export declare class SessionManager {
+    private readonly client;
+    private readonly channel;
+    private readonly titleFn;
+    /**
+     * @param client   opencode plugin 客户端（用于创建 session 和日志）
+     * @param channel  渠道名称（用于日志标识）
+     * @param titleFn  生成 session 标题的函数（可选，默认使用 userId）
+     */
+    constructor(client: PluginClient, channel: string, titleFn?: (userId: string) => string);
+    private readonly sessions;
+    /** 获取已有的有效 session，或为该用户创建新 session。 */
+    getOrCreate(userId: string): Promise<string>;
+    /** 清理所有已过期的 session 记录。 */
+    cleanup(): void;
+    /** 启动定时清理（默认每 30 分钟）。返回 timer，供外部 clearInterval。 */
+    startAutoCleanup(intervalMs?: number): ReturnType<typeof setInterval>;
+}
+/**
+ * 从 AI 响应 parts 中提取纯文本。
+ * 与渠道无关，各 channel 实现均可复用。
+ */
+export declare function extractResponseText(parts: unknown[]): string;
+/**
+ * 从 ~/.config/opencode/.env 读取环境变量并注入 process.env。
+ * opencode 不会自动加载该文件，需插件自行调用。
+ */
+export declare function loadDotEnv(envPath: string): void;
+//# sourceMappingURL=session-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../src/session-manager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAgB/C,qBAAa,cAAc;IAOvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAR1B;;;;OAIG;gBAEgB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MACxB;IAGxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAE3D,wCAAwC;IAClC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA6BlD,2BAA2B;IAC3B,OAAO,IAAI,IAAI;IASf,oDAAoD;IACpD,gBAAgB,CAAC,UAAU,SAAiB,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC;CAG9E;AAID;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAO5D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAiBhD"}

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * opencode-chat-channel — 多渠道抽象层
+ *
+ * 每个渠道（飞书、企业微信等）实现 ChatChannel 接口即可接入。
+ */
+import type { Plugin } from "@opencode-ai/plugin";
+/** opencode Plugin 客户端类型（从 Plugin 回调参数中提取） */
+export type PluginClient = Parameters<Plugin>[0]["client"];
+/** 从渠道收到的标准化消息 */
+export interface IncomingMessage {
+    /** 消息唯一 ID（用于去重） */
+    messageId: string;
+    /** 用户唯一标识（用于 session 绑定，不同渠道格式不同） */
+    userId: string;
+    /** 回复目标 ID（群 ID / 用户 ID，由渠道决定具体含义） */
+    replyTarget: string;
+    /** 消息文本内容 */
+    text: string;
+}
+/**
+ * ChatChannel — 渠道适配器接口
+ *
+ * 每个渠道实现此接口：
+ *   - name: 渠道标识符（用于日志、配置 key）
+ *   - start(): 启动监听，收到消息时调用 onMessage 回调
+ *   - send(): 向指定 target 发送文本回复
+ *   - stop(): 优雅关闭（可选）
+ */
+export interface ChatChannel {
+    /** 渠道唯一名称，如 "feishu"、"wecom" */
+    readonly name: string;
+    /**
+     * 启动渠道监听。
+     * 每当收到用户消息时，调用 onMessage(msg)。
+     */
+    start(onMessage: (msg: IncomingMessage) => Promise<void>): Promise<void>;
+    /**
+     * 向指定目标发送文本消息。
+     * replyTarget 为 IncomingMessage.replyTarget。
+     */
+    send(replyTarget: string, text: string): Promise<void>;
+    /** 优雅停止渠道（可选）。 */
+    stop?(): Promise<void>;
+}
+/**
+ * ChannelFactory — 渠道工厂函数签名
+ *
+ * 工厂函数负责读取配置、验证凭证、构造并返回 ChatChannel 实例。
+ * 若凭证未配置，应返回 null（插件将跳过该渠道并记录日志）。
+ */
+export type ChannelFactory = (client: PluginClient) => Promise<ChatChannel | null>;
+/**
+ * 已注册的渠道名称。
+ * 新增渠道时在此处添加对应字面量，便于编译期检查。
+ */
+export type ChannelName = "feishu" | "wecom";
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,8CAA8C;AAC9C,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;AAI3D,kBAAkB;AAClB,MAAM,WAAW,eAAe;IAC9B,oBAAoB;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAID;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,KAAK,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzE;;;OAGG;IACH,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvD,kBAAkB;IAClB,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAID;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,CAC3B,MAAM,EAAE,YAAY,KACjB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;AAIjC;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,OAAO,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-chat-channel",
-  "version": "1.0.0",
-  "description": "opencode plugin — Feishu (Lark) bot channel via WebSocket long connection",
+  "version": "1.2.0",
+  "description": "opencode plugin — multi-channel bot (Feishu/Lark, WeCom) with extensible ChatChannel interface",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -29,8 +29,11 @@
     "opencode-plugin",
     "feishu",
     "lark",
+    "wecom",
+    "wechat",
     "bot",
-    "websocket"
+    "websocket",
+    "multi-channel"
   ],
   "author": "",
   "license": "MIT",