gewe-openclaw 2026.3.13 → 2026.3.23

package/src/moments-api.ts

@@ -0,0 +1,138 @@
+import {
+  createGeweAccountMethod,
+  type GeweApiList,
+  type GeweApiObject,
+} from "./gewe-account-api.js";
+
+type GeweTagId = string | number;
+
+type GeweSnsVisibilityParams = {
+  allowWxIds?: string[];
+  atWxIds?: string[];
+  disableWxIds?: string[];
+  privacy?: number;
+  allowTagIds?: GeweTagId[];
+  disableTagIds?: GeweTagId[];
+};
+
+export type GeweSnsImageInfo = GeweApiObject;
+export type GeweSnsVideoInfo = GeweApiObject;
+
+export const uploadSnsImageGewe = createGeweAccountMethod<{
+  imgUrls: string[];
+}>("/gewe/v2/api/sns/uploadSnsImage");
+
+export const uploadSnsVideoGewe = createGeweAccountMethod<{
+  thumbUrl: string;
+  videoUrl: string;
+}>("/gewe/v2/api/sns/uploadSnsVideo");
+
+export const downloadSnsVideoGewe = createGeweAccountMethod<{
+  snsXml: string;
+}>("/gewe/v2/api/sns/downloadSnsVideo");
+
+export const delSnsGewe = createGeweAccountMethod<{
+  snsId: string;
+}>("/gewe/v2/api/sns/delSns");
+
+export const sendImgSnsGewe = createGeweAccountMethod<
+  GeweSnsVisibilityParams & {
+    content?: string;
+    imgInfos: GeweSnsImageInfo[];
+  }
+>("/gewe/v2/api/sns/sendImgSns");
+
+export const sendTextSnsGewe = createGeweAccountMethod<
+  GeweSnsVisibilityParams & {
+    content: string;
+  }
+>("/gewe/v2/api/sns/sendTextSns");
+
+export const sendVideoSnsGewe = createGeweAccountMethod<
+  GeweSnsVisibilityParams & {
+    content?: string;
+    videoInfo: GeweSnsVideoInfo;
+  }
+>("/gewe/v2/api/sns/sendVideoSns");
+
+export const sendUrlSnsGewe = createGeweAccountMethod<
+  GeweSnsVisibilityParams & {
+    content?: string;
+    thumbUrl: string;
+    linkUrl: string;
+    title: string;
+    description: string;
+  }
+>("/gewe/v2/api/sns/sendUrlSns");
+
+export const strangerVisibilityEnabledGewe = createGeweAccountMethod<{
+  enabled: boolean;
+}>("/gewe/v2/api/sns/strangerVisibilityEnabled");
+
+export const snsDetailsGewe = createGeweAccountMethod<{
+  snsId: string;
+}>("/gewe/v2/api/sns/snsDetails");
+
+export const likeSnsGewe = createGeweAccountMethod<{
+  snsId: string;
+  operType: number;
+  wxid: string;
+}>("/gewe/v2/api/sns/likeSns");
+
+export const contactsSnsListGewe = createGeweAccountMethod<{
+  wxid: string;
+  maxId?: string | number;
+  decrypt?: boolean;
+  firstPageMd5?: string;
+}>("/gewe/v2/api/sns/contactsSnsList");
+
+export const snsListGewe = createGeweAccountMethod<{
+  maxId?: string | number;
+  decrypt?: boolean;
+  firstPageMd5?: string;
+}>("/gewe/v2/api/sns/snsList");
+
+export const snsVisibleScopeGewe = createGeweAccountMethod<{
+  option: number;
+}>("/gewe/v2/api/sns/snsVisibleScope");
+
+export const snsSetPrivacyGewe = createGeweAccountMethod<{
+  snsId: string;
+  open: boolean;
+}>("/gewe/v2/api/sns/snsSetPrivacy");
+
+export const commentSnsGewe = createGeweAccountMethod<{
+  snsId: string;
+  operType: number;
+  wxid: string;
+  commentId?: string | number;
+  content?: string;
+}>("/gewe/v2/api/sns/commentSns");
+
+export const forwardSnsGewe = createGeweAccountMethod<
+  Pick<GeweSnsVisibilityParams, "allowWxIds" | "atWxIds" | "disableWxIds" | "privacy"> & {
+    snsXml: string;
+  }
+>("/gewe/v2/api/sns/forwardSns");
+
+export const geweMomentsApi = {
+  uploadSnsImage: uploadSnsImageGewe,
+  uploadSnsVideo: uploadSnsVideoGewe,
+  downloadSnsVideo: downloadSnsVideoGewe,
+  delSns: delSnsGewe,
+  sendImgSns: sendImgSnsGewe,
+  sendTextSns: sendTextSnsGewe,
+  sendVideoSns: sendVideoSnsGewe,
+  sendUrlSns: sendUrlSnsGewe,
+  strangerVisibilityEnabled: strangerVisibilityEnabledGewe,
+  snsDetails: snsDetailsGewe,
+  likeSns: likeSnsGewe,
+  contactsSnsList: contactsSnsListGewe,
+  snsList: snsListGewe,
+  snsVisibleScope: snsVisibleScopeGewe,
+  snsSetPrivacy: snsSetPrivacyGewe,
+  commentSns: commentSnsGewe,
+  forwardSns: forwardSnsGewe,
+};
+
+export type GeweSnsList = GeweApiList;

package/src/monitor.ts

@@ -1,12 +1,20 @@
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 
-import type { OpenClawConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import {
+  DEFAULT_WEBHOOK_BODY_TIMEOUT_MS,
+  DEFAULT_WEBHOOK_MAX_BODY_BYTES,
+  readJsonBodyWithLimit,
+  type OpenClawConfig,
+  type RuntimeEnv,
+} from "./openclaw-compat.js";
 
 import { resolveGeweAccount } from "./accounts.js";
+import { parseGeweJsonText } from "./api.js";
 import { GeweDownloadQueue } from "./download-queue.js";
 import { createGeweInboundDebouncer } from "./inbound-batch.js";
 import { handleGeweInboundBatch } from "./inbound.js";
 import { createGeweMediaServer, DEFAULT_MEDIA_HOST, DEFAULT_MEDIA_PATH, DEFAULT_MEDIA_PORT } from "./media-server.js";
+import { maybeHandleGeweMediaRequest } from "./media-server.js";
 import { getGeweRuntime } from "./runtime.js";
 import type {
   CoreConfig,
@@ -40,20 +48,18 @@ function isDuplicate(key: string): boolean {
   return false;
 }
 
+export function buildGeweInboundDedupeKey(params: {
+  accountId: string;
+  message: Pick<GeweInboundMessage, "appId" | "newMessageId">;
+}): string {
+  return `${params.accountId}:${params.message.appId}:${params.message.newMessageId}`;
+}
+
 function formatError(err: unknown): string {
   if (err instanceof Error) return err.message;
   return typeof err === "string" ? err : JSON.stringify(err);
 }
 
-function readBody(req: IncomingMessage): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    req.on("data", (chunk: Buffer) => chunks.push(chunk));
-    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-    req.on("error", reject);
-  });
-}
-
 function resolveWebhookToken(req: IncomingMessage): string | undefined {
   const headers = req.headers as Record<string, string | string[] | undefined>;
   const candidates = [
@@ -122,7 +128,7 @@ function resolveSenderName(pushContent?: string): string | undefined {
 
 function parseWebhookPayload(body: string): GeweCallbackPayload | null {
   try {
-    const data = JSON.parse(body);
+    const data = parseGeweJsonText<GeweCallbackPayload>(body);
     return data as GeweCallbackPayload;
   } catch {
     return null;
@@ -172,7 +178,7 @@ export function createGeweWebhookServer(opts: GeweWebhookServerOptions): {
   start: () => Promise<void>;
   stop: () => void;
 } {
-  const { port, host, path, secret, onMessage, onError, abortSignal } = opts;
+  const { port, host, path, mediaPath, secret, onMessage, onError, abortSignal } = opts;
 
   const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
     if (req.url === HEALTH_PATH) {
@@ -181,6 +187,17 @@ export function createGeweWebhookServer(opts: GeweWebhookServerOptions): {
       return;
     }
 
+    if (
+      mediaPath &&
+      (await maybeHandleGeweMediaRequest({
+        req,
+        res,
+        path: mediaPath,
+      }))
+    ) {
+      return;
+    }
+
     if (req.url?.split("?")[0] !== path || req.method !== "POST") {
       res.writeHead(404);
       res.end();
@@ -195,8 +212,25 @@ export function createGeweWebhookServer(opts: GeweWebhookServerOptions): {
     }
 
     try {
-      const body = await readBody(req);
-      const payload = parseWebhookPayload(body);
+      const bodyResult = await readJsonBodyWithLimit(req, {
+        maxBytes: DEFAULT_WEBHOOK_MAX_BODY_BYTES,
+        timeoutMs: DEFAULT_WEBHOOK_BODY_TIMEOUT_MS,
+        emptyObjectOnEmpty: false,
+      });
+      if (!bodyResult.ok) {
+        res.writeHead(
+          bodyResult.code === "PAYLOAD_TOO_LARGE"
+            ? 413
+            : bodyResult.code === "REQUEST_BODY_TIMEOUT"
+              ? 408
+              : 400,
+          { "Content-Type": "application/json" },
+        );
+        res.end(JSON.stringify({ error: bodyResult.error || "Invalid JSON payload" }));
+        return;
+      }
+
+      const payload = parseWebhookPayload(bodyResult.raw);
       if (!payload) {
         res.writeHead(400, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Invalid JSON payload" }));
@@ -228,8 +262,20 @@ export function createGeweWebhookServer(opts: GeweWebhookServerOptions): {
   });
 
   const start = (): Promise<void> => {
-    return new Promise((resolve) => {
-      server.listen(port, host, () => resolve());
+    return new Promise((resolve, reject) => {
+      const onError = (err: Error) => {
+        reject(err);
+      };
+      server.once("error", onError);
+      try {
+        server.listen(port, host, () => {
+          server.off("error", onError);
+          resolve();
+        });
+      } catch (err) {
+        server.off("error", onError);
+        reject(err);
+      }
     });
   };
 
@@ -259,9 +305,12 @@ export async function monitorGeweProvider(
   const core = getGeweRuntime();
   const cfg = opts.config ?? (core.config.loadConfig() as CoreConfig);
   const account = opts.account ?? resolveGeweAccount({ cfg, accountId: opts.accountId });
+  const fallbackLogger = core.logging.getChildLogger();
+  const formatRuntimeArgs = (args: unknown[]) =>
+    args.map((arg) => (typeof arg === "string" ? arg : String(arg))).join(" ");
   const runtime: RuntimeEnv = opts.runtime ?? {
-    log: (message: string) => core.logging.getChildLogger().info(message),
-    error: (message: string) => core.logging.getChildLogger().error(message),
+    log: (...args: unknown[]) => fallbackLogger.info(formatRuntimeArgs(args)),
+    error: (...args: unknown[]) => fallbackLogger.error(formatRuntimeArgs(args)),
     exit: () => {
       throw new Error("Runtime exit not available");
     },
@@ -276,6 +325,10 @@ export async function monitorGeweProvider(
   const rawPath = account.config.webhookPath?.trim() || DEFAULT_WEBHOOK_PATH;
   const path = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
   const secret = account.config.webhookSecret?.trim() || undefined;
+  const shouldStartMedia =
+    Boolean(account.config.mediaPublicUrl) ||
+    Boolean(account.config.mediaPort || account.config.mediaHost || account.config.mediaPath);
+  const mediaPath = account.config.mediaPath ?? DEFAULT_MEDIA_PATH;
 
   const downloadQueue = new GeweDownloadQueue({
     minDelayMs: account.config.downloadMinDelayMs,
@@ -302,12 +355,16 @@ export async function monitorGeweProvider(
     port,
     host,
     path,
+    mediaPath: shouldStartMedia ? mediaPath : undefined,
     secret,
     onMessage: async (message) => {
       const isSelf = message.fromId === message.botWxid || message.senderId === message.botWxid;
       if (isSelf) return;
 
-      const dedupeKey = `${message.appId}:${message.newMessageId}`;
+      const dedupeKey = buildGeweInboundDedupeKey({
+        accountId: account.accountId,
+        message,
+      });
       if (isDuplicate(dedupeKey)) return;
       opts.statusSink?.({ lastInboundAt: Date.now() });
 
@@ -318,18 +375,18 @@ export async function monitorGeweProvider(
   });
 
   await webhookServer.start();
-  runtime.log?.(`[${account.accountId}] GeWe webhook server listening on ${host}:${port}${path}`);
+  const webhookPublicUrl =
+    account.config.webhookPublicUrl?.trim() ||
+    `http://${host === "0.0.0.0" ? "localhost" : host}:${port}${path}`;
+  runtime.log?.(`[${account.accountId}] GeWe webhook server listening on ${webhookPublicUrl}`);
 
   let mediaStop: (() => void) | undefined;
-  const shouldStartMedia =
-    Boolean(account.config.mediaPublicUrl) ||
-    Boolean(account.config.mediaPort || account.config.mediaHost || account.config.mediaPath);
 
   if (shouldStartMedia) {
     const mediaServer = createGeweMediaServer({
       host: account.config.mediaHost ?? DEFAULT_MEDIA_HOST,
       port: account.config.mediaPort ?? DEFAULT_MEDIA_PORT,
-      path: account.config.mediaPath ?? DEFAULT_MEDIA_PATH,
+      path: mediaPath,
       abortSignal: opts.abortSignal,
     });
     await mediaServer.start();

package/src/onboarding.ts

@@ -1,5 +1,10 @@
-import type { ChannelPlugin, OpenClawConfig, WizardPrompter } from "openclaw/plugin-sdk";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
+import {
+  DEFAULT_ACCOUNT_ID,
+  normalizeAccountId,
+  type ChannelPlugin,
+  type OpenClawConfig,
+  type WizardPrompter,
+} from "./openclaw-compat.js";
 
 import type { CoreConfig, GeweAccountConfig, ResolvedGeweAccount } from "./types.js";
 import { resolveGeweAccount, resolveDefaultGeweAccountId, listGeweAccountIds } from "./accounts.js";
@@ -265,14 +270,14 @@ export const geweOnboarding: GeweOnboardingAdapter = {
         placeholder: "gewe-openclaw/outbound",
         initialValue: existing.s3KeyPrefix,
       });
-      const s3UrlMode = await ctx.prompter.select({
+      const s3UrlMode = (await ctx.prompter.select({
         message: "S3 URL mode",
         options: [
           { value: "public", label: "public (default)" },
           { value: "presigned", label: "presigned" },
         ],
         initialValue: existing.s3UrlMode ?? "public",
-      });
+      })) as NonNullable<GeweAccountConfig["s3UrlMode"]>;
       const s3PublicBaseUrl =
         s3UrlMode === "public"
           ? await ctx.prompter.text({