@dsh-plugin/dsh-synapse 0.0.0-stage → 0.1.0-dev.41044228975

package/vendor/gugle-chat-bot/src/features/hermes/message.ts

@@ -0,0 +1,319 @@
+/**
+ * QQ 消息段的深度解析（纯函数 + 注入式 resolver，抽离自 HermesBridge 以便冒烟测试）。
+ *
+ * 深度表（depth = 正在解析内容的层级，触发消息本身为 0）：
+ * | 段类型           | depth 0            | depth 1    | depth 2                | depth ≥3        |
+ * | 图片             | `[图片]` + 原图入 images | 同左  | `[图片]`，不下载       | `[图片]`，不下载 |
+ * | reply / forward  | 拉取并解析（depth+1） | 同左      | 拉取但仅文字（不下载图片） | 不拉取，输出 `[聊天记录]` |
+ * | text / at / video / record | 原样（at：群名片优先，缺失回退 `@QQ号`） | 同左 | 同左 | 同左 |
+ *
+ * 有意的取舍：交付物 5 中「引用里含聊天记录 → 节点内图片入 images」按深度表解释为
+ * forward 处于 depth 0 时其节点图片入 images；若 forward 落在 depth 1，则节点文字展开、
+ * 节点图片在 depth 2 不下载（深度表为准）。
+ *
+ * 本模块不产生任何 IO：拉取、图片下载、昵称与时间格式化全部由调用方经 MessageResolvers 注入。
+ */
+
+/** 聊天记录（合并转发）在文本中的占位符 */
+export const FORWARD_PLACEHOLDER = '[聊天记录]';
+
+/** 解析护栏：单次解析的段/节点/图片总量与深度上限，防超长消息与自环拖垮调用方 */
+export const PARSE_LIMITS = {
+  /** 单次解析处理的段总量上限（跨层级累计） */
+  maxSegments: 500,
+  /** 单个聊天记录展开的节点上限 */
+  maxNodes: 50,
+  /** 单次解析收集的图片上限 */
+  maxImages: 10,
+  /** 深度上限：处于该深度的 reply/forward 不再拉取，只留 `[聊天记录]` 占位 */
+  maxDepth: 3,
+  /** 下载图片的最大深度（depth 2 起只保留 `[图片]` 占位） */
+  maxImageDepth: 1
+} as const;
+
+export interface MessageResolvers {
+  /** get_msg，失败抛错 */
+  getMsg(
+    messageId: number
+  ): Promise<{ sender?: { nickname?: string; user_id?: number }; time?: number; message: unknown }>;
+  /** get_forward_msg，失败抛错 */
+  getForward(forwardId: string): Promise<{ messages: unknown[] }>;
+  /** 图片段 → base64 data URL；失败/不需要时返回 null */
+  resolveImage(segment: { data: { file: string; url?: string } }): Promise<string | null>;
+  /** @提及昵称解析（可选；缺省用 QQ 号） */
+  resolveName?(qq: string): Promise<string | null>;
+  /** 时间戳格式化（注入以保持纯净） */
+  formatTime(unixTs: number): string;
+  /** 是否下载/转发图片（config.forwardImages） */
+  forwardImages: boolean;
+}
+
+export interface ParsedMessage {
+  text: string;
+  images: string[];
+}
+
+/**
+ * 单次解析的共享状态：护栏计数、去重集合与 @提及昵称缓存。
+ * 由 parseMessage 建立并传给各层 parseSegments；直接调用 parseSegments 时可省略。
+ */
+export interface ParseState {
+  /** 已展开的引用/转发 id，防自环与重复展开 */
+  visitedIds: Set<string>;
+  /** 跨层级累计的段计数（护栏） */
+  segmentCount: number;
+  /** 已展开的转发节点计数（护栏） */
+  nodeCount: number;
+  /** 是否解析 @提及昵称（群聊上下文才解析，私聊直接回退 QQ 号） */
+  resolveNames: boolean;
+  /** @提及昵称缓存（qq → 昵称，空串表示解析失败） */
+  nameCache: Map<string, string>;
+}
+
+/** 建立解析状态；resolveNames=false 时 @提及 一律回退 QQ 号 */
+export function createParseState(resolveNames: boolean): ParseState {
+  return { visitedIds: new Set<string>(), segmentCount: 0, nodeCount: 0, resolveNames, nameCache: new Map() };
+}
+
+/** 取消息段的数据体（非对象按空对象处理） */
+function segmentData(segment: unknown): Record<string, unknown> {
+  if (!segment || typeof segment !== 'object') return {};
+  const data = (segment as { data?: unknown }).data;
+  return data && typeof data === 'object' ? (data as Record<string, unknown>) : {};
+}
+
+/** 取消息段类型（缺失/非字符串返回空串） */
+function segmentType(segment: unknown): string {
+  if (!segment || typeof segment !== 'object') return '';
+  const type = (segment as { type?: unknown }).type;
+  return typeof type === 'string' ? type : '';
+}
+
+/** id 字段归一化为字符串（number/string 皆可，0 与空串视为无 id） */
+function readId(raw: unknown): string {
+  if (typeof raw === 'number' && Number.isFinite(raw) && raw !== 0) return String(raw);
+  if (typeof raw === 'string' && raw.length > 0) return raw;
+  return '';
+}
+
+/** 取首个非空字符串 */
+function pickString(values: unknown[]): string {
+  for (const value of values) {
+    if (typeof value === 'string' && value.length > 0) return value;
+    if (typeof value === 'number' && Number.isFinite(value)) return String(value);
+  }
+  return '';
+}
+
+/** 引用块 / 转发节点行的统一格式：`> {昵称}({id}) {时间}\n> {内容}\n` */
+function quoteBlock(name: string, id: string, time: string, content: string): string {
+  return `${`> ${name}(${id}) ${time}`.trimEnd()}\n> ${content}\n`;
+}
+
+/** 解析 @提及 昵称：群聊上下文经 resolver 查询并缓存，失败回退 null（调用方用 QQ 号） */
+async function resolveAtName(qq: string, resolvers: MessageResolvers, state: ParseState): Promise<string | null> {
+  if (!state.resolveNames || !resolvers.resolveName) return null;
+  const cached = state.nameCache.get(qq);
+  if (cached !== undefined) return cached || null;
+  try {
+    const name = await resolvers.resolveName(qq);
+    state.nameCache.set(qq, name ?? '');
+    return name ?? null;
+  } catch {
+    state.nameCache.set(qq, '');
+    return null;
+  }
+}
+
+/** 解析图片段为 base64 data URL；失败/不需要时返回 null（调用方保留 `[图片]` 占位） */
+async function resolveImageSafe(segment: unknown, resolvers: MessageResolvers): Promise<string | null> {
+  const data = segmentData(segment);
+  const file = typeof data.file === 'string' ? data.file : '';
+  const url = typeof data.url === 'string' ? data.url : '';
+  if (!file && !url) return null;
+  const target: { data: { file: string; url?: string } } = { data: { file } };
+  if (url) target.data.url = url;
+  try {
+    return await resolvers.resolveImage(target);
+  } catch {
+    return null;
+  }
+}
+
+/** 转发节点归一化结果（兼容 NapCat node 格式与 go-cqhttp 旧格式） */
+interface ForwardNodeContent {
+  segments: unknown;
+  name: string;
+  id: string;
+  time: string;
+}
+
+/** 节点正文：message 非空取 message，否则取 content（content 可能是字符串） */
+function pickNodeContent(data: Record<string, unknown>): unknown {
+  const message = data.message;
+  if (Array.isArray(message) && message.length > 0) return message;
+  if (typeof message === 'string' && message.length > 0) return message;
+  return data.content ?? [];
+}
+
+/**
+ * 归一化转发节点：
+ * - NapCat：`{ type: 'node', data: { user_id, nickname, card, time, message, content } }`
+ * - go-cqhttp 旧格式：`{ sender, time, content }`
+ */
+function normalizeForwardNode(raw: unknown, resolvers: MessageResolvers): ForwardNodeContent {
+  const record = raw && typeof raw === 'object' ? (raw as Record<string, unknown>) : {};
+  const data =
+    record.type === 'node' && record.data && typeof record.data === 'object'
+      ? (record.data as Record<string, unknown>)
+      : record;
+  const sender = data.sender && typeof data.sender === 'object' ? (data.sender as Record<string, unknown>) : {};
+  const rawTime = data.time ?? record.time;
+  return {
+    segments: pickNodeContent(data),
+    name: pickString([data.nickname, data.card, sender.nickname, sender.card]) || '未知',
+    id: pickString([data.user_id, sender.user_id]),
+    time: typeof rawTime === 'number' && rawTime > 0 ? resolvers.formatTime(rawTime) : ''
+  };
+}
+
+/** 展开转发（聊天记录）：逐节点输出引用块，节点正文按 depth+1 继续解析 */
+async function parseForward(
+  forwardId: string,
+  depth: number,
+  resolvers: MessageResolvers,
+  images: string[],
+  state: ParseState
+): Promise<string> {
+  try {
+    const forward = await resolvers.getForward(forwardId);
+    const parts: string[] = [];
+    for (const raw of forward?.messages ?? []) {
+      if (state.nodeCount >= PARSE_LIMITS.maxNodes) break;
+      state.nodeCount++;
+      const node = normalizeForwardNode(raw, resolvers);
+      const content = await parseSegments(node.segments, depth + 1, resolvers, images, state);
+      parts.push(quoteBlock(node.name, node.id, node.time, content));
+    }
+    return parts.join('');
+  } catch {
+    return '> [转发消息获取失败]\n';
+  }
+}
+
+/** 展开引用：输出引用块，被引用消息按 depth+1 继续解析 */
+async function parseReply(
+  repliedId: string,
+  depth: number,
+  resolvers: MessageResolvers,
+  images: string[],
+  state: ParseState
+): Promise<string> {
+  try {
+    const numericId = Number(repliedId);
+    const original = await resolvers.getMsg(Number.isFinite(numericId) ? numericId : 0);
+    const name = pickString([original?.sender?.nickname]) || '未知';
+    const id = pickString([original?.sender?.user_id]);
+    const time = typeof original?.time === 'number' && original.time > 0 ? resolvers.formatTime(original.time) : '';
+    const content = await parseSegments(original?.message, depth + 1, resolvers, images, state);
+    return quoteBlock(name, id, time, content);
+  } catch {
+    return '> [引用消息获取失败]\n';
+  }
+}
+
+/**
+ * 解析消息段数组为可读文本：
+ * 文本 → 原文；@提及 → `@昵称`（群聊上下文，缺失回退 `@QQ号`，`all` → `@全体成员`）；
+ * 图片 → `[图片]`（depth ≤ 1 且开启 forwardImages 时原图入 images）；
+ * 视频/语音 → `[视频]` / `[语音]`；引用/转发 → 拉取并逐块展开（depth+1，见文件头深度表）。
+ *
+ * `images` 为调用方持有的收集数组（函数只追加）；`state` 省略时按单次解析新建（昵称解析开启）。
+ */
+export async function parseSegments(
+  segments: unknown,
+  depth: number,
+  resolvers: MessageResolvers,
+  images: string[],
+  state?: ParseState
+): Promise<string> {
+  if (typeof segments === 'string') return segments;
+  if (!Array.isArray(segments)) return '';
+  const current = state ?? createParseState(true);
+  const parts: string[] = [];
+
+  for (const segment of segments) {
+    if (current.segmentCount >= PARSE_LIMITS.maxSegments) break;
+    current.segmentCount++;
+    const data = segmentData(segment);
+
+    switch (segmentType(segment)) {
+      case 'text': {
+        const text = data.text;
+        if (typeof text === 'string') parts.push(text);
+        break;
+      }
+      case 'at': {
+        const qq = pickString([data.qq]);
+        if (qq === 'all') parts.push('@全体成员');
+        else if (qq) parts.push(`@${(await resolveAtName(qq, resolvers, current)) ?? qq}`);
+        break;
+      }
+      case 'image': {
+        parts.push('[图片]');
+        if (!resolvers.forwardImages || depth > PARSE_LIMITS.maxImageDepth) break;
+        if (images.length >= PARSE_LIMITS.maxImages) break;
+        const url = await resolveImageSafe(segment, resolvers);
+        if (url) images.push(url);
+        break;
+      }
+      case 'video':
+        parts.push('[视频]');
+        break;
+      case 'record':
+        parts.push('[语音]');
+        break;
+      case 'reply':
+      case 'forward': {
+        const id = readId(data.id);
+        if (!id) break;
+        const key = `${segmentType(segment)}:${id}`;
+        // depth ≥ 3 不拉取；已展开过的 id（含自环）不再进入，统一留占位
+        if (depth >= PARSE_LIMITS.maxDepth || current.visitedIds.has(key)) {
+          parts.push(FORWARD_PLACEHOLDER);
+          break;
+        }
+        current.visitedIds.add(key);
+        parts.push(
+          segmentType(segment) === 'reply'
+            ? await parseReply(id, depth, resolvers, images, current)
+            : await parseForward(id, depth, resolvers, images, current)
+        );
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  return parts.join('').trim();
+}
+
+/**
+ * 解析整条消息（触发消息本身为 depth 0）：
+ * - 非数组输入（string/undefined 等）→ text 为该字符串或 ''，images 为 []；
+ * - `groupId` 为 undefined（私聊）时 @提及 不查昵称，直接回退 `@QQ号`；
+ * - 图片收集上限、段/节点上限与 visitedIds 去重见 PARSE_LIMITS。
+ */
+export async function parseMessage(
+  message: unknown,
+  groupId: number | undefined,
+  resolvers: MessageResolvers
+): Promise<ParsedMessage> {
+  const images: string[] = [];
+  if (typeof message === 'string') return { text: message, images };
+  if (!Array.isArray(message)) return { text: '', images };
+  const state = createParseState(groupId !== undefined);
+  const text = await parseSegments(message, 0, resolvers, images, state);
+  return { text, images };
+}

package/vendor/gugle-chat-bot/src/features/hermes/reaction.ts

@@ -0,0 +1,181 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { QQBot } from '@/index';
+import { getHermesConfig } from '@/features/hermes/config';
+import { writeConfigFile } from '@/config/manager';
+
+/**
+ * AI「处理中」表情回应管理。
+ *
+ * 用户消息触发 Hermes 运行时，给触发消息贴上表情回应（QQ 走 NapCat
+ * set_msg_emoji_like，Discord 走 message.react）；完整回复完成（含查询技能的
+ * 回喂轮）后摘除。
+ *
+ * 记录立即持久化到 data/hermes-reactions.json：若回应期间进程重启/宕机，
+ * 下次启动时按残留记录逐条摘除并清空（cleanupQQ 由 after-start 钩子调用，
+ * Discord 残留由 DiscordBridge 在 clientReady 后调用 listDiscord/drop 处理），
+ * 避免「处理中」表情永久残留。
+ */
+
+/** 一条待摘除的表情回应记录 */
+export interface PendingReaction {
+  /** 唯一键：`qq:{messageId}` / `discord:{channelId}:{messageId}` */
+  key: string;
+  platform: 'qq' | 'discord';
+  /** QQ: OneBot message_id 字符串；Discord: 消息 snowflake */
+  messageId: string;
+  /** Discord 频道 snowflake（QQ 记录无此字段） */
+  channelId?: string;
+  /** QQ: emoji_id；Discord: unicode emoji */
+  emoji: string;
+  createdAt: number;
+}
+
+interface ReactionStoreFile {
+  version: number;
+  reactions: PendingReaction[];
+}
+
+export class ReactionManager {
+  private static instance?: ReactionManager;
+
+  public static getInstance(): ReactionManager {
+    if (!ReactionManager.instance) ReactionManager.instance = new ReactionManager();
+    return ReactionManager.instance;
+  }
+
+  private readonly file = path.resolve(process.cwd(), 'data', 'hermes-reactions.json');
+  private readonly records = new Map<string, PendingReaction>();
+  private loaded = false;
+
+  private constructor() {}
+
+  /** 懒加载持久化记录（损坏按空处理） */
+  private load(): void {
+    if (this.loaded) return;
+    this.loaded = true;
+    try {
+      if (!fs.existsSync(this.file)) return;
+      const raw = JSON.parse(fs.readFileSync(this.file, 'utf-8')) as ReactionStoreFile;
+      if (!Array.isArray(raw?.reactions)) return;
+      for (const record of raw.reactions) {
+        if (record && typeof record.key === 'string' && typeof record.messageId === 'string') {
+          this.records.set(record.key, record);
+        }
+      }
+    } catch {
+      // 文件损坏或格式错误，按空记录处理
+    }
+  }
+
+  /** 立即落盘（原子写，复用 config/manager 的 writeConfigFile） */
+  private persist(): void {
+    try {
+      writeConfigFile(this.file, { version: 1, reactions: [...this.records.values()] } satisfies ReactionStoreFile);
+    } catch {
+      // 持久化失败不阻塞主流程
+    }
+  }
+
+  /**
+   * QQ：给消息贴「处理中」表情，成功后立即持久化记录并返回记录键。
+   * 返回 null 表示没贴上（功能关闭或 NapCat 拒绝，例如私聊消息通常不支持表情回应），
+   * 调用方据此决定是否改用文字回执；具体原因写入日志便于排查。
+   */
+  public async addQQ(bot: QQBot, messageId: number): Promise<string | null> {
+    const config = getHermesConfig();
+    if (!config.reactionEnabled) {
+      bot.logger?.debug(`[Hermes] 表情回应已关闭，跳过（message ${messageId}）`);
+      return null;
+    }
+    try {
+      await bot.axiosInstance.post('/set_msg_emoji_like', {
+        message_id: messageId,
+        emoji_id: config.reactionEmojiQq,
+        set: true
+      });
+    } catch (error) {
+      bot.logger?.warn(
+        `[Hermes] 表情回应失败（message ${messageId}）: ${(error as Error).message}` +
+          `；NapCat 对私聊消息通常不支持 set_msg_emoji_like`
+      );
+      return null;
+    }
+    const key = `qq:${messageId}`;
+    this.load();
+    this.records.set(key, {
+      key,
+      platform: 'qq',
+      messageId: String(messageId),
+      emoji: config.reactionEmojiQq,
+      createdAt: Date.now()
+    });
+    this.persist();
+    return key;
+  }
+
+  /**
+   * Discord：message.react 成功后调用，立即持久化记录并返回记录键。
+   */
+  public persistDiscord(channelId: string, messageId: string, emoji: string): string {
+    const key = `discord:${channelId}:${messageId}`;
+    this.load();
+    this.records.set(key, { key, platform: 'discord', messageId, channelId, emoji, createdAt: Date.now() });
+    this.persist();
+    return key;
+  }
+
+  /**
+   * QQ：摘除表情（set=false）。无论摘除成败都移除持久化记录
+   * （失败多为消息已被撤回等不可重试原因，残留记录只会在下次启动时再次失败）。
+   */
+  public async removeQQ(bot: QQBot | undefined, key: string): Promise<void> {
+    this.load();
+    const record = this.records.get(key);
+    if (this.records.delete(key)) this.persist();
+    if (!record || !bot) return;
+    try {
+      await bot.axiosInstance.post('/set_msg_emoji_like', {
+        message_id: Number(record.messageId),
+        emoji_id: record.emoji,
+        set: false
+      });
+    } catch (error) {
+      bot.logger?.warn(`[Hermes] 摘除表情回应失败（${key}）: ${(error as Error).message}`);
+    }
+  }
+
+  /** 移除一条记录（Discord 摘除动作由调用方完成后调用） */
+  public drop(key: string): void {
+    this.load();
+    if (this.records.delete(key)) this.persist();
+  }
+
+  /** 全部残留的 Discord 记录（启动清理用，摘除后逐条 drop） */
+  public listDiscord(): PendingReaction[] {
+    this.load();
+    return [...this.records.values()].filter(record => record.platform === 'discord');
+  }
+
+  /** 启动清理：摘除全部残留的 QQ 表情回应并清空对应记录 */
+  public async cleanupQQ(bot: QQBot): Promise<void> {
+    this.load();
+    const stale = [...this.records.values()].filter(record => record.platform === 'qq');
+    for (const record of stale) {
+      try {
+        await bot.axiosInstance.post('/set_msg_emoji_like', {
+          message_id: Number(record.messageId),
+          emoji_id: record.emoji,
+          set: false
+        });
+      } catch {
+        // 消息已撤回/不存在等：放弃摘除，仅清理记录
+      }
+      this.records.delete(record.key);
+    }
+    if (stale.length > 0) {
+      this.persist();
+      bot.logger?.info(`[Hermes] 已清理 ${stale.length} 条残留的 QQ 表情回应`);
+    }
+  }
+}

package/vendor/gugle-chat-bot/src/features/hermes/render.ts

@@ -0,0 +1,118 @@
+import { Template, tryGenerateImage } from '@/image';
+import { getHermesConfig } from '@/features/hermes/config';
+import { RunCurrentTool, RunToolRecord } from '@/features/hermes/types';
+
+/**
+ * Hermes 进度/审批卡片渲染（移植自 qq-hermes-bridge src/renderer.ts，MIT 协议，原作者 Amorter）。
+ * HTML/CSS 拆为模板文件，渲染改用 src/image 的共享 Chrome + 串行截图队列。
+ * 渲染失败返回 null，调用方降级为纯文本。
+ */
+
+/** 进度卡片渲染数据 */
+export interface ProgressCardData {
+  tools: RunToolRecord[];
+  currentTool: RunCurrentTool | null;
+  messageDelta?: string;
+  elapsed: string;
+}
+
+/** 审批卡片渲染数据 */
+export interface ApprovalCardData {
+  command: string;
+  riskLevel: string;
+  toolName?: string;
+  runId?: string;
+  preview?: string;
+}
+
+function escapeHtml(text: unknown): string {
+  return String(text || '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${Math.floor(ms / 60000)}m${Math.round((ms % 60000) / 1000)}s`;
+}
+
+function render(templateName: string, template: Template): Promise<string> {
+  return new Promise<string>((resolve, reject) => {
+    const templateFile = template.file();
+    template
+      .handler()
+      .then(html => tryGenerateImage(resolve, reject, html, 500, templateFile))
+      .catch(reject);
+  });
+}
+
+/** 渲染进度卡片为 base64 图片；progressAsImage=false 或渲染失败时返回 null */
+export async function renderProgressImage(data: ProgressCardData): Promise<string | null> {
+  const config = getHermesConfig();
+  if (!config.progressAsImage) return null;
+  try {
+    const toolRows = data.tools
+      .slice(-config.progressMaxTools)
+      .map(tool => {
+        const icon = tool.error ? '❌' : '✅';
+        const duration = tool.duration ? ` (${formatDuration(tool.duration)})` : '';
+        return `<div class="tool-row">
+      <span class="icon">${icon}</span>
+      <span class="name">${escapeHtml(tool.name)}</span>
+      <span class="dur">${duration}</span>
+    </div>
+    ${tool.preview ? `<div class="preview">${escapeHtml(tool.preview).slice(0, 120)}</div>` : ''}`;
+      })
+      .join('\n');
+
+    const currentHtml = data.currentTool
+      ? `<div class="current-tool">
+        <span class="spinner">⏳</span>
+        <span class="name">${escapeHtml(data.currentTool.name)}</span>
+        ${data.currentTool.preview ? `<div class="preview">${escapeHtml(data.currentTool.preview).slice(0, 120)}</div>` : ''}
+      </div>`
+      : '';
+
+    const previewHtml = data.messageDelta
+      ? `<div class="response-preview">${escapeHtml(data.messageDelta.slice(-300))}</div>`
+      : '';
+
+    const template = Template.load('progress', 'src/features/hermes/template')
+      .arg('elapsed', escapeHtml(data.elapsed))
+      .arg('tools', toolRows)
+      .arg('current', currentHtml)
+      .arg('preview', previewHtml)
+      .arg('botName', escapeHtml(config.botName));
+    return await render('progress', template);
+  } catch {
+    return null;
+  }
+}
+
+/** 渲染审批卡片为 base64 图片；渲染失败时返回 null */
+export async function renderApprovalImage(data: ApprovalCardData): Promise<string | null> {
+  try {
+    const riskColors: Record<string, string> = { high: '#E94560', medium: '#F5C842', low: '#53D8FB' };
+    const riskColor = riskColors[data.riskLevel] || riskColors.high!;
+
+    const toolSection = data.toolName
+      ? `<div class="section"><div class="label">工具</div><div class="value">${escapeHtml(data.toolName)}</div></div>`
+      : '';
+    const previewSection = data.preview
+      ? `<div class="section"><div class="label">说明</div><div class="value">${escapeHtml(data.preview).slice(0, 200)}</div></div>`
+      : '';
+
+    const template = Template.load('approval', 'src/features/hermes/template')
+      .arg('riskColor', riskColor)
+      .arg('toolSection', toolSection)
+      .arg('command', escapeHtml(data.command))
+      .arg('previewSection', previewSection)
+      .arg('runId', escapeHtml(data.runId?.slice(-8) ?? ''));
+    return await render('approval', template);
+  } catch {
+    return null;
+  }
+}