@marshulll/openclaw-wecom 0.1.17 → 0.1.19

package/docs/wecom.config.full.example.json

@@ -43,7 +43,8 @@
           "corpSecret": "CORP_SECRET",
           "agentId": 1000001,
           "callbackToken": "CALLBACK_TOKEN",
-          "callbackAesKey": "CALLBACK_AES"
+          "callbackAesKey": "CALLBACK_AES",
+          "pushToken": "PUSH_TOKEN"
         }
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marshulll/openclaw-wecom",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "type": "module",
   "description": "OpenClaw WeCom channel plugin (intelligent bot + internal app)",
   "author": "OpenClaw",

package/wecom/src/accounts.ts

@@ -88,6 +88,9 @@ export function resolveWecomAccount(params: {
   const callbackAesKey = merged.callbackAesKey?.trim()
     || resolveAccountEnv(params.cfg, accountId, "CALLBACK_AES_KEY")
     || undefined;
+  const pushToken = merged.pushToken?.trim()
+    || resolveAccountEnv(params.cfg, accountId, "PUSH_TOKEN")
+    || undefined;
   const webhookPath = merged.webhookPath?.trim()
     || resolveAccountEnv(params.cfg, accountId, "WEBHOOK_PATH")
     || undefined;
@@ -109,6 +112,7 @@ export function resolveWecomAccount(params: {
     agentId,
     callbackToken,
     callbackAesKey,
+    pushToken,
   };
 
   return {

package/wecom/src/channel.ts

@@ -183,6 +183,7 @@ export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
         return { stop: () => {} };
       }
       const path = (account.config.webhookPath ?? "/wecom").trim();
+      const pushPath = path.endsWith("/") ? `${path}push` : `${path}/push`;
       const unregister = registerWecomWebhookTarget({
         account,
         config: ctx.cfg as ClawdbotConfig,
@@ -191,7 +192,16 @@ export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
         path,
         statusSink: (patch) => ctx.setStatus({ accountId: ctx.accountId, ...patch }),
       });
+      const unregisterPush = registerWecomWebhookTarget({
+        account,
+        config: ctx.cfg as ClawdbotConfig,
+        runtime: ctx.runtime,
+        core: ({} as unknown) as any,
+        path: pushPath,
+        statusSink: (patch) => ctx.setStatus({ accountId: ctx.accountId, ...patch }),
+      });
       ctx.log?.info(`[${account.accountId}] wecom webhook registered at ${path}`);
+      ctx.log?.info(`[${account.accountId}] wecom push endpoint registered at ${pushPath}`);
       ctx.setStatus({
         accountId: account.accountId,
         running: true,
@@ -202,6 +212,7 @@ export const wecomPlugin: ChannelPlugin<ResolvedWecomAccount> = {
       return {
         stop: () => {
           unregister();
+          unregisterPush();
           ctx.setStatus({
             accountId: account.accountId,
             running: false,

package/wecom/src/commands.ts

@@ -1,8 +1,10 @@
 import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import { readFile, stat } from "node:fs/promises";
+import { basename } from "node:path";
 
 import { getWecomRuntime } from "./runtime.js";
 import { listWecomAccountIds } from "./accounts.js";
-import { sendWecomText } from "./wecom-api.js";
+import { sendWecomFile, sendWecomText, uploadWecomMedia } from "./wecom-api.js";
 import type { ResolvedWecomAccount } from "./types.js";
 
 export type CommandContext = {
@@ -21,6 +23,65 @@ async function sendAndRecord(ctx: CommandContext, text: string): Promise<void> {
   ctx.log?.(`[wecom] command reply sent to ${ctx.fromUser}`);
 }
 
+function parseQuotedArgs(raw: string): string[] {
+  const args: string[] = [];
+  const normalized = raw.replace(/,/g, " ");
+  const regex = /"([^"]+)"|'([^']+)'|(\S+)/g;
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(normalized))) {
+    const value = match[1] || match[2] || match[3];
+    if (value) args.push(value.trim());
+  }
+  return args;
+}
+
+async function sendFiles(ctx: CommandContext, paths: string[]): Promise<{ sent: number; skipped: number }> {
+  let sent = 0;
+  let skipped = 0;
+  const maxBytes = ctx.account.config.media?.maxBytes;
+  for (const rawPath of paths) {
+    const path = rawPath.startsWith("file://") ? rawPath.replace(/^file:\/\//, "") : rawPath;
+    if (!path.startsWith("/")) {
+      skipped += 1;
+      await sendAndRecord(ctx, `⚠️ 路径需为绝对路径：${rawPath}`);
+      continue;
+    }
+    try {
+      const info = await stat(path);
+      if (!info.isFile()) {
+        skipped += 1;
+        await sendAndRecord(ctx, `⚠️ 不是文件：${path}`);
+        continue;
+      }
+      if (typeof maxBytes === "number" && maxBytes > 0 && info.size > maxBytes) {
+        skipped += 1;
+        await sendAndRecord(ctx, `⚠️ 文件过大(${info.size} bytes)：${path}`);
+        continue;
+      }
+      const buffer = await readFile(path);
+      const filename = basename(path) || "file.bin";
+      const mediaId = await uploadWecomMedia({
+        account: ctx.account,
+        type: "file",
+        buffer,
+        filename,
+      });
+      await sendWecomFile({
+        account: ctx.account,
+        toUser: ctx.fromUser,
+        chatId: ctx.isGroup ? ctx.chatId : undefined,
+        mediaId,
+      });
+      sent += 1;
+    } catch (err) {
+      skipped += 1;
+      await sendAndRecord(ctx, `⚠️ 发送失败：${path} (${String(err)})`);
+    }
+  }
+  ctx.statusSink?.({ lastOutboundAt: Date.now() });
+  return { sent, skipped };
+}
+
 async function handleHelp(ctx: CommandContext): Promise<void> {
   const helpText = `🤖 WeCom 助手使用帮助
 
@@ -28,6 +89,7 @@ async function handleHelp(ctx: CommandContext): Promise<void> {
 /help - 显示此帮助信息
 /clear - 清除会话历史，开始新对话
 /status - 查看系统状态
+/sendfile <path...> - 发送服务器文件（支持多个路径，可用引号）
 
 直接发送消息即可与 AI 对话。`;
   await sendAndRecord(ctx, helpText);
@@ -79,6 +141,16 @@ async function handleClear(ctx: CommandContext): Promise<void> {
   await sendAndRecord(ctx, "✅ 会话已重置，请开始新的对话。");
 }
 
+async function handleSendFile(cmd: string, ctx: CommandContext): Promise<void> {
+  const args = parseQuotedArgs(cmd.replace(/^\/sendfile(s)?\s*/i, ""));
+  if (args.length === 0) {
+    await sendAndRecord(ctx, "用法：/sendfile /absolute/path/to/file1 /absolute/path/to/file2\n支持引号：/sendfile \"/path/with space/a.txt\"");
+    return;
+  }
+  const { sent, skipped } = await sendFiles(ctx, args);
+  await sendAndRecord(ctx, `✅ 已发送 ${sent} 个文件${skipped ? `，跳过 ${skipped} 个` : ""}。`);
+}
+
 const COMMANDS: Record<string, (ctx: CommandContext) => Promise<void>> = {
   "/help": handleHelp,
   "/status": handleStatus,
@@ -88,6 +160,11 @@ const COMMANDS: Record<string, (ctx: CommandContext) => Promise<void>> = {
 export async function handleCommand(cmd: string, ctx: CommandContext): Promise<boolean> {
   const key = cmd.trim().split(/\s+/)[0]?.toLowerCase();
   if (!key) return false;
+  if (key === "/sendfile" || key === "/sendfiles") {
+    ctx.log?.(`[wecom] handling command ${key}`);
+    await handleSendFile(cmd, ctx);
+    return true;
+  }
   const handler = COMMANDS[key];
   if (!handler) return false;
   ctx.log?.(`[wecom] handling command ${key}`);

package/wecom/src/config-schema.ts

@@ -41,6 +41,7 @@ const accountSchema = z.object({
   agentId: z.union([z.string(), z.number()]).optional(),
   callbackToken: z.string().optional(),
   callbackAesKey: z.string().optional(),
+  pushToken: z.string().optional(),
 
   media: z.object({
     tempDir: z.string().optional(),
@@ -85,6 +86,7 @@ export const WecomConfigSchema = ensureJsonSchema(z.object({
   agentId: z.union([z.string(), z.number()]).optional(),
   callbackToken: z.string().optional(),
   callbackAesKey: z.string().optional(),
+  pushToken: z.string().optional(),
 
   media: z.object({
     tempDir: z.string().optional(),

package/wecom/src/monitor.ts

@@ -3,7 +3,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { ClawdbotConfig, PluginRuntime } from "openclaw/plugin-sdk";
 
 import type { ResolvedWecomAccount } from "./types.js";
-import { handleWecomAppWebhook } from "./wecom-app.js";
+import { handleWecomAppWebhook, handleWecomPushRequest } from "./wecom-app.js";
 import { handleWecomBotWebhook } from "./wecom-bot.js";
 
 export type WecomRuntimeEnv = {
@@ -55,6 +55,9 @@ export async function handleWecomWebhookRequest(
   const path = resolvePath(req);
   const targets = webhookTargets.get(path);
   if (!targets || targets.length === 0) return false;
+  if (path.endsWith("/push")) {
+    return await handleWecomPushRequest({ req, res, targets });
+  }
   const firstTarget = targets[0];
   const ua = req.headers["user-agent"] ?? "";
   const fwd = req.headers["x-forwarded-for"] ?? "";

package/wecom/src/types.ts

@@ -40,6 +40,7 @@ export type WecomAccountConfig = {
   agentId?: string | number;
   callbackToken?: string;
   callbackAesKey?: string;
+  pushToken?: string;
 
   // Media handling
   media?: {

package/wecom/src/wecom-app.ts

@@ -101,6 +101,27 @@ async function readRequestBody(req: IncomingMessage, maxSize = MAX_REQUEST_BODY_
   });
 }
 
+function resolveHeaderToken(req: IncomingMessage): string {
+  const auth = req.headers.authorization ?? "";
+  if (typeof auth === "string" && auth.toLowerCase().startsWith("bearer ")) {
+    return auth.slice(7).trim();
+  }
+  const token = req.headers["x-openclaw-token"];
+  if (typeof token === "string") return token.trim();
+  return "";
+}
+
+function pickFirstString(...values: unknown[]): string {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 function logVerbose(target: WecomWebhookTarget, message: string): void {
   target.runtime.log?.(`[wecom] ${message}`);
 }
@@ -809,6 +830,163 @@ async function processAppMessage(params: {
   }
 }
 
+type PushMessage = {
+  text?: string;
+  mediaUrl?: string;
+  mediaPath?: string;
+  mediaBase64?: string;
+  mediaType?: string;
+  filename?: string;
+  title?: string;
+  description?: string;
+  delayMs?: number;
+};
+
+type PushPayload = PushMessage & {
+  accountId?: string;
+  toUser?: string;
+  chatId?: string;
+  token?: string;
+  intervalMs?: number;
+  messages?: PushMessage[];
+};
+
+function resolvePushToken(target: WecomWebhookTarget): string {
+  return target.account.config.pushToken?.trim() || "";
+}
+
+function selectPushTarget(targets: WecomWebhookTarget[], accountId?: string): WecomWebhookTarget | undefined {
+  const appTargets = targets.filter((candidate) => shouldHandleApp(candidate));
+  if (!accountId) return appTargets[0];
+  return appTargets.find((candidate) => candidate.account.accountId === accountId);
+}
+
+export async function handleWecomPushRequest(params: {
+  req: IncomingMessage;
+  res: ServerResponse;
+  targets: WecomWebhookTarget[];
+}): Promise<boolean> {
+  const { req, res, targets } = params;
+  if ((req.method ?? "").toUpperCase() !== "POST") {
+    res.statusCode = 405;
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end("Method Not Allowed");
+    return true;
+  }
+
+  let payload: PushPayload | null = null;
+  try {
+    const raw = await readRequestBody(req, MAX_REQUEST_BODY_SIZE);
+    payload = raw ? (JSON.parse(raw) as PushPayload) : {};
+  } catch (err) {
+    res.statusCode = 400;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify({ ok: false, error: `Invalid JSON: ${String(err)}` }));
+    return true;
+  }
+
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const accountId = pickFirstString(payload?.accountId, url.searchParams.get("accountId"));
+  const target = selectPushTarget(targets, accountId);
+  if (!target) {
+    res.statusCode = 404;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify({ ok: false, error: "No matching WeCom app account" }));
+    return true;
+  }
+
+  const expectedToken = resolvePushToken(target);
+  const requestToken = pickFirstString(
+    payload?.token,
+    url.searchParams.get("token"),
+    resolveHeaderToken(req),
+  );
+  if (expectedToken && expectedToken !== requestToken) {
+    res.statusCode = 403;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify({ ok: false, error: "Invalid push token" }));
+    return true;
+  }
+
+  const toUser = pickFirstString(payload?.toUser, url.searchParams.get("toUser"));
+  const chatId = pickFirstString(payload?.chatId, url.searchParams.get("chatId"));
+  if (!toUser && !chatId) {
+    res.statusCode = 400;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify({ ok: false, error: "Missing toUser or chatId" }));
+    return true;
+  }
+
+  if (!target.account.corpId || !target.account.corpSecret || !target.account.agentId) {
+    res.statusCode = 500;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify({ ok: false, error: "WeCom app not configured" }));
+    return true;
+  }
+
+  const messages = Array.isArray(payload?.messages) && payload?.messages.length > 0
+    ? payload.messages
+    : [payload ?? {}];
+  const intervalMs = typeof payload?.intervalMs === "number" && payload.intervalMs > 0 ? payload.intervalMs : 0;
+  let sent = 0;
+
+  for (const message of messages) {
+    if (message.delayMs && message.delayMs > 0) {
+      await sleep(message.delayMs);
+    }
+    try {
+      const outbound = await loadOutboundMedia({
+        payload: message,
+        account: target.account,
+        maxBytes: resolveMediaMaxBytes(target),
+      });
+      if (outbound) {
+        const mediaId = await uploadWecomMedia({
+          account: target.account,
+          type: outbound.type,
+          buffer: outbound.buffer,
+          filename: outbound.filename,
+        });
+        if (outbound.type === "image") {
+          await sendWecomImage({ account: target.account, toUser, chatId: chatId || undefined, mediaId });
+        } else if (outbound.type === "voice") {
+          await sendWecomVoice({ account: target.account, toUser, chatId: chatId || undefined, mediaId });
+        } else if (outbound.type === "video") {
+          await sendWecomVideo({
+            account: target.account,
+            toUser,
+            chatId: chatId || undefined,
+            mediaId,
+            title: message.title,
+            description: message.description,
+          });
+        } else {
+          await sendWecomFile({ account: target.account, toUser, chatId: chatId || undefined, mediaId });
+        }
+        sent += 1;
+      }
+
+      const text = markdownToWecomText(message.text ?? "");
+      if (text) {
+        await sendWecomText({ account: target.account, toUser, chatId: chatId || undefined, text });
+        sent += 1;
+      }
+    } catch (err) {
+      target.runtime.error?.(`wecom push failed: ${String(err)}`);
+    }
+
+    if (intervalMs) {
+      await sleep(intervalMs);
+    }
+  }
+
+  target.statusSink?.({ lastOutboundAt: Date.now() });
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.end(JSON.stringify({ ok: true, sent }));
+  return true;
+}
+
 export async function handleWecomAppWebhook(params: {
   req: IncomingMessage;
   res: ServerResponse;