gewe-openclaw 2026.1.29

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let runtime: PluginRuntime | null = null;
+
+export function setGeweRuntime(next: PluginRuntime) {
+  runtime = next;
+}
+
+export function getGeweRuntime(): PluginRuntime {
+  if (!runtime) {
+    throw new Error("GeWe runtime not initialized");
+  }
+  return runtime;
+}

package/src/send.ts

@@ -0,0 +1,171 @@
+import { assertGeweOk, postGeweJson } from "./api.js";
+import type { GeweSendResult, ResolvedGeweAccount } from "./types.js";
+
+type GeweSendContext = {
+  baseUrl: string;
+  token: string;
+  appId: string;
+};
+
+function buildContext(account: ResolvedGeweAccount): GeweSendContext {
+  const baseUrl = account.config.apiBaseUrl?.trim() || "http://api.geweapi.com";
+  return { baseUrl, token: account.token, appId: account.appId };
+}
+
+function resolveSendResult(params: {
+  toWxid: string;
+  data?: {
+    msgId?: number | string;
+    newMsgId?: number | string;
+    createTime?: number | null;
+  };
+}): GeweSendResult {
+  const msgId = params.data?.newMsgId ?? params.data?.msgId ?? "ok";
+  const createTime = params.data?.createTime;
+  return {
+    toWxid: params.toWxid,
+    messageId: String(msgId),
+    newMessageId: params.data?.newMsgId ? String(params.data.newMsgId) : undefined,
+    timestamp: typeof createTime === "number" ? createTime * 1000 : undefined,
+  };
+}
+
+export async function sendTextGewe(params: {
+  account: ResolvedGeweAccount;
+  toWxid: string;
+  content: string;
+  ats?: string;
+}): Promise<GeweSendResult> {
+  const ctx = buildContext(params.account);
+  const resp = await postGeweJson<{
+    msgId?: number | string;
+    newMsgId?: number | string;
+    createTime?: number;
+  }>({
+    baseUrl: ctx.baseUrl,
+    token: ctx.token,
+    path: "/gewe/v2/api/message/postText",
+    body: {
+      appId: ctx.appId,
+      toWxid: params.toWxid,
+      content: params.content,
+      ...(params.ats ? { ats: params.ats } : {}),
+    },
+  });
+  const data = assertGeweOk(resp, "postText");
+  return resolveSendResult({ toWxid: params.toWxid, data });
+}
+
+export async function sendImageGewe(params: {
+  account: ResolvedGeweAccount;
+  toWxid: string;
+  imgUrl: string;
+}): Promise<GeweSendResult> {
+  const ctx = buildContext(params.account);
+  const resp = await postGeweJson({
+    baseUrl: ctx.baseUrl,
+    token: ctx.token,
+    path: "/gewe/v2/api/message/postImage",
+    body: {
+      appId: ctx.appId,
+      toWxid: params.toWxid,
+      imgUrl: params.imgUrl,
+    },
+  });
+  const data = assertGeweOk(resp, "postImage");
+  return resolveSendResult({ toWxid: params.toWxid, data });
+}
+
+export async function sendVoiceGewe(params: {
+  account: ResolvedGeweAccount;
+  toWxid: string;
+  voiceUrl: string;
+  voiceDuration: number;
+}): Promise<GeweSendResult> {
+  const ctx = buildContext(params.account);
+  const resp = await postGeweJson({
+    baseUrl: ctx.baseUrl,
+    token: ctx.token,
+    path: "/gewe/v2/api/message/postVoice",
+    body: {
+      appId: ctx.appId,
+      toWxid: params.toWxid,
+      voiceUrl: params.voiceUrl,
+      voiceDuration: params.voiceDuration,
+    },
+  });
+  const data = assertGeweOk(resp, "postVoice");
+  return resolveSendResult({ toWxid: params.toWxid, data });
+}
+
+export async function sendVideoGewe(params: {
+  account: ResolvedGeweAccount;
+  toWxid: string;
+  videoUrl: string;
+  thumbUrl: string;
+  videoDuration: number;
+}): Promise<GeweSendResult> {
+  const ctx = buildContext(params.account);
+  const resp = await postGeweJson({
+    baseUrl: ctx.baseUrl,
+    token: ctx.token,
+    path: "/gewe/v2/api/message/postVideo",
+    body: {
+      appId: ctx.appId,
+      toWxid: params.toWxid,
+      videoUrl: params.videoUrl,
+      thumbUrl: params.thumbUrl,
+      videoDuration: params.videoDuration,
+    },
+  });
+  const data = assertGeweOk(resp, "postVideo");
+  return resolveSendResult({ toWxid: params.toWxid, data });
+}
+
+export async function sendFileGewe(params: {
+  account: ResolvedGeweAccount;
+  toWxid: string;
+  fileUrl: string;
+  fileName: string;
+}): Promise<GeweSendResult> {
+  const ctx = buildContext(params.account);
+  const resp = await postGeweJson({
+    baseUrl: ctx.baseUrl,
+    token: ctx.token,
+    path: "/gewe/v2/api/message/postFile",
+    body: {
+      appId: ctx.appId,
+      toWxid: params.toWxid,
+      fileUrl: params.fileUrl,
+      fileName: params.fileName,
+    },
+  });
+  const data = assertGeweOk(resp, "postFile");
+  return resolveSendResult({ toWxid: params.toWxid, data });
+}
+
+export async function sendLinkGewe(params: {
+  account: ResolvedGeweAccount;
+  toWxid: string;
+  title: string;
+  desc: string;
+  linkUrl: string;
+  thumbUrl: string;
+}): Promise<GeweSendResult> {
+  const ctx = buildContext(params.account);
+  const resp = await postGeweJson({
+    baseUrl: ctx.baseUrl,
+    token: ctx.token,
+    path: "/gewe/v2/api/message/postLink",
+    body: {
+      appId: ctx.appId,
+      toWxid: params.toWxid,
+      title: params.title,
+      desc: params.desc,
+      linkUrl: params.linkUrl,
+      thumbUrl: params.thumbUrl,
+    },
+  });
+  const data = assertGeweOk(resp, "postLink");
+  return resolveSendResult({ toWxid: params.toWxid, data });
+}

