@max1874/openclaw-wecom 0.1.0

package/src/config-schema.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+export { z };
+
+const DmPolicySchema = z.enum(["open", "allowlist"]);
+const GroupPolicySchema = z.enum(["open", "allowlist", "disabled"]);
+
+const ToolPolicySchema = z
+  .object({
+    allow: z.array(z.string()).optional(),
+    deny: z.array(z.string()).optional(),
+  })
+  .strict()
+  .optional();
+
+const DmConfigSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    systemPrompt: z.string().optional(),
+  })
+  .strict()
+  .optional();
+
+export const WecomGroupSchema = z
+  .object({
+    requireMention: z.boolean().optional(),
+    tools: ToolPolicySchema,
+    skills: z.array(z.string()).optional(),
+    enabled: z.boolean().optional(),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    systemPrompt: z.string().optional(),
+  })
+  .strict();
+
+export const WecomConfigSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    // Stride API credentials
+    token: z.string().optional(),
+    chatId: z.string().optional(), // Default chatId for outbound
+    // Webhook configuration
+    webhookPath: z.string().optional().default("/webhooks/wechat"),
+    webhookPort: z.number().int().positive().optional(),
+    // Policy
+    dmPolicy: DmPolicySchema.optional().default("allowlist"),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+    groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    requireMention: z.boolean().optional().default(true),
+    // Per-group configuration
+    groups: z.record(z.string(), WecomGroupSchema.optional()).optional(),
+    // Per-DM configuration
+    dms: z.record(z.string(), DmConfigSchema).optional(),
+    // History limits
+    historyLimit: z.number().int().min(0).optional(),
+    dmHistoryLimit: z.number().int().min(0).optional(),
+    // Message chunking
+    textChunkLimit: z.number().int().positive().optional(),
+    chunkMode: z.enum(["length", "newline"]).optional(),
+    // Media limits
+    mediaMaxMb: z.number().positive().optional(),
+    // Render mode: WeChat doesn't support cards, so only raw/auto matter for table conversion
+    renderMode: z.enum(["auto", "raw"]).optional(),
+  })
+  .strict()
+  .superRefine((value, ctx) => {
+    if (value.dmPolicy === "open") {
+      const allowFrom = value.allowFrom ?? [];
+      const hasWildcard = allowFrom.some((entry) => String(entry).trim() === "*");
+      if (!hasWildcard) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["allowFrom"],
+          message: 'channels.wecom.dmPolicy="open" requires channels.wecom.allowFrom to include "*"',
+        });
+      }
+    }
+  });

package/src/media.ts

@@ -0,0 +1,149 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { WecomMediaInfo } from "./types.js";
+import { getWecomRuntime } from "./runtime.js";
+
+/**
+ * Infer placeholder text based on content type.
+ */
+function inferPlaceholder(contentType: string | undefined): string {
+  if (!contentType) return "<media:document>";
+  if (contentType.startsWith("image/")) return "<media:image>";
+  if (contentType.startsWith("audio/")) return "<media:audio>";
+  if (contentType.startsWith("video/")) return "<media:video>";
+  return "<media:document>";
+}
+
+/**
+ * Download media from a URL and save it locally.
+ * Stride provides direct URLs for all media, so this is simpler than Feishu.
+ */
+export async function downloadWecomMedia(params: {
+  url: string;
+  maxBytes: number;
+  log?: (msg: string) => void;
+}): Promise<{ path: string; contentType?: string } | null> {
+  const { url, maxBytes, log } = params;
+
+  if (!url) return null;
+
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      log?.(`wecom: failed to download media: ${response.status} ${response.statusText}`);
+      return null;
+    }
+
+    const contentType = response.headers.get("content-type") || undefined;
+    const buffer = Buffer.from(await response.arrayBuffer());
+
+    const core = getWecomRuntime();
+    const saved = await core.channel.media.saveMediaBuffer(
+      buffer,
+      contentType,
+      "inbound",
+      maxBytes,
+    );
+
+    log?.(`wecom: downloaded media from ${url}, saved to ${saved.path}`);
+    return {
+      path: saved.path,
+      contentType: saved.contentType,
+    };
+  } catch (err) {
+    log?.(`wecom: failed to download media: ${String(err)}`);
+    return null;
+  }
+}
+
+/**
+ * Resolve media from a webhook event.
+ * Returns media info list for attaching to inbound context.
+ */
+export async function resolveWecomMediaList(params: {
+  cfg: ClawdbotConfig;
+  type: number;
+  payload: Record<string, unknown>;
+  maxBytes: number;
+  log?: (msg: string) => void;
+}): Promise<WecomMediaInfo[]> {
+  const { type, payload, maxBytes, log } = params;
+
+  const out: WecomMediaInfo[] = [];
+
+  // Type 1: File
+  if (type === 1 && payload.fileUrl) {
+    const result = await downloadWecomMedia({
+      url: payload.fileUrl as string,
+      maxBytes,
+      log,
+    });
+    if (result) {
+      out.push({
+        url: result.path,
+        contentType: result.contentType,
+        placeholder: "<media:document>",
+      });
+    }
+  }
+
+  // Type 2: Voice (download audio, but text is already transcribed)
+  if (type === 2 && payload.voiceUrl) {
+    const result = await downloadWecomMedia({
+      url: payload.voiceUrl as string,
+      maxBytes,
+      log,
+    });
+    if (result) {
+      out.push({
+        url: result.path,
+        contentType: result.contentType ?? "audio/mp3",
+        placeholder: "<media:audio>",
+      });
+    }
+  }
+
+  // Type 6: Image
+  if (type === 6 && payload.imageUrl) {
+    const result = await downloadWecomMedia({
+      url: payload.imageUrl as string,
+      maxBytes,
+      log,
+    });
+    if (result) {
+      out.push({
+        url: result.path,
+        contentType: result.contentType,
+        placeholder: "<media:image>",
+      });
+    }
+  }
+
+  return out;
+}
+
+/**
+ * Build media payload for inbound context.
+ */
+export function buildWecomMediaPayload(
+  mediaList: WecomMediaInfo[],
+): {
+  MediaPath?: string;
+  MediaType?: string;
+  MediaUrl?: string;
+  MediaPaths?: string[];
+  MediaUrls?: string[];
+  MediaTypes?: string[];
+} {
+  const first = mediaList[0];
+  const mediaPaths = mediaList.map((media) => media.url);
+  const mediaTypes = mediaList.map((media) => media.contentType).filter(Boolean) as string[];
+
+  return {
+    MediaPath: first?.url,
+    MediaType: first?.contentType,
+    MediaUrl: first?.url,
+    MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+    MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+    MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+  };
+}

package/src/monitor.ts

@@ -0,0 +1,75 @@
+import type { Server } from "http";
+import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk";
+import type { WecomConfig } from "./types.js";
+import { resolveWecomCredentials } from "./accounts.js";
+import { startWebhookServer, stopWebhookServer } from "./webhook.js";
+
+export type MonitorWecomOpts = {
+  config?: ClawdbotConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  accountId?: string;
+};
+
+let currentServer: Server | null = null;
+
+/**
+ * Start the WeChat webhook monitor.
+ */
+export async function monitorWecomProvider(opts: MonitorWecomOpts = {}): Promise<void> {
+  const cfg = opts.config;
+  if (!cfg) {
+    throw new Error("Config is required for WeChat monitor");
+  }
+
+  const wecomCfg = cfg.channels?.wecom as WecomConfig | undefined;
+  const creds = resolveWecomCredentials(wecomCfg);
+  if (!creds) {
+    throw new Error("WeChat credentials not configured (token required)");
+  }
+
+  const log = opts.runtime?.log ?? console.log;
+  const error = opts.runtime?.error ?? console.error;
+
+  log(`wecom: starting webhook server...`);
+
+  const chatHistories = new Map<string, HistoryEntry[]>();
+
+  const server = await startWebhookServer({
+    cfg,
+    runtime: opts.runtime,
+    abortSignal: opts.abortSignal,
+    chatHistories,
+  });
+
+  currentServer = server;
+
+  // Return a promise that resolves when the server is closed
+  return new Promise((resolve) => {
+    server.on("close", () => {
+      log(`wecom: webhook server closed`);
+      if (currentServer === server) {
+        currentServer = null;
+      }
+      resolve();
+    });
+
+    // Handle abort signal
+    if (opts.abortSignal) {
+      opts.abortSignal.addEventListener("abort", () => {
+        log(`wecom: abort signal received, stopping server`);
+        stopWecomMonitor();
+      });
+    }
+  });
+}
+
+/**
+ * Stop the WeChat monitor.
+ */
+export function stopWecomMonitor(): void {
+  if (currentServer) {
+    currentServer.close();
+    currentServer = null;
+  }
+}

package/src/outbound.ts

@@ -0,0 +1,75 @@
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+import { getWecomRuntime } from "./runtime.js";
+import { sendMessageWecom, sendImageWecom, sendFileWecom } from "./send.js";
+
+export const wecomOutbound: ChannelOutboundAdapter = {
+  deliveryMode: "direct",
+  chunker: (text, limit) => getWecomRuntime().channel.text.chunkMarkdownText(text, limit),
+  chunkerMode: "markdown",
+  textChunkLimit: 4000,
+
+  sendText: async ({ cfg, to, text }) => {
+    const result = await sendMessageWecom({ cfg, to, text });
+    return {
+      channel: "wecom",
+      chatId: result.chatId,
+      messageId: result.chatId, // Stride doesn't return message ID
+    };
+  },
+
+  sendMedia: async ({ cfg, to, text, mediaUrl }) => {
+    // Send text first if provided
+    if (text?.trim()) {
+      await sendMessageWecom({ cfg, to, text });
+    }
+
+    // Send media if URL provided
+    if (mediaUrl) {
+      try {
+        // Detect media type from URL
+        const isImage = /\.(jpg|jpeg|png|gif|webp|bmp)$/i.test(mediaUrl);
+
+        if (isImage) {
+          const result = await sendImageWecom({ cfg, to, imageUrl: mediaUrl });
+          return {
+            channel: "wecom",
+            chatId: result.chatId,
+            messageId: result.chatId,
+          };
+        } else {
+          // Send as file
+          const fileName = mediaUrl.split("/").pop() || "file";
+          const result = await sendFileWecom({
+            cfg,
+            to,
+            fileUrl: mediaUrl,
+            fileName,
+          });
+          return {
+            channel: "wecom",
+            chatId: result.chatId,
+            messageId: result.chatId,
+          };
+        }
+      } catch (err) {
+        console.error(`[wecom] sendMedia failed:`, err);
+        // Fallback to URL link if upload fails
+        const fallbackText = `[File] ${mediaUrl}`;
+        const result = await sendMessageWecom({ cfg, to, text: fallbackText });
+        return {
+          channel: "wecom",
+          chatId: result.chatId,
+          messageId: result.chatId,
+        };
+      }
+    }
+
+    // No media URL, just return text result
+    const result = await sendMessageWecom({ cfg, to, text: text ?? "" });
+    return {
+      channel: "wecom",
+      chatId: result.chatId,
+      messageId: result.chatId,
+    };
+  },
+};

package/src/policy.ts

@@ -0,0 +1,111 @@
+import type { ChannelGroupContext, GroupToolPolicyConfig } from "openclaw/plugin-sdk";
+import type { WecomConfig, WecomGroupConfig } from "./types.js";
+
+export type WecomAllowlistMatch = {
+  allowed: boolean;
+  matchKey?: string;
+  matchSource?: "wildcard" | "id" | "name";
+};
+
+/**
+ * Check if a sender is in the allowlist.
+ */
+export function resolveWecomAllowlistMatch(params: {
+  allowFrom: Array<string | number>;
+  senderId: string;
+  senderName?: string | null;
+}): WecomAllowlistMatch {
+  const allowFrom = params.allowFrom
+    .map((entry) => String(entry).trim().toLowerCase())
+    .filter(Boolean);
+
+  if (allowFrom.length === 0) return { allowed: false };
+  if (allowFrom.includes("*")) {
+    return { allowed: true, matchKey: "*", matchSource: "wildcard" };
+  }
+
+  const senderId = params.senderId.toLowerCase();
+  if (allowFrom.includes(senderId)) {
+    return { allowed: true, matchKey: senderId, matchSource: "id" };
+  }
+
+  const senderName = params.senderName?.toLowerCase();
+  if (senderName && allowFrom.includes(senderName)) {
+    return { allowed: true, matchKey: senderName, matchSource: "name" };
+  }
+
+  return { allowed: false };
+}
+
+/**
+ * Get group-specific configuration by group ID (chatId or roomId).
+ */
+export function resolveWecomGroupConfig(params: {
+  cfg?: WecomConfig;
+  groupId?: string | null;
+}): WecomGroupConfig | undefined {
+  const groups = params.cfg?.groups ?? {};
+  const groupId = params.groupId?.trim();
+  if (!groupId) return undefined;
+
+  // Try exact match first
+  const direct = groups[groupId] as WecomGroupConfig | undefined;
+  if (direct) return direct;
+
+  // Try case-insensitive match
+  const lowered = groupId.toLowerCase();
+  const matchKey = Object.keys(groups).find((key) => key.toLowerCase() === lowered);
+  return matchKey ? (groups[matchKey] as WecomGroupConfig | undefined) : undefined;
+}
+
+/**
+ * Resolve tool policy for a specific group.
+ */
+export function resolveWecomGroupToolPolicy(
+  params: ChannelGroupContext,
+): GroupToolPolicyConfig | undefined {
+  const cfg = params.cfg.channels?.wecom as WecomConfig | undefined;
+  if (!cfg) return undefined;
+
+  const groupConfig = resolveWecomGroupConfig({
+    cfg,
+    groupId: params.groupId,
+  });
+
+  return groupConfig?.tools;
+}
+
+/**
+ * Check if a message from a group is allowed based on policy.
+ */
+export function isWecomGroupAllowed(params: {
+  groupPolicy: "open" | "allowlist" | "disabled";
+  allowFrom: Array<string | number>;
+  senderId: string;
+  senderName?: string | null;
+}): boolean {
+  const { groupPolicy } = params;
+  if (groupPolicy === "disabled") return false;
+  if (groupPolicy === "open") return true;
+  return resolveWecomAllowlistMatch(params).allowed;
+}
+
+/**
+ * Resolve reply policy (whether @mention is required).
+ */
+export function resolveWecomReplyPolicy(params: {
+  isDirectMessage: boolean;
+  globalConfig?: WecomConfig;
+  groupConfig?: WecomGroupConfig;
+}): { requireMention: boolean } {
+  // DMs never require mention
+  if (params.isDirectMessage) {
+    return { requireMention: false };
+  }
+
+  // Group: check group-specific config, then global
+  const requireMention =
+    params.groupConfig?.requireMention ?? params.globalConfig?.requireMention ?? true;
+
+  return { requireMention };
+}

package/src/probe.ts

@@ -0,0 +1,32 @@
+import type { WecomConfig, WecomProbeResult } from "./types.js";
+import { resolveWecomCredentials } from "./accounts.js";
+
+/**
+ * Test WeChat/Stride connection by verifying credentials.
+ * Since Stride doesn't have a dedicated "test" endpoint, we just verify the token is set.
+ * A real probe could attempt to send a message to validate the token.
+ */
+export async function probeWecom(wecomCfg?: WecomConfig): Promise<WecomProbeResult> {
+  try {
+    const creds = resolveWecomCredentials(wecomCfg);
+
+    if (!creds) {
+      return {
+        ok: false,
+        error: "WeChat credentials not configured (token required)",
+      };
+    }
+
+    // We could try sending a test message here, but that might be intrusive.
+    // For now, just verify credentials are present.
+    return {
+      ok: true,
+      chatId: creds.chatId,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: String(err),
+    };
+  }
+}

package/src/reply-dispatcher.ts

@@ -0,0 +1,91 @@
+import {
+  createReplyPrefixContext,
+  type ClawdbotConfig,
+  type RuntimeEnv,
+  type ReplyPayload,
+} from "openclaw/plugin-sdk";
+import { getWecomRuntime } from "./runtime.js";
+import { sendMessageWecom } from "./send.js";
+import type { WecomConfig } from "./types.js";
+
+export type CreateWecomReplyDispatcherParams = {
+  cfg: ClawdbotConfig;
+  agentId: string;
+  runtime: RuntimeEnv;
+  chatId: string;
+};
+
+export function createWecomReplyDispatcher(params: CreateWecomReplyDispatcherParams) {
+  const core = getWecomRuntime();
+  const { cfg, agentId, chatId } = params;
+
+  const prefixContext = createReplyPrefixContext({
+    cfg,
+    agentId,
+  });
+
+  const textChunkLimit = core.channel.text.resolveTextChunkLimit({
+    cfg,
+    channel: "wecom",
+    defaultLimit: 4000,
+  });
+  const chunkMode = core.channel.text.resolveChunkMode(cfg, "wecom");
+  const tableMode = core.channel.text.resolveMarkdownTableMode({
+    cfg,
+    channel: "wecom",
+  });
+
+  // WeChat doesn't have a native typing indicator API
+  // We could potentially add one using reactions or status, but skip for now
+
+  const { dispatcher, replyOptions, markDispatchIdle } =
+    core.channel.reply.createReplyDispatcherWithTyping({
+      responsePrefix: prefixContext.responsePrefix,
+      responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+      humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
+      onReplyStart: async () => {
+        // No typing indicator for WeChat
+      },
+      deliver: async (payload: ReplyPayload) => {
+        params.runtime.log?.(`wecom deliver called: text=${payload.text?.slice(0, 100)}`);
+        const text = payload.text ?? "";
+        if (!text.trim()) {
+          params.runtime.log?.(`wecom deliver: empty text, skipping`);
+          return;
+        }
+
+        // Convert markdown tables for plain text display
+        const converted = core.channel.text.convertMarkdownTables(text, tableMode);
+        const chunks = core.channel.text.chunkTextWithMode(converted, textChunkLimit, chunkMode);
+
+        params.runtime.log?.(`wecom deliver: sending ${chunks.length} chunks to ${chatId}`);
+
+        for (const chunk of chunks) {
+          const result = await sendMessageWecom({
+            cfg,
+            to: chatId,
+            text: chunk,
+          });
+
+          if (!result.success) {
+            params.runtime.error?.(`wecom: failed to send message: ${result.error}`);
+          }
+        }
+      },
+      onError: (err, info) => {
+        params.runtime.error?.(`wecom ${info.kind} reply failed: ${String(err)}`);
+      },
+      onIdle: () => {
+        // No typing indicator cleanup needed
+      },
+    });
+
+  return {
+    dispatcher,
+    replyOptions: {
+      ...replyOptions,
+      onModelSelected: prefixContext.onModelSelected,
+    },
+    markDispatchIdle,
+  };
+}

package/src/runtime.ts

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