@dsh-overdrive/gateway 0.1.2 → 0.1.4

package/src/adapters/feishu.ts

@@ -1,5 +1,6 @@
 import lark from '@larksuiteoapi/node-sdk';
 import type { Adapter, NormalizedMessage, OutboundButton, OutboundPayload } from '../adapter.js';
+import { PendingButtons } from '../pending-buttons.js';
 
 // @larksuiteoapi/node-sdk 是 CommonJS 包（main=lib/index.js，无 "type":"module"）：
 // Node 原生 ESM 下必须 default 导入后解构（同 M2b 的 @slack/bolt 处理）。
@@ -46,6 +47,42 @@ export function matchNumberedButton(text: string, buttons: OutboundButton[]): Ou
   return buttons[n - 1];
 }
 
+/** 按钮 id（"approve:<reqId>" / "reject:<reqId>"）→ 卡片按钮 value。 */
+export function buttonValue(button: OutboundButton): { action: string; reqId: string } {
+  const idx = button.id.indexOf(':');
+  return {
+    action: idx >= 0 ? button.id.slice(0, idx) : button.id,
+    reqId: idx >= 0 ? button.id.slice(idx + 1) : '',
+  };
+}
+
+/** 交互卡片 JSON（msg_type: interactive）。原生按钮点击走 card.action.trigger 回调。 */
+export function buildApprovalCard(text: string, buttons: OutboundButton[]): string {
+  const actions = buttons.map((b) => ({
+    tag: 'button',
+    text: { tag: 'plain_text', content: b.label },
+    type: b.id.startsWith('approve:') ? 'primary' : 'default',
+    value: buttonValue(b),
+  }));
+  const card = {
+    config: { wide_screen_mode: true },
+    header: { title: { tag: 'plain_text', content: text.slice(0, 60) }, template: 'blue' },
+    elements: [
+      { tag: 'div', text: { tag: 'lark_md', content: text } },
+      { tag: 'action', actions },
+    ],
+  };
+  return JSON.stringify(card);
+}
+
+/** 卡片回调 value → 按钮 id（"approve:<reqId>"）；缺字段返回 null。 */
+export function cardActionToButtonId(value: unknown): string | null {
+  if (!value || typeof value !== 'object') return null;
+  const { action, reqId } = value as { action?: unknown; reqId?: unknown };
+  if ((action !== 'approve' && action !== 'reject') || typeof reqId !== 'string' || !reqId) return null;
+  return `${action}:${reqId}`;
+}
+
 // ── 适配器 ────────────────────────────────────────────────────
 
 export interface FeishuAdapterOptions {
@@ -60,7 +97,7 @@ export class FeishuAdapter implements Adapter {
   private connected = false;
   private messageCb?: (msg: NormalizedMessage) => void;
   private replyCb?: (buttonId: string) => void;
-  private readonly pendingButtons = new Map<string, OutboundButton[]>();
+  private readonly pendingButtons = new PendingButtons();
   /** chatId → 最近一条入站消息的 message_id（send 优先 reply，缺失则 create 兜底） */
   private readonly lastMessageIds = new Map<string, string>();
 
@@ -78,17 +115,18 @@ export class FeishuAdapter implements Adapter {
         const normalized = parseFeishuTextMessage(data);
         if (!normalized) return;
         const chatId = normalized.chatId;
-        const pending = this.pendingButtons.get(chatId);
-        if (pending) {
-          const button = matchNumberedButton(normalized.text, pending);
-          if (button) {
-            this.pendingButtons.delete(chatId);
-            this.replyCb?.(button.id);
-            return;
-          }
+        const button = this.pendingButtons.match(chatId, normalized.text);
+        if (button) {
+          this.replyCb?.(button.id);
+          return;
         }
         this.messageCb?.(normalized);
       },
+      // 原生交互卡片按钮回调 → 审批应答（Roadmap v0.2）
+      'card.action.trigger': async (data: { action?: { value?: unknown } }) => {
+        const buttonId = cardActionToButtonId(data?.action?.value);
+        if (buttonId) this.replyCb?.(buttonId);
+      },
     });
     this.ws = new WSClient({
       appId: this.opts.appId,
@@ -101,7 +139,23 @@ export class FeishuAdapter implements Adapter {
   }
 
   async send(chatId: string, payload: OutboundPayload): Promise<void> {
-    if (payload.buttons?.length) this.pendingButtons.set(chatId, payload.buttons);
+    if (payload.buttons?.length) {
+      this.pendingButtons.set(chatId, payload.buttons); // 卡片之外仍支持编号回复兜底
+      const content = buildApprovalCard(payload.text, payload.buttons);
+      const messageId = this.lastMessageIds.get(chatId);
+      if (messageId) {
+        await this.client.im.message.reply({
+          path: { message_id: messageId },
+          data: { msg_type: 'interactive', content },
+        });
+      } else {
+        await this.client.im.message.create({
+          params: { receive_id_type: 'chat_id' },
+          data: { receive_id: chatId, msg_type: 'interactive', content },
+        });
+      }
+      return;
+    }
     const text = buildNumberedText(payload.text, payload.buttons ?? []);
     const content = JSON.stringify({ text });
     const messageId = this.lastMessageIds.get(chatId);

package/src/adapters/telegram.ts

@@ -10,8 +10,8 @@ export interface RawTelegramMessage {
     text?: string;
     caption?: string;
     photo?: Array<{ file_id?: string }>;
-    voice?: { file_id?: string };
-    audio?: { file_id?: string };
+    voice?: { file_id?: string; mime_type?: string };
+    audio?: { file_id?: string; mime_type?: string };
     video?: { file_id?: string };
     document?: { file_id?: string };
   };
@@ -22,6 +22,16 @@ export function telegramPhotoFileId(photo: Array<{ file_id?: string }>): string
   return photo[photo.length - 1]?.file_id;
 }
 
+/** 纯函数：语音消息的 file_id（voice 或 audio）；无返回 undefined。 */
+export function telegramVoiceFileId(raw: RawTelegramMessage): string | undefined {
+  return raw.message?.voice?.file_id ?? raw.message?.audio?.file_id;
+}
+
+/** 纯函数：语音消息的 MIME（voice 优先，audio 兜底）。 */
+export function telegramVoiceMime(raw: RawTelegramMessage): string | undefined {
+  return raw.message?.voice?.mime_type ?? raw.message?.audio?.mime_type;
+}
+
 /** 纯函数：Telegram 文件下载 URL 模板。file_path 需 getFile(file_id) 换取（真实调用在 adapter 薄层）。 */
 export function telegramImageUrl(token: string, filePath: string): string {
   return `https://api.telegram.org/file/bot${token}/${filePath}`;
@@ -34,7 +44,9 @@ export function normalizeTelegramMessage(raw: RawTelegramMessage): NormalizedMes
   const text = msg.text ?? msg.caption ?? '';
   let media: NormalizedMessage['media'];
   if (msg.photo?.length) media = { kind: 'image' }; // url 由 adapter getFile 薄层填充
-  else if (msg.voice || msg.audio) media = { kind: 'voice' };
+  else if (msg.voice || msg.audio) {
+    media = { kind: 'voice', mime: telegramVoiceMime(raw) }; // url 由 adapter getFile 薄层填充（ASR 用）
+  }
   else if (msg.video) media = { kind: 'video' };
   else if (msg.document) media = { kind: 'file' };
   if (!text && !media) return null;
@@ -80,11 +92,16 @@ export class TelegramAdapter implements Adapter {
     void this.bot.start(); // 长轮询（自托管无需 webhook）
   }
 
-  /** 薄层：photo → getFile(file_id) 换 file_path → 下载 URL 填充 msg.media.url（纯函数只做模板）。 */
+  /** 薄层：photo/voice/audio → getFile(file_id) 换 file_path → 下载 URL 填充 msg.media.url（纯函数只做模板）。 */
   private async handleMessage(raw: RawTelegramMessage): Promise<void> {
     const msg = normalizeTelegramMessage(raw);
     if (!msg) return;
-    const fileId = msg.media?.kind === 'image' ? telegramPhotoFileId(raw.message?.photo ?? []) : undefined;
+    const fileId =
+      msg.media?.kind === 'image'
+        ? telegramPhotoFileId(raw.message?.photo ?? [])
+        : msg.media?.kind === 'voice'
+          ? telegramVoiceFileId(raw)
+          : undefined;
     if (fileId) {
       try {
         const file = await this.bot.api.getFile(fileId);

package/src/adapters/wecom.ts

@@ -1,6 +1,7 @@
 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';
+import { PendingButtons } from '../pending-buttons.js';
 
 // ── 纯函数：AES-256-CBC 加解密（企业微信协议）──────────────────
 
@@ -98,7 +99,9 @@ export class WeComAdapter implements Adapter {
   private connected = false;
   private messageCb?: (msg: NormalizedMessage) => void;
   private replyCb?: (buttonId: string) => void;
-  private readonly pendingButtons = new Map<string, OutboundButton[]>();
+  private readonly pendingButtons = new PendingButtons();
+  /** access_token 缓存：企业微信 token 有效期 7200s，且有获取频率限制，必须复用。 */
+  private tokenCache?: { token: string; expiresAt: number };
 
   constructor(private readonly opts: WeComAdapterOptions) {}
 
@@ -138,14 +141,10 @@ export class WeComAdapter implements Adapter {
       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;
-        }
+      const button = this.pendingButtons.match(normalized.chatId, normalized.text);
+      if (button) {
+        this.replyCb?.(button.id);
+        return;
       }
       this.messageCb?.(normalized);
     }
@@ -169,9 +168,12 @@ export class WeComAdapter implements Adapter {
   }
 
   private async fetchAccessToken(): Promise<string> {
+    if (this.tokenCache && this.tokenCache.expiresAt > Date.now()) return this.tokenCache.token;
     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}`);
+    // 官方有效期 7200s；留 200s 余量，避免临界过期
+    this.tokenCache = { token: data.access_token, expiresAt: Date.now() + 7_000_000 };
     return data.access_token;
   }
 

package/src/adapters/whatsapp.ts

@@ -8,6 +8,7 @@ import makeWASocket, {
 import * as qrcode from 'qrcode-terminal';
 import pino from 'pino';
 import type { Adapter, NormalizedMessage, OutboundButton, OutboundPayload } from '../adapter.js';
+import { PendingButtons } from '../pending-buttons.js';
 
 // ── 纯函数（可单测）────────────────────────────────────────────
 
@@ -129,8 +130,8 @@ export class WhatsAppAdapter implements Adapter {
   private connected = false;
   private messageCb?: (msg: NormalizedMessage) => void;
   private replyCb?: (buttonId: string) => void;
-  /** chatId → 当前 pending 按钮（编号回复 → 按钮 id） */
-  private readonly pendingButtons = new Map<string, OutboundButton[]>();
+  /** chatId → 当前 pending 按钮（编号回复 → 按钮 id，带 TTL 防过期误吞） */
+  private readonly pendingButtons = new PendingButtons();
 
   constructor(private readonly opts: WhatsAppAdapterOptions) {}
 
@@ -173,21 +174,17 @@ export class WhatsAppAdapter implements Adapter {
         const buttonId = parseNativeButtonResponse(waRaw);
         if (buttonId) {
           const chatId = waRaw.key?.remoteJid;
-          if (chatId) this.pendingButtons.delete(chatId);
+          if (chatId) this.pendingButtons.consume(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;
-          }
+        // 编号回复兜底：若该 chat 有 pending 按钮且消息是数字（TTL 内），转成按钮点击
+        const button = this.pendingButtons.match(normalized.msg.chatId, normalized.msg.text);
+        if (button) {
+          this.replyCb?.(button.id);
+          continue;
         }
         this.messageCb?.(normalized.msg);
       }

package/src/asr.ts

@@ -0,0 +1,83 @@
+// ASR 语音转写（Roadmap v0.2）。
+// 通过 OpenAI 兼容的 /audio/transcriptions 端点（OpenAI / SiliconFlow / Groq 等）把
+// 语音消息转成文本。未配置 API key 时完全禁用（保持原有"不支持转写"降级路径）。
+
+export interface AsrConfig {
+  apiKey?: string;
+  /** OpenAI 兼容 API 根地址，默认 https://api.openai.com/v1 */
+  baseUrl?: string;
+  /** 转写模型，默认 whisper-1 */
+  model?: string;
+}
+
+export interface AsrVoiceInput {
+  url?: string;
+  mime?: string;
+}
+
+export interface AsrTranscriber {
+  readonly enabled: boolean;
+  /** 转写语音消息 → 文本；未启用 / 下载或转写失败 → null（调用方走原降级路径）。 */
+  transcribe(voice: AsrVoiceInput): Promise<string | null>;
+}
+
+const DEFAULT_BASE_URL = 'https://api.openai.com/v1';
+const DEFAULT_MODEL = 'whisper-1';
+
+/** MIME → 文件扩展名（OpenAI 转写接口要求带正确扩展名的文件名）。 */
+export function extensionForMime(mime?: string): string {
+  if (!mime) return 'oga';
+  const map: Record<string, string> = {
+    'audio/ogg': 'ogg',
+    'audio/oga': 'oga',
+    'audio/opus': 'opus',
+    'audio/mpeg': 'mp3',
+    'audio/mp3': 'mp3',
+    'audio/mp4': 'm4a',
+    'audio/m4a': 'm4a',
+    'audio/wav': 'wav',
+    'audio/webm': 'webm',
+    'audio/aac': 'aac',
+    'audio/amr': 'amr',
+  };
+  const key = mime.split(';')[0].trim().toLowerCase();
+  return map[key] ?? 'oga';
+}
+
+export function createTranscriber(config: AsrConfig = {}): AsrTranscriber {
+  const enabled = Boolean(config.apiKey);
+  const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, '');
+  const model = config.model ?? DEFAULT_MODEL;
+
+  async function transcribe(voice: AsrVoiceInput): Promise<string | null> {
+    if (!enabled || !voice.url) return null;
+    try {
+      const audioRes = await fetch(voice.url);
+      if (!audioRes.ok) {
+        console.warn(`[asr] 下载音频失败: ${audioRes.status}`);
+        return null;
+      }
+      const audioBlob = await audioRes.blob();
+      const form = new FormData();
+      form.append('file', audioBlob, `voice.${extensionForMime(voice.mime)}`);
+      form.append('model', model);
+      const res = await fetch(`${baseUrl}/audio/transcriptions`, {
+        method: 'POST',
+        headers: { authorization: `Bearer ${config.apiKey}` },
+        body: form,
+      });
+      if (!res.ok) {
+        console.warn(`[asr] 转写失败 ${res.status}: ${(await res.text()).slice(0, 200)}`);
+        return null;
+      }
+      const data = (await res.json()) as { text?: string };
+      const text = data.text?.trim();
+      return text ? text : null;
+    } catch (error) {
+      console.warn(`[asr] 转写异常: ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }
+  }
+
+  return { enabled, transcribe };
+}

package/src/commands.ts

@@ -4,7 +4,9 @@ export type ParsedCommand =
   | { kind: 'agents' }
   | { kind: 'help' }
   | { kind: 'task'; prompt: string }
-  | { kind: 'cron'; schedule: string; prompt: string };
+  | { kind: 'cron'; schedule: string; prompt: string }
+  | { kind: 'crons' }
+  | { kind: 'cronrm'; taskId: string };
 
 // cron 语法：/cron <分 时 日 月 周> <需求>（schedule 为 5 个空白分隔字段）
 const CRON_RE = /^\/cron\s+(\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(.+)$/;
@@ -15,10 +17,13 @@ export function parseCommand(text: string): ParsedCommand | null {
   if (trimmed === '/new') return { kind: 'new' };
   if (trimmed === '/agents') return { kind: 'agents' };
   if (trimmed === '/help') return { kind: 'help' };
+  if (trimmed === '/crons') return { kind: 'crons' };
   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] };
+  const cronrm = trimmed.match(/^\/cronrm\s+(\S+)$/);
+  if (cronrm) return { kind: 'cronrm', taskId: cronrm[1] };
   return null;
 }
 
@@ -27,6 +32,8 @@ export const HELP_TEXT = [
   '/trace — 查看最近一轮轨迹',
   '/task <需求> — 派子任务',
   '/cron <分 时 日 月 周> <需求> — 定时任务',
+  '/crons — 查看定时任务列表',
+  '/cronrm <任务id> — 删除定时任务',
   '/agents — 查看子任务状态',
   '/new — 重置会话',
 ].join('\n');

package/src/config.ts

@@ -25,6 +25,9 @@ export interface AdapterEnv {
   wecomToken?: string;
   wecomEncodingAESKey?: string;
   wecomCallbackPort?: string;
+  asrApiKey?: string;
+  asrBaseUrl?: string;
+  asrModel?: string;
 }
 
 export function parseAdapterIds(raw: string): string[] {
@@ -86,5 +89,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,
+    asrApiKey: env.ASR_API_KEY,
+    asrBaseUrl: env.ASR_BASE_URL,
+    asrModel: env.ASR_MODEL,
   };
 }

package/src/index.ts

@@ -6,6 +6,7 @@ import { CliAdapter } from './adapters/cli.js';
 import { parseCommand, HELP_TEXT, type ParsedCommand } from './commands.js';
 import { TrajectoryAggregator, formatTrajectorySummary } from './trajectory.js';
 import { createStatusServer } from './status.js';
+import { createTranscriber, type AsrTranscriber } from './asr.js';
 
 /**
  * message.delta → 打字指示去重：同一 turn 内首个 delta 触发一次 typing，
@@ -64,6 +65,8 @@ export function planOutbound(ev: ServerEvent): { payload: OutboundPayload } | nu
 
 export interface WireOptions {
   allowlist: string[];
+  /** ASR 转写器；配置了 API key 时启用，语音消息转成文本再发给 agent。 */
+  asr?: AsrTranscriber;
 }
 
 /** 命令面分发：/trace /new /task /cron /agents /help（M4）。 */
@@ -96,6 +99,21 @@ async function handleCommand(
       await adapter.send(chatId, { text: '⏰ 定时任务已注册' });
       return;
     }
+    case 'crons': {
+      const res = await client.listTasks();
+      const text = res.tasks.length
+        ? res.tasks.map((task) => `- \`${task.id}\` ${task.schedule} — ${task.prompt}`).join('\n')
+        : '暂无定时任务。';
+      await adapter.send(chatId, { text: `⏰ 定时任务（${res.tasks.length}）:\n${text}` });
+      return;
+    }
+    case 'cronrm': {
+      const res = await client.removeTask(command.taskId);
+      await adapter.send(chatId, {
+        text: res.ok ? `🗑️ 已删除定时任务 \`${command.taskId}\`` : `未找到定时任务 \`${command.taskId}\``,
+      });
+      return;
+    }
     case 'agents': {
       await adapter.send(chatId, { text: '（M4 简化）子任务状态由 agent 汇报，/task 派发' });
       return;
@@ -135,6 +153,16 @@ export async function wireAdapter(
         return;
       }
 
+      // ASR 语音转写：配置了 API key 时把语音消息转成文本；失败/未配置走原降级路径
+      if (msg.media?.kind === 'voice' && opts.asr?.enabled) {
+        const transcript = await opts.asr.transcribe(msg.media);
+        if (transcript) {
+          msg.text = msg.text ? `${msg.text}\n[语音转写] ${transcript}` : `[语音转写] ${transcript}`;
+          msg.media = undefined;
+          console.log(`[gateway][${adapter.id}] 语音转写: ${transcript.slice(0, 60)}`);
+        }
+      }
+
       await client.upsertSession({ platform: adapter.id, channel: msg.chatId, user: msg.userId });
       console.log(`[gateway][${adapter.id}] upsertSession OK -> ${key}`);
       await client.sendMessage(key, { text: msg.text, media: msg.media });
@@ -195,6 +223,12 @@ async function main(): Promise<void> {
     .split(',').map((s) => s.trim()).filter(Boolean);
   const adapterIds = parseAdapterIds(process.env.GATEWAY_ADAPTERS ?? 'cli');
   const env = adapterEnvFromProcess();
+  const asr = createTranscriber({
+    apiKey: env.asrApiKey,
+    baseUrl: env.asrBaseUrl,
+    model: env.asrModel,
+  });
+  if (asr.enabled) console.log('[gateway] ASR 语音转写已启用');
 
   const client = new GatewayClient(dshBaseUrl, dshToken);
   await client.health(); // 确认 DSH 侧（或 mock）活着
@@ -202,7 +236,7 @@ async function main(): Promise<void> {
   const adapters: Adapter[] = adapterIds.map((id) => createAdapter(id, env));
   for (const adapter of adapters) {
     await adapter.connect();
-    await wireAdapter(adapter, client, { allowlist });
+    await wireAdapter(adapter, client, { allowlist, asr });
     console.log(`[gateway] ${adapter.id} 适配器已就绪`);
   }
 

package/src/pending-buttons.ts

@@ -0,0 +1,45 @@
+import type { OutboundButton } from './adapter.js';
+
+export const PENDING_BUTTONS_TTL_MS = 5 * 60_000;
+
+interface PendingButtonEntry {
+  buttons: OutboundButton[];
+  expiresAt: number;
+}
+
+/**
+ * 编号回复兜底的按钮暂存（带 TTL）。
+ *
+ * 审批/危险操作按钮发出后，用户在聊天里回复数字（"1"/"2"…）选择；
+ * 若按钮长期不消费，后续的普通数字消息会被误判成按钮回复。
+ * 本类在 TTL（默认 5 分钟）后自动失效，杜绝"过期按钮吞消息"。
+ */
+export class PendingButtons {
+  private readonly map = new Map<string, PendingButtonEntry>();
+
+  constructor(private readonly ttlMs: number = PENDING_BUTTONS_TTL_MS) {}
+
+  set(chatId: string, buttons: OutboundButton[]): void {
+    this.map.set(chatId, { buttons, expiresAt: Date.now() + this.ttlMs });
+  }
+
+  /** 数字回复命中：返回匹配按钮并消费（删除）；无 pending / 已过期 / 非数字或越界返回 undefined。 */
+  match(chatId: string, text: string): OutboundButton | undefined {
+    const entry = this.map.get(chatId);
+    if (!entry) return undefined;
+    if (entry.expiresAt < Date.now()) {
+      this.map.delete(chatId);
+      return undefined;
+    }
+    const n = Number(text.trim());
+    if (!Number.isInteger(n) || n < 1 || n > entry.buttons.length) return undefined;
+    const button = entry.buttons[n - 1];
+    if (button) this.map.delete(chatId);
+    return button;
+  }
+
+  /** 消费原生按钮点击（如 WhatsApp 原生交互按钮）：删除该 chat 的 pending。 */
+  consume(chatId: string): void {
+    this.map.delete(chatId);
+  }
+}

package/src/status.ts

@@ -14,10 +14,9 @@ export interface StatusServerOptions {
  * 健康控制台：GET / 与 /console 返回静态页，GET /api/status 返回 DSH 健康 + 适配器状态。
  *
  * console.html 读取路径说明（与 dist 产物核对过）：
- * - src 运行（vitest）：import.meta.url = packages/gateway/src/status.ts → ../../web/console.html = packages/web/console.html
- * - dist 运行（node packages/gateway/dist/index.js）：import.meta.url = packages/gateway/dist/status.js → ../../web/console.html = packages/web/console.html
- * 两种形态下 `../../web/console.html` 均解析到 packages/web/console.html（plan 中的
- * ../../../web/console.html 会多上一级到仓库根目录，不正确，已修正）。
+ * - src 运行（vitest）：import.meta.url = packages/gateway/src/status.ts → ../web/console.html = packages/gateway/web/console.html
+ * - dist 运行（node packages/gateway/dist/index.js）：import.meta.url = packages/gateway/dist/status.js → ../web/console.html = packages/gateway/web/console.html
+ * - npm 安装（@dsh-overdrive/gateway）：console.html 随包分发，两种形态均可命中。
  */
 export function createStatusServer(opts: StatusServerOptions): {
   server: Server;
@@ -43,7 +42,7 @@ export function createStatusServer(opts: StatusServerOptions): {
     }
     if (url.pathname === '/' || url.pathname === '/console') {
       const html = await readFile(
-        fileURLToPath(new URL('../../web/console.html', import.meta.url)),
+        fileURLToPath(new URL('../web/console.html', import.meta.url)),
         'utf8',
       ).catch(() => '<h1>console.html not found</h1>');
       res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });

package/test/adapters.dingtalk.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { buildReplyBody, parseBotMessage } from '../src/adapters/dingtalk.js';
+import { buildActionCard, buildReplyBody, buttonCallbackData, parseBotMessage, parseCardCallback } from '../src/adapters/dingtalk.js';
 
 describe('parseBotMessage（RobotMessage → NormalizedMessage）', () => {
   it('文本消息', () => {
@@ -23,3 +23,36 @@ describe('buildReplyBody（sessionWebhook 回发载荷）', () => {
     expect(buildReplyBody('hi')).toEqual({ msgtype: 'text', text: { content: 'hi' } });
   });
 });
+
+describe('buildActionCard（钉钉 actionCard）', () => {
+  it('生成带 cardCallbackData 的按钮', () => {
+    const card = buildActionCard('需要批准', [
+      { id: 'approve:r1', label: '✅ 同意' },
+      { id: 'reject:r1', label: '🚫 拒绝' },
+    ]);
+    expect(card.msgtype).toBe('actionCard');
+    expect(card.actionCard.btns).toHaveLength(2);
+    expect(card.actionCard.btns[0].actionURL).toContain('cardCallbackData=');
+    expect(decodeURIComponent(card.actionCard.btns[0].actionURL.split('cardCallbackData=')[1])).toBe('{"action":"approve","reqId":"r1"}');
+  });
+});
+
+describe('parseCardCallback（TOPIC_CARD 回调载荷 → 按钮 id）', () => {
+  it('识别 cardCallbackData 字段', () => {
+    expect(parseCardCallback({ cardPrivateData: { cardCallbackData: '{"action":"approve","reqId":"r1"}' } })).toBe('approve:r1');
+  });
+  it('识别 params / cardActionData 字段与嵌套结构', () => {
+    expect(parseCardCallback({ cardPrivateData: { params: '{"action":"reject","reqId":"r9"}' } })).toBe('reject:r9');
+    expect(parseCardCallback({ a: { b: { cardActionData: '{"action":"approve","reqId":"x"}' } } })).toBe('approve:x');
+  });
+  it('非法载荷返回 null', () => {
+    expect(parseCardCallback(null)).toBeNull();
+    expect(parseCardCallback({ cardPrivateData: { cardCallbackData: 'not-json' } })).toBeNull();
+    expect(parseCardCallback({ cardPrivateData: { cardCallbackData: '{"action":"other","reqId":"r1"}' } })).toBeNull();
+    expect(parseCardCallback({ cardPrivateData: { cardCallbackData: '{"action":"approve"}' } })).toBeNull();
+  });
+  it('buttonCallbackData 与 parseCardCallback 往返一致', () => {
+    const data = buttonCallbackData({ id: 'reject:r7', label: 'x' });
+    expect(parseCardCallback({ cardPrivateData: { cardCallbackData: data } })).toBe('reject:r7');
+  });
+});

package/test/adapters.feishu.test.ts

@@ -1,5 +1,7 @@
 import { describe, expect, it } from 'vitest';
-import { buildNumberedText, parseFeishuTextMessage } from '../src/adapters/feishu.js';
+import {
+  buildApprovalCard, buildNumberedText, cardActionToButtonId, parseFeishuTextMessage,
+} from '../src/adapters/feishu.js';
 
 describe('parseFeishuTextMessage（im.message.receive_v1 载荷 → NormalizedMessage）', () => {
   it('文本私聊消息', () => {
@@ -28,3 +30,37 @@ describe('buildNumberedText（审批编号回复）', () => {
     expect(text).toContain('2) 🚫 拒绝');
   });
 });
+
+describe('buildApprovalCard（飞书原生交互卡片）', () => {
+  it('生成 interactive 卡片 JSON：header + 文本 + action 按钮', () => {
+    const content = buildApprovalCard('需要批准：执行危险操作', [
+      { id: 'approve:r1', label: '✅ 同意' },
+      { id: 'reject:r1', label: '🚫 拒绝' },
+    ]);
+    const card = JSON.parse(content);
+    expect(card.config.wide_screen_mode).toBe(true);
+    expect(card.header.title.content).toContain('需要批准');
+    const actions = card.elements.find((e: { tag: string }) => e.tag === 'action').actions;
+    expect(actions).toHaveLength(2);
+    expect(actions[0]).toMatchObject({
+      tag: 'button',
+      type: 'primary', // approve 主按钮
+      value: { action: 'approve', reqId: 'r1' },
+    });
+    expect(actions[1].value).toEqual({ action: 'reject', reqId: 'r1' });
+  });
+});
+
+describe('cardActionToButtonId（卡片回调 → 按钮 id）', () => {
+  it('approve/reject 值还原为按钮 id', () => {
+    expect(cardActionToButtonId({ action: 'approve', reqId: 'r1' })).toBe('approve:r1');
+    expect(cardActionToButtonId({ action: 'reject', reqId: 'r9' })).toBe('reject:r9');
+  });
+  it('非法值返回 null', () => {
+    expect(cardActionToButtonId(null)).toBeNull();
+    expect(cardActionToButtonId({})).toBeNull();
+    expect(cardActionToButtonId({ action: 'other', reqId: 'r1' })).toBeNull();
+    expect(cardActionToButtonId({ action: 'approve' })).toBeNull();
+    expect(cardActionToButtonId('str')).toBeNull();
+  });
+});