gewe-openclaw 2026.3.12 → 2026.3.14

package/README.md

@@ -44,6 +44,8 @@ openclaw onboard
 
 在通道列表中选择 **GeWe**，按提示填写 `token`、`appId`、`webhook`，以及可选的 `mediaPublicUrl`/`S3` 媒体配置。
 
+如果你使用 `gewe-gateway` 网关模式，则改为填写 `gatewayUrl`、`gatewayKey`、`gatewayInstanceId`、`webhookPublicUrl` 和显式群列表。
+
 ### 方式 B：直接编辑配置文件
 
 直接编辑 `~/.openclaw/openclaw.json` 的 `channels.gewe-openclaw` 段落（见下方示例）。
@@ -117,6 +119,48 @@ openclaw onboard
 
 > 配置变更后需重启 Gateway。
 
+## 网关模式
+
+当你没有足够多的微信号，但希望让多台 OpenClaw 临时分别服务不同微信群时，可以把 `gewe-openclaw` 配成网关模式。
+
+网关模式下：
+
+- GeWe 官方 webhook 只打到 `gewe-gateway`
+- `gewe-openclaw` 不再直连 GeWe，也不再要求本地配置 `token/appId`
+- 每台 OpenClaw 只声明自己负责的群
+- 网关按群转发入站消息，并统一代理所有出站请求
+
+最小配置示例：
+
+```json5
+{
+  "channels": {
+    "gewe-openclaw": {
+      "enabled": true,
+      "gatewayUrl": "https://your-gateway.example.com",
+      "gatewayKey": "<gateway-key>",
+      "gatewayInstanceId": "openclaw-demo-a",
+      "webhookPublicUrl": "https://your-openclaw.example.com/gewe/webhook",
+      "webhookSecret": "<callback-secret>",
+      "groups": {
+        "123456@chatroom": {
+          "enabled": true,
+          "requireMention": true
+        }
+      }
+    }
+  }
+}
+```
+
+网关模式注意事项：
+
+- `gatewayUrl` 和 `gatewayKey` 必须成对配置
+- 一旦进入网关模式，`apiBaseUrl` 会被忽略
+- `groups` 必须显式列出群 ID，不能用 `*`
+- `webhookPublicUrl` 必须是网关可访问到的完整回调地址
+- 一个群同一时间只能绑定到一个活跃 OpenClaw 实例
+
 ## 高级用法：让未安装插件也出现在 onboarding 列表
 
 默认情况下，**只有已安装的插件**会出现在 onboarding 列表中。  

package/package.json

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

package/src/accounts.ts

@@ -3,21 +3,16 @@ import { readFileSync } from "node:fs";
 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";
+import type {
+  CoreConfig,
+  GeweAccountConfig,
+  GeweAppIdSource,
+  GeweTokenSource,
+  ResolvedGeweAccount,
+} from "./types.js";
 
 const DEFAULT_API_BASE_URL = "https://www.geweapi.com";
 
-export type ResolvedGeweAccount = {
-  accountId: string;
-  enabled: boolean;
-  name?: string;
-  token: string;
-  tokenSource: GeweTokenSource;
-  appId: string;
-  appIdSource: GeweAppIdSource;
-  config: GeweAccountConfig;
-};
-
 function listConfiguredAccountIds(cfg: CoreConfig): string[] {
   const accounts = cfg.channels?.[CHANNEL_CONFIG_KEY]?.accounts;
   if (!accounts || typeof accounts !== "object") return [];
@@ -59,11 +54,24 @@ function mergeGeweAccountConfig(cfg: CoreConfig, accountId: string): GeweAccount
   return { ...base, ...account };
 }
 
+function normalizeUrl(url?: string): string | undefined {
+  const trimmed = url?.trim();
+  if (!trimmed) return undefined;
+  return trimmed.replace(/\/$/, "");
+}
+
+function isGatewayModeConfig(config?: Pick<GeweAccountConfig, "gatewayUrl" | "gatewayKey">): boolean {
+  return Boolean(normalizeUrl(config?.gatewayUrl) && config?.gatewayKey?.trim());
+}
+
 function resolveToken(
   cfg: CoreConfig,
   accountId: string,
 ): { token: string; source: GeweTokenSource } {
   const merged = mergeGeweAccountConfig(cfg, accountId);
+  if (isGatewayModeConfig(merged)) {
+    return { token: "", source: "none" };
+  }
 
   const envToken = process.env.GEWE_TOKEN?.trim();
   if (envToken && accountId === DEFAULT_ACCOUNT_ID) {
@@ -91,6 +99,9 @@ function resolveAppId(
   accountId: string,
 ): { appId: string; source: GeweAppIdSource } {
   const merged = mergeGeweAccountConfig(cfg, accountId);
+  if (isGatewayModeConfig(merged)) {
+    return { appId: "", source: "none" };
+  }
 
   const envAppId = process.env.GEWE_APP_ID?.trim();
   if (envAppId && accountId === DEFAULT_ACCOUNT_ID) {
@@ -124,19 +135,18 @@ export function resolveGeweAccount(params: {
     const merged = mergeGeweAccountConfig(params.cfg, accountId);
     const accountEnabled = merged.enabled !== false;
     const enabled = baseEnabled && accountEnabled;
+    const mode = isGatewayModeConfig(merged) ? "gateway" : "direct";
     const tokenResolution = resolveToken(params.cfg, accountId);
     const appIdResolution = resolveAppId(params.cfg, accountId);
 
-    if (!merged.apiBaseUrl) {
-      merged.apiBaseUrl = DEFAULT_API_BASE_URL;
-    } else {
-      merged.apiBaseUrl = merged.apiBaseUrl.trim().replace(/\/$/, "");
-    }
+    merged.apiBaseUrl = normalizeUrl(merged.apiBaseUrl) ?? DEFAULT_API_BASE_URL;
+    merged.gatewayUrl = normalizeUrl(merged.gatewayUrl);
 
     return {
       accountId,
       enabled,
       name: merged.name?.trim() || undefined,
+      mode,
       token: tokenResolution.token,
       tokenSource: tokenResolution.source,
       appId: appIdResolution.appId,
@@ -162,3 +172,59 @@ export function listEnabledGeweAccounts(cfg: CoreConfig): ResolvedGeweAccount[]
     .map((accountId) => resolveGeweAccount({ cfg, accountId }))
     .filter((account) => account.enabled);
 }
+
+export function resolveIsGatewayMode(
+  account: ResolvedGeweAccount | GeweAccountConfig | null | undefined,
+): boolean {
+  if (!account) return false;
+  if ("mode" in account && account.mode) {
+    return account.mode === "gateway";
+  }
+  if ("config" in account && account.config) {
+    return isGatewayModeConfig(account.config);
+  }
+  return isGatewayModeConfig(account);
+}
+
+export function resolveIsGeweAccountConfigured(account: ResolvedGeweAccount): boolean {
+  if (resolveIsGatewayMode(account)) {
+    return Boolean(
+      account.config.gatewayUrl?.trim() &&
+        account.config.gatewayKey?.trim() &&
+        account.config.gatewayInstanceId?.trim() &&
+        resolveGatewayCallbackUrl(account) &&
+        resolveGatewayGroupBindings(account).length > 0,
+    );
+  }
+  return Boolean(account.token?.trim() && account.appId?.trim());
+}
+
+export function resolveGeweTransportBaseUrl(account: ResolvedGeweAccount): string {
+  if (resolveIsGatewayMode(account)) {
+    return normalizeUrl(account.config.gatewayUrl) ?? DEFAULT_API_BASE_URL;
+  }
+  return normalizeUrl(account.config.apiBaseUrl) ?? DEFAULT_API_BASE_URL;
+}
+
+export function resolveGatewayGroupBindings(account: ResolvedGeweAccount): string[] {
+  const groups = account.config.groups;
+  if (!groups || typeof groups !== "object") return [];
+  return Object.keys(groups).filter((groupId) => {
+    const trimmed = groupId.trim();
+    if (!trimmed || trimmed === "*") return false;
+    const groupConfig = groups[groupId];
+    return groupConfig?.enabled !== false;
+  });
+}
+
+export function resolveGatewayCallbackUrl(account: ResolvedGeweAccount): string | undefined {
+  return account.config.webhookPublicUrl?.trim() || undefined;
+}
+
+export function resolveGatewayRegisterIntervalMs(account: ResolvedGeweAccount): number {
+  const seconds = account.config.gatewayRegisterIntervalSec;
+  if (typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0) {
+    return Math.round(seconds * 1000);
+  }
+  return 60_000;
+}

package/src/api.ts

@@ -18,6 +18,26 @@ async function readResponseText(res: Response): Promise<string> {
   }
 }
 
+async function postJson<T>(params: {
+  url: string;
+  headers: Record<string, string>;
+  body: Record<string, unknown>;
+}): Promise<T> {
+  const res = await fetch(params.url, {
+    method: "POST",
+    headers: params.headers,
+    body: JSON.stringify(params.body),
+  });
+
+  if (!res.ok) {
+    const text = await readResponseText(res);
+    const detail = text ? `: ${text}` : "";
+    throw new Error(`HTTP request failed (${res.status})${detail}`);
+  }
+
+  return (await res.json()) as T;
+}
+
 export async function postGeweJson<T>(params: {
   baseUrl: string;
   token: string;
@@ -25,23 +45,31 @@ export async function postGeweJson<T>(params: {
   body: Record<string, unknown>;
 }): Promise<GeweApiResponse<T>> {
   const url = buildGeweUrl(params.baseUrl, params.path);
-  const res = await fetch(url, {
-    method: "POST",
+  return postJson<GeweApiResponse<T>>({
+    url,
     headers: {
       "Content-Type": "application/json",
       "X-GEWE-TOKEN": params.token,
     },
-    body: JSON.stringify(params.body),
+    body: params.body,
   });
+}
 
-  if (!res.ok) {
-    const text = await readResponseText(res);
-    const detail = text ? `: ${text}` : "";
-    throw new Error(`GeWe API request failed (${res.status})${detail}`);
-  }
-
-  const json = (await res.json()) as GeweApiResponse<T>;
-  return json;
+export async function postGatewayJson<T>(params: {
+  baseUrl: string;
+  gatewayKey: string;
+  path: string;
+  body: Record<string, unknown>;
+}): Promise<T> {
+  const url = buildGeweUrl(params.baseUrl, params.path);
+  return postJson<T>({
+    url,
+    headers: {
+      "Content-Type": "application/json",
+      "X-GeWe-Gateway-Key": params.gatewayKey,
+    },
+    body: params.body,
+  });
 }
 
 export function assertGeweOk<T>(resp: GeweApiResponse<T>, context: string): T | undefined {

package/src/channel.ts

@@ -13,7 +13,13 @@ import {
   type ChannelSetupInput,
 } from "openclaw/plugin-sdk";
 
-import { resolveGeweAccount, resolveDefaultGeweAccountId, listGeweAccountIds } from "./accounts.js";
+import {
+  listGeweAccountIds,
+  resolveDefaultGeweAccountId,
+  resolveGeweAccount,
+  resolveGeweTransportBaseUrl,
+  resolveIsGeweAccountConfigured,
+} from "./accounts.js";
 import { GeweConfigSchema } from "./config-schema.js";
 import {
   CHANNEL_ALIASES,
@@ -62,8 +68,8 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
     normalizeAllowEntry: (entry) => stripChannelPrefix(entry),
     notifyApproval: async ({ cfg, id }) => {
       const account = resolveGeweAccount({ cfg: cfg as CoreConfig });
-      if (!account.token || !account.appId) {
-        throw new Error("GeWe token/appId not configured");
+      if (!resolveIsGeweAccountConfigured(account)) {
+        throw new Error("GeWe account is not configured");
       }
       await sendTextGewe({
         account,
@@ -101,14 +107,15 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
         accountId,
         clearBaseFields: ["token", "tokenFile", "appId", "appIdFile", "name"],
       }),
-    isConfigured: (account) => Boolean(account.token?.trim() && account.appId?.trim()),
+    isConfigured: (account) => resolveIsGeweAccountConfigured(account),
     describeAccount: (account) => ({
       accountId: account.accountId,
       name: account.name,
       enabled: account.enabled,
-      configured: Boolean(account.token?.trim() && account.appId?.trim()),
+      configured: resolveIsGeweAccountConfigured(account),
+      mode: account.mode ?? "direct",
       tokenSource: account.tokenSource,
-      baseUrl: account.config.apiBaseUrl ? "[set]" : "[missing]",
+      baseUrl: resolveGeweTransportBaseUrl(account),
     }),
     resolveAllowFrom: ({ cfg, accountId }) =>
       (resolveGeweAccount({ cfg: cfg as CoreConfig, accountId }).config.allowFrom ?? []).map(
@@ -270,6 +277,9 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
       lastStartAt: null,
       lastStopAt: null,
       lastError: null,
+      lastGatewayRegisterAt: null,
+      lastGatewayHeartbeatAt: null,
+      lastGatewayError: null,
     },
     buildChannelSummary: ({ snapshot }) => ({
       configured: snapshot.configured ?? false,
@@ -281,23 +291,29 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
       lastError: snapshot.lastError ?? null,
       lastInboundAt: snapshot.lastInboundAt ?? null,
       lastOutboundAt: snapshot.lastOutboundAt ?? null,
+      lastGatewayRegisterAt: snapshot.lastGatewayRegisterAt ?? null,
+      lastGatewayHeartbeatAt: snapshot.lastGatewayHeartbeatAt ?? null,
+      lastGatewayError: snapshot.lastGatewayError ?? null,
     }),
     buildAccountSnapshot: ({ account, runtime }) => {
-      const configured = Boolean(account.token?.trim() && account.appId?.trim());
+      const configured = resolveIsGeweAccountConfigured(account);
       return {
         accountId: account.accountId,
         name: account.name,
         enabled: account.enabled,
         configured,
         tokenSource: account.tokenSource,
-        baseUrl: account.config.apiBaseUrl ? "[set]" : "[missing]",
+        baseUrl: resolveGeweTransportBaseUrl(account),
         running: runtime?.running ?? false,
         lastStartAt: runtime?.lastStartAt ?? null,
         lastStopAt: runtime?.lastStopAt ?? null,
         lastError: runtime?.lastError ?? null,
-        mode: "webhook",
+        mode: account.mode ?? "direct",
         lastInboundAt: runtime?.lastInboundAt ?? null,
         lastOutboundAt: runtime?.lastOutboundAt ?? null,
+        lastGatewayRegisterAt: runtime?.lastGatewayRegisterAt ?? null,
+        lastGatewayHeartbeatAt: runtime?.lastGatewayHeartbeatAt ?? null,
+        lastGatewayError: runtime?.lastGatewayError ?? null,
         dmPolicy: account.config.dmPolicy ?? "pairing",
       };
     },
@@ -305,10 +321,8 @@ export const gewePlugin: ChannelPlugin<ResolvedGeweAccount> = {
   gateway: {
     startAccount: async (ctx) => {
       const account = ctx.account;
-      if (!account.token || !account.appId) {
-        throw new Error(
-          `GeWe not configured for account "${account.accountId}" (missing token/appId)`,
-        );
+      if (!resolveIsGeweAccountConfigured(account)) {
+        throw new Error(`GeWe not configured for account "${account.accountId}"`);
       }
       ctx.log?.info(`[${account.accountId}] starting GeWe webhook server`);
       const { stop } = await monitorGeweProvider({

package/src/config-schema.ts

@@ -26,6 +26,10 @@ export const GeweAccountSchemaBase = z
     enabled: z.boolean().optional(),
     markdown: MarkdownConfigSchema,
     apiBaseUrl: z.string().optional(),
+    gatewayUrl: z.string().optional(),
+    gatewayKey: z.string().optional(),
+    gatewayInstanceId: z.string().optional(),
+    gatewayRegisterIntervalSec: z.number().positive().optional(),
     token: z.string().optional(),
     tokenFile: z.string().optional(),
     appId: z.string().optional(),
@@ -128,6 +132,68 @@ export const GeweAccountSchemaBase = z
         }
       }
     }
+
+    const gatewayUrl = value.gatewayUrl?.trim();
+    const gatewayKey = value.gatewayKey?.trim();
+    const gatewayMode = Boolean(gatewayUrl || gatewayKey);
+
+    if (gatewayMode && (!gatewayUrl || !gatewayKey)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [gatewayUrl ? "gatewayKey" : "gatewayUrl"],
+        message: "gatewayUrl and gatewayKey must be configured together",
+      });
+    }
+
+    if (!gatewayMode) return;
+
+    const instanceId = value.gatewayInstanceId?.trim();
+    if (!instanceId) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["gatewayInstanceId"],
+        message: "gatewayInstanceId is required in gateway mode",
+      });
+    }
+
+    const callbackUrl = value.webhookPublicUrl?.trim();
+    if (!callbackUrl) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["webhookPublicUrl"],
+        message: "webhookPublicUrl is required in gateway mode",
+      });
+    } else {
+      try {
+        new URL(callbackUrl);
+      } catch {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["webhookPublicUrl"],
+          message: "webhookPublicUrl must be a valid URL in gateway mode",
+        });
+      }
+    }
+
+    const groups = value.groups ?? {};
+    const explicitGroups = Object.keys(groups).filter((groupId) => {
+      const trimmed = groupId.trim();
+      return Boolean(trimmed) && trimmed !== "*";
+    });
+    if (explicitGroups.length === 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["groups"],
+        message: "gateway mode requires explicit group bindings",
+      });
+    }
+    if (Object.prototype.hasOwnProperty.call(groups, "*")) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["groups", "*"],
+        message: 'gateway mode does not allow wildcard group "*"',
+      });
+    }
   });
 
 export const GeweAccountSchema = GeweAccountSchemaBase.superRefine((value, ctx) => {

package/src/delivery.ts

@@ -1,8 +1,6 @@
-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";
@@ -267,80 +265,6 @@ 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;
@@ -373,52 +297,11 @@ 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)}`);
     }
   }