@dsh-overdrive/gateway 0.1.0

package/src/adapters/wecom.ts

@@ -0,0 +1,187 @@
+import { createHash, createDecipheriv, createCipheriv, randomBytes } from 'node:crypto';
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import type { Adapter, NormalizedMessage, OutboundButton, OutboundPayload } from '../adapter.js';
+
+// ── 纯函数：AES-256-CBC 加解密（企业微信协议）──────────────────
+
+export function deriveAesKey(encodingAESKey: string): Buffer {
+  return Buffer.from(encodingAESKey + '=', 'base64'); // 43 位 + '=' → 32 字节
+}
+
+export function pkcs7Unpad(buf: Buffer): Buffer {
+  const pad = buf[buf.length - 1];
+  if (pad < 1 || pad > 32) throw new Error('invalid pkcs7 padding');
+  return buf.subarray(0, buf.length - pad);
+}
+
+export function pkcs7Pad(buf: Buffer): Buffer {
+  const pad = 32 - (buf.length % 32);
+  return Buffer.concat([buf, Buffer.alloc(pad, pad)]);
+}
+
+export function decryptWeComPayload(encodingAESKey: string, encrypted: string): { message: string; receiveId: string } {
+  const key = deriveAesKey(encodingAESKey);
+  const iv = key.subarray(0, 16);
+  const decipher = createDecipheriv('aes-256-cbc', key, iv);
+  decipher.setAutoPadding(false);
+  const plain = Buffer.concat([decipher.update(Buffer.from(encrypted, 'base64')), decipher.final()]);
+  const unpadded = pkcs7Unpad(plain);
+  // 结构：random(16) + msgLen(4, big-endian) + msg + receiveId
+  const msgLen = unpadded.readUInt32BE(16);
+  const message = unpadded.subarray(20, 20 + msgLen).toString('utf8');
+  const receiveId = unpadded.subarray(20 + msgLen).toString('utf8');
+  return { message, receiveId };
+}
+
+export function encryptWeComPayload(encodingAESKey: string, message: string, receiveId: string): { encrypted: string } {
+  const key = deriveAesKey(encodingAESKey);
+  const iv = key.subarray(0, 16);
+  const msgBuf = Buffer.from(message, 'utf8');
+  const head = Buffer.alloc(20);
+  randomBytes(16).copy(head, 0);
+  head.writeUInt32BE(msgBuf.length, 16);
+  const plain = pkcs7Pad(Buffer.concat([head, msgBuf, Buffer.from(receiveId, 'utf8')]));
+  const cipher = createCipheriv('aes-256-cbc', key, iv);
+  cipher.setAutoPadding(false);
+  const encrypted = Buffer.concat([cipher.update(plain), cipher.final()]);
+  return { encrypted: encrypted.toString('base64') };
+}
+
+export function weComSignature(token: string, timestamp: string, nonce: string, encrypt: string): string {
+  const arr = [token, timestamp, nonce, encrypt].sort();
+  return createHash('sha1').update(arr.join('')).digest('hex');
+}
+
+// ── 纯函数：XML 消息解析 ─────────────────────────────────────
+
+export function parseWeComXmlMessage(xml: string): NormalizedMessage | null {
+  const get = (tag: string): string => {
+    const m = xml.match(new RegExp(`<${tag}><!\\[CDATA\\[([\\s\\S]*?)\\]\\]></${tag}>`));
+    return m ? m[1] : '';
+  };
+  const msgType = get('MsgType');
+  if (msgType !== 'text') return null;
+  const from = get('FromUserName');
+  const content = get('Content');
+  if (!from || !content) return null;
+  return { chatId: from, userId: from, text: content };
+}
+
+// ── 纯函数：审批编号回复 ─────────────────────────────────────
+
+export function buildNumberedText(text: string, buttons: OutboundButton[]): string {
+  if (buttons.length === 0) return text;
+  const options = buttons.map((b, i) => `${i + 1}) ${b.label}`).join('\n');
+  return `${text}\n\n${options}\n\n回复数字选择。`;
+}
+
+export function matchNumberedButton(text: string, buttons: OutboundButton[]): OutboundButton | undefined {
+  const n = Number(text.trim());
+  if (!Number.isInteger(n) || n < 1 || n > buttons.length) return undefined;
+  return buttons[n - 1];
+}
+
+// ── 适配器（自带回调 HTTP 服务器）────────────────────────────
+
+export interface WeComAdapterOptions {
+  corpId: string;
+  secret: string;
+  agentId: string;
+  token: string;
+  encodingAESKey: string;
+  callbackPort: number;
+}
+
+export class WeComAdapter implements Adapter {
+  readonly id = 'wecom';
+  private server?: ReturnType<typeof createServer>;
+  private connected = false;
+  private messageCb?: (msg: NormalizedMessage) => void;
+  private replyCb?: (buttonId: string) => void;
+  private readonly pendingButtons = new Map<string, OutboundButton[]>();
+
+  constructor(private readonly opts: WeComAdapterOptions) {}
+
+  async connect(): Promise<void> {
+    this.server = createServer((req, res) => void this.route(req, res));
+    await new Promise<void>((resolve) => this.server!.listen(this.opts.callbackPort, '0.0.0.0', () => resolve()));
+    this.connected = true;
+    console.log(`[wecom] 回调服务器已启动 http://0.0.0.0:${this.opts.callbackPort}（需公网可达并配置为企业微信回调 URL）`);
+  }
+
+  private async route(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    const url = new URL(req.url ?? '/', 'http://localhost');
+    const params = url.searchParams;
+    if (req.method === 'GET') {
+      // URL 验证：回显解密后的 echostr
+      const msgSignature = params.get('msg_signature') ?? '';
+      const timestamp = params.get('timestamp') ?? '';
+      const nonce = params.get('nonce') ?? '';
+      const echostr = params.get('echostr') ?? '';
+      const sign = weComSignature(this.opts.token, timestamp, nonce, echostr);
+      if (sign !== msgSignature) { res.writeHead(403); res.end('invalid signature'); return; }
+      const { message } = decryptWeComPayload(this.opts.encodingAESKey, echostr);
+      res.writeHead(200, { 'content-type': 'text/plain' });
+      res.end(message);
+      return;
+    }
+    if (req.method === 'POST') {
+      const raw = await readBody(req);
+      const msgSignature = params.get('msg_signature') ?? '';
+      const timestamp = params.get('timestamp') ?? '';
+      const nonce = params.get('nonce') ?? '';
+      const encrypt = (raw.match(/<Encrypt><!\[CDATA\[([\s\S]*?)\]\]><\/Encrypt>/) ?? [])[1] ?? '';
+      const sign = weComSignature(this.opts.token, timestamp, nonce, encrypt);
+      if (sign !== msgSignature) { res.writeHead(403); res.end('invalid signature'); return; }
+      const { message } = decryptWeComPayload(this.opts.encodingAESKey, encrypt);
+      const normalized = parseWeComXmlMessage(message);
+      res.writeHead(200, { 'content-type': 'text/plain' });
+      res.end('success'); // 先应答，避免企业微信重试
+      if (!normalized) return;
+      const pending = this.pendingButtons.get(normalized.chatId);
+      if (pending) {
+        const button = matchNumberedButton(normalized.text, pending);
+        if (button) {
+          this.pendingButtons.delete(normalized.chatId);
+          this.replyCb?.(button.id);
+          return;
+        }
+      }
+      this.messageCb?.(normalized);
+    }
+  }
+
+  async send(chatId: string, payload: OutboundPayload): Promise<void> {
+    if (payload.buttons?.length) this.pendingButtons.set(chatId, payload.buttons);
+    const text = buildNumberedText(payload.text, payload.buttons ?? []);
+    const token = await this.fetchAccessToken();
+    const res = await fetch(`https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=${encodeURIComponent(token)}`, {
+      method: 'POST',
+      body: JSON.stringify({
+        touser: chatId,
+        msgtype: 'text',
+        agentid: this.opts.agentId,
+        text: { content: text },
+      }),
+      headers: { 'content-type': 'application/json' },
+    }).then((r) => r.json() as Promise<{ errcode?: number; errmsg?: string }>);
+    if (res.errcode !== 0) throw new Error(`企业微信发送失败: ${res.errcode} ${res.errmsg}`);
+  }
+
+  private async fetchAccessToken(): Promise<string> {
+    const url = `https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=${encodeURIComponent(this.opts.corpId)}&corpsecret=${encodeURIComponent(this.opts.secret)}`;
+    const data = (await fetch(url).then((r) => r.json())) as { access_token?: string; errcode?: number };
+    if (!data.access_token) throw new Error(`企业微信 token 获取失败: ${data.errcode}`);
+    return data.access_token;
+  }
+
+  onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
+  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  status(): { connected: boolean } { return { connected: this.connected }; }
+}
+
+async function readBody(req: IncomingMessage): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) chunks.push(chunk as Buffer);
+  return Buffer.concat(chunks).toString('utf8');
+}

package/src/adapters/whatsapp.ts

@@ -0,0 +1,231 @@
+import makeWASocket, {
+  useMultiFileAuthState,
+  DisconnectReason,
+  generateWAMessageFromContent,
+  type WASocket,
+  type AnyMessageContent,
+} from '@whiskeysockets/baileys';
+import * as qrcode from 'qrcode-terminal';
+import pino from 'pino';
+import type { Adapter, NormalizedMessage, OutboundButton, OutboundPayload } from '../adapter.js';
+
+// ── 纯函数（可单测）────────────────────────────────────────────
+
+export interface RawWhatsAppMessage {
+  key?: { remoteJid?: string; participant?: string; fromMe?: boolean };
+  message?: {
+    conversation?: string;
+    extendedTextMessage?: { text?: string };
+    imageMessage?: { url?: string; directPath?: string; caption?: string; mimetype?: string };
+    audioMessage?: { url?: string; directPath?: string; mimetype?: string };
+    videoMessage?: { url?: string; directPath?: string; mimetype?: string; caption?: string };
+    documentMessage?: { url?: string; directPath?: string; mimetype?: string; fileName?: string };
+    interactiveResponseMessage?: { nativeFlowResponseMessage?: { paramsJson?: string } };
+  } & Record<string, unknown>;
+  messageType?: string;
+}
+
+export function extractWhatsAppText(raw: RawWhatsAppMessage): string | null {
+  const msg = raw.message;
+  if (!msg) return null;
+  if (typeof msg.conversation === 'string' && msg.conversation) return msg.conversation;
+  if (msg.extendedTextMessage && typeof msg.extendedTextMessage.text === 'string') return msg.extendedTextMessage.text;
+  return null;
+}
+
+/** 纯函数：imageMessage 的下载 URL（Baileys 已解析的 url 优先，退 directPath）；无图返回 undefined。 */
+export function whatsappImageUrl(raw: RawWhatsAppMessage): string | undefined {
+  const img = raw.message?.imageMessage;
+  return img?.url ?? img?.directPath ?? undefined;
+}
+
+function waMediaUrl(m: { url?: string; directPath?: string } | undefined): string | undefined {
+  return m?.url ?? m?.directPath ?? undefined;
+}
+
+/** 媒体消息 → media 引用（kind + url）：image/voice/video/file；无 url 视为无法透传，返回 undefined。 */
+function whatsappMedia(raw: RawWhatsAppMessage): NormalizedMessage['media'] {
+  const msg = raw.message;
+  if (!msg) return undefined;
+  if (msg.imageMessage) {
+    const url = whatsappImageUrl(raw);
+    return url ? { kind: 'image', url } : undefined;
+  }
+  if (msg.audioMessage) {
+    const url = waMediaUrl(msg.audioMessage);
+    return url ? { kind: 'voice', url } : undefined;
+  }
+  if (msg.videoMessage) {
+    const url = waMediaUrl(msg.videoMessage);
+    return url ? { kind: 'video', url } : undefined;
+  }
+  if (msg.documentMessage) {
+    const url = waMediaUrl(msg.documentMessage);
+    return url ? { kind: 'file', url } : undefined;
+  }
+  return undefined;
+}
+
+export function normalizeWhatsAppMessage(raw: RawWhatsAppMessage):
+  | { kind: 'message'; msg: NormalizedMessage }
+  | null {
+  if (raw.key?.fromMe) return null;
+  const media = whatsappMedia(raw);
+  const text = extractWhatsAppText(raw) ?? raw.message?.imageMessage?.caption ?? '';
+  if (!text && !media) return null;
+  const remoteJid = raw.key?.remoteJid;
+  if (!remoteJid) return null;
+  const userId = raw.key?.participant ?? remoteJid;
+  const msg: NormalizedMessage = { chatId: remoteJid, userId, text };
+  if (media) msg.media = media;
+  return { kind: 'message', msg };
+}
+
+export function buildNumberedReply(text: string, buttons: OutboundButton[]): string {
+  const options = buttons.map((b, i) => `${i + 1}) ${b.label}`).join('\n');
+  return `${text}\n\n${options}\n\n回复数字选择。`;
+}
+
+export function matchNumberedReply(text: string, buttons: OutboundButton[]): OutboundButton | undefined {
+  const n = Number(text.trim());
+  if (!Number.isInteger(n) || n < 1 || n > buttons.length) return undefined;
+  return buttons[n - 1];
+}
+
+export interface NativeFlowButton {
+  name: string;
+  buttonParamsJson: string;
+}
+
+/** WhatsApp 原生交互按钮：nativeFlowMessage.buttons 数组（{ name: 'quick_reply', buttonParamsJson: JSON({id, display_text}) }）。 */
+export function buildNativeFlowButtons(buttons: OutboundButton[]): NativeFlowButton[] {
+  return buttons.map((b) => ({
+    name: 'quick_reply',
+    buttonParamsJson: JSON.stringify({ id: b.id, display_text: b.label }),
+  }));
+}
+
+/** 解析原生按钮响应：interactiveResponseMessage.nativeFlowResponseMessage.paramsJson 中的 id；非交互/非法 JSON/缺 id 返回 null。 */
+export function parseNativeButtonResponse(raw: RawWhatsAppMessage): string | null {
+  const params = raw.message?.interactiveResponseMessage?.nativeFlowResponseMessage?.paramsJson;
+  if (!params) return null;
+  try {
+    const parsed = JSON.parse(params) as { id?: string };
+    return parsed.id ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// ── 适配器（真实连接，薄层）────────────────────────────────────
+
+export interface WhatsAppAdapterOptions {
+  authDir: string;
+}
+
+export class WhatsAppAdapter implements Adapter {
+  readonly id = 'whatsapp';
+  private sock?: WASocket;
+  private connected = false;
+  private messageCb?: (msg: NormalizedMessage) => void;
+  private replyCb?: (buttonId: string) => void;
+  /** chatId → 当前 pending 按钮（编号回复 → 按钮 id） */
+  private readonly pendingButtons = new Map<string, OutboundButton[]>();
+
+  constructor(private readonly opts: WhatsAppAdapterOptions) {}
+
+  async connect(): Promise<void> {
+    const { state, saveCreds } = await useMultiFileAuthState(this.opts.authDir);
+    const sock = makeWASocket({
+      auth: state,
+      printQRInTerminal: false,
+      logger: pino({ level: 'silent' }),
+      browser: ['dsh-overdrive', 'Chrome', '120.0.0.0'],
+    });
+    this.sock = sock;
+
+    sock.ev.on('creds.update', saveCreds);
+    sock.ev.on('connection.update', (update) => {
+      if (update.qr) {
+        qrcode.generate(update.qr, { small: true });
+        console.log('[whatsapp] 请用 WhatsApp 扫上方二维码完成配对（重启应用可重新生成）');
+      }
+      if (update.connection === 'open') {
+        this.connected = true;
+        console.log('[whatsapp] 已连接 WhatsApp');
+      }
+      if (update.connection === 'close') {
+        this.connected = false;
+        const status = (update.lastDisconnect?.error as { output?: { statusCode?: number } } | undefined)?.output?.statusCode;
+        if (status === DisconnectReason.loggedOut) {
+          console.error('[whatsapp] 已登出：删除 data/whatsapp 目录后重启可重新扫码');
+          return;
+        }
+        console.warn('[whatsapp] 连接断开，3s 后重连…');
+        setTimeout(() => void this.connect().catch((e) => console.error('[whatsapp] 重连失败:', e)), 3000);
+      }
+    });
+
+    sock.ev.on('messages.upsert', ({ messages }) => {
+      for (const raw of messages) {
+        const waRaw = raw as RawWhatsAppMessage;
+        // 原生交互按钮响应：interactiveResponseMessage → 按钮 id（优先于编号回复兜底）
+        const buttonId = parseNativeButtonResponse(waRaw);
+        if (buttonId) {
+          const chatId = waRaw.key?.remoteJid;
+          if (chatId) this.pendingButtons.delete(chatId);
+          this.replyCb?.(buttonId);
+          continue;
+        }
+        const normalized = normalizeWhatsAppMessage(waRaw);
+        if (!normalized) continue;
+        // 编号回复兜底：若该 chat 有 pending 按钮且消息是数字，转成按钮点击
+        const pending = this.pendingButtons.get(normalized.msg.chatId);
+        if (pending) {
+          const button = matchNumberedReply(normalized.msg.text, pending);
+          if (button) {
+            this.pendingButtons.delete(normalized.msg.chatId);
+            this.replyCb?.(button.id);
+            continue;
+          }
+        }
+        this.messageCb?.(normalized.msg);
+      }
+    });
+  }
+
+  async send(chatId: string, payload: OutboundPayload): Promise<void> {
+    if (!this.sock) return;
+    if (payload.buttons?.length) {
+      this.pendingButtons.set(chatId, payload.buttons);
+      // 原生交互按钮优先：Baileys 6.x 的 AnyMessageContent 无 interactive 键，
+      // 以 proto.IMessage（interactiveMessage.nativeFlowMessage）+ relayMessage 发送。
+      const userJid = this.sock.user?.id;
+      if (userJid) {
+        const waMsg = generateWAMessageFromContent(
+          chatId,
+          {
+            interactiveMessage: {
+              body: { text: payload.text },
+              nativeFlowMessage: { buttons: buildNativeFlowButtons(payload.buttons) },
+            },
+          },
+          { userJid },
+        );
+        if (waMsg.message) {
+          await this.sock.relayMessage(chatId, waMsg.message, { messageId: waMsg.key.id ?? undefined });
+          return;
+        }
+      }
+      // 兜底：连接未就绪（无 userJid）或生成失败时退回编号文本方案
+      const text = buildNumberedReply(payload.text, payload.buttons);
+      await this.sock.sendMessage(chatId, { text } satisfies AnyMessageContent);
+      return;
+    }
+    await this.sock.sendMessage(chatId, { text: payload.text } satisfies AnyMessageContent);
+  }
+
+  onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
+  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  status(): { connected: boolean } { return { connected: this.connected }; }
+}

package/src/commands.ts

@@ -0,0 +1,32 @@
+export type ParsedCommand =
+  | { kind: 'trace' }
+  | { kind: 'new' }
+  | { kind: 'agents' }
+  | { kind: 'help' }
+  | { kind: 'task'; prompt: string }
+  | { kind: 'cron'; schedule: string; prompt: string };
+
+// cron 语法：/cron <分 时 日 月 周> <需求>（schedule 为 5 个空白分隔字段）
+const CRON_RE = /^\/cron\s+(\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(.+)$/;
+
+export function parseCommand(text: string): ParsedCommand | null {
+  const trimmed = text.trim();
+  if (trimmed === '/trace') return { kind: 'trace' };
+  if (trimmed === '/new') return { kind: 'new' };
+  if (trimmed === '/agents') return { kind: 'agents' };
+  if (trimmed === '/help') return { kind: 'help' };
+  const task = trimmed.match(/^\/task\s+(.+)$/);
+  if (task) return { kind: 'task', prompt: task[1] };
+  const cron = trimmed.match(CRON_RE);
+  if (cron) return { kind: 'cron', schedule: cron[1], prompt: cron[2] };
+  return null;
+}
+
+export const HELP_TEXT = [
+  '/help — 帮助',
+  '/trace — 查看最近一轮轨迹',
+  '/task <需求> — 派子任务',
+  '/cron <分 时 日 月 周> <需求> — 定时任务',
+  '/agents — 查看子任务状态',
+  '/new — 重置会话',
+].join('\n');

package/src/config.ts

@@ -0,0 +1,90 @@
+import type { Adapter } from './adapter.js';
+import { CliAdapter } from './adapters/cli.js';
+import { WhatsAppAdapter } from './adapters/whatsapp.js';
+import { TelegramAdapter } from './adapters/telegram.js';
+import { DiscordAdapter } from './adapters/discord.js';
+import { SlackAdapter } from './adapters/slack.js';
+import { FeishuAdapter } from './adapters/feishu.js';
+import { DingTalkAdapter } from './adapters/dingtalk.js';
+import { WeComAdapter } from './adapters/wecom.js';
+
+/** 平台适配器需要的全部环境变量（缺省为 undefined = 不启用该平台）。 */
+export interface AdapterEnv {
+  whatsappDataDir?: string;
+  telegramBotToken?: string;
+  discordBotToken?: string;
+  slackBotToken?: string;
+  slackAppToken?: string;
+  feishuAppId?: string;
+  feishuAppSecret?: string;
+  dingtalkClientId?: string;
+  dingtalkClientSecret?: string;
+  wecomCorpId?: string;
+  wecomSecret?: string;
+  wecomAgentId?: string;
+  wecomToken?: string;
+  wecomEncodingAESKey?: string;
+  wecomCallbackPort?: string;
+}
+
+export function parseAdapterIds(raw: string): string[] {
+  const ids = raw.split(',').map((s) => s.trim()).filter(Boolean);
+  return ids.length > 0 ? ids : ['cli'];
+}
+
+/** 按 id 创建适配器实例；依赖注入 env 便于测试。 */
+export function createAdapter(id: string, env: AdapterEnv): Adapter {
+  switch (id) {
+    case 'cli':
+      return new CliAdapter();
+    case 'whatsapp':
+      return new WhatsAppAdapter({ authDir: env.whatsappDataDir ?? 'data/whatsapp' });
+    case 'telegram':
+      if (!env.telegramBotToken) throw new Error('telegram 适配器需要 TELEGRAM_BOT_TOKEN');
+      return new TelegramAdapter({ token: env.telegramBotToken });
+    case 'discord':
+      if (!env.discordBotToken) throw new Error('discord 适配器需要 DISCORD_BOT_TOKEN');
+      return new DiscordAdapter({ token: env.discordBotToken });
+    case 'slack':
+      if (!env.slackBotToken || !env.slackAppToken) throw new Error('slack 适配器需要 SLACK_BOT_TOKEN 与 SLACK_APP_TOKEN');
+      return new SlackAdapter({ botToken: env.slackBotToken, appToken: env.slackAppToken });
+    case 'feishu':
+      if (!env.feishuAppId || !env.feishuAppSecret) throw new Error('feishu 适配器需要 FEISHU_APP_ID / FEISHU_APP_SECRET');
+      return new FeishuAdapter({ appId: env.feishuAppId, appSecret: env.feishuAppSecret });
+    case 'dingtalk':
+      if (!env.dingtalkClientId || !env.dingtalkClientSecret) throw new Error('dingtalk 适配器需要 DINGTALK_CLIENT_ID / DINGTALK_CLIENT_SECRET');
+      return new DingTalkAdapter({ clientId: env.dingtalkClientId, clientSecret: env.dingtalkClientSecret });
+    case 'wecom':
+      if (!env.wecomCorpId || !env.wecomSecret || !env.wecomAgentId || !env.wecomToken || !env.wecomEncodingAESKey) {
+        throw new Error('wecom 适配器需要 WECOM_CORP_ID / WECOM_SECRET / WECOM_AGENT_ID / WECOM_TOKEN / WECOM_ENCODING_AES_KEY');
+      }
+      return new WeComAdapter({
+        corpId: env.wecomCorpId, secret: env.wecomSecret, agentId: env.wecomAgentId,
+        token: env.wecomToken, encodingAESKey: env.wecomEncodingAESKey,
+        callbackPort: Number(env.wecomCallbackPort ?? 3193),
+      });
+    default:
+      throw new Error(`unknown adapter: ${id}`);
+  }
+}
+
+/** 从 process.env 读适配器配置。 */
+export function adapterEnvFromProcess(env: NodeJS.ProcessEnv = process.env): AdapterEnv {
+  return {
+    whatsappDataDir: env.WHATSAPP_DATA_DIR,
+    telegramBotToken: env.TELEGRAM_BOT_TOKEN,
+    discordBotToken: env.DISCORD_BOT_TOKEN,
+    slackBotToken: env.SLACK_BOT_TOKEN,
+    slackAppToken: env.SLACK_APP_TOKEN,
+    feishuAppId: env.FEISHU_APP_ID,
+    feishuAppSecret: env.FEISHU_APP_SECRET,
+    dingtalkClientId: env.DINGTALK_CLIENT_ID,
+    dingtalkClientSecret: env.DINGTALK_CLIENT_SECRET,
+    wecomCorpId: env.WECOM_CORP_ID,
+    wecomSecret: env.WECOM_SECRET,
+    wecomAgentId: env.WECOM_AGENT_ID,
+    wecomToken: env.WECOM_TOKEN,
+    wecomEncodingAESKey: env.WECOM_ENCODING_AES_KEY,
+    wecomCallbackPort: env.WECOM_CALLBACK_PORT,
+  };
+}