package/src/types.ts

@@ -0,0 +1,137 @@
+import type {
+  BlockStreamingCoalesceConfig,
+  DmConfig,
+  DmPolicy,
+  GroupPolicy,
+  GroupToolPolicyConfig,
+} from "openclaw/plugin-sdk";
+
+export type GeweGroupConfig = {
+  requireMention?: boolean;
+  tools?: GroupToolPolicyConfig;
+  skills?: string[];
+  enabled?: boolean;
+  allowFrom?: string[];
+  systemPrompt?: string;
+};
+
+export type GeweAccountConfig = {
+  name?: string;
+  enabled?: boolean;
+  apiBaseUrl?: string;
+  token?: string;
+  tokenFile?: string;
+  appId?: string;
+  appIdFile?: string;
+  webhookPort?: number;
+  webhookHost?: string;
+  webhookPath?: string;
+  webhookSecret?: string;
+  webhookPublicUrl?: string;
+  mediaHost?: string;
+  mediaPort?: number;
+  mediaPath?: string;
+  mediaPublicUrl?: string;
+  mediaMaxMb?: number;
+  voiceAutoConvert?: boolean;
+  voiceFfmpegPath?: string;
+  voiceSilkPath?: string;
+  voiceSilkArgs?: string[];
+  voiceSampleRate?: number;
+  voiceDecodePath?: string;
+  voiceDecodeArgs?: string[];
+  voiceDecodeSampleRate?: number;
+  voiceDecodeOutput?: "pcm" | "wav";
+  videoFfmpegPath?: string;
+  videoFfprobePath?: string;
+  videoThumbUrl?: string;
+  downloadMinDelayMs?: number;
+  downloadMaxDelayMs?: number;
+  dmPolicy?: DmPolicy;
+  allowFrom?: Array<string | number>;
+  groupAllowFrom?: Array<string | number>;
+  groupPolicy?: GroupPolicy;
+  groups?: Record<string, GeweGroupConfig>;
+  historyLimit?: number;
+  dmHistoryLimit?: number;
+  dms?: Record<string, DmConfig>;
+  textChunkLimit?: number;
+  chunkMode?: "length" | "newline";
+  blockStreaming?: boolean;
+  blockStreamingCoalesce?: BlockStreamingCoalesceConfig;
+};
+
+export type GeweConfig = {
+  accounts?: Record<string, GeweAccountConfig>;
+} & GeweAccountConfig;
+
+export type CoreConfig = {
+  channels?: {
+    gewe?: GeweConfig;
+  };
+  [key: string]: unknown;
+};
+
+export type GeweTokenSource = "env" | "config" | "configFile" | "none";
+
+export type GeweAppIdSource = "env" | "config" | "configFile" | "none";
+
+export type ResolvedGeweAccount = {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  token: string;
+  tokenSource: GeweTokenSource;
+  appId: string;
+  appIdSource: GeweAppIdSource;
+  config: GeweAccountConfig;
+};
+
+export type GeweCallbackPayload = {
+  TypeName?: string;
+  Appid?: string;
+  Wxid?: string;
+  Data?: {
+    MsgId?: number;
+    NewMsgId?: number;
+    FromUserName?: { string?: string };
+    ToUserName?: { string?: string };
+    MsgType?: number;
+    Content?: { string?: string };
+    CreateTime?: number;
+    PushContent?: string;
+  };
+};
+
+export type GeweInboundMessage = {
+  messageId: string;
+  newMessageId: string;
+  appId: string;
+  botWxid: string;
+  fromId: string;
+  toId: string;
+  senderId: string;
+  senderName?: string;
+  text: string;
+  msgType: number;
+  xml?: string;
+  timestamp: number;
+  isGroupChat: boolean;
+};
+
+export type GeweWebhookServerOptions = {
+  port: number;
+  host: string;
+  path: string;
+  secret?: string;
+  onMessage: (message: GeweInboundMessage) => void | Promise<void>;
+  onError?: (error: Error) => void;
+  abortSignal?: AbortSignal;
+};
+
+export type GeweSendResult = {
+  messageId: string;
+  newMessageId?: string;
+  toWxid: string;
+  timestamp?: number;
+};

