gewe-openclaw 2026.2.3 → 2026.3.2

package/README.md

@@ -32,21 +32,31 @@ openclaw plugins install ./gewe-openclaw.tgz
 
 > 安装或启用插件后需要重启 Gateway。
 
+## 配置方式（二选一）
+
+安装完成后可任选一种方式完成配置：
+
+### 方式 A：Onboarding 向导
+
+```bash
+openclaw onboard
+```
+
+在通道列表中选择 **GeWe**，按提示填写 `token`、`appId`、`webhook`，以及可选的 `mediaPublicUrl`/`S3` 媒体配置。
+
+### 方式 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,21 +66,33 @@ 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
+      "s3Enabled": true,
+      "s3Endpoint": "https://s3.amazonaws.com",
+      "s3Region": "us-east-1",
+      "s3Bucket": "your-bucket",
+      "s3AccessKeyId": "<access-key-id>",
+      "s3SecretAccessKey": "<secret-access-key>",
+      "s3UrlMode": "public",
+      "s3PublicBaseUrl": "https://cdn.example.com/gewe-media",
+      "s3KeyPrefix": "gewe-openclaw/outbound",
+      "allowFrom": ["wxid_xxx"]
     }
   }
 }
 ```
 
-说明：
+完整参数说明：
 - `webhookHost/webhookPort/webhookPath`：GeWe 回调入口（需公网可达，常配合 FRP）。
 - `mediaPath`：本地媒体服务的路由前缀（默认 `/gewe-media`）。
-- `mediaPublicUrl`：公网访问地址的“基础前缀”，会自动拼接媒体 ID。通常应与 `mediaPath` 对齐，例如 `mediaPath="/gewe-media"` 时，`mediaPublicUrl` 也应包含 `/gewe-media`。
+- `mediaPublicUrl`：本地反代回退时的公网地址前缀（可选）。配置后会自动拼接媒体 ID；通常应与 `mediaPath` 对齐。
+- `s3Enabled`：是否启用 S3 兼容上传。
+- `s3Endpoint/s3Region/s3Bucket/s3AccessKeyId/s3SecretAccessKey`：S3 兼容服务连接参数。
+- `s3SessionToken`：临时凭证可选字段。
+- `s3ForcePathStyle`：是否启用 path-style（部分 S3 兼容服务需要）。
+- `s3UrlMode`：`public` 或 `presigned`（默认 `public`）。
+- `s3PublicBaseUrl`：`public` 模式下用于拼接可访问 URL（必填）。
+- `s3PresignExpiresSec`：`presigned` 模式签名有效期（默认 3600 秒）。
+- `s3KeyPrefix`：对象 key 前缀（默认 `gewe-openclaw/outbound`）。
 - `allowFrom`：允许私聊触发的微信 ID（或在群里走 allowlist 规则）。
 - `voiceAutoConvert`：自动将音频转为 silk（默认开启；设为 `false` 可关闭）。
 - `silkAutoDownload`：自动下载 `rust-silk`（默认开启；可关闭后自行配置 `voiceSilkPath` / `voiceDecodePath`）。
@@ -79,18 +101,32 @@ 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`：入站媒体下载节流。
+
+发送媒体时的 URL 策略：
+- 本地文件：优先上传 S3，失败回退 `mediaPublicUrl` 本地反代。
+- 公网 URL：先尝试原 URL 发送，失败后再尝试上传 S3，仍失败回退本地反代。
 
 > 配置变更后需重启 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.3",
+  "version": "2026.3.2",
   "type": "module",
   "description": "OpenClaw GeWe channel plugin",
   "license": "MIT",
@@ -32,6 +32,8 @@
     }
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.922.0",
+    "@aws-sdk/s3-request-presigner": "^3.922.0",
     "zod": "^4.3.6"
   },
   "peerDependencies": {

package/src/config-schema.ts

@@ -40,10 +40,23 @@ export const GeweAccountSchemaBase = z
     mediaPath: z.string().optional(),
     mediaPublicUrl: z.string().optional(),
     mediaMaxMb: z.number().positive().optional(),
+    s3Enabled: z.boolean().optional(),
+    s3Endpoint: z.string().optional(),
+    s3Region: z.string().optional(),
+    s3Bucket: z.string().optional(),
+    s3AccessKeyId: z.string().optional(),
+    s3SecretAccessKey: z.string().optional(),
+    s3SessionToken: z.string().optional(),
+    s3ForcePathStyle: z.boolean().optional(),
+    s3PublicBaseUrl: z.string().optional(),
+    s3KeyPrefix: z.string().optional(),
+    s3UrlMode: z.enum(["public", "presigned"]).optional(),
+    s3PresignExpiresSec: z.number().int().positive().optional(),
     voiceAutoConvert: z.boolean().optional(),
     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(),
@@ -84,6 +97,37 @@ export const GeweAccountSchemaBase = z
         message: "downloadMaxDelayMs must be >= downloadMinDelayMs",
       });
     }
+
+    if (value.s3Enabled === true) {
+      const required: Array<keyof typeof value> = [
+        "s3Endpoint",
+        "s3Region",
+        "s3Bucket",
+        "s3AccessKeyId",
+        "s3SecretAccessKey",
+      ];
+      for (const key of required) {
+        const raw = value[key];
+        if (typeof raw !== "string" || !raw.trim()) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: [key],
+            message: `${String(key)} is required when s3Enabled=true`,
+          });
+        }
+      }
+      const mode = value.s3UrlMode ?? "public";
+      if (mode === "public") {
+        const base = value.s3PublicBaseUrl?.trim();
+        if (!base) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["s3PublicBaseUrl"],
+            message: "s3PublicBaseUrl is required when s3UrlMode=public",
+          });
+        }
+      }
+    }
   });
 
 export const GeweAccountSchema = GeweAccountSchemaBase.superRefine((value, ctx) => {

package/src/delivery.ts

@@ -1,12 +1,15 @@
+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";
 import { extractOriginalFilename, extensionForMime } from "openclaw/plugin-sdk";
 import { CHANNEL_ID } from "./constants.js";
 import { getGeweRuntime } from "./runtime.js";
+import { resolveS3Config, uploadToS3 } from "./s3.js";
 import { ensureRustSilkBinary } from "./silk.js";
 import {
   sendFileGewe,
@@ -41,6 +44,9 @@ type ResolvedMedia = {
   contentType?: string;
   fileName?: string;
   localPath?: string;
+  sourceKind: "remote" | "local";
+  sourceUrl: string;
+  provider: "direct" | "s3" | "proxy";
 };
 
 const LINK_THUMB_MAX_BYTES = 50 * 1024;
@@ -92,6 +98,21 @@ function buildPublicUrl(baseUrl: string, id: string): string {
   return `${trimmed}/${encodeURIComponent(id)}`;
 }
 
+function hasProxyBase(account: ResolvedGeweAccount): boolean {
+  return Boolean(account.config.mediaPublicUrl?.trim());
+}
+
+function hasS3(account: ResolvedGeweAccount): boolean {
+  return account.config.s3Enabled === true;
+}
+
+function resolveFallbackProviders(account: ResolvedGeweAccount): Array<"s3" | "proxy"> {
+  const providers: Array<"s3" | "proxy"> = [];
+  if (hasS3(account)) providers.push("s3");
+  if (hasProxyBase(account)) providers.push("proxy");
+  return providers;
+}
+
 function resolveMediaMaxBytes(account: ResolvedGeweAccount): number {
   const maxMb = account.config.mediaMaxMb;
   if (typeof maxMb === "number" && maxMb > 0) return Math.floor(maxMb * 1024 * 1024);
@@ -246,6 +267,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 +373,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)}`);
     }
   }
 
@@ -436,11 +572,6 @@ async function stageThumbBuffer(params: {
   fileName?: string;
 }): Promise<string> {
   const core = getGeweRuntime();
-  const publicBase = params.account.config.mediaPublicUrl?.trim();
-  if (!publicBase) {
-    throw new Error("mediaPublicUrl not configured (required for link thumbnails)");
-  }
-
   const normalized = await normalizeThumbBuffer({
     buffer: params.buffer,
     contentType: params.contentType,
@@ -449,6 +580,31 @@ async function stageThumbBuffer(params: {
     throw new Error("link thumbnail exceeds 50KB after resize");
   }
 
+  if (hasS3(params.account)) {
+    try {
+      const s3Config = resolveS3Config(params.account.config);
+      if (!s3Config) throw new Error("s3 not configured");
+      const uploaded = await uploadToS3({
+        config: s3Config,
+        accountId: params.account.accountId,
+        buffer: normalized.buffer,
+        contentType: normalized.contentType,
+        fileName: params.fileName,
+      });
+      return uploaded.url;
+    } catch (err) {
+      if (!hasProxyBase(params.account)) {
+        throw new Error(`s3 thumb upload failed and proxy fallback unavailable: ${String(err)}`);
+      }
+      const logger = core.logging.getChildLogger({ channel: CHANNEL_ID, module: "thumb" });
+      logger.warn?.(`gewe thumb s3 upload failed, fallback proxy: ${String(err)}`);
+    }
+  }
+
+  const publicBase = params.account.config.mediaPublicUrl?.trim();
+  if (!publicBase) {
+    throw new Error("mediaPublicUrl not configured (required for thumbnail fallback)");
+  }
   const saved = await core.channel.media.saveMediaBuffer(
     normalized.buffer,
     normalized.contentType,
@@ -521,26 +677,27 @@ async function stageMedia(params: {
   const core = getGeweRuntime();
   const rawUrl = normalizeMediaToken(params.mediaUrl);
   if (!rawUrl) throw new Error("mediaUrl is empty");
-
-  if (looksLikeHttpUrl(rawUrl) && params.allowRemote) {
+  const isRemote = looksLikeHttpUrl(rawUrl);
+  if (isRemote && params.allowRemote) {
     const contentType = await core.media.detectMime({ filePath: rawUrl });
     const fileName = path.basename(new URL(rawUrl).pathname || "");
-    return { publicUrl: rawUrl, contentType: contentType ?? undefined, fileName };
-  }
-
-  const publicBase = params.account.config.mediaPublicUrl?.trim();
-  if (!publicBase) {
-    throw new Error(
-      "mediaPublicUrl not configured (required for local media or forced proxy)",
-    );
+    return {
+      publicUrl: rawUrl,
+      contentType: contentType ?? undefined,
+      fileName,
+      sourceKind: "remote",
+      sourceUrl: rawUrl,
+      provider: "direct",
+    };
   }
 
   const maxBytes = resolveMediaMaxBytes(params.account);
   let buffer: Buffer;
   let contentType: string | undefined;
   let fileName: string | undefined;
+  let sourceLocalPath: string | undefined;
 
-  if (looksLikeHttpUrl(rawUrl)) {
+  if (isRemote) {
     const fetched = await core.channel.media.fetchRemoteMedia({
       url: rawUrl,
       maxBytes,
@@ -554,6 +711,41 @@ async function stageMedia(params: {
     buffer = await fs.readFile(localPath);
     contentType = await core.media.detectMime({ buffer, filePath: localPath });
     fileName = path.basename(localPath);
+    sourceLocalPath = localPath;
+  }
+
+  if (hasS3(params.account)) {
+    try {
+      const s3Config = resolveS3Config(params.account.config);
+      if (!s3Config) throw new Error("s3 not configured");
+      const uploaded = await uploadToS3({
+        config: s3Config,
+        accountId: params.account.accountId,
+        buffer,
+        contentType,
+        fileName,
+      });
+      return {
+        publicUrl: uploaded.url,
+        contentType,
+        fileName,
+        localPath: sourceLocalPath,
+        sourceKind: isRemote ? "remote" : "local",
+        sourceUrl: rawUrl,
+        provider: "s3",
+      };
+    } catch (err) {
+      if (!hasProxyBase(params.account)) {
+        throw new Error(`s3 upload failed and proxy fallback unavailable: ${String(err)}`);
+      }
+      const logger = core.logging.getChildLogger({ channel: CHANNEL_ID, module: "media" });
+      logger.warn?.(`gewe s3 upload failed, fallback to proxy: ${String(err)}`);
+    }
+  }
+
+  const publicBase = params.account.config.mediaPublicUrl?.trim();
+  if (!publicBase) {
+    throw new Error("mediaPublicUrl not configured (required for proxy fallback)");
   }
 
   const saved = await core.channel.media.saveMediaBuffer(
@@ -567,8 +759,7 @@ async function stageMedia(params: {
   let resolvedId = saved.id;
   let resolvedPath = saved.path;
   const desiredExt =
-    extensionForMime(contentType ?? saved.contentType) ||
-    path.extname(resolvedFileName);
+    extensionForMime(contentType ?? saved.contentType) || path.extname(resolvedFileName);
   if (desiredExt && !path.extname(resolvedId)) {
     const nextId = `${resolvedId}${desiredExt}`;
     const nextPath = path.join(path.dirname(saved.path), nextId);
@@ -580,7 +771,10 @@ async function stageMedia(params: {
     publicUrl: buildPublicUrl(publicBase, resolvedId),
     contentType: contentType ?? saved.contentType,
     fileName: resolvedFileName || resolvedId,
-    localPath: resolvedPath,
+    localPath: sourceLocalPath ?? resolvedPath,
+    sourceKind: isRemote ? "remote" : "local",
+    sourceUrl: rawUrl,
+    provider: "proxy",
   };
 }
 
@@ -599,6 +793,29 @@ async function resolvePublicUrl(params: {
   return staged.publicUrl;
 }
 
+function shouldRetryWithStagedFallback(params: {
+  originalUrl: string;
+  staged: ResolvedMedia;
+  account: ResolvedGeweAccount;
+}): boolean {
+  if (!looksLikeHttpUrl(params.originalUrl)) return false;
+  if (params.staged.provider !== "direct") return false;
+  return resolveFallbackProviders(params.account).length > 0;
+}
+
+async function stageFallbackFromRemote(params: {
+  account: ResolvedGeweAccount;
+  cfg: OpenClawConfig;
+  originalUrl: string;
+}): Promise<ResolvedMedia> {
+  return await stageMedia({
+    account: params.account,
+    cfg: params.cfg,
+    mediaUrl: params.originalUrl,
+    allowRemote: false,
+  });
+}
+
 export async function deliverGewePayload(params: {
   payload: ReplyPayload;
   account: ResolvedGeweAccount;
@@ -657,12 +874,34 @@ export async function deliverGewePayload(params: {
       const declaredDuration = resolveVoiceDurationMs(geweData);
       if (isSilkAudio({ contentType, fileName })) {
         if (declaredDuration) {
-          const result = await sendVoiceGewe({
-            account,
-            toWxid,
-            voiceUrl: staged.publicUrl,
-            voiceDuration: declaredDuration,
-          });
+          let result: GeweSendResult;
+          try {
+            result = await sendVoiceGewe({
+              account,
+              toWxid,
+              voiceUrl: staged.publicUrl,
+              voiceDuration: declaredDuration,
+            });
+          } catch (err) {
+            if (!shouldRetryWithStagedFallback({
+              originalUrl: normalizedMediaUrl,
+              staged,
+              account,
+            })) {
+              throw err;
+            }
+            const fallback = await stageFallbackFromRemote({
+              account,
+              cfg,
+              originalUrl: normalizedMediaUrl,
+            });
+            result = await sendVoiceGewe({
+              account,
+              toWxid,
+              voiceUrl: fallback.publicUrl,
+              voiceDuration: declaredDuration,
+            });
+          }
           core.channel.activity.record({
             channel: CHANNEL_ID,
             accountId: account.accountId,
@@ -678,21 +917,56 @@ export async function deliverGewePayload(params: {
         });
         if (converted) {
           const voiceDuration = declaredDuration ?? converted.durationMs;
-          const publicBase = account.config.mediaPublicUrl?.trim();
-          if (!publicBase) {
-            throw new Error("mediaPublicUrl not configured (required for silk voice)");
+          let voiceUrl: string;
+          if (hasS3(account)) {
+            try {
+              const s3Config = resolveS3Config(account.config);
+              if (!s3Config) throw new Error("s3 not configured");
+              const uploaded = await uploadToS3({
+                config: s3Config,
+                accountId: account.accountId,
+                buffer: converted.buffer,
+                contentType: "audio/silk",
+                fileName: "voice.silk",
+              });
+              voiceUrl = uploaded.url;
+            } catch (err) {
+              if (!hasProxyBase(account)) {
+                throw new Error(
+                  `s3 silk upload failed and proxy fallback unavailable: ${String(err)}`,
+                );
+              }
+              const publicBase = account.config.mediaPublicUrl?.trim();
+              if (!publicBase) {
+                throw new Error("mediaPublicUrl not configured (required for silk voice)");
+              }
+              const saved = await core.channel.media.saveMediaBuffer(
+                converted.buffer,
+                "audio/silk",
+                "outbound",
+                resolveMediaMaxBytes(account),
+                "voice.silk",
+              );
+              voiceUrl = buildPublicUrl(publicBase, saved.id);
+            }
+          } else {
+            const publicBase = account.config.mediaPublicUrl?.trim();
+            if (!publicBase) {
+              throw new Error("mediaPublicUrl not configured (required for silk voice)");
+            }
+            const saved = await core.channel.media.saveMediaBuffer(
+              converted.buffer,
+              "audio/silk",
+              "outbound",
+              resolveMediaMaxBytes(account),
+              "voice.silk",
+            );
+            voiceUrl = buildPublicUrl(publicBase, saved.id);
           }
-          const saved = await core.channel.media.saveMediaBuffer(
-            converted.buffer,
-            "audio/silk",
-            "outbound",
-            resolveMediaMaxBytes(account),
-            "voice.silk",
-          );
           const result = await sendVoiceGewe({
             account,
             toWxid,
-            voiceUrl: buildPublicUrl(publicBase, saved.id),
+            voiceUrl,
             voiceDuration,
           });
           core.channel.activity.record({
@@ -707,11 +981,32 @@ export async function deliverGewePayload(params: {
     }
 
     if (!forceFile && kind === "image") {
-      const result = await sendImageGewe({
-        account,
-        toWxid,
-        imgUrl: staged.publicUrl,
-      });
+      let result: GeweSendResult;
+      try {
+        result = await sendImageGewe({
+          account,
+          toWxid,
+          imgUrl: staged.publicUrl,
+        });
+      } catch (err) {
+        if (!shouldRetryWithStagedFallback({
+          originalUrl: normalizedMediaUrl,
+          staged,
+          account,
+        })) {
+          throw err;
+        }
+        const fallback = await stageFallbackFromRemote({
+          account,
+          cfg,
+          originalUrl: normalizedMediaUrl,
+        });
+        result = await sendImageGewe({
+          account,
+          toWxid,
+          imgUrl: fallback.publicUrl,
+        });
+      }
       core.channel.activity.record({
         channel: CHANNEL_ID,
         accountId: account.accountId,
@@ -785,6 +1080,11 @@ export async function deliverGewePayload(params: {
           url: thumbUrl,
           allowRemote: true,
         });
+        const canRetryMediaFallback = shouldRetryWithStagedFallback({
+          originalUrl: normalizedMediaUrl,
+          staged: stagedVideo,
+          account,
+        });
         try {
           const result = await sendVideoGewe({
             account,
@@ -801,6 +1101,33 @@ export async function deliverGewePayload(params: {
           statusSink?.({ lastOutboundAt: Date.now() });
           return result;
         } catch (err) {
+          if (canRetryMediaFallback) {
+            const fallbackVideo = await stageFallbackFromRemote({
+              account,
+              cfg,
+              originalUrl: normalizedMediaUrl,
+            });
+            const fallbackThumb = await resolvePublicUrl({
+              account,
+              cfg,
+              url: thumbUrl,
+              allowRemote: false,
+            });
+            const result = await sendVideoGewe({
+              account,
+              toWxid,
+              videoUrl: fallbackVideo.publicUrl,
+              thumbUrl: fallbackThumb,
+              videoDuration: Math.floor(videoDuration),
+            });
+            core.channel.activity.record({
+              channel: CHANNEL_ID,
+              accountId: account.accountId,
+              direction: "outbound",
+            });
+            statusSink?.({ lastOutboundAt: Date.now() });
+            return result;
+          }
           if (fallbackThumbUrl && fallbackThumbUrl !== thumbUrl) {
             logger.warn?.(
               `gewe video send failed with primary thumb, retrying fallback: ${String(err)}`,
@@ -835,12 +1162,34 @@ export async function deliverGewePayload(params: {
       geweData?.fileName ||
       fileName ||
       (contentType ? `file${contentType.includes("/") ? `.${contentType.split("/")[1]}` : ""}` : "file");
-    const result = await sendFileGewe({
-      account,
-      toWxid,
-      fileUrl: staged.publicUrl,
-      fileName: fallbackName,
-    });
+    let result: GeweSendResult;
+    try {
+      result = await sendFileGewe({
+        account,
+        toWxid,
+        fileUrl: staged.publicUrl,
+        fileName: fallbackName,
+      });
+    } catch (err) {
+      if (!shouldRetryWithStagedFallback({
+        originalUrl: normalizedMediaUrl,
+        staged,
+        account,
+      })) {
+        throw err;
+      }
+      const fallback = await stageFallbackFromRemote({
+        account,
+        cfg,
+        originalUrl: normalizedMediaUrl,
+      });
+      result = await sendFileGewe({
+        account,
+        toWxid,
+        fileUrl: fallback.publicUrl,
+        fileName: fallbackName,
+      });
+    }
     core.channel.activity.record({
       channel: CHANNEL_ID,
       accountId: account.accountId,

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/onboarding.ts

@@ -171,7 +171,7 @@ export const geweOnboarding: GeweOnboardingAdapter = {
         "You will need:",
         "- GeWe token + appId",
         "- Public webhook endpoint (FRP or reverse proxy)",
-        "- Public media base URL (for sending voice/media)",
+        "- Public media base URL (optional proxy fallback)",
       ].join("\n"),
       "GeWe setup",
     );
@@ -217,9 +217,109 @@ export const geweOnboarding: GeweOnboardingAdapter = {
       message: "Media public URL (prefix)",
       placeholder: "https://your-domain/gewe-media",
       initialValue: existing.mediaPublicUrl,
-      validate: (value) => (value.trim() ? undefined : "Required"),
     });
 
+    const enableS3 = await ctx.prompter.confirm({
+      message: "Enable S3-compatible media delivery?",
+      initialValue: existing.s3Enabled === true,
+    });
+    let s3Patch: Partial<GeweAccountConfig> = {};
+    if (enableS3) {
+      const s3Endpoint = await ctx.prompter.text({
+        message: "S3 endpoint",
+        placeholder: "https://s3.amazonaws.com",
+        initialValue: existing.s3Endpoint,
+        validate: (value) => (value.trim() ? undefined : "Required"),
+      });
+      const s3Region = await ctx.prompter.text({
+        message: "S3 region",
+        placeholder: "us-east-1",
+        initialValue: existing.s3Region,
+        validate: (value) => (value.trim() ? undefined : "Required"),
+      });
+      const s3Bucket = await ctx.prompter.text({
+        message: "S3 bucket",
+        initialValue: existing.s3Bucket,
+        validate: (value) => (value.trim() ? undefined : "Required"),
+      });
+      const s3AccessKeyId = await ctx.prompter.text({
+        message: "S3 access key id",
+        initialValue: existing.s3AccessKeyId,
+        validate: (value) => (value.trim() ? undefined : "Required"),
+      });
+      const s3SecretAccessKey = await ctx.prompter.text({
+        message: "S3 secret access key",
+        initialValue: existing.s3SecretAccessKey,
+        validate: (value) => (value.trim() ? undefined : "Required"),
+      });
+      const s3SessionToken = await ctx.prompter.text({
+        message: "S3 session token (optional)",
+        initialValue: existing.s3SessionToken,
+      });
+      const s3ForcePathStyle = await ctx.prompter.confirm({
+        message: "Use path-style for S3 endpoint?",
+        initialValue: existing.s3ForcePathStyle === true,
+      });
+      const s3KeyPrefix = await ctx.prompter.text({
+        message: "S3 key prefix (optional)",
+        placeholder: "gewe-openclaw/outbound",
+        initialValue: existing.s3KeyPrefix,
+      });
+      const s3UrlMode = await ctx.prompter.select({
+        message: "S3 URL mode",
+        options: [
+          { value: "public", label: "public (default)" },
+          { value: "presigned", label: "presigned" },
+        ],
+        initialValue: existing.s3UrlMode ?? "public",
+      });
+      const s3PublicBaseUrl =
+        s3UrlMode === "public"
+          ? await ctx.prompter.text({
+              message: "S3 public base URL",
+              placeholder: "https://cdn.example.com/gewe-media",
+              initialValue: existing.s3PublicBaseUrl,
+              validate: (value) => (value.trim() ? undefined : "Required"),
+            })
+          : await ctx.prompter.text({
+              message: "S3 public base URL (optional in presigned mode)",
+              initialValue: existing.s3PublicBaseUrl,
+            });
+      const s3PresignExpiresSecRaw =
+        s3UrlMode === "presigned"
+          ? await ctx.prompter.text({
+              message: "Presigned URL expire seconds",
+              initialValue: String(existing.s3PresignExpiresSec ?? 3600),
+              validate: (value) => {
+                const parsed = Number(value);
+                if (!Number.isInteger(parsed) || parsed <= 0) {
+                  return "Must be a positive integer";
+                }
+                return undefined;
+              },
+            })
+          : "";
+      s3Patch = {
+        s3Enabled: true,
+        s3Endpoint: s3Endpoint.trim(),
+        s3Region: s3Region.trim(),
+        s3Bucket: s3Bucket.trim(),
+        s3AccessKeyId: s3AccessKeyId.trim(),
+        s3SecretAccessKey: s3SecretAccessKey.trim(),
+        s3SessionToken: s3SessionToken.trim() || undefined,
+        s3ForcePathStyle,
+        s3KeyPrefix: s3KeyPrefix.trim() || undefined,
+        s3UrlMode,
+        s3PublicBaseUrl: s3PublicBaseUrl.trim() || undefined,
+        s3PresignExpiresSec:
+          s3UrlMode === "presigned" ? Number(s3PresignExpiresSecRaw) : undefined,
+      };
+    } else {
+      s3Patch = {
+        s3Enabled: false,
+      };
+    }
+
     let allowFrom = existing.allowFrom;
     let dmPolicy: GeweAccountConfig["dmPolicy"] | undefined;
     if (ctx.forceAllowFrom) {
@@ -255,7 +355,8 @@ export const geweOnboarding: GeweOnboardingAdapter = {
       mediaHost: existing.mediaHost ?? DEFAULT_MEDIA_HOST,
       mediaPort: existing.mediaPort ?? DEFAULT_MEDIA_PORT,
       mediaPath: existing.mediaPath ?? DEFAULT_MEDIA_PATH,
-      mediaPublicUrl: mediaPublicUrl.trim(),
+      mediaPublicUrl: mediaPublicUrl.trim() || undefined,
+      ...s3Patch,
       ...(allowFrom ? { allowFrom } : {}),
       ...(dmPolicy ? { dmPolicy } : {}),
     });

package/src/s3.ts

@@ -0,0 +1,149 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+
+import { GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { extensionForMime } from "openclaw/plugin-sdk";
+
+import type { GeweAccountConfig } from "./types.js";
+
+const DEFAULT_S3_KEY_PREFIX = "gewe-openclaw/outbound";
+const DEFAULT_PRESIGN_EXPIRES_SEC = 3600;
+
+export type ResolvedS3Config = {
+  endpoint: string;
+  region: string;
+  bucket: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  sessionToken?: string;
+  forcePathStyle: boolean;
+  publicBaseUrl?: string;
+  keyPrefix: string;
+  urlMode: "public" | "presigned";
+  presignExpiresSec: number;
+};
+
+function trimTrailingSlash(value: string): string {
+  return value.replace(/\/+$/, "");
+}
+
+function normalizePrefix(value?: string): string {
+  const raw = value?.trim() || DEFAULT_S3_KEY_PREFIX;
+  return raw.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+
+export function resolveS3Config(config: GeweAccountConfig): ResolvedS3Config | null {
+  if (config.s3Enabled !== true) return null;
+  const endpoint = config.s3Endpoint?.trim();
+  const region = config.s3Region?.trim();
+  const bucket = config.s3Bucket?.trim();
+  const accessKeyId = config.s3AccessKeyId?.trim();
+  const secretAccessKey = config.s3SecretAccessKey?.trim();
+  if (!endpoint || !region || !bucket || !accessKeyId || !secretAccessKey) {
+    throw new Error("s3Enabled=true but S3 credentials or endpoint is incomplete");
+  }
+  const urlMode = config.s3UrlMode ?? "public";
+  const publicBaseUrl = config.s3PublicBaseUrl?.trim();
+  if (urlMode === "public" && !publicBaseUrl) {
+    throw new Error("s3PublicBaseUrl is required when s3UrlMode=public");
+  }
+  return {
+    endpoint: trimTrailingSlash(endpoint),
+    region,
+    bucket,
+    accessKeyId,
+    secretAccessKey,
+    sessionToken: config.s3SessionToken?.trim() || undefined,
+    forcePathStyle: config.s3ForcePathStyle === true,
+    publicBaseUrl: publicBaseUrl ? trimTrailingSlash(publicBaseUrl) : undefined,
+    keyPrefix: normalizePrefix(config.s3KeyPrefix),
+    urlMode,
+    presignExpiresSec:
+      config.s3PresignExpiresSec && config.s3PresignExpiresSec > 0
+        ? Math.floor(config.s3PresignExpiresSec)
+        : DEFAULT_PRESIGN_EXPIRES_SEC,
+  };
+}
+
+function createClient(config: ResolvedS3Config): S3Client {
+  return new S3Client({
+    endpoint: config.endpoint,
+    region: config.region,
+    forcePathStyle: config.forcePathStyle,
+    credentials: {
+      accessKeyId: config.accessKeyId,
+      secretAccessKey: config.secretAccessKey,
+      ...(config.sessionToken ? { sessionToken: config.sessionToken } : {}),
+    },
+  });
+}
+
+function inferExtension(fileName?: string, contentType?: string): string {
+  const byName = fileName ? path.extname(fileName).toLowerCase() : "";
+  if (byName) return byName;
+  const byMime = contentType ? extensionForMime(contentType) : "";
+  return byMime || "";
+}
+
+export function buildS3ObjectKey(params: {
+  accountId: string;
+  config: ResolvedS3Config;
+  fileName?: string;
+  contentType?: string;
+}): string {
+  const now = new Date();
+  const yyyy = String(now.getUTCFullYear());
+  const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(now.getUTCDate()).padStart(2, "0");
+  const ext = inferExtension(params.fileName, params.contentType);
+  return [
+    params.config.keyPrefix,
+    params.accountId,
+    yyyy,
+    mm,
+    dd,
+    `${randomUUID()}${ext}`,
+  ].join("/");
+}
+
+function buildPublicUrl(config: ResolvedS3Config, key: string): string {
+  if (!config.publicBaseUrl) {
+    throw new Error("s3PublicBaseUrl missing");
+  }
+  return `${config.publicBaseUrl}/${key.split("/").map(encodeURIComponent).join("/")}`;
+}
+
+export async function uploadToS3(params: {
+  config: ResolvedS3Config;
+  accountId: string;
+  buffer: Buffer;
+  contentType?: string;
+  fileName?: string;
+}): Promise<{ key: string; url: string }> {
+  const key = buildS3ObjectKey({
+    accountId: params.accountId,
+    config: params.config,
+    fileName: params.fileName,
+    contentType: params.contentType,
+  });
+  const client = createClient(params.config);
+  const put = new PutObjectCommand({
+    Bucket: params.config.bucket,
+    Key: key,
+    Body: params.buffer,
+    ...(params.contentType ? { ContentType: params.contentType } : {}),
+  });
+  await client.send(put);
+  if (params.config.urlMode === "public") {
+    return { key, url: buildPublicUrl(params.config, key) };
+  }
+  const getCommand = new GetObjectCommand({
+    Bucket: params.config.bucket,
+    Key: key,
+  });
+  const url = await getSignedUrl(client, getCommand, {
+    expiresIn: params.config.presignExpiresSec,
+  });
+  return { key, url };
+}

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

@@ -33,10 +33,23 @@ export type GeweAccountConfig = {
   mediaPath?: string;
   mediaPublicUrl?: string;
   mediaMaxMb?: number;
+  s3Enabled?: boolean;
+  s3Endpoint?: string;
+  s3Region?: string;
+  s3Bucket?: string;
+  s3AccessKeyId?: string;
+  s3SecretAccessKey?: string;
+  s3SessionToken?: string;
+  s3ForcePathStyle?: boolean;
+  s3PublicBaseUrl?: string;
+  s3KeyPrefix?: string;
+  s3UrlMode?: "public" | "presigned";
+  s3PresignExpiresSec?: number;
   voiceAutoConvert?: boolean;
   voiceFfmpegPath?: string;
   voiceSilkPath?: string;
   voiceSilkArgs?: string[];
+  voiceSilkPipe?: boolean;
   voiceSampleRate?: number;
   voiceDecodePath?: string;
   voiceDecodeArgs?: string[];