gewe-openclaw 2026.1.30 → 2026.2.1

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,
@@ -19,8 +20,7 @@ import {
 } from "./policy.js";
 import type { CoreConfig, GeweInboundMessage, ResolvedGeweAccount } from "./types.js";
 import { extractAppMsgType, extractFileName, extractLinkDetails } from "./xml.js";
-
-const CHANNEL_ID = "gewe" as const;
+import { CHANNEL_ID } from "./constants.js";
 
 type PreparedInbound = {
   rawBody: string;
@@ -103,7 +103,7 @@ async function decodeSilkVoice(params: {
   fileName?: string | null;
 }): Promise<DecodedVoice | null> {
   const core = getGeweRuntime();
-  const logger = core.logging.getChildLogger({ channel: "gewe", module: "voice" });
+  const logger = core.logging.getChildLogger({ channel: CHANNEL_ID, module: "voice" });
   const decodeOutput = params.account.config.voiceDecodeOutput ?? "pcm";
   const sampleRate = resolveVoiceDecodeSampleRate(params.account);
   const ffmpegPath = params.account.config.voiceFfmpegPath?.trim() || "ffmpeg";
@@ -117,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");
@@ -261,8 +279,10 @@ async function dispatchGeweInbound(params: {
     Body: body,
     RawBody: prepared.rawBody,
     CommandBody: prepared.rawBody,
-    From: prepared.groupId ? `gewe:group:${prepared.groupId}` : `gewe:${prepared.senderId}`,
-    To: `gewe:${prepared.toWxid}`,
+    From: prepared.groupId
+      ? `${CHANNEL_ID}:group:${prepared.groupId}`
+      : `${CHANNEL_ID}:${prepared.senderId}`,
+    To: `${CHANNEL_ID}:${prepared.toWxid}`,
     SessionKey: prepared.route.sessionKey,
     AccountId: prepared.route.accountId,
     ChatType: prepared.isGroup ? "group" : "direct",
@@ -272,16 +292,16 @@ async function dispatchGeweInbound(params: {
     SenderName: prepared.senderName || undefined,
     SenderId: prepared.senderId,
     CommandAuthorized: prepared.commandAuthorized,
-    Provider: "gewe",
-    Surface: "gewe",
+    Provider: CHANNEL_ID,
+    Surface: CHANNEL_ID,
     MessageSid: prepared.messageSid,
     MessageSidFull: prepared.messageSid,
     MediaPath: media?.path,
     MediaType: media?.contentType,
     MediaUrl: media?.path,
     GroupSystemPrompt: prepared.groupSystemPrompt,
-    OriginatingChannel: "gewe",
-    OriginatingTo: `gewe:${prepared.toWxid}`,
+    OriginatingChannel: CHANNEL_ID,
+    OriginatingTo: `${CHANNEL_ID}:${prepared.toWxid}`,
   });
 
   await core.channel.session.recordInboundSession({
@@ -523,7 +543,7 @@ export async function handleGeweInbound(params: {
   };
 
   core.channel.activity.record({
-    channel: "gewe",
+    channel: CHANNEL_ID,
     accountId: account.accountId,
     direction: "inbound",
   });

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

@@ -1,17 +1,16 @@
 export function normalizeGeweMessagingTarget(target: string): string | null {
   const trimmed = target.trim();
   if (!trimmed) return null;
+  const prefix = /^(gewe-openclaw|gewe|wechat|wx):(group:|user:)?/i;
   return trimmed
-    .replace(/^gewe:(group:|user:)?/i, "")
-    .replace(/^wechat:(group:|user:)?/i, "")
-    .replace(/^wx:/i, "")
+    .replace(prefix, "")
     .trim();
 }
 
 export function looksLikeGeweTargetId(id: string): boolean {
   const trimmed = id?.trim();
   if (!trimmed) return false;
-  if (/^gewe:/i.test(trimmed)) return true;
+  if (/^(gewe-openclaw|gewe):/i.test(trimmed)) return true;
   if (/@chatroom$/i.test(trimmed)) return true;
   if (/^wxid_/i.test(trimmed)) return true;
   if (/^gh_/i.test(trimmed)) return true;

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

@@ -7,10 +7,11 @@ import {
   resolveNestedAllowlistDecision,
 } from "openclaw/plugin-sdk";
 
+import { CHANNEL_CONFIG_KEY, CHANNEL_PREFIX_REGEX } from "./constants.js";
 import type { GeweGroupConfig } from "./types.js";
 
 function normalizeAllowEntry(raw: string): string {
-  return raw.trim().toLowerCase().replace(/^(gewe|wechat|wx):/i, "");
+  return raw.trim().toLowerCase().replace(CHANNEL_PREFIX_REGEX, "");
 }
 
 export function normalizeGeweAllowlist(values: Array<string | number> | undefined): string[] {
@@ -89,7 +90,7 @@ export function resolveGeweGroupToolPolicy(
 ): GeweGroupConfig["tools"] | undefined {
   const cfg = params.cfg as {
     channels?: {
-      gewe?: {
+      "gewe-openclaw"?: {
         groups?: Record<string, GeweGroupConfig>;
         accounts?: Record<string, { groups?: Record<string, GeweGroupConfig> }>;
       };
@@ -99,10 +100,10 @@ export function resolveGeweGroupToolPolicy(
   if (!groupId) return undefined;
   const groupName = params.groupChannel?.trim() || undefined;
   const accountGroups =
-    params.accountId && cfg.channels?.gewe?.accounts?.[params.accountId]?.groups
-      ? cfg.channels?.gewe?.accounts?.[params.accountId]?.groups
+    params.accountId && cfg.channels?.[CHANNEL_CONFIG_KEY]?.accounts?.[params.accountId]?.groups
+      ? cfg.channels?.[CHANNEL_CONFIG_KEY]?.accounts?.[params.accountId]?.groups
       : undefined;
-  const groups = accountGroups ?? cfg.channels?.gewe?.groups;
+  const groups = accountGroups ?? cfg.channels?.[CHANNEL_CONFIG_KEY]?.groups;
   const match = resolveGeweGroupMatch({
     groups,
     groupId,

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 };
 }