package/src/xml.ts

@@ -0,0 +1,59 @@
+function decodeEntities(value: string): string {
+  return value
+    .replace(/&/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&#x([0-9a-fA-F]+);/g, (_match, hex) => {
+      const code = Number.parseInt(hex, 16);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : _match;
+    })
+    .replace(/&#(\d+);/g, (_match, dec) => {
+      const code = Number.parseInt(dec, 10);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : _match;
+    });
+}
+
+function stripCdata(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("<![CDATA[") && trimmed.endsWith("]]>")) {
+    return trimmed.slice(9, -3);
+  }
+  return trimmed;
+}
+
+export function extractXmlTag(xml: string, tag: string): string | undefined {
+  const re = new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`, "i");
+  const match = re.exec(xml);
+  if (!match) return undefined;
+  const raw = stripCdata(match[1]);
+  return decodeEntities(raw);
+}
+
+export function extractAppMsgType(xml: string): number | undefined {
+  const match = /<appmsg[\s\S]*?<type>(\d+)<\/type>/i.exec(xml);
+  if (!match?.[1]) return undefined;
+  const value = Number.parseInt(match[1], 10);
+  return Number.isFinite(value) ? value : undefined;
+}
+
+export function extractLinkDetails(xml: string): {
+  title?: string;
+  desc?: string;
+  linkUrl?: string;
+  thumbUrl?: string;
+} {
+  return {
+    title: extractXmlTag(xml, "title"),
+    desc: extractXmlTag(xml, "des"),
+    linkUrl: extractXmlTag(xml, "url"),
+    thumbUrl: extractXmlTag(xml, "thumburl"),
+  };
+}
+
+export function extractFileName(xml: string): string | undefined {
+  const title = extractXmlTag(xml, "title");
+  if (title) return title.trim();
+  return undefined;
+}