gewe-openclaw 2026.3.13 → 2026.3.23

package/src/delivery.ts

@@ -1,26 +1,85 @@
 import fs from "node:fs/promises";
+import crypto from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import type { OpenClawConfig, ReplyPayload } from "openclaw/plugin-sdk";
-import { extractOriginalFilename, extensionForMime } from "openclaw/plugin-sdk";
+import {
+  extensionForMime,
+  extractOriginalFilename,
+  type OpenClawConfig,
+  type ReplyPayload,
+} from "./openclaw-compat.js";
+import { runBinaryCommand, type BinaryCommandResult } from "./binary-command.js";
 import { CHANNEL_ID } from "./constants.js";
 import { getGeweRuntime } from "./runtime.js";
 import { resolveS3Config, uploadToS3 } from "./s3.js";
-import { ensureRustSilkBinary } from "./silk.js";
+import { buildRustSilkEncodeArgs, ensureRustSilkBinary } from "./silk.js";
 import {
+  forwardFileGewe,
+  forwardImageGewe,
+  forwardLinkGewe,
+  forwardMiniAppGewe,
+  forwardVideoGewe,
+  sendAppMsgGewe,
+  sendEmojiGewe,
   sendFileGewe,
   sendImageGewe,
   sendLinkGewe,
+  sendMiniAppGewe,
+  sendNameCardGewe,
   sendTextGewe,
   sendVideoGewe,
   sendVoiceGewe,
+  revokeMessageGewe,
 } from "./send.js";
+import { recallGeweQuoteReplyContext } from "./quote-context-cache.js";
 import type { GeweSendResult, ResolvedGeweAccount } from "./types.js";
 
 type GeweChannelData = {
   ats?: string;
+  appMsg?: {
+    appmsg: string;
+  };
+  quoteReply?: {
+    svrid?: string | number;
+    title?: string;
+    atWxid?: string;
+    partialText?: {
+      text?: string;
+      start?: string;
+      end?: string;
+      startIndex?: string | number;
+      endIndex?: string | number;
+      quoteMd5?: string;
+    };
+  };
+  emoji?: {
+    emojiMd5: string;
+    emojiSize: number;
+  };
+  nameCard?: {
+    nickName: string;
+    nameCardWxid: string;
+  };
+  miniApp?: {
+    miniAppId: string;
+    displayName: string;
+    pagePath: string;
+    coverImgUrl: string;
+    title: string;
+    userName: string;
+  };
+  revoke?: {
+    msgId: string | number;
+    newMsgId: string | number;
+    createTime: string | number;
+  };
+  forward?: {
+    kind: "image" | "video" | "file" | "link" | "miniApp";
+    xml: string;
+    coverImgUrl?: string;
+  };
   link?: {
     title: string;
     desc: string;
@@ -265,46 +324,115 @@ function resolveSilkArgs(params: {
   return next;
 }
 
-async function convertAudioToSilk(params: {
-  account: ResolvedGeweAccount;
-  sourcePath: string;
-}): Promise<{ buffer: Buffer; durationMs: number } | null> {
-  const core = getGeweRuntime();
-  const logger = core.logging.getChildLogger({ channel: CHANNEL_ID, module: "voice" });
-  if (params.account.config.voiceAutoConvert === false) return null;
+function trimPcmBuffer(params: {
+  buffer: Buffer;
+  sampleRate: number;
+}): { buffer: Buffer; durationMs: number } {
+  let pcmBuffer = params.buffer;
+  const frameSamples = params.sampleRate % 50 === 0 ? params.sampleRate / 50 : 0; // 20ms frames
+  const frameBytes = frameSamples > 0 ? frameSamples * PCM_BYTES_PER_SAMPLE : 0;
+  if (frameBytes > 0 && pcmBuffer.length % frameBytes !== 0) {
+    const trimmedSize = pcmBuffer.length - (pcmBuffer.length % frameBytes);
+    if (trimmedSize <= 0) {
+      throw new Error("ffmpeg produced empty PCM after frame trim");
+    }
+    pcmBuffer = Buffer.from(pcmBuffer.subarray(0, trimmedSize));
+  }
+  if (!pcmBuffer.length) {
+    throw new Error("ffmpeg produced empty PCM");
+  }
+  return {
+    buffer: pcmBuffer,
+    durationMs: Math.max(
+      1,
+      Math.round((pcmBuffer.length / (params.sampleRate * PCM_BYTES_PER_SAMPLE)) * 1000),
+    ),
+  };
+}
 
-  const sampleRate = resolveVoiceSampleRate(params.account);
-  const ffmpegPath = params.account.config.voiceFfmpegPath?.trim() || DEFAULT_VOICE_FFMPEG;
-  const fallbackArgs = [
-    ["-i", "{input}", "-o", "{output}", "-rate", "{sampleRate}"],
-    ["{input}", "{output}", "-rate", "{sampleRate}"],
-    ["{input}", "{output}", "{sampleRate}"],
-    ["{input}", "{output}"],
-  ];
-  const rustArgs = [
-    "encode",
+function formatBinaryCommandFailure(params: {
+  label: string;
+  result: BinaryCommandResult;
+}): string {
+  if (params.result.timedOut) {
+    return `${params.label} timed out after ${DEFAULT_VOICE_TIMEOUT_MS}ms`;
+  }
+  const detail = params.result.stderr.trim();
+  if (detail) return detail;
+  if (params.result.signal) return `signal ${params.result.signal}`;
+  return `exit code ${params.result.code ?? "?"}`;
+}
+
+async function convertAudioToSilkViaPipe(params: {
+  sourcePath: string;
+  ffmpegPath: string;
+  silkPath: string;
+  argTemplates: string[][];
+  sampleRate: number;
+}): Promise<{ buffer: Buffer; durationMs: number }> {
+  const ffmpegArgs = [
+    "-y",
     "-i",
-    "{input}",
-    "-o",
-    "{output}",
-    "--sample-rate",
-    "{sampleRate}",
-    "--tencent",
-    "--quiet",
+    params.sourcePath,
+    "-ac",
+    "1",
+    "-ar",
+    String(params.sampleRate),
+    "-f",
+    "s16le",
+    "pipe:1",
   ];
-  const customPath = params.account.config.voiceSilkPath?.trim();
-  const customArgs =
-    params.account.config.voiceSilkArgs?.length ? [params.account.config.voiceSilkArgs] : [];
-  let silkPath = customPath || DEFAULT_VOICE_SILK;
-  let argTemplates = customArgs.length ? customArgs : fallbackArgs;
-  if (!customPath) {
-    const rustSilk = await ensureRustSilkBinary(params.account);
-    if (rustSilk) {
-      silkPath = rustSilk;
-      argTemplates = [rustArgs];
+  const ffmpegResult = await runBinaryCommand({
+    argv: [params.ffmpegPath, ...ffmpegArgs],
+    timeoutMs: DEFAULT_VOICE_TIMEOUT_MS,
+  });
+  if (ffmpegResult.code !== 0) {
+    throw new Error(
+      `ffmpeg pipe failed: ${formatBinaryCommandFailure({
+        label: "ffmpeg",
+        result: ffmpegResult,
+      })}`,
+    );
+  }
+
+  const trimmedPcm = trimPcmBuffer({
+    buffer: ffmpegResult.stdout,
+    sampleRate: params.sampleRate,
+  });
+
+  let lastError: string | null = null;
+  for (const template of params.argTemplates) {
+    const args = resolveSilkArgs({
+      template,
+      input: "-",
+      output: "-",
+      sampleRate: params.sampleRate,
+    });
+    const result = await runBinaryCommand({
+      argv: [params.silkPath, ...args],
+      timeoutMs: DEFAULT_VOICE_TIMEOUT_MS,
+      input: trimmedPcm.buffer,
+    });
+    if (result.code === 0 && result.stdout.length > 0) {
+      return { buffer: result.stdout, durationMs: trimmedPcm.durationMs };
     }
+    lastError =
+      result.code === 0
+        ? "encoder produced empty stdout"
+        : formatBinaryCommandFailure({ label: "silk", result });
   }
 
+  throw new Error(`silk encoder pipe failed (${params.silkPath}): ${lastError ?? "unknown error"}`);
+}
+
+async function convertAudioToSilkViaFiles(params: {
+  sourcePath: string;
+  ffmpegPath: string;
+  silkPath: string;
+  argTemplates: string[][];
+  sampleRate: number;
+}): Promise<{ buffer: Buffer; durationMs: number }> {
+  const core = getGeweRuntime();
   const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-gewe-voice-"));
   const pcmPath = path.join(tmpDir, "voice.pcm");
   const silkOutPath = path.join(tmpDir, "voice.silk");
@@ -317,13 +445,13 @@ async function convertAudioToSilk(params: {
       "-ac",
       "1",
       "-ar",
-      String(sampleRate),
+      String(params.sampleRate),
       "-f",
       "s16le",
       pcmPath,
     ];
     const ffmpegResult = await core.system.runCommandWithTimeout(
-      [ffmpegPath, ...ffmpegArgs],
+      [params.ffmpegPath, ...ffmpegArgs],
       { timeoutMs: DEFAULT_VOICE_TIMEOUT_MS },
     );
     if (ffmpegResult.code !== 0) {
@@ -332,33 +460,22 @@ async function convertAudioToSilk(params: {
       );
     }
 
-    let pcmStat = await fs.stat(pcmPath);
-    const frameSamples = sampleRate % 50 === 0 ? sampleRate / 50 : 0; // 20ms frames
-    const frameBytes = frameSamples > 0 ? frameSamples * PCM_BYTES_PER_SAMPLE : 0;
-    if (frameBytes > 0 && pcmStat.size % frameBytes !== 0) {
-      const trimmedSize = pcmStat.size - (pcmStat.size % frameBytes);
-      if (trimmedSize <= 0) {
-        throw new Error("ffmpeg produced empty PCM after frame trim");
-      }
-      await fs.truncate(pcmPath, trimmedSize);
-      pcmStat = await fs.stat(pcmPath);
-    }
-
-    const durationMs = Math.max(
-      1,
-      Math.round((pcmStat.size / (sampleRate * PCM_BYTES_PER_SAMPLE)) * 1000),
-    );
+    const trimmedPcm = trimPcmBuffer({
+      buffer: await fs.readFile(pcmPath),
+      sampleRate: params.sampleRate,
+    });
+    await fs.writeFile(pcmPath, trimmedPcm.buffer);
 
     let encoded = false;
     let lastError: string | null = null;
-    for (const template of argTemplates) {
+    for (const template of params.argTemplates) {
       const args = resolveSilkArgs({
         template,
         input: pcmPath,
         output: silkOutPath,
-        sampleRate,
+        sampleRate: params.sampleRate,
       });
-      const result = await core.system.runCommandWithTimeout([silkPath, ...args], {
+      const result = await core.system.runCommandWithTimeout([params.silkPath, ...args], {
         timeoutMs: DEFAULT_VOICE_TIMEOUT_MS,
       });
       if (result.code === 0) {
@@ -372,7 +489,7 @@ async function convertAudioToSilk(params: {
     }
     if (!encoded) {
       throw new Error(
-        `silk encoder failed (${silkPath}): ${lastError ?? "unknown error"}`,
+        `silk encoder failed (${params.silkPath}): ${lastError ?? "unknown error"}`,
       );
     }
 
@@ -381,12 +498,71 @@ async function convertAudioToSilk(params: {
       throw new Error("silk encoder produced empty output");
     }
 
-    return { buffer, durationMs };
+    return { buffer, durationMs: trimmedPcm.durationMs };
+  } finally {
+    await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+export async function convertAudioToSilk(params: {
+  account: ResolvedGeweAccount;
+  sourcePath: string;
+}): Promise<{ buffer: Buffer; durationMs: number } | null> {
+  const core = getGeweRuntime();
+  const logger = core.logging.getChildLogger({ channel: CHANNEL_ID, module: "voice" });
+  if (params.account.config.voiceAutoConvert === false) return null;
+
+  const sampleRate = resolveVoiceSampleRate(params.account);
+  const ffmpegPath = params.account.config.voiceFfmpegPath?.trim() || DEFAULT_VOICE_FFMPEG;
+  const fallbackArgs = [
+    ["-i", "{input}", "-o", "{output}", "-rate", "{sampleRate}"],
+    ["{input}", "{output}", "-rate", "{sampleRate}"],
+    ["{input}", "{output}", "{sampleRate}"],
+    ["{input}", "{output}"],
+  ];
+  const rustArgs = buildRustSilkEncodeArgs({
+    input: "{input}",
+    output: "{output}",
+    sampleRate,
+  });
+  const customPath = params.account.config.voiceSilkPath?.trim();
+  const customArgs =
+    params.account.config.voiceSilkArgs?.length ? [params.account.config.voiceSilkArgs] : [];
+  let silkPath = customPath || DEFAULT_VOICE_SILK;
+  let argTemplates = customArgs.length ? customArgs : fallbackArgs;
+  if (!customPath) {
+    const rustSilk = await ensureRustSilkBinary(params.account);
+    if (rustSilk) {
+      silkPath = rustSilk;
+      argTemplates = [rustArgs];
+    }
+  }
+
+  try {
+    if (params.account.config.voiceSilkPipe === true) {
+      try {
+        return await convertAudioToSilkViaPipe({
+          sourcePath: params.sourcePath,
+          ffmpegPath,
+          silkPath,
+          argTemplates,
+          sampleRate,
+        });
+      } catch (err) {
+        logger.warn?.(`gewe voice pipe convert failed, falling back to temp files: ${String(err)}`);
+      }
+    }
+
+    return await convertAudioToSilkViaFiles({
+      sourcePath: params.sourcePath,
+      ffmpegPath,
+      silkPath,
+      argTemplates,
+      sampleRate,
+    });
   } catch (err) {
     logger.warn?.(`gewe voice convert failed: ${String(err)}`);
     return null;
-  } finally {
-    await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
   }
 }
 
@@ -551,6 +727,69 @@ function normalizeMediaToken(raw: string): string {
   return value;
 }
 
+function escapeXmlText(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+function md5Hex(value: string): string {
+  return crypto.createHash("md5").update(value, "utf8").digest("hex");
+}
+
+function buildPartialQuoteXml(params?: {
+  text?: string;
+  start?: string;
+  end?: string;
+  startIndex?: string | number;
+  endIndex?: string | number;
+  quoteMd5?: string;
+}): string {
+  if (!params) return "";
+  const text = params.text?.trim();
+  const start = (params.start?.trim() || text?.slice(0, 1) || "").trim();
+  const end = (params.end?.trim() || text?.slice(-1) || "").trim();
+  const quoteMd5 = (params.quoteMd5?.trim() || (text ? md5Hex(text) : "")).toLowerCase();
+  if (!start || !end || !quoteMd5) return "";
+
+  const startIndex =
+    params.startIndex != null && String(params.startIndex).trim()
+      ? String(params.startIndex).trim()
+      : "0";
+  const endIndex =
+    params.endIndex != null && String(params.endIndex).trim()
+      ? String(params.endIndex).trim()
+      : "0";
+
+  return `<partialtext><start>${escapeXmlText(start)}</start><end>${escapeXmlText(end)}</end><startindex>${escapeXmlText(startIndex)}</startindex><endindex>${escapeXmlText(endIndex)}</endindex><quotemd5>${escapeXmlText(quoteMd5)}</quotemd5></partialtext>`;
+}
+
+function buildQuoteReplyAppMsg(params: {
+  title: string;
+  svrid: string;
+  atWxid?: string;
+  partialText?: {
+    text?: string;
+    start?: string;
+    end?: string;
+    startIndex?: string | number;
+    endIndex?: string | number;
+    quoteMd5?: string;
+  };
+}): string {
+  const safeTitle = escapeXmlText(params.title.trim() || "引用回复");
+  const safeSvrid = escapeXmlText(params.svrid.trim());
+  const safeAtWxid = params.atWxid?.trim() ? escapeXmlText(params.atWxid.trim()) : undefined;
+  const encodedMsgSource = safeAtWxid
+    ? `&lt;msgsource&gt;&lt;atuserlist&gt;${safeAtWxid}&lt;/atuserlist&gt;&lt;/msgsource&gt;`
+    : "";
+  const partialTextXml = buildPartialQuoteXml(params.partialText);
+  return `<appmsg><title>${safeTitle}</title><type>57</type><refermsg>${partialTextXml}<svrid>${safeSvrid}</svrid>${safeAtWxid ? `<msgsource>${encodedMsgSource}</msgsource>` : ""}</refermsg></appmsg>`;
+}
+
 async function stageMedia(params: {
   account: ResolvedGeweAccount;
   cfg: OpenClawConfig;
@@ -714,6 +953,188 @@ export async function deliverGewePayload(params: {
   const mediaUrl =
     payload.mediaUrl?.trim() || payload.mediaUrls?.[0]?.trim() || "";
   const normalizedMediaUrl = normalizeMediaToken(mediaUrl);
+  const autoQuoteContext =
+    trimmedText && payload.replyToId?.trim() && !mediaUrl
+      ? recallGeweQuoteReplyContext({
+          accountId: account.accountId,
+          messageId: payload.replyToId,
+        })
+      : null;
+  const autoQuoteReplyEnabled = account.config.autoQuoteReply !== false;
+
+  if (geweData?.appMsg?.appmsg?.trim()) {
+    const result = await sendAppMsgGewe({
+      account,
+      toWxid,
+      appmsg: geweData.appMsg.appmsg.trim(),
+    });
+    core.channel.activity.record({
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      direction: "outbound",
+    });
+    statusSink?.({ lastOutboundAt: Date.now() });
+    return result;
+  }
+
+  const quoteReplySvrid =
+    geweData?.quoteReply?.svrid != null
+      ? String(geweData.quoteReply.svrid).trim()
+      : payload.replyToId?.trim() || "";
+  const quoteReplyTitle = geweData?.quoteReply?.title?.trim() || trimmedText;
+  if (quoteReplySvrid && quoteReplyTitle && geweData?.quoteReply) {
+    const result = await sendAppMsgGewe({
+      account,
+      toWxid,
+      appmsg: buildQuoteReplyAppMsg({
+        svrid: quoteReplySvrid,
+        title: quoteReplyTitle,
+        atWxid: geweData.quoteReply.atWxid?.trim(),
+        partialText: geweData.quoteReply.partialText,
+      }),
+    });
+    core.channel.activity.record({
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      direction: "outbound",
+    });
+    statusSink?.({ lastOutboundAt: Date.now() });
+    return result;
+  }
+
+  if (geweData?.emoji?.emojiMd5?.trim() && typeof geweData.emoji.emojiSize === "number") {
+    const result = await sendEmojiGewe({
+      account,
+      toWxid,
+      emojiMd5: geweData.emoji.emojiMd5.trim(),
+      emojiSize: Math.floor(geweData.emoji.emojiSize),
+    });
+    core.channel.activity.record({
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      direction: "outbound",
+    });
+    statusSink?.({ lastOutboundAt: Date.now() });
+    return result;
+  }
+
+  if (geweData?.nameCard?.nickName?.trim() && geweData.nameCard.nameCardWxid?.trim()) {
+    const result = await sendNameCardGewe({
+      account,
+      toWxid,
+      nickName: geweData.nameCard.nickName.trim(),
+      nameCardWxid: geweData.nameCard.nameCardWxid.trim(),
+    });
+    core.channel.activity.record({
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      direction: "outbound",
+    });
+    statusSink?.({ lastOutboundAt: Date.now() });
+    return result;
+  }
+
+  if (
+    geweData?.miniApp?.miniAppId?.trim() &&
+    geweData.miniApp.displayName?.trim() &&
+    geweData.miniApp.pagePath?.trim() &&
+    geweData.miniApp.coverImgUrl?.trim() &&
+    geweData.miniApp.title?.trim() &&
+    geweData.miniApp.userName?.trim()
+  ) {
+    const result = await sendMiniAppGewe({
+      account,
+      toWxid,
+      miniAppId: geweData.miniApp.miniAppId.trim(),
+      displayName: geweData.miniApp.displayName.trim(),
+      pagePath: geweData.miniApp.pagePath.trim(),
+      coverImgUrl: geweData.miniApp.coverImgUrl.trim(),
+      title: geweData.miniApp.title.trim(),
+      userName: geweData.miniApp.userName.trim(),
+    });
+    core.channel.activity.record({
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      direction: "outbound",
+    });
+    statusSink?.({ lastOutboundAt: Date.now() });
+    return result;
+  }
+
+  if (
+    geweData?.revoke?.msgId != null &&
+    geweData.revoke.newMsgId != null &&
+    geweData.revoke.createTime != null
+  ) {
+    const result = await revokeMessageGewe({
+      account,
+      toWxid,
+      msgId: String(geweData.revoke.msgId).trim(),
+      newMsgId: String(geweData.revoke.newMsgId).trim(),
+      createTime: String(geweData.revoke.createTime).trim(),
+    });
+    core.channel.activity.record({
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      direction: "outbound",
+    });
+    statusSink?.({ lastOutboundAt: Date.now() });
+    return result;
+  }
+
+  if (geweData?.forward?.kind && geweData.forward.xml?.trim()) {
+    let result: GeweSendResult | null = null;
+    switch (geweData.forward.kind) {
+      case "image":
+        result = await forwardImageGewe({
+          account,
+          toWxid,
+          xml: geweData.forward.xml.trim(),
+        });
+        break;
+      case "video":
+        result = await forwardVideoGewe({
+          account,
+          toWxid,
+          xml: geweData.forward.xml.trim(),
+        });
+        break;
+      case "file":
+        result = await forwardFileGewe({
+          account,
+          toWxid,
+          xml: geweData.forward.xml.trim(),
+        });
+        break;
+      case "link":
+        result = await forwardLinkGewe({
+          account,
+          toWxid,
+          xml: geweData.forward.xml.trim(),
+        });
+        break;
+      case "miniApp":
+        if (!geweData.forward.coverImgUrl?.trim()) {
+          break;
+        }
+        result = await forwardMiniAppGewe({
+          account,
+          toWxid,
+          xml: geweData.forward.xml.trim(),
+          coverImgUrl: geweData.forward.coverImgUrl.trim(),
+        });
+        break;
+    }
+    if (result) {
+      core.channel.activity.record({
+        channel: CHANNEL_ID,
+        accountId: account.accountId,
+        direction: "outbound",
+      });
+      statusSink?.({ lastOutboundAt: Date.now() });
+      return result;
+    }
+  }
 
   if (geweData?.link) {
     const link = geweData.link;
@@ -738,6 +1159,25 @@ export async function deliverGewePayload(params: {
     return result;
   }
 
+  if (autoQuoteReplyEnabled && trimmedText && payload.replyToId?.trim() && !mediaUrl) {
+    const result = await sendAppMsgGewe({
+      account,
+      toWxid,
+      appmsg: buildQuoteReplyAppMsg({
+        svrid: autoQuoteContext?.svrid ?? payload.replyToId.trim(),
+        title: trimmedText,
+        partialText: autoQuoteContext?.partialText,
+      }),
+    });
+    core.channel.activity.record({
+      channel: CHANNEL_ID,
+      accountId: account.accountId,
+      direction: "outbound",
+    });
+    statusSink?.({ lastOutboundAt: Date.now() });
+    return result;
+  }
+
   if (mediaUrl) {
     const audioAsVoice = payload.audioAsVoice === true;
     const forceFile = geweData?.forceFile === true;