gewe-openclaw 2026.2.2 → 2026.2.4

package/README.md

@@ -32,21 +32,31 @@ openclaw plugins install ./gewe-openclaw.tgz
 
 > 安装或启用插件后需要重启 Gateway。
 
+## 配置方式（二选一）
+
+安装完成后可任选一种方式完成配置：
+
+### 方式 A：Onboarding 向导
+
+```bash
+openclaw onboard
+```
+
+在通道列表中选择 **GeWe**，按提示填写 `token`、`appId`、`webhook` 与 `mediaPublicUrl` 等信息。
+
+### 方式 B：直接编辑配置文件
+
+直接编辑 `~/.openclaw/openclaw.json` 的 `channels.gewe-openclaw` 段落（见下方示例）。
+
 ## 配置
 
-插件配置放在 `~/.openclaw/openclaw.json` 的 `channels.gewe-openclaw`，并确保插件开启：
+插件配置放在 `~/.openclaw/openclaw.json` 的 `channels.gewe-openclaw`，并确保通道开启（示例仅保留必填/常用字段）：
 
 ```json5
 {
-  "plugins": {
-    "entries": {
-      "gewe-openclaw": { "enabled": true }
-    }
-  },
   "channels": {
     "gewe-openclaw": {
       "enabled": true,
-      "apiBaseUrl": "https://www.geweapi.com",
       "token": "<gewe-token>",
       "appId": "<gewe-app-id>",
       "webhookHost": "0.0.0.0",
@@ -56,18 +66,13 @@ openclaw plugins install ./gewe-openclaw.tgz
       "mediaPort": 4400,
       "mediaPath": "/gewe-media",
       "mediaPublicUrl": "https://your-public-domain/gewe-media",
-      "allowFrom": ["wxid_xxx"],
-      "silkAutoDownload": true,
-      "silkVersion": "latest",
-      "silkBaseUrl": "https://github.com/Wangnov/rust-silk/releases/download",
-      "silkInstallDir": "~/.openclaw/tools/rust-silk",
-      "silkAllowUnverified": false
+      "allowFrom": ["wxid_xxx"]
     }
   }
 }
 ```
 
-说明：
+完整参数说明：
 - `webhookHost/webhookPort/webhookPath`：GeWe 回调入口（需公网可达，常配合 FRP）。
 - `mediaPath`：本地媒体服务的路由前缀（默认 `/gewe-media`）。
 - `mediaPublicUrl`：公网访问地址的“基础前缀”，会自动拼接媒体 ID。通常应与 `mediaPath` 对齐，例如 `mediaPath="/gewe-media"` 时，`mediaPublicUrl` 也应包含 `/gewe-media`。
@@ -79,18 +84,28 @@ openclaw plugins install ./gewe-openclaw.tgz
 - `silkInstallDir`：自定义安装目录（默认 `~/.openclaw/tools/rust-silk/<version>`）。
 - `silkAllowUnverified`：校验文件缺失时是否允许继续（默认 `false`）。
 - `silkSha256`：手动指定下载包 SHA256（用于私有源或校验文件缺失场景）。
+ - `apiBaseUrl`：GeWe API 地址（默认 `https://www.geweapi.com`）。
+ - `voiceFfmpegPath`/`videoFfmpegPath`/`videoFfprobePath`：自定义 ffmpeg/ffprobe 路径。
+ - `voiceSilkPath`/`voiceSilkArgs`：自定义 silk 编码器路径和参数（不使用自动下载时）。
+ - `voiceSilkPipe`：是否启用 ffmpeg+rust-silk 的 stdin/stdout 管道（默认关闭；失败会回退到临时文件）。
+   - 低频/非高并发且磁盘压力不高时，推荐临时文件方案（更稳定/更快）。
+   - 高频/多并发或磁盘压力大时，推荐 pipe 方案（减少磁盘 IO）。
+ - `voiceDecodePath`/`voiceDecodeArgs`/`voiceDecodeOutput`：自定义 silk 解码器（入站语音转写用）。
+ - `mediaMaxMb`：上传媒体大小上限（默认 20MB）。
+ - `downloadMinDelayMs`/`downloadMaxDelayMs`：入站媒体下载节流。
 
 > 配置变更后需重启 Gateway。
 
-## 在 onboarding 列表中显示（可选）
+## 高级用法：让未安装插件也出现在 onboarding 列表
 
-OpenClaw 支持外部插件目录（catalog）。放置到以下路径即可被 onboarding 读取：
+默认情况下，**只有已安装的插件**会出现在 onboarding 列表中。  
+如果你希望“未安装时也能在列表中展示”，需要配置本地 catalog：
 
 ```
 ~/.openclaw/plugins/catalog.json
 ```
 
-示例（只需添加一次）：
+示例（添加一次即可）：
 
 ```json
 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gewe-openclaw",
-  "version": "2026.2.2",
+  "version": "2026.2.4",
   "type": "module",
   "description": "OpenClaw GeWe channel plugin",
   "license": "MIT",

package/src/config-schema.ts

@@ -44,6 +44,7 @@ export const GeweAccountSchemaBase = z
     voiceFfmpegPath: z.string().optional(),
     voiceSilkPath: z.string().optional(),
     voiceSilkArgs: z.array(z.string()).optional(),
+    voiceSilkPipe: z.boolean().optional(),
     voiceSampleRate: z.number().int().positive().optional(),
     voiceDecodePath: z.string().optional(),
     voiceDecodeArgs: z.array(z.string()).optional(),

package/src/delivery.ts

@@ -1,6 +1,8 @@
+import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { PassThrough } from "node:stream";
 import { fileURLToPath } from "node:url";
 
 import type { OpenClawConfig, ReplyPayload } from "openclaw/plugin-sdk";
@@ -246,6 +248,80 @@ function resolveSilkArgs(params: {
   return next;
 }
 
+async function encodeSilkWithPipes(params: {
+  ffmpegPath: string;
+  ffmpegArgs: string[];
+  silkPath: string;
+  silkArgs: string[];
+  timeoutMs: number;
+  sampleRate: number;
+}): Promise<{ buffer: Buffer; durationMs: number }> {
+  const ffmpeg = spawn(params.ffmpegPath, params.ffmpegArgs, {
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  const silk = spawn(params.silkPath, params.silkArgs, {
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  let pcmBytes = 0;
+  const pass = new PassThrough();
+  ffmpeg.stdout?.pipe(pass);
+  pass.on("data", (chunk) => {
+    pcmBytes += chunk.length;
+  });
+  pass.pipe(silk.stdin!);
+
+  const silkChunks: Buffer[] = [];
+  let ffmpegErr = "";
+  let silkErr = "";
+
+  ffmpeg.stderr?.on("data", (d) => {
+    ffmpegErr += d.toString();
+  });
+  silk.stderr?.on("data", (d) => {
+    silkErr += d.toString();
+  });
+  silk.stdout?.on("data", (d) => {
+    silkChunks.push(Buffer.from(d));
+  });
+
+  const timer = setTimeout(() => {
+    ffmpeg.kill("SIGKILL");
+    silk.kill("SIGKILL");
+  }, params.timeoutMs);
+
+  const [ffmpegRes, silkRes] = await Promise.all([
+    new Promise<{ code: number | null }>((resolve, reject) => {
+      ffmpeg.on("error", reject);
+      ffmpeg.on("close", (code) => resolve({ code }));
+    }),
+    new Promise<{ code: number | null }>((resolve, reject) => {
+      silk.on("error", reject);
+      silk.on("close", (code) => resolve({ code }));
+    }),
+  ]).finally(() => {
+    clearTimeout(timer);
+  });
+
+  if (ffmpegRes.code !== 0) {
+    throw new Error(`ffmpeg failed: ${ffmpegErr.trim() || `exit code ${ffmpegRes.code ?? "?"}`}`);
+  }
+  if (silkRes.code !== 0) {
+    throw new Error(`silk encoder failed: ${silkErr.trim() || `exit code ${silkRes.code ?? "?"}`}`);
+  }
+
+  const buffer = Buffer.concat(silkChunks);
+  if (!buffer.length) {
+    throw new Error("silk encoder produced empty output");
+  }
+
+  const durationMs = Math.max(
+    1,
+    Math.round((pcmBytes / (params.sampleRate * PCM_BYTES_PER_SAMPLE)) * 1000),
+  );
+  return { buffer, durationMs };
+}
+
 async function convertAudioToSilk(params: {
   account: ResolvedGeweAccount;
   sourcePath: string;
@@ -278,11 +354,52 @@ async function convertAudioToSilk(params: {
     params.account.config.voiceSilkArgs?.length ? [params.account.config.voiceSilkArgs] : [];
   let silkPath = customPath || DEFAULT_VOICE_SILK;
   let argTemplates = customArgs.length ? customArgs : fallbackArgs;
+  const pipeEnabled = params.account.config.voiceSilkPipe === true;
+  let usePipe = false;
   if (!customPath) {
     const rustSilk = await ensureRustSilkBinary(params.account);
     if (rustSilk) {
       silkPath = rustSilk;
       argTemplates = [rustArgs];
+      usePipe = pipeEnabled && customArgs.length === 0;
+    }
+  }
+
+  if (usePipe) {
+    try {
+      const ffmpegArgs = [
+        "-y",
+        "-i",
+        params.sourcePath,
+        "-ac",
+        "1",
+        "-ar",
+        String(sampleRate),
+        "-f",
+        "s16le",
+        "pipe:1",
+      ];
+      const silkArgs = [
+        "encode",
+        "-i",
+        "-",
+        "-o",
+        "-",
+        "--sample-rate",
+        String(sampleRate),
+        "--tencent",
+        "--quiet",
+      ];
+      return await encodeSilkWithPipes({
+        ffmpegPath,
+        ffmpegArgs,
+        silkPath,
+        silkArgs,
+        timeoutMs: DEFAULT_VOICE_TIMEOUT_MS,
+        sampleRate,
+      });
+    } catch (err) {
+      logger.warn?.(`gewe voice convert pipe failed: ${String(err)}`);
     }
   }
 
@@ -497,6 +614,21 @@ async function resolveLinkThumbUrl(params: {
   }
 }
 
+function normalizeMediaToken(raw: string): string {
+  let value = raw.trim();
+  if (value.toUpperCase().startsWith("MEDIA:")) {
+    value = value.slice("MEDIA:".length).trim();
+  }
+  if (
+    (value.startsWith("`") && value.endsWith("`")) ||
+    (value.startsWith("\"") && value.endsWith("\"")) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    value = value.slice(1, -1).trim();
+  }
+  return value;
+}
+
 async function stageMedia(params: {
   account: ResolvedGeweAccount;
   cfg: OpenClawConfig;
@@ -504,7 +636,7 @@ async function stageMedia(params: {
   allowRemote: boolean;
 }): Promise<ResolvedMedia> {
   const core = getGeweRuntime();
-  const rawUrl = params.mediaUrl.trim();
+  const rawUrl = normalizeMediaToken(params.mediaUrl);
   if (!rawUrl) throw new Error("mediaUrl is empty");
 
   if (looksLikeHttpUrl(rawUrl) && params.allowRemote) {
@@ -598,6 +730,7 @@ export async function deliverGewePayload(params: {
   const trimmedText = payload.text?.trim() ?? "";
   const mediaUrl =
     payload.mediaUrl?.trim() || payload.mediaUrls?.[0]?.trim() || "";
+  const normalizedMediaUrl = normalizeMediaToken(mediaUrl);
 
   if (geweData?.link) {
     const link = geweData.link;
@@ -625,12 +758,12 @@ export async function deliverGewePayload(params: {
   if (mediaUrl) {
     const audioAsVoice = payload.audioAsVoice === true;
     const forceFile = geweData?.forceFile === true;
-    const ttsVoiceHint = !forceFile && looksLikeTtsVoiceMediaUrl(mediaUrl);
+    const ttsVoiceHint = !forceFile && looksLikeTtsVoiceMediaUrl(normalizedMediaUrl);
     const wantsVoice = !forceFile && (audioAsVoice || ttsVoiceHint);
     const staged = await stageMedia({
       account,
       cfg,
-      mediaUrl,
+      mediaUrl: normalizedMediaUrl,
       allowRemote: !wantsVoice,
     });
     const contentType = staged.contentType;

package/src/inbound.ts

@@ -1,3 +1,4 @@
+import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -97,6 +98,71 @@ function resolveDecodeArgs(params: {
   return next;
 }
 
+async function decodeSilkWithPipes(params: {
+  silkPath: string;
+  silkArgs: string[];
+  ffmpegPath: string;
+  ffmpegArgs: string[];
+  input: Buffer;
+  timeoutMs: number;
+}): Promise<Buffer> {
+  const silk = spawn(params.silkPath, params.silkArgs, {
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  const ffmpeg = spawn(params.ffmpegPath, params.ffmpegArgs, {
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  let silkErr = "";
+  let ffmpegErr = "";
+  const chunks: Buffer[] = [];
+
+  silk.stderr?.on("data", (d) => {
+    silkErr += d.toString();
+  });
+  ffmpeg.stderr?.on("data", (d) => {
+    ffmpegErr += d.toString();
+  });
+  ffmpeg.stdout?.on("data", (d) => {
+    chunks.push(Buffer.from(d));
+  });
+
+  silk.stdout?.pipe(ffmpeg.stdin!);
+  silk.stdin?.write(params.input);
+  silk.stdin?.end();
+
+  const timer = setTimeout(() => {
+    silk.kill("SIGKILL");
+    ffmpeg.kill("SIGKILL");
+  }, params.timeoutMs);
+
+  const [silkRes, ffmpegRes] = await Promise.all([
+    new Promise<{ code: number | null }>((resolve, reject) => {
+      silk.on("error", reject);
+      silk.on("close", (code) => resolve({ code }));
+    }),
+    new Promise<{ code: number | null }>((resolve, reject) => {
+      ffmpeg.on("error", reject);
+      ffmpeg.on("close", (code) => resolve({ code }));
+    }),
+  ]).finally(() => {
+    clearTimeout(timer);
+  });
+
+  if (silkRes.code !== 0) {
+    throw new Error(`silk decode failed: ${silkErr.trim() || `exit code ${silkRes.code ?? "?"}`}`);
+  }
+  if (ffmpegRes.code !== 0) {
+    throw new Error(`ffmpeg failed: ${ffmpegErr.trim() || `exit code ${ffmpegRes.code ?? "?"}`}`);
+  }
+
+  const buffer = Buffer.concat(chunks);
+  if (!buffer.length) {
+    throw new Error("ffmpeg produced empty output");
+  }
+  return buffer;
+}
+
 async function decodeSilkVoice(params: {
   account: ResolvedGeweAccount;
   buffer: Buffer;
@@ -129,6 +195,52 @@ async function decodeSilkVoice(params: {
   ];
   if (decodeOutput === "wav") rustArgs.push("--wav");
   const rustSilk = customPath ? null : await ensureRustSilkBinary(params.account);
+  const pipeEnabled = params.account.config.voiceSilkPipe === true;
+  const usePipe = pipeEnabled && !!rustSilk && !customPath && customArgs.length === 0;
+  if (usePipe) {
+    try {
+      const silkArgs = [
+        "decode",
+        "-i",
+        "-",
+        "-o",
+        "-",
+        "--sample-rate",
+        String(sampleRate),
+        "--quiet",
+      ];
+      const ffmpegArgs = [
+        "-y",
+        "-f",
+        "s16le",
+        "-ar",
+        String(sampleRate),
+        "-ac",
+        "1",
+        "-i",
+        "pipe:0",
+        "-f",
+        "wav",
+        "pipe:1",
+      ];
+      const buffer = await decodeSilkWithPipes({
+        silkPath: rustSilk!,
+        silkArgs,
+        ffmpegPath,
+        ffmpegArgs,
+        input: params.buffer,
+        timeoutMs: DEFAULT_VOICE_DECODE_TIMEOUT_MS,
+      });
+      return {
+        buffer,
+        contentType: "audio/wav",
+        fileName: "voice.wav",
+      };
+    } catch (err) {
+      logger.warn?.(`gewe voice decode pipe failed: ${String(err)}`);
+    }
+  }
+
   const argTemplates = customArgs.length
     ? customArgs
     : rustSilk

package/src/silk.ts

@@ -30,6 +30,7 @@ type ResolvedVersion = {
 };
 
 const installCache = new Map<string, Promise<string | null>>();
+const resolvedPathCache = new Map<string, string | null>();
 
 export function buildRustSilkEncodeArgs(params: {
   input: string;
@@ -94,6 +95,10 @@ export async function ensureRustSilkBinary(
     process.arch,
   ].join("|");
 
+  if (resolvedPathCache.has(cacheKey)) {
+    return resolvedPathCache.get(cacheKey) ?? null;
+  }
+
   if (installCache.has(cacheKey)) {
     return installCache.get(cacheKey) ?? null;
   }
@@ -106,9 +111,14 @@ export async function ensureRustSilkBinary(
     folder,
     isLatest: resolved.isLatest,
     resolvedTag: resolved.resolvedTag,
-  }).finally(() => {
-    installCache.delete(cacheKey);
-  });
+  })
+    .then((result) => {
+      resolvedPathCache.set(cacheKey, result);
+      return result;
+    })
+    .finally(() => {
+      installCache.delete(cacheKey);
+    });
   installCache.set(cacheKey, installPromise);
   return installPromise;
 }

package/src/types.ts

@@ -37,6 +37,7 @@ export type GeweAccountConfig = {
   voiceFfmpegPath?: string;
   voiceSilkPath?: string;
   voiceSilkArgs?: string[];
+  voiceSilkPipe?: boolean;
   voiceSampleRate?: number;
   voiceDecodePath?: string;
   voiceDecodeArgs?: string[];