gewe-openclaw 2026.1.29

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Peter Steinberger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# GeWe OpenClaw Plugin
+
+基于 GeWe API + Webhook 回调的 OpenClaw 微信通道插件。
+
+## 安装
+
+### 从 npm 安装
+
+```bash
+openclaw plugins install gewe-openclaw
+```
+
+### 从本地目录安装
+
+```bash
+openclaw plugins install /path/to/gewe-openclaw
+```
+
+或使用软链接（便于开发调试）：
+
+```bash
+openclaw plugins install --link /path/to/gewe-openclaw
+```
+
+### 从归档安装
+
+OpenClaw 支持本地 `.zip` / `.tgz` / `.tar.gz` / `.tar` 归档：
+
+```bash
+openclaw plugins install ./gewe-openclaw.tgz
+```
+
+> 安装或启用插件后需要重启 Gateway。
+
+## 依赖
+
+### npm 依赖
+
+- `zod`
+
+### peer 依赖
+
+- `openclaw` (>= 2026.1.29)
+
+### 系统级工具
+
+- `ffmpeg` / `ffprobe`（用于视频缩略图与时长）
+- `silk-encoder`（出站语音转 silk）
+- `silk-decoder`（入站语音解码）
+
+### 网络/服务依赖
+
+- GeWe API 服务
+- Webhook 回调需要公网可达（可配合 FRP）
+- 媒体对外地址（`mediaPublicUrl`）
+

package/index.ts

@@ -0,0 +1,18 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+
+import { gewePlugin } from "./src/channel.js";
+import { setGeweRuntime } from "./src/runtime.js";
+
+const plugin = {
+  id: "gewe",
+  name: "GeWe",
+  description: "OpenClaw GeWe channel plugin",
+  configSchema: emptyPluginConfigSchema(),
+  register(api: OpenClawPluginApi) {
+    setGeweRuntime(api.runtime);
+    api.registerChannel({ plugin: gewePlugin });
+  },
+};
+
+export default plugin;

package/openclaw.plugin.json

@@ -0,0 +1,11 @@
+{
+  "id": "gewe",
+  "channels": [
+    "gewe"
+  ],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "gewe-openclaw",
+  "version": "2026.1.29",
+  "type": "module",
+  "description": "OpenClaw GeWe channel plugin",
+  "license": "MIT",
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "channel": {
+      "id": "gewe",
+      "label": "GeWe",
+      "selectionLabel": "WeChat (GeWe)",
+      "detailLabel": "WeChat (GeWe)",
+      "docsPath": "/channels/gewe",
+      "docsLabel": "gewe",
+      "blurb": "WeChat channel via GeWe API and webhook callbacks.",
+      "aliases": [
+        "wechat",
+        "wx",
+        "gewe"
+      ],
+      "order": 72,
+      "quickstartAllowFrom": true
+    },
+    "install": {
+      "npmSpec": "gewe-openclaw",
+      "localPath": ".",
+      "defaultChoice": "npm"
+    }
+  },
+  "dependencies": {
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.1.29"
+  }
+}

package/src/accounts.ts

@@ -0,0 +1,164 @@
+import { readFileSync } from "node:fs";
+
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
+
+import type { CoreConfig, GeweAccountConfig, GeweAppIdSource, GeweTokenSource } from "./types.js";
+
+const DEFAULT_API_BASE_URL = "http://api.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?.gewe?.accounts;
+  if (!accounts || typeof accounts !== "object") return [];
+  const ids = new Set<string>();
+  for (const key of Object.keys(accounts)) {
+    if (!key) continue;
+    ids.add(normalizeAccountId(key));
+  }
+  return [...ids];
+}
+
+export function listGeweAccountIds(cfg: CoreConfig): string[] {
+  const ids = listConfiguredAccountIds(cfg);
+  if (ids.length === 0) return [DEFAULT_ACCOUNT_ID];
+  return ids.sort((a, b) => a.localeCompare(b));
+}
+
+export function resolveDefaultGeweAccountId(cfg: CoreConfig): string {
+  const ids = listGeweAccountIds(cfg);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) return DEFAULT_ACCOUNT_ID;
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+
+function resolveAccountConfig(cfg: CoreConfig, accountId: string): GeweAccountConfig | undefined {
+  const accounts = cfg.channels?.gewe?.accounts;
+  if (!accounts || typeof accounts !== "object") return undefined;
+  const direct = accounts[accountId] as GeweAccountConfig | undefined;
+  if (direct) return direct;
+  const normalized = normalizeAccountId(accountId);
+  const matchKey = Object.keys(accounts).find((key) => normalizeAccountId(key) === normalized);
+  return matchKey ? (accounts[matchKey] as GeweAccountConfig | undefined) : undefined;
+}
+
+function mergeGeweAccountConfig(cfg: CoreConfig, accountId: string): GeweAccountConfig {
+  const { accounts: _ignored, ...base } = (cfg.channels?.gewe ?? {}) as GeweAccountConfig & {
+    accounts?: unknown;
+  };
+  const account = resolveAccountConfig(cfg, accountId) ?? {};
+  return { ...base, ...account };
+}
+
+function resolveToken(
+  cfg: CoreConfig,
+  accountId: string,
+): { token: string; source: GeweTokenSource } {
+  const merged = mergeGeweAccountConfig(cfg, accountId);
+
+  const envToken = process.env.GEWE_TOKEN?.trim();
+  if (envToken && accountId === DEFAULT_ACCOUNT_ID) {
+    return { token: envToken, source: "env" };
+  }
+
+  if (merged.tokenFile) {
+    try {
+      const fileToken = readFileSync(merged.tokenFile, "utf8").trim();
+      if (fileToken) return { token: fileToken, source: "configFile" };
+    } catch {
+      // ignore read failures
+    }
+  }
+
+  if (merged.token?.trim()) {
+    return { token: merged.token.trim(), source: "config" };
+  }
+
+  return { token: "", source: "none" };
+}
+
+function resolveAppId(
+  cfg: CoreConfig,
+  accountId: string,
+): { appId: string; source: GeweAppIdSource } {
+  const merged = mergeGeweAccountConfig(cfg, accountId);
+
+  const envAppId = process.env.GEWE_APP_ID?.trim();
+  if (envAppId && accountId === DEFAULT_ACCOUNT_ID) {
+    return { appId: envAppId, source: "env" };
+  }
+
+  if (merged.appIdFile) {
+    try {
+      const fileAppId = readFileSync(merged.appIdFile, "utf8").trim();
+      if (fileAppId) return { appId: fileAppId, source: "configFile" };
+    } catch {
+      // ignore read failures
+    }
+  }
+
+  if (merged.appId?.trim()) {
+    return { appId: merged.appId.trim(), source: "config" };
+  }
+
+  return { appId: "", source: "none" };
+}
+
+export function resolveGeweAccount(params: {
+  cfg: CoreConfig;
+  accountId?: string | null;
+}): ResolvedGeweAccount {
+  const hasExplicitAccountId = Boolean(params.accountId?.trim());
+  const baseEnabled = params.cfg.channels?.gewe?.enabled !== false;
+
+  const resolve = (accountId: string): ResolvedGeweAccount => {
+    const merged = mergeGeweAccountConfig(params.cfg, accountId);
+    const accountEnabled = merged.enabled !== false;
+    const enabled = baseEnabled && accountEnabled;
+    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(/\/$/, "");
+    }
+
+    return {
+      accountId,
+      enabled,
+      name: merged.name?.trim() || undefined,
+      token: tokenResolution.token,
+      tokenSource: tokenResolution.source,
+      appId: appIdResolution.appId,
+      appIdSource: appIdResolution.source,
+      config: merged,
+    };
+  };
+
+  const normalized = normalizeAccountId(params.accountId);
+  const primary = resolve(normalized);
+  if (hasExplicitAccountId) return primary;
+  if (primary.tokenSource !== "none" && primary.appIdSource !== "none") return primary;
+
+  const fallbackId = resolveDefaultGeweAccountId(params.cfg);
+  if (fallbackId === primary.accountId) return primary;
+  const fallback = resolve(fallbackId);
+  if (fallback.tokenSource === "none" || fallback.appIdSource === "none") return primary;
+  return fallback;
+}
+
+export function listEnabledGeweAccounts(cfg: CoreConfig): ResolvedGeweAccount[] {
+  return listGeweAccountIds(cfg)
+    .map((accountId) => resolveGeweAccount({ cfg, accountId }))
+    .filter((account) => account.enabled);
+}
+

package/src/api.ts

@@ -0,0 +1,53 @@
+export type GeweApiResponse<T> = {
+  ret: number;
+  msg: string;
+  data?: T;
+};
+
+export function buildGeweUrl(baseUrl: string, path: string): string {
+  const base = baseUrl.replace(/\/$/, "");
+  const suffix = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${suffix}`;
+}
+
+async function readResponseText(res: Response): Promise<string> {
+  try {
+    return await res.text();
+  } catch {
+    return "";
+  }
+}
+
+export async function postGeweJson<T>(params: {
+  baseUrl: string;
+  token: string;
+  path: string;
+  body: Record<string, unknown>;
+}): Promise<GeweApiResponse<T>> {
+  const url = buildGeweUrl(params.baseUrl, params.path);
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-GEWE-TOKEN": params.token,
+    },
+    body: JSON.stringify(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 function assertGeweOk<T>(resp: GeweApiResponse<T>, context: string): T | undefined {
+  if (resp.ret !== 200) {
+    const msg = resp.msg?.trim() || "unknown error";
+    throw new Error(`GeWe API ${context} failed: ${resp.ret} ${msg}`);
+  }
+  return resp.data;
+}