gewe-openclaw 2026.1.31 → 2026.2.2

package/README.md

@@ -56,7 +56,12 @@ openclaw plugins install ./gewe-openclaw.tgz
       "mediaPort": 4400,
       "mediaPath": "/gewe-media",
       "mediaPublicUrl": "https://your-public-domain/gewe-media",
-      "allowFrom": ["wxid_xxx"]
+      "allowFrom": ["wxid_xxx"],
+      "silkAutoDownload": true,
+      "silkVersion": "latest",
+      "silkBaseUrl": "https://github.com/Wangnov/rust-silk/releases/download",
+      "silkInstallDir": "~/.openclaw/tools/rust-silk",
+      "silkAllowUnverified": false
     }
   }
 }
@@ -64,8 +69,16 @@ openclaw plugins install ./gewe-openclaw.tgz
 
 说明：
 - `webhookHost/webhookPort/webhookPath`：GeWe 回调入口（需公网可达，常配合 FRP）。
-- `mediaPublicUrl`：公网访问地址，供微信拉取媒体。
+- `mediaPath`：本地媒体服务的路由前缀（默认 `/gewe-media`）。
+- `mediaPublicUrl`：公网访问地址的“基础前缀”，会自动拼接媒体 ID。通常应与 `mediaPath` 对齐，例如 `mediaPath="/gewe-media"` 时，`mediaPublicUrl` 也应包含 `/gewe-media`。
 - `allowFrom`：允许私聊触发的微信 ID（或在群里走 allowlist 规则）。
+- `voiceAutoConvert`：自动将音频转为 silk（默认开启；设为 `false` 可关闭）。
+- `silkAutoDownload`：自动下载 `rust-silk`（默认开启；可关闭后自行配置 `voiceSilkPath` / `voiceDecodePath`）。
+- `silkVersion`：自动下载的 `rust-silk` 版本（`latest` 会自动清理旧版本）。
+- `silkBaseUrl`：自定义下载源（默认 GitHub Releases）。
+- `silkInstallDir`：自定义安装目录（默认 `~/.openclaw/tools/rust-silk/<version>`）。
+- `silkAllowUnverified`：校验文件缺失时是否允许继续（默认 `false`）。
+- `silkSha256`：手动指定下载包 SHA256（用于私有源或校验文件缺失场景）。
 
 > 配置变更后需重启 Gateway。
 
@@ -107,6 +120,8 @@ OpenClaw 支持外部插件目录（catalog）。放置到以下路径即可被
 }
 ```
 
+> 现在插件已支持 onboarding：选择 GeWe 通道后会提示填写 token/appId/webhook/mediaPublicUrl 等配置。
+
 ## 依赖
 
 ### npm 依赖
@@ -120,8 +135,8 @@ OpenClaw 支持外部插件目录（catalog）。放置到以下路径即可被
 ### 系统级工具
 
 - `ffmpeg` / `ffprobe`（用于视频缩略图与时长）
-- `silk-encoder`（出站语音转 silk）
-- `silk-decoder`（入站语音解码）
+- `rust-silk`（出站语音转 silk + 入站语音解码；支持自动下载）
+- 或者自行安装 `silk-encoder` / `silk-decoder` 并在配置中指定路径
 
 ### 网络/服务依赖
 

package/package.json

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

package/src/accounts.ts

@@ -5,7 +5,7 @@ import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
 import { CHANNEL_CONFIG_KEY } from "./constants.js";
 import type { CoreConfig, GeweAccountConfig, GeweAppIdSource, GeweTokenSource } from "./types.js";
 
-const DEFAULT_API_BASE_URL = "http://api.geweapi.com";
+const DEFAULT_API_BASE_URL = "https://www.geweapi.com";
 
 export type ResolvedGeweAccount = {
   accountId: string;

package/src/channel.ts

@@ -30,6 +30,7 @@ import { resolveGeweGroupToolPolicy, resolveGeweRequireMention } from "./policy.
 import { getGeweRuntime } from "./runtime.js";
 import { sendTextGewe } from "./send.js";
 import type { CoreConfig, ResolvedGeweAccount } from "./types.js";
+import { geweOnboarding } from "./onboarding.js";
 
 const meta = {
   id: CHANNEL_ID,
@@ -55,6 +56,7 @@ type GeweSetupInput = ChannelSetupInput & {
 export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
   id: CHANNEL_ID,
   meta,
+  onboarding: geweOnboarding,
   pairing: {
     idLabel: "wechatUserId",
     normalizeAllowEntry: (entry) => stripChannelPrefix(entry),

package/src/config-schema.ts

@@ -49,6 +49,12 @@ export const GeweAccountSchemaBase = z
     voiceDecodeArgs: z.array(z.string()).optional(),
     voiceDecodeSampleRate: z.number().int().positive().optional(),
     voiceDecodeOutput: z.enum(["pcm", "wav"]).optional(),
+    silkAutoDownload: z.boolean().optional(),
+    silkVersion: z.string().optional(),
+    silkBaseUrl: z.string().optional(),
+    silkSha256: z.string().optional(),
+    silkAllowUnverified: z.boolean().optional(),
+    silkInstallDir: z.string().optional(),
     videoFfmpegPath: z.string().optional(),
     videoFfprobePath: z.string().optional(),
     videoThumbUrl: z.string().optional(),

package/src/delivery.ts

@@ -7,6 +7,7 @@ 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 { ensureRustSilkBinary } from "./silk.js";
 import {
   sendFileGewe,
   sendImageGewe,
@@ -251,20 +252,39 @@ async function convertAudioToSilk(params: {
 }): Promise<{ buffer: Buffer; durationMs: number } | null> {
   const core = getGeweRuntime();
   const logger = core.logging.getChildLogger({ channel: CHANNEL_ID, module: "voice" });
-  if (!params.account.config.voiceAutoConvert) return null;
+  if (params.account.config.voiceAutoConvert === false) return null;
 
   const sampleRate = resolveVoiceSampleRate(params.account);
   const ffmpegPath = params.account.config.voiceFfmpegPath?.trim() || DEFAULT_VOICE_FFMPEG;
-  const silkPath = params.account.config.voiceSilkPath?.trim() || DEFAULT_VOICE_SILK;
-  const customArgs =
-    params.account.config.voiceSilkArgs?.length ? [params.account.config.voiceSilkArgs] : [];
   const fallbackArgs = [
     ["-i", "{input}", "-o", "{output}", "-rate", "{sampleRate}"],
     ["{input}", "{output}", "-rate", "{sampleRate}"],
     ["{input}", "{output}", "{sampleRate}"],
     ["{input}", "{output}"],
   ];
-  const argTemplates = customArgs.length ? customArgs : fallbackArgs;
+  const rustArgs = [
+    "encode",
+    "-i",
+    "{input}",
+    "-o",
+    "{output}",
+    "--sample-rate",
+    "{sampleRate}",
+    "--tencent",
+    "--quiet",
+  ];
+  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 tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-gewe-voice-"));
   const pcmPath = path.join(tmpDir, "voice.pcm");

package/src/download.ts

@@ -4,7 +4,7 @@ import type { ResolvedGeweAccount } from "./types.js";
 type DownloadResult = { fileUrl: string };
 
 function resolveBaseUrl(account: ResolvedGeweAccount): string {
-  return account.config.apiBaseUrl?.trim() || "http://api.geweapi.com";
+  return account.config.apiBaseUrl?.trim() || "https://www.geweapi.com";
 }
 
 export async function downloadGeweImage(params: {

package/src/inbound.ts

@@ -9,6 +9,7 @@ import type { GeweDownloadQueue } from "./download-queue.js";
 import { downloadGeweFile, downloadGeweImage, downloadGeweVideo, downloadGeweVoice } from "./download.js";
 import { deliverGewePayload } from "./delivery.js";
 import { getGeweRuntime } from "./runtime.js";
+import { ensureRustSilkBinary } from "./silk.js";
 import {
   normalizeGeweAllowlist,
   resolveGeweAllowlistMatch,
@@ -116,10 +117,28 @@ async function decodeSilkVoice(params: {
     ["{input}", "-o", "{output}"],
     ["-i", "{input}", "{output}"],
   ];
-  const argTemplates = customArgs.length ? customArgs : fallbackArgs;
+  const rustArgs = [
+    "decode",
+    "-i",
+    "{input}",
+    "-o",
+    "{output}",
+    "--sample-rate",
+    "{sampleRate}",
+    "--quiet",
+  ];
+  if (decodeOutput === "wav") rustArgs.push("--wav");
+  const rustSilk = customPath ? null : await ensureRustSilkBinary(params.account);
+  const argTemplates = customArgs.length
+    ? customArgs
+    : rustSilk
+      ? [rustArgs]
+      : fallbackArgs;
   const candidates = customPath
     ? [customPath]
-    : ["silk-decoder", "silk-v3-decoder", "decoder"];
+    : rustSilk
+      ? [rustSilk]
+      : ["silk-decoder", "silk-v3-decoder", "decoder"];
 
   const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-gewe-voice-in-"));
   const silkPath = path.join(tmpDir, "voice.silk");

package/src/monitor.ts

@@ -15,9 +15,9 @@ import type {
   ResolvedGeweAccount,
 } from "./types.js";
 
-const DEFAULT_WEBHOOK_PORT = 18786;
+const DEFAULT_WEBHOOK_PORT = 4399;
 const DEFAULT_WEBHOOK_HOST = "0.0.0.0";
-const DEFAULT_WEBHOOK_PATH = "/gewe-webhook";
+const DEFAULT_WEBHOOK_PATH = "/webhook";
 const HEALTH_PATH = "/healthz";
 const DEDUPE_TTL_MS = 12 * 60 * 60 * 1000;
 

package/src/onboarding.ts

@@ -0,0 +1,265 @@
+import type { ChannelPlugin, OpenClawConfig, WizardPrompter } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
+
+import type { CoreConfig, GeweAccountConfig, ResolvedGeweAccount } from "./types.js";
+import { resolveGeweAccount, resolveDefaultGeweAccountId, listGeweAccountIds } from "./accounts.js";
+import { CHANNEL_CONFIG_KEY, CHANNEL_ID, stripChannelPrefix } from "./constants.js";
+
+const DEFAULT_WEBHOOK_HOST = "0.0.0.0";
+const DEFAULT_WEBHOOK_PORT = 4399;
+const DEFAULT_WEBHOOK_PATH = "/webhook";
+const DEFAULT_MEDIA_HOST = "0.0.0.0";
+const DEFAULT_MEDIA_PORT = 4400;
+const DEFAULT_MEDIA_PATH = "/gewe-media";
+const DEFAULT_API_BASE_URL = "https://www.geweapi.com";
+
+type GeweOnboardingAdapter = NonNullable<
+  ChannelPlugin<ResolvedGeweAccount>["onboarding"]
+>;
+
+type AccountSelection = {
+  accountId: string;
+  label: string;
+};
+
+function listAccountChoices(cfg: OpenClawConfig): AccountSelection[] {
+  const ids = listGeweAccountIds(cfg as CoreConfig);
+  return ids.map((accountId) => ({
+    accountId,
+    label: accountId === DEFAULT_ACCOUNT_ID ? "default (primary)" : accountId,
+  }));
+}
+
+async function promptAccountId(params: {
+  cfg: OpenClawConfig;
+  prompter: WizardPrompter;
+  currentId?: string;
+}): Promise<string> {
+  const choices = listAccountChoices(params.cfg);
+  const defaultId = resolveDefaultGeweAccountId(params.cfg as CoreConfig);
+  const initial = params.currentId?.trim() || defaultId || DEFAULT_ACCOUNT_ID;
+  const selection = await params.prompter.select({
+    message: "GeWe account",
+    options: [
+      ...choices.map((item) => ({ value: item.accountId, label: item.label })),
+      { value: "__new__", label: "Add a new account" },
+    ],
+    initialValue: initial,
+  });
+
+  if (selection !== "__new__") {
+    return normalizeAccountId(selection) ?? DEFAULT_ACCOUNT_ID;
+  }
+
+  const entered = await params.prompter.text({
+    message: "New GeWe account id",
+    validate: (value) => (value?.trim() ? undefined : "Required"),
+  });
+  const normalized = normalizeAccountId(String(entered));
+  if (String(entered).trim() !== normalized) {
+    await params.prompter.note(`Normalized account id to "${normalized}".`, "GeWe account");
+  }
+  return normalized;
+}
+
+function parseAllowFrom(raw: string): string[] {
+  return raw
+    .split(/[\n,;]+/g)
+    .map((entry) => stripChannelPrefix(entry.trim()))
+    .filter(Boolean);
+}
+
+async function promptAllowFrom(params: {
+  prompter: WizardPrompter;
+  existing?: Array<string | number>;
+  required?: boolean;
+}): Promise<string[]> {
+  const initial = (params.existing ?? []).map((entry) => String(entry)).join(", ");
+  const value = await params.prompter.text({
+    message: "Allowlist wxid (comma or newline separated)",
+    placeholder: "wxid_xxx, wxid_yyy",
+    initialValue: initial || undefined,
+    validate: params.required
+      ? (input) => (parseAllowFrom(input).length > 0 ? undefined : "Required")
+      : undefined,
+  });
+  return parseAllowFrom(String(value));
+}
+
+function applyAccountPatch(
+  cfg: OpenClawConfig,
+  accountId: string,
+  patch: GeweAccountConfig,
+): OpenClawConfig {
+  const existing = (cfg.channels?.[CHANNEL_CONFIG_KEY] ?? {}) as GeweAccountConfig & {
+    accounts?: Record<string, GeweAccountConfig>;
+  };
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    return {
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        [CHANNEL_CONFIG_KEY]: {
+          ...existing,
+          ...patch,
+          enabled: patch.enabled ?? existing.enabled ?? true,
+        },
+      },
+    };
+  }
+
+  return {
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      [CHANNEL_CONFIG_KEY]: {
+        ...existing,
+        accounts: {
+          ...(existing.accounts ?? {}),
+          [accountId]: {
+            ...(existing.accounts?.[accountId] ?? {}),
+            ...patch,
+            enabled:
+              patch.enabled ??
+              existing.accounts?.[accountId]?.enabled ??
+              existing.enabled ??
+              true,
+          },
+        },
+      },
+    },
+  };
+}
+
+function readAccountConfig(cfg: OpenClawConfig, accountId: string): GeweAccountConfig {
+  const channelCfg = (cfg.channels?.[CHANNEL_CONFIG_KEY] ?? {}) as GeweAccountConfig & {
+    accounts?: Record<string, GeweAccountConfig>;
+  };
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    return channelCfg;
+  }
+  return channelCfg.accounts?.[accountId] ?? {};
+}
+
+export const geweOnboarding: GeweOnboardingAdapter = {
+  channel: CHANNEL_ID,
+  async getStatus(ctx) {
+    const accountId =
+      ctx.accountOverrides?.[CHANNEL_ID] ??
+      resolveDefaultGeweAccountId(ctx.cfg as CoreConfig);
+    const account = resolveGeweAccount({ cfg: ctx.cfg as CoreConfig, accountId });
+    const configured = Boolean(account.token?.trim() && account.appId?.trim());
+    const label = configured ? "configured" : "not configured";
+    const status = `GeWe (${accountId}): ${label}`;
+    return {
+      channel: CHANNEL_ID,
+      configured,
+      statusLines: [status],
+      selectionHint: label,
+      quickstartScore: configured ? 2 : 0,
+    };
+  },
+  async configure(ctx) {
+    const accountId = ctx.shouldPromptAccountIds
+      ? await promptAccountId({ cfg: ctx.cfg, prompter: ctx.prompter })
+      : resolveDefaultGeweAccountId(ctx.cfg as CoreConfig);
+    const resolved = resolveGeweAccount({ cfg: ctx.cfg as CoreConfig, accountId });
+    const existing = readAccountConfig(ctx.cfg, accountId);
+
+    await ctx.prompter.note(
+      [
+        "You will need:",
+        "- GeWe token + appId",
+        "- Public webhook endpoint (FRP or reverse proxy)",
+        "- Public media base URL (for sending voice/media)",
+      ].join("\n"),
+      "GeWe setup",
+    );
+
+    const token = await ctx.prompter.text({
+      message: "GeWe token",
+      initialValue: resolved.tokenSource !== "none" ? resolved.token : existing.token,
+      validate: (value) => (value.trim() ? undefined : "Required"),
+    });
+    const appId = await ctx.prompter.text({
+      message: "GeWe appId",
+      initialValue: resolved.appIdSource !== "none" ? resolved.appId : existing.appId,
+      validate: (value) => (value.trim() ? undefined : "Required"),
+    });
+
+    const apiBaseUrl = await ctx.prompter.text({
+      message: "GeWe API base URL",
+      initialValue: existing.apiBaseUrl ?? DEFAULT_API_BASE_URL,
+      validate: (value) => (value.trim() ? undefined : "Required"),
+    });
+
+    const webhookHost = await ctx.prompter.text({
+      message: "Webhook host",
+      initialValue: existing.webhookHost ?? DEFAULT_WEBHOOK_HOST,
+      validate: (value) => (value.trim() ? undefined : "Required"),
+    });
+    const webhookPortRaw = await ctx.prompter.text({
+      message: "Webhook port",
+      initialValue: String(existing.webhookPort ?? DEFAULT_WEBHOOK_PORT),
+      validate: (value) => {
+        const parsed = Number(value);
+        if (!Number.isInteger(parsed) || parsed <= 0) return "Must be a positive integer";
+        return undefined;
+      },
+    });
+    const webhookPath = await ctx.prompter.text({
+      message: "Webhook path",
+      initialValue: existing.webhookPath ?? DEFAULT_WEBHOOK_PATH,
+      validate: (value) => (value.trim() ? undefined : "Required"),
+    });
+
+    const mediaPublicUrl = await ctx.prompter.text({
+      message: "Media public URL (prefix)",
+      placeholder: "https://your-domain/gewe-media",
+      initialValue: existing.mediaPublicUrl,
+      validate: (value) => (value.trim() ? undefined : "Required"),
+    });
+
+    let allowFrom = existing.allowFrom;
+    let dmPolicy: GeweAccountConfig["dmPolicy"] | undefined;
+    if (ctx.forceAllowFrom) {
+      allowFrom = await promptAllowFrom({
+        prompter: ctx.prompter,
+        existing: existing.allowFrom,
+        required: true,
+      });
+      dmPolicy = "allowlist";
+    } else {
+      const wantsAllowlist = await ctx.prompter.confirm({
+        message: "Set a DM allowlist now? (optional)",
+        initialValue: false,
+      });
+      if (wantsAllowlist) {
+        allowFrom = await promptAllowFrom({
+          prompter: ctx.prompter,
+          existing: existing.allowFrom,
+          required: true,
+        });
+        dmPolicy = "allowlist";
+      }
+    }
+
+    let nextCfg = applyAccountPatch(ctx.cfg, accountId, {
+      enabled: true,
+      token: token.trim(),
+      appId: appId.trim(),
+      apiBaseUrl: apiBaseUrl.trim().replace(/\/$/, ""),
+      webhookHost: webhookHost.trim(),
+      webhookPort: Number(webhookPortRaw),
+      webhookPath: webhookPath.trim(),
+      mediaHost: existing.mediaHost ?? DEFAULT_MEDIA_HOST,
+      mediaPort: existing.mediaPort ?? DEFAULT_MEDIA_PORT,
+      mediaPath: existing.mediaPath ?? DEFAULT_MEDIA_PATH,
+      mediaPublicUrl: mediaPublicUrl.trim(),
+      ...(allowFrom ? { allowFrom } : {}),
+      ...(dmPolicy ? { dmPolicy } : {}),
+    });
+
+    return { cfg: nextCfg, accountId };
+  },
+};

package/src/send.ts

@@ -8,7 +8,7 @@ type GeweSendContext = {
 };
 
 function buildContext(account: ResolvedGeweAccount): GeweSendContext {
-  const baseUrl = account.config.apiBaseUrl?.trim() || "http://api.geweapi.com";
+  const baseUrl = account.config.apiBaseUrl?.trim() || "https://www.geweapi.com";
   return { baseUrl, token: account.token, appId: account.appId };
 }
 

package/src/silk.ts

@@ -0,0 +1,465 @@
+import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream, existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+
+import type { ResolvedGeweAccount } from "./types.js";
+import { getGeweRuntime } from "./runtime.js";
+import { CHANNEL_ID } from "./constants.js";
+
+const DEFAULT_SILK_VERSION = "latest";
+const DEFAULT_SILK_BASE_URL =
+  "https://github.com/Wangnov/rust-silk/releases/download";
+const DEFAULT_DOWNLOAD_TIMEOUT_MS = 120_000;
+const DEFAULT_EXTRACT_TIMEOUT_MS = 60_000;
+
+type RustSilkAsset = {
+  name: string;
+  archive: "tar.xz" | "zip";
+  binary: string;
+};
+
+type ResolvedVersion = {
+  tag: string;
+  folder: string;
+  isLatest: boolean;
+  resolvedTag?: string;
+};
+
+const installCache = new Map<string, Promise<string | null>>();
+
+export function buildRustSilkEncodeArgs(params: {
+  input: string;
+  output: string;
+  sampleRate: number;
+  tencent?: boolean;
+}): string[] {
+  const args = [
+    "encode",
+    "-i",
+    params.input,
+    "-o",
+    params.output,
+    "--sample-rate",
+    String(params.sampleRate),
+    "--quiet",
+  ];
+  if (params.tencent ?? true) {
+    args.push("--tencent");
+  }
+  return args;
+}
+
+export function buildRustSilkDecodeArgs(params: {
+  input: string;
+  output: string;
+  sampleRate: number;
+  wav?: boolean;
+}): string[] {
+  const args = [
+    "decode",
+    "-i",
+    params.input,
+    "-o",
+    params.output,
+    "--sample-rate",
+    String(params.sampleRate),
+    "--quiet",
+  ];
+  if (params.wav) args.push("--wav");
+  return args;
+}
+
+export async function ensureRustSilkBinary(
+  account: ResolvedGeweAccount,
+): Promise<string | null> {
+  if (account.config.silkAutoDownload === false) return null;
+
+  const asset = resolveRustSilkAsset(process.platform, process.arch);
+  if (!asset) return null;
+
+  const versionInput = account.config.silkVersion?.trim() || DEFAULT_SILK_VERSION;
+  const baseUrl = account.config.silkBaseUrl?.trim() || DEFAULT_SILK_BASE_URL;
+  const resolved = await resolveRequestedVersion(versionInput, baseUrl);
+  const { tag, folder } = resolved;
+  const cacheKey = [
+    baseUrl,
+    tag,
+    folder,
+    asset.name,
+    process.platform,
+    process.arch,
+  ].join("|");
+
+  if (installCache.has(cacheKey)) {
+    return installCache.get(cacheKey) ?? null;
+  }
+
+  const installPromise = installRustSilk({
+    account,
+    asset,
+    baseUrl,
+    tag,
+    folder,
+    isLatest: resolved.isLatest,
+    resolvedTag: resolved.resolvedTag,
+  }).finally(() => {
+    installCache.delete(cacheKey);
+  });
+  installCache.set(cacheKey, installPromise);
+  return installPromise;
+}
+
+async function installRustSilk(params: {
+  account: ResolvedGeweAccount;
+  asset: RustSilkAsset;
+  baseUrl: string;
+  tag: string;
+  folder: string;
+  isLatest: boolean;
+  resolvedTag?: string;
+}): Promise<string | null> {
+  const core = getGeweRuntime();
+  const logger = core.logging.getChildLogger({ channel: CHANNEL_ID, module: "silk" });
+  const customInstall = params.account.config.silkInstallDir?.trim();
+  const installRoot = customInstall
+    ? resolveUserPath(customInstall)
+    : path.join(resolveConfigDir(), "tools", "rust-silk");
+  const installDir = path.join(installRoot, params.folder);
+  const binaryPath = path.join(installDir, params.asset.binary);
+
+  if (existsSync(binaryPath)) {
+    if (params.isLatest && params.folder !== "latest") {
+      await cleanupOldVersions(installRoot, params.folder);
+    }
+    return binaryPath;
+  }
+
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-gewe-silk-"));
+  try {
+    const archivePath = path.join(tmpDir, params.asset.name);
+    const archiveUrl = `${params.baseUrl}/${params.tag}/${params.asset.name}`;
+    await downloadFile(archiveUrl, archivePath);
+
+    const expectedHash = await resolveChecksum({
+      account: params.account,
+      baseUrl: params.baseUrl,
+      tag: params.tag,
+      assetName: params.asset.name,
+    });
+    if (!expectedHash && params.account.config.silkAllowUnverified !== true) {
+      throw new Error("missing checksum for rust-silk download");
+    }
+    if (expectedHash) {
+      const actual = await sha256File(archivePath);
+      if (actual !== expectedHash) {
+        throw new Error(
+          `checksum mismatch for ${params.asset.name}: expected ${expectedHash} got ${actual}`,
+        );
+      }
+    }
+
+    await extractArchive(core, archivePath, tmpDir, params.asset.archive);
+    const extracted = await findBinary(tmpDir, params.asset.binary);
+    if (!extracted) {
+      throw new Error(`rust-silk binary not found in ${params.asset.name}`);
+    }
+
+    await fs.mkdir(installDir, { recursive: true });
+    await fs.copyFile(extracted, binaryPath);
+    await fs.chmod(binaryPath, 0o755).catch(() => {});
+    await fs.writeFile(
+      path.join(installDir, "install.json"),
+      JSON.stringify(
+        {
+          version: params.folder,
+          tag: params.tag,
+          resolvedTag: params.resolvedTag ?? null,
+          asset: params.asset.name,
+          installedAt: new Date().toISOString(),
+        },
+        null,
+        2,
+      ),
+      "utf8",
+    );
+    if (params.isLatest && params.folder !== "latest") {
+      await cleanupOldVersions(installRoot, params.folder);
+    }
+    return binaryPath;
+  } catch (err) {
+    logger.warn?.(`rust-silk install failed: ${String(err)}`);
+    return null;
+  } finally {
+    await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+async function resolveRequestedVersion(
+  versionInput: string,
+  baseUrl: string,
+): Promise<ResolvedVersion> {
+  const trimmed = versionInput.trim();
+  if (!trimmed || trimmed === "latest") {
+    const latestTag = await resolveLatestTag(baseUrl).catch(() => null);
+    if (latestTag) {
+      const folder = latestTag.startsWith("v") ? latestTag.slice(1) : latestTag;
+      return {
+        tag: latestTag,
+        folder,
+        isLatest: true,
+        resolvedTag: latestTag,
+      };
+    }
+    return { tag: "latest", folder: "latest", isLatest: true };
+  }
+  const { tag, folder } = normalizeVersion(trimmed);
+  return { tag, folder, isLatest: false };
+}
+
+function normalizeVersion(version: string): { tag: string; folder: string } {
+  const trimmed = version.trim();
+  const tag = trimmed.startsWith("v") ? trimmed : `v${trimmed}`;
+  const folder = trimmed.startsWith("v") ? trimmed.slice(1) : trimmed;
+  return { tag, folder };
+}
+
+async function resolveLatestTag(baseUrl: string): Promise<string | null> {
+  const repoUrl = deriveRepoUrl(baseUrl);
+  if (!repoUrl) return null;
+  const response = await fetchWithTimeout(
+    `${repoUrl}/releases/latest`,
+    DEFAULT_DOWNLOAD_TIMEOUT_MS,
+  );
+  const finalUrl = response.url || "";
+  const match = finalUrl.match(/\/tag\/([^/?#]+)/);
+  if (!match) return null;
+  return decodeURIComponent(match[1]);
+}
+
+function deriveRepoUrl(baseUrl: string): string | null {
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  const match = trimmed.match(
+    /^(https?:\/\/github\.com\/[^/]+\/[^/]+)(?:\/releases\/download)?$/i,
+  );
+  if (match) return match[1];
+  return null;
+}
+
+function resolveRustSilkAsset(
+  platform: NodeJS.Platform,
+  arch: string,
+): RustSilkAsset | null {
+  if (platform === "darwin" && arch === "arm64") {
+    return {
+      name: "rust-silk-aarch64-apple-darwin.tar.xz",
+      archive: "tar.xz",
+      binary: "rust-silk",
+    };
+  }
+  if (platform === "darwin" && (arch === "x64" || arch === "amd64")) {
+    return {
+      name: "rust-silk-x86_64-apple-darwin.tar.xz",
+      archive: "tar.xz",
+      binary: "rust-silk",
+    };
+  }
+  if (platform === "linux" && arch === "arm64") {
+    return {
+      name: "rust-silk-aarch64-unknown-linux-gnu.tar.xz",
+      archive: "tar.xz",
+      binary: "rust-silk",
+    };
+  }
+  if (platform === "linux" && (arch === "x64" || arch === "amd64")) {
+    return {
+      name: "rust-silk-x86_64-unknown-linux-gnu.tar.xz",
+      archive: "tar.xz",
+      binary: "rust-silk",
+    };
+  }
+  if (platform === "win32" && (arch === "x64" || arch === "amd64")) {
+    return {
+      name: "rust-silk-x86_64-pc-windows-msvc.zip",
+      archive: "zip",
+      binary: "rust-silk.exe",
+    };
+  }
+  return null;
+}
+
+async function resolveChecksum(params: {
+  account: ResolvedGeweAccount;
+  baseUrl: string;
+  tag: string;
+  assetName: string;
+}): Promise<string | null> {
+  if (params.account.config.silkSha256?.trim()) {
+    return params.account.config.silkSha256.trim().toLowerCase();
+  }
+
+  const sumUrl = `${params.baseUrl}/${params.tag}/sha256.sum`;
+  const sum = await fetchText(sumUrl).catch(() => "");
+  if (sum) {
+    const parsed = parseChecksum(sum, params.assetName);
+    if (parsed) return parsed;
+  }
+
+  const assetSumUrl = `${params.baseUrl}/${params.tag}/${params.assetName}.sha256`;
+  const assetSum = await fetchText(assetSumUrl).catch(() => "");
+  if (assetSum) {
+    const parsed = parseChecksum(assetSum, params.assetName);
+    if (parsed) return parsed;
+    const fallback = assetSum.trim().split(/\s+/)[0];
+    if (/^[a-f0-9]{64}$/i.test(fallback)) return fallback.toLowerCase();
+  }
+
+  return null;
+}
+
+function parseChecksum(contents: string, assetName: string): string | null {
+  const lines = contents.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(/^([a-f0-9]{64})\s+\*?(.+)$/i);
+    if (!match) continue;
+    const [, hash, name] = match;
+    if (name.trim() === assetName) return hash.toLowerCase();
+  }
+  return null;
+}
+
+async function downloadFile(url: string, dest: string): Promise<void> {
+  const response = await fetchWithTimeout(url, DEFAULT_DOWNLOAD_TIMEOUT_MS);
+  if (!response.ok) {
+    throw new Error(`download failed: ${response.status} ${response.statusText}`);
+  }
+  if (!response.body) {
+    throw new Error("download failed: empty response body");
+  }
+  const stream = Readable.fromWeb(response.body as unknown as ReadableStream);
+  await pipeline(stream, createWriteStream(dest));
+}
+
+async function fetchText(url: string): Promise<string> {
+  const response = await fetchWithTimeout(url, DEFAULT_DOWNLOAD_TIMEOUT_MS);
+  if (!response.ok) {
+    throw new Error(`download failed: ${response.status} ${response.statusText}`);
+  }
+  return response.text();
+}
+
+async function fetchWithTimeout(url: string, timeoutMs: number): Promise<Response> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function sha256File(filePath: string): Promise<string> {
+  const hash = createHash("sha256");
+  const fileStream = createReadStream(filePath);
+  for await (const chunk of fileStream) {
+    hash.update(chunk as Buffer);
+  }
+  return hash.digest("hex");
+}
+
+async function extractArchive(
+  core: ReturnType<typeof getGeweRuntime>,
+  archivePath: string,
+  destDir: string,
+  archiveType: RustSilkAsset["archive"],
+): Promise<void> {
+  const args =
+    archiveType === "zip"
+      ? ["-xf", archivePath, "-C", destDir]
+      : ["-xJf", archivePath, "-C", destDir];
+  let result = await core.system.runCommandWithTimeout(["tar", ...args], {
+    timeoutMs: DEFAULT_EXTRACT_TIMEOUT_MS,
+  });
+  if (result.code === 0) return;
+
+  if (archiveType === "zip") {
+    result = await core.system.runCommandWithTimeout(
+      ["powershell", "-Command", `Expand-Archive -Path "${archivePath}" -DestinationPath "${destDir}" -Force`],
+      { timeoutMs: DEFAULT_EXTRACT_TIMEOUT_MS },
+    );
+    if (result.code === 0) return;
+  }
+
+  throw new Error(result.stderr.trim() || `extract failed with code ${result.code ?? "?"}`);
+}
+
+async function findBinary(root: string, fileName: string): Promise<string | null> {
+  const entries = await fs.readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(root, entry.name);
+    if (entry.isFile() && entry.name === fileName) {
+      return fullPath;
+    }
+    if (entry.isDirectory()) {
+      const nested = await findBinary(fullPath, fileName);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+async function cleanupOldVersions(
+  installRoot: string,
+  keepFolder: string,
+): Promise<void> {
+  const entries = await fs.readdir(installRoot, { withFileTypes: true }).catch(() => []);
+  const tasks: Promise<void>[] = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === keepFolder) continue;
+    const fullPath = path.join(installRoot, entry.name);
+    tasks.push(fs.rm(fullPath, { recursive: true, force: true }).then(() => {}));
+  }
+  if (tasks.length) await Promise.all(tasks);
+}
+
+function resolveConfigDir(
+  env: NodeJS.ProcessEnv = process.env,
+  homedir: () => string = os.homedir,
+): string {
+  const override = env.OPENCLAW_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
+  if (override) return resolveUserPath(override);
+  const legacyDirs = [".clawdbot", ".moltbot", ".moldbot"].map((dir) =>
+    path.join(homedir(), dir),
+  );
+  const newDir = path.join(homedir(), ".openclaw");
+  try {
+    if (existsSync(newDir)) return newDir;
+    const existingLegacy = legacyDirs.find((dir) => {
+      try {
+        return existsSync(dir);
+      } catch {
+        return false;
+      }
+    });
+    if (existingLegacy) return existingLegacy;
+  } catch {
+    // best-effort
+  }
+  return newDir;
+}
+
+function resolveUserPath(input: string): string {
+  const trimmed = input.trim();
+  if (!trimmed) return trimmed;
+  if (trimmed.startsWith("~")) {
+    const expanded = trimmed.replace(/^~(?=$|[\\/])/, os.homedir());
+    return path.resolve(expanded);
+  }
+  return path.resolve(trimmed);
+}

package/src/types.ts

@@ -42,6 +42,12 @@ export type GeweAccountConfig = {
   voiceDecodeArgs?: string[];
   voiceDecodeSampleRate?: number;
   voiceDecodeOutput?: "pcm" | "wav";
+  silkAutoDownload?: boolean;
+  silkVersion?: string;
+  silkBaseUrl?: string;
+  silkSha256?: string;
+  silkAllowUnverified?: boolean;
+  silkInstallDir?: string;
   videoFfmpegPath?: string;
   videoFfprobePath?: string;
   videoThumbUrl?: string;