@dsh-overdrive/gateway 0.1.4 → 0.1.6

package/src/adapter.ts

@@ -12,6 +12,12 @@ export interface OutboundPayload {
   buttons?: OutboundButton[];
 }
 
+/** 按钮回执的点击者身份（用于白名单校验）。chatId 在个别平台回调中可能缺失，缺失时按未授权处理（fail-closed）。 */
+export interface ReplySender {
+  chatId: string;
+  userId: string;
+}
+
 /** 平台适配器契约：M2/M3 的 WhatsApp/Telegram/… 都实现它。 */
 export interface Adapter {
   readonly id: string;
@@ -22,5 +28,6 @@ export interface Adapter {
   /** 可选：连接状态（供控制台）。 */
   status?(): { connected: boolean };
   onMessage(cb: (msg: NormalizedMessage) => void): void;
-  onReply(cb: (buttonId: string) => void): void;
+  /** 按钮点击回执：buttonId + 点击者身份。身份缺失即传空字符串，由上层按未授权处理。 */
+  onReply(cb: (buttonId: string, sender: ReplySender) => void): void;
 }

package/src/adapters/cli.ts

@@ -5,7 +5,7 @@ import type { Adapter, NormalizedMessage, OutboundPayload } from '../adapter.js'
 export class CliAdapter implements Adapter {
   readonly id = 'cli';
   private messageCb?: (msg: NormalizedMessage) => void;
-  private replyCb?: (buttonId: string) => void;
+  private replyCb?: (buttonId: string, sender: { chatId: string; userId: string }) => void;
   private rl?: ReturnType<typeof createInterface>;
 
   async connect(): Promise<void> {
@@ -15,7 +15,7 @@ export class CliAdapter implements Adapter {
       if (!trimmed) return;
       const btn = trimmed.match(/^\/btn\s+(\S+)$/i);
       if (btn) {
-        this.replyCb?.(btn[1]);
+        this.replyCb?.(btn[1], { chatId: 'cli', userId: 'local' });
         return;
       }
       this.messageCb?.({ chatId: 'cli', userId: 'local', text: trimmed });
@@ -31,7 +31,7 @@ export class CliAdapter implements Adapter {
   }
 
   onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
-  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  onReply(cb: (buttonId: string, sender: { chatId: string; userId: string }) => void): void { this.replyCb = cb; }
   /** CLI 是本地进程内适配器：恒为已连接。 */
   status(): { connected: boolean } { return { connected: true }; }
 }

package/src/adapters/dingtalk.ts

@@ -70,31 +70,46 @@ export function buildActionCard(text: string, buttons: OutboundButton[]): {
   };
 }
 
+export interface CardCallbackResult {
+  buttonId: string;
+  chatId?: string;
+  userId?: string;
+}
+
 /**
- * 钉钉卡片回调载荷 → 按钮 id（"approve:<reqId>"）。
- * Stream 模式下回调 JSON 的字段名（cardCallbackData / params / cardActionData）在不同卡片版本有差异，
- * 这里做多路径深度兜底解析；真机验证后可按实际字段收敛。找不到返回 null。
+ * 钉钉卡片回调载荷 → { buttonId, chatId?, userId? }。
+ * Stream 模式下回调 JSON 的字段名（cardCallbackData / params / cardActionData，以及会话/用户字段）
+ * 在不同卡片版本有差异，这里做多路径深度兜底解析；真机验证后可按实际字段收敛。找不到返回 null。
  */
-export function parseCardCallback(raw: unknown): string | null {
-  const visit = (obj: unknown, depth: number): string | null => {
-    if (depth > 5 || !obj || typeof obj !== 'object') return null;
+export function parseCardCallback(raw: unknown): CardCallbackResult | null {
+  let buttonId: string | null = null;
+  let chatId: string | undefined;
+  let userId: string | undefined;
+
+  const visit = (obj: unknown, depth: number): void => {
+    if (depth > 5 || !obj || typeof obj !== 'object') return;
     for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-      if (typeof value === 'string' && (key === 'cardCallbackData' || key === 'params' || key === 'cardActionData')) {
+      if (!buttonId && typeof value === 'string' && (key === 'cardCallbackData' || key === 'params' || key === 'cardActionData')) {
         try {
           const parsed = JSON.parse(value) as { action?: string; reqId?: string };
           if ((parsed.action === 'approve' || parsed.action === 'reject') && typeof parsed.reqId === 'string' && parsed.reqId) {
-            return `${parsed.action}:${parsed.reqId}`;
+            buttonId = `${parsed.action}:${parsed.reqId}`;
           }
         } catch {
           /* 该字段不是 JSON 载荷，继续往下找 */
         }
       }
-      const found = visit(value, depth + 1);
-      if (found) return found;
+      if (!chatId && typeof value === 'string' && (key === 'conversationId' || key === 'conversation_id') && value) {
+        chatId = value;
+      }
+      if (!userId && typeof value === 'string' && (key === 'senderStaffId' || key === 'senderId' || key === 'userid' || key === 'userId') && value) {
+        userId = value;
+      }
+      if (typeof value === 'object') visit(value, depth + 1);
     }
-    return null;
   };
-  return visit(raw, 0);
+  visit(raw, 0);
+  return buttonId ? { buttonId, chatId, userId } : null;
 }
 
 // ── 适配器 ────────────────────────────────────────────────────
@@ -109,7 +124,7 @@ export class DingTalkAdapter implements Adapter {
   private client?: DWClient;
   private connected = false;
   private messageCb?: (msg: NormalizedMessage) => void;
-  private replyCb?: (buttonId: string) => void;
+  private replyCb?: (buttonId: string, sender: { chatId: string; userId: string }) => void;
   private readonly pendingButtons = new PendingButtons();
   /** conversationId → 最近的 sessionWebhook（回复通道，过期由钉钉侧管理） */
   private readonly webhooks = new Map<string, string>();
@@ -131,7 +146,7 @@ export class DingTalkAdapter implements Adapter {
       this.webhooks.set(parsed.chatId, parsed.sessionWebhook);
       const button = this.pendingButtons.match(parsed.chatId, parsed.text);
       if (button) {
-        this.replyCb?.(button.id);
+        this.replyCb?.(button.id, { chatId: parsed.chatId, userId: parsed.userId });
         return;
       }
       this.messageCb?.({ chatId: parsed.chatId, userId: parsed.userId, text: parsed.text });
@@ -144,8 +159,13 @@ export class DingTalkAdapter implements Adapter {
       } catch {
         return;
       }
-      const buttonId = parseCardCallback(data);
-      if (buttonId) this.replyCb?.(buttonId);
+      const result = parseCardCallback(data);
+      if (result) {
+        this.replyCb?.(result.buttonId, {
+          chatId: result.chatId ?? result.userId ?? '',
+          userId: result.userId ?? '',
+        });
+      }
     });
     await client.connect();
     this.connected = true;
@@ -181,6 +201,6 @@ export class DingTalkAdapter implements Adapter {
   }
 
   onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
-  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  onReply(cb: (buttonId: string, sender: { chatId: string; userId: string }) => void): void { this.replyCb = cb; }
   status(): { connected: boolean } { return { connected: this.connected }; }
 }

package/src/adapters/discord.ts

@@ -64,7 +64,7 @@ export class DiscordAdapter implements Adapter {
   private readonly client: Client;
   private connected = false;
   private messageCb?: (msg: NormalizedMessage) => void;
-  private replyCb?: (buttonId: string) => void;
+  private replyCb?: (buttonId: string, sender: { chatId: string; userId: string }) => void;
 
   constructor(opts: DiscordAdapterOptions) {
     this.client = new Client({
@@ -89,7 +89,10 @@ export class DiscordAdapter implements Adapter {
       if (!interaction.isButton()) return;
       const button = interaction as ButtonInteraction;
       await button.deferUpdate().catch(() => undefined);
-      this.replyCb?.(button.customId);
+      this.replyCb?.(button.customId, {
+        chatId: button.channelId,
+        userId: button.user.id,
+      });
     });
   }
 
@@ -112,6 +115,6 @@ export class DiscordAdapter implements Adapter {
   }
 
   onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
-  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  onReply(cb: (buttonId: string, sender: { chatId: string; userId: string }) => void): void { this.replyCb = cb; }
   status(): { connected: boolean } { return { connected: this.connected }; }
 }

package/src/adapters/feishu.ts

@@ -96,7 +96,7 @@ export class FeishuAdapter implements Adapter {
   private ws?: InstanceType<typeof WSClient>;
   private connected = false;
   private messageCb?: (msg: NormalizedMessage) => void;
-  private replyCb?: (buttonId: string) => void;
+  private replyCb?: (buttonId: string, sender: { chatId: string; userId: string }) => void;
   private readonly pendingButtons = new PendingButtons();
   /** chatId → 最近一条入站消息的 message_id（send 优先 reply，缺失则 create 兜底） */
   private readonly lastMessageIds = new Map<string, string>();
@@ -117,15 +117,26 @@ export class FeishuAdapter implements Adapter {
         const chatId = normalized.chatId;
         const button = this.pendingButtons.match(chatId, normalized.text);
         if (button) {
-          this.replyCb?.(button.id);
+          this.replyCb?.(button.id, { chatId, userId: normalized.userId });
           return;
         }
         this.messageCb?.(normalized);
       },
       // 原生交互卡片按钮回调 → 审批应答（Roadmap v0.2）
-      'card.action.trigger': async (data: { action?: { value?: unknown } }) => {
+      // 载荷字段（operator.open_id / context.open_chat_id）取自官方卡片回调事件；
+      // 个别版本字段名可能不同 —— 拿不到身份时上层按未授权处理（fail-closed），编号回复兜底不受影响。
+      'card.action.trigger': async (data: {
+        action?: { value?: unknown };
+        operator?: { open_id?: string };
+        context?: { open_chat_id?: string };
+      }) => {
         const buttonId = cardActionToButtonId(data?.action?.value);
-        if (buttonId) this.replyCb?.(buttonId);
+        if (buttonId) {
+          this.replyCb?.(buttonId, {
+            chatId: data?.context?.open_chat_id ?? '',
+            userId: data?.operator?.open_id ?? '',
+          });
+        }
       },
     });
     this.ws = new WSClient({
@@ -175,6 +186,6 @@ export class FeishuAdapter implements Adapter {
   }
 
   onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
-  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  onReply(cb: (buttonId: string, sender: { chatId: string; userId: string }) => void): void { this.replyCb = cb; }
   status(): { connected: boolean } { return { connected: this.connected }; }
 }

package/src/adapters/slack.ts

@@ -69,7 +69,7 @@ export class SlackAdapter implements Adapter {
   private readonly app: InstanceType<typeof App>;
   private connected = false;
   private messageCb?: (msg: NormalizedMessage) => void;
-  private replyCb?: (buttonId: string) => void;
+  private replyCb?: (buttonId: string, sender: { chatId: string; userId: string }) => void;
 
   constructor(opts: SlackAdapterOptions) {
     this.app = new App({ token: opts.botToken, appToken: opts.appToken, socketMode: true });
@@ -82,8 +82,18 @@ export class SlackAdapter implements Adapter {
     });
     this.app.action(/^approve:|^reject:/, async ({ ack, body, respond }) => {
       await ack();
-      const action = (body as { actions?: Array<{ value?: string }> }).actions?.[0];
-      if (action?.value) this.replyCb?.(action.value);
+      const b = body as {
+        actions?: Array<{ value?: string }>;
+        user?: { id?: string };
+        channel?: { id?: string };
+      };
+      const action = b.actions?.[0];
+      if (action?.value) {
+        this.replyCb?.(action.value, {
+          chatId: b.channel?.id ?? '',
+          userId: b.user?.id ?? '',
+        });
+      }
       await respond({ text: '处理中…', replace_original: false }).catch(() => undefined);
     });
     await this.app.start(0); // Socket Mode 不需要端口；start(0) 仅建立连接
@@ -100,6 +110,6 @@ export class SlackAdapter implements Adapter {
   }
 
   onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
-  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  onReply(cb: (buttonId: string, sender: { chatId: string; userId: string }) => void): void { this.replyCb = cb; }
   status(): { connected: boolean } { return { connected: this.connected }; }
 }

package/src/adapters/telegram.ts

@@ -69,7 +69,7 @@ export class TelegramAdapter implements Adapter {
   private readonly token: string;
   private connected = false;
   private messageCb?: (msg: NormalizedMessage) => void;
-  private replyCb?: (buttonId: string) => void;
+  private replyCb?: (buttonId: string, sender: { chatId: string; userId: string }) => void;
 
   constructor(opts: TelegramAdapterOptions) {
     this.token = opts.token;
@@ -86,7 +86,11 @@ export class TelegramAdapter implements Adapter {
     this.bot.on('callback_query:data', async (ctx) => {
       const data = ctx.callbackQuery.data;
       await ctx.answerCallbackQuery().catch(() => undefined);
-      this.replyCb?.(data);
+      const chat = ctx.callbackQuery.message?.chat as { id?: number | string } | undefined;
+      this.replyCb?.(data, {
+        chatId: String(chat?.id ?? ''),
+        userId: String(ctx.callbackQuery.from.id),
+      });
     });
     this.bot.catch((err) => console.error('[telegram]', err));
     void this.bot.start(); // 长轮询（自托管无需 webhook）
@@ -124,6 +128,6 @@ export class TelegramAdapter implements Adapter {
   }
 
   onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
-  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  onReply(cb: (buttonId: string, sender: { chatId: string; userId: string }) => void): void { this.replyCb = cb; }
   status(): { connected: boolean } { return { connected: this.connected }; }
 }

package/src/adapters/wechat.ts

@@ -0,0 +1,247 @@
+// v0.2b 实验性：个人微信适配器（腾讯官方 iLink / ClawBot 协议，HTTP/JSON）。
+// 协议形状与 DSH 生态已验证实现（super-wechat-bridge）一致：
+//   - 登录：GET /ilink/bot/get_bot_qrcode?bot_type=3 → GET /ilink/bot/get_qrcode_status?qrcode=
+//   - 收：POST /ilink/bot/getupdates（长轮询，响应 data.msgs + get_updates_buf 同步游标）
+//   - 发：POST /ilink/bot/sendmessage（msg 包裹 + item_list[].text_item，必须带 base_info.channel_version）
+// 使用 iLink 需遵守《微信 ClawBot 功能使用条款》；本适配器标记为实验性，需真实设备验证。
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import * as qrcode from 'qrcode-terminal';
+import type { Adapter, NormalizedMessage, OutboundButton, OutboundPayload } from '../adapter.js';
+import { PendingButtons } from '../pending-buttons.js';
+
+const DEFAULT_BASE = 'https://ilinkai.weixin.qq.com';
+const CHANNEL_VERSION = '1.0.2';
+const TEXT_CHUNK_LIMIT = 800;
+
+// ── 纯函数（可单测）───────────────────────────────────────────
+
+export interface WeChatIncomingMsg {
+  from_user_id?: string;
+  context_token?: string;
+  text_item?: { text?: string };
+  item_list?: Array<{ type?: number; text_item?: { text?: string } }>;
+}
+
+/** 纯函数：从 iLink 消息提取文本（text_item 或 item_list[].text_item，type===1 为文本）。 */
+export function extractWeChatText(msg: WeChatIncomingMsg): string | null {
+  if (msg.text_item?.text) return msg.text_item.text;
+  for (const item of msg.item_list ?? []) {
+    if (item.type === 1 && item.text_item?.text) return item.text_item.text;
+  }
+  return null;
+}
+
+/** 纯函数：iLink 入站消息 → NormalizedMessage；非文本/缺发送者返回 null。 */
+export function parseWeChatUpdate(msg: WeChatIncomingMsg): NormalizedMessage | null {
+  const userId = msg.from_user_id;
+  const text = extractWeChatText(msg);
+  if (!userId || !text) return null;
+  return { chatId: userId, userId, text };
+}
+
+/** 纯函数：getupdates 长轮询请求体。base_info.channel_version 缺失时服务器不投递（生态实测）。 */
+export function buildGetUpdatesBody(syncBuf: string): Record<string, unknown> {
+  return { get_updates_buf: syncBuf, longpolling_timeout: 35000, base_info: { channel_version: CHANNEL_VERSION } };
+}
+
+/** 纯函数：sendmessage 请求体（msg 包裹 + text_item）。clientId 可注入以便测试。 */
+export function buildSendMessageBody(
+  toUserId: string,
+  text: string,
+  contextToken: string,
+  clientId = `dsh-${randomUUID()}`,
+): Record<string, unknown> {
+  return {
+    msg: {
+      from_user_id: '',
+      to_user_id: toUserId,
+      client_id: clientId,
+      message_type: 2,
+      message_state: 2,
+      context_token: contextToken,
+      item_list: [{ type: 1, text_item: { text } }],
+    },
+    base_info: { channel_version: CHANNEL_VERSION },
+  };
+}
+
+/** 纯函数：长文本按上限分段（iLink 单条消息长度限制）。 */
+export function chunkText(text: string, limit = TEXT_CHUNK_LIMIT): string[] {
+  const chunks: string[] = [];
+  for (let i = 0; i < text.length; i += limit) chunks.push(text.slice(i, i + limit));
+  return chunks;
+}
+
+/** 纯函数：审批按钮 → 编号回复文本（原生按钮不支持时的兜底）。 */
+export function buildNumberedReplyText(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 interface WeChatAdapterOptions {
+  /** iLink api-token（扫码登录后自动保存；也可预先配置 WECHAT_TOKEN） */
+  token?: string;
+  baseUrl?: string;
+  stateDir?: string;
+}
+
+export class WeChatAdapter implements Adapter {
+  readonly id = 'wechat';
+  private messageCb?: (msg: NormalizedMessage) => void;
+  private replyCb?: (buttonId: string, sender: { chatId: string; userId: string }) => void;
+  private readonly pendingButtons = new PendingButtons();
+  private readonly stateDir: string;
+  private token: string;
+  private syncBuf = '';
+  private readonly contextTokens = new Map<string, string>();
+  private polling = false;
+  private stopped = false;
+
+  constructor(private readonly opts: WeChatAdapterOptions) {
+    this.stateDir = opts.stateDir ?? 'data/wechat';
+    this.token = opts.token ?? '';
+    // 恢复持久化状态：token / sync 游标 / 上下文 token（回话关联必需）
+    try {
+      if (existsSync(join(this.stateDir, 'token.txt'))) this.token = this.token || readFileSync(join(this.stateDir, 'token.txt'), 'utf8').trim();
+      if (existsSync(join(this.stateDir, 'sync_buf.txt'))) this.syncBuf = readFileSync(join(this.stateDir, 'sync_buf.txt'), 'utf8').trim();
+      if (existsSync(join(this.stateDir, 'context_tokens.json'))) {
+        const tokens = JSON.parse(readFileSync(join(this.stateDir, 'context_tokens.json'), 'utf8')) as Record<string, unknown>;
+        for (const [k, v] of Object.entries(tokens)) if (typeof v === 'string') this.contextTokens.set(k, v);
+      }
+    } catch {
+      /* 状态文件损坏则忽略，走全新登录 */
+    }
+  }
+
+  private persistState(): void {
+    try {
+      mkdirSync(this.stateDir, { recursive: true });
+      writeFileSync(join(this.stateDir, 'token.txt'), this.token, 'utf8');
+      writeFileSync(join(this.stateDir, 'sync_buf.txt'), this.syncBuf, 'utf8');
+      writeFileSync(join(this.stateDir, 'context_tokens.json'), JSON.stringify(Object.fromEntries(this.contextTokens)), 'utf8');
+    } catch {
+      /* 持久化失败不阻断 */
+    }
+  }
+
+  async connect(): Promise<void> {
+    if (!this.token) {
+      console.log('[wechat] 未配置 WECHAT_TOKEN：尝试实验性扫码登录（v0.2b）…');
+      void this.tryLogin().then((ok) => { if (ok) this.startPolling(); });
+      return;
+    }
+    this.startPolling();
+  }
+
+  private base(): string {
+    return (this.opts.baseUrl ?? DEFAULT_BASE).replace(/\/$/, '');
+  }
+
+  private async apiFetch(endpoint: string, body: Record<string, unknown>, timeoutMs = 45000): Promise<Record<string, unknown>> {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await fetch(`${this.base()}/${endpoint}`, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          AuthorizationType: 'ilink_bot_token',
+          Authorization: `Bearer ${this.token}`,
+          'X-WECHAT-UIN': String(Math.floor(Math.random() * 0x7fffffff)),
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+      if (!res.ok) throw new Error(`iLink ${endpoint} HTTP ${res.status}`);
+      return (await res.json()) as Record<string, unknown>;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  /** 实验性扫码登录：打印二维码（liteapp URL 渲染为 QR），轮询扫码状态，成功后持久化 token。 */
+  private async tryLogin(): Promise<boolean> {
+    try {
+      const res = await fetch(`${this.base()}/ilink/bot/get_bot_qrcode?bot_type=3`);
+      const d = (await res.json().catch(() => null)) as { qrcode?: string; qrcode_img_content?: string } | null;
+      if (!d?.qrcode || !d.qrcode_img_content) {
+        console.warn(`[wechat] 获取登录二维码失败: ${JSON.stringify(d).slice(0, 200)}`);
+        return false;
+      }
+      console.log('[wechat] 请用微信扫描下方二维码完成 iLink ClawBot 登录:');
+      qrcode.generate(d.qrcode_img_content, { small: true });
+      for (let i = 0; i < 60 && !this.stopped; i++) {
+        await new Promise((r) => setTimeout(r, 3000));
+        try {
+          const st = (await fetch(`${this.base()}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(d.qrcode)}`).then((r) => r.json())) as { bot_token?: string };
+          if (st?.bot_token) {
+            this.token = st.bot_token;
+            this.persistState();
+            console.log('[wechat] 扫码成功，已保存 token，开始收消息');
+            return true;
+          }
+        } catch {
+          /* 状态轮询瞬时失败继续重试 */
+        }
+      }
+      console.log('[wechat] 扫码超时（3 分钟未确认）；重启适配器可重新生成二维码');
+      return false;
+    } catch (error) {
+      console.warn(`[wechat] 登录流程异常: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
+
+  private startPolling(): void {
+    if (this.polling) return;
+    this.polling = true;
+    void this.pollLoop();
+  }
+
+  private async pollLoop(): Promise<void> {
+    while (!this.stopped && this.token) {
+      try {
+        const data = await this.apiFetch('ilink/bot/getupdates', buildGetUpdatesBody(this.syncBuf));
+        if (typeof data.get_updates_buf === 'string') {
+          this.syncBuf = data.get_updates_buf;
+          this.persistState();
+        }
+        for (const msg of (data.msgs as WeChatIncomingMsg[] | undefined) ?? []) {
+          const normalized = parseWeChatUpdate(msg);
+          if (!normalized) continue;
+          if (msg.context_token) this.contextTokens.set(normalized.userId, msg.context_token);
+          const button = this.pendingButtons.match(normalized.chatId, normalized.text);
+          if (button) {
+            this.replyCb?.(button.id, { chatId: normalized.chatId, userId: normalized.userId });
+            continue;
+          }
+          this.messageCb?.(normalized);
+        }
+      } catch (error) {
+        if (this.stopped) break;
+        console.warn(`[wechat] 轮询失败: ${error instanceof Error ? error.message : String(error)}`);
+        await new Promise((r) => setTimeout(r, 5000));
+      }
+    }
+    this.polling = false;
+  }
+
+  async send(chatId: string, payload: OutboundPayload): Promise<void> {
+    if (!this.token) throw new Error('wechat 未登录（无 token），无法发送');
+    if (payload.buttons?.length) this.pendingButtons.set(chatId, payload.buttons);
+    const text = buildNumberedReplyText(payload.text, payload.buttons ?? []);
+    const contextToken = this.contextTokens.get(chatId) ?? '';
+    for (const chunk of chunkText(text)) {
+      await this.apiFetch('ilink/bot/sendmessage', buildSendMessageBody(chatId, chunk, contextToken));
+    }
+  }
+
+  onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
+  onReply(cb: (buttonId: string, sender: { chatId: string; userId: string }) => void): void { this.replyCb = cb; }
+  status(): { connected: boolean } { return { connected: Boolean(this.token) }; }
+}

package/src/adapters/wecom.ts

@@ -98,7 +98,7 @@ export class WeComAdapter implements Adapter {
   private server?: ReturnType<typeof createServer>;
   private connected = false;
   private messageCb?: (msg: NormalizedMessage) => void;
-  private replyCb?: (buttonId: string) => void;
+  private replyCb?: (buttonId: string, sender: { chatId: string; userId: string }) => void;
   private readonly pendingButtons = new PendingButtons();
   /** access_token 缓存：企业微信 token 有效期 7200s，且有获取频率限制，必须复用。 */
   private tokenCache?: { token: string; expiresAt: number };
@@ -143,7 +143,7 @@ export class WeComAdapter implements Adapter {
       if (!normalized) return;
       const button = this.pendingButtons.match(normalized.chatId, normalized.text);
       if (button) {
-        this.replyCb?.(button.id);
+        this.replyCb?.(button.id, { chatId: normalized.chatId, userId: normalized.userId });
         return;
       }
       this.messageCb?.(normalized);
@@ -178,7 +178,7 @@ export class WeComAdapter implements Adapter {
   }
 
   onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
-  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  onReply(cb: (buttonId: string, sender: { chatId: string; userId: string }) => void): void { this.replyCb = cb; }
   status(): { connected: boolean } { return { connected: this.connected }; }
 }
 

package/src/adapters/whatsapp.ts

@@ -129,7 +129,7 @@ export class WhatsAppAdapter implements Adapter {
   private sock?: WASocket;
   private connected = false;
   private messageCb?: (msg: NormalizedMessage) => void;
-  private replyCb?: (buttonId: string) => void;
+  private replyCb?: (buttonId: string, sender: { chatId: string; userId: string }) => void;
   /** chatId → 当前 pending 按钮（编号回复 → 按钮 id，带 TTL 防过期误吞） */
   private readonly pendingButtons = new PendingButtons();
 
@@ -175,7 +175,10 @@ export class WhatsAppAdapter implements Adapter {
         if (buttonId) {
           const chatId = waRaw.key?.remoteJid;
           if (chatId) this.pendingButtons.consume(chatId);
-          this.replyCb?.(buttonId);
+          this.replyCb?.(buttonId, {
+            chatId: chatId ?? '',
+            userId: waRaw.key?.participant ?? chatId ?? '',
+          });
           continue;
         }
         const normalized = normalizeWhatsAppMessage(waRaw);
@@ -183,7 +186,10 @@ export class WhatsAppAdapter implements Adapter {
         // 编号回复兜底：若该 chat 有 pending 按钮且消息是数字（TTL 内），转成按钮点击
         const button = this.pendingButtons.match(normalized.msg.chatId, normalized.msg.text);
         if (button) {
-          this.replyCb?.(button.id);
+          this.replyCb?.(button.id, {
+            chatId: normalized.msg.chatId,
+            userId: normalized.msg.userId,
+          });
           continue;
         }
         this.messageCb?.(normalized.msg);
@@ -223,6 +229,6 @@ export class WhatsAppAdapter implements Adapter {
   }
 
   onMessage(cb: (msg: NormalizedMessage) => void): void { this.messageCb = cb; }
-  onReply(cb: (buttonId: string) => void): void { this.replyCb = cb; }
+  onReply(cb: (buttonId: string, sender: { chatId: string; userId: string }) => void): void { this.replyCb = cb; }
   status(): { connected: boolean } { return { connected: this.connected }; }
 }

package/src/config.ts

@@ -7,6 +7,7 @@ import { SlackAdapter } from './adapters/slack.js';
 import { FeishuAdapter } from './adapters/feishu.js';
 import { DingTalkAdapter } from './adapters/dingtalk.js';
 import { WeComAdapter } from './adapters/wecom.js';
+import { WeChatAdapter } from './adapters/wechat.js';
 
 /** 平台适配器需要的全部环境变量（缺省为 undefined = 不启用该平台）。 */
 export interface AdapterEnv {
@@ -25,6 +26,8 @@ export interface AdapterEnv {
   wecomToken?: string;
   wecomEncodingAESKey?: string;
   wecomCallbackPort?: string;
+  wechatToken?: string;
+  wechatStateDir?: string;
   asrApiKey?: string;
   asrBaseUrl?: string;
   asrModel?: string;
@@ -66,6 +69,9 @@ export function createAdapter(id: string, env: AdapterEnv): Adapter {
         token: env.wecomToken, encodingAESKey: env.wecomEncodingAESKey,
         callbackPort: Number(env.wecomCallbackPort ?? 3193),
       });
+    case 'wechat':
+      // 实验性（v0.2b）：token 可缺省——未配置时启动扫码登录（iLink/ClawBot）
+      return new WeChatAdapter({ token: env.wechatToken, stateDir: env.wechatStateDir ?? 'data/wechat' });
     default:
       throw new Error(`unknown adapter: ${id}`);
   }
@@ -89,6 +95,8 @@ export function adapterEnvFromProcess(env: NodeJS.ProcessEnv = process.env): Ada
     wecomToken: env.WECOM_TOKEN,
     wecomEncodingAESKey: env.WECOM_ENCODING_AES_KEY,
     wecomCallbackPort: env.WECOM_CALLBACK_PORT,
+    wechatToken: env.WECHAT_TOKEN,
+    wechatStateDir: env.WECHAT_STATE_DIR,
     asrApiKey: env.ASR_API_KEY,
     asrBaseUrl: env.ASR_BASE_URL,
     asrModel: env.ASR_MODEL,