@marshulll/wecom-dual 0.1.0

package/wecom/src/wecom-bot.ts

@@ -0,0 +1,645 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import crypto from "node:crypto";
+
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+import type { WecomWebhookTarget } from "./monitor.js";
+import type { ResolvedWecomAccount, WecomInboundMessage } from "./types.js";
+import { computeWecomMsgSignature, decryptWecomEncrypted, encryptWecomPlaintext, verifyWecomSignature } from "./crypto.js";
+import { fetchMediaFromUrl, sendWecomFile, sendWecomImage, sendWecomVideo, sendWecomVoice, uploadWecomMedia } from "./wecom-api.js";
+import { getWecomRuntime } from "./runtime.js";
+
+const STREAM_TTL_MS = 10 * 60 * 1000;
+const STREAM_MAX_BYTES = 20_480;
+
+type StreamState = {
+  streamId: string;
+  msgid?: string;
+  createdAt: number;
+  updatedAt: number;
+  started: boolean;
+  finished: boolean;
+  error?: string;
+  content: string;
+};
+
+const streams = new Map<string, StreamState>();
+const msgidToStreamId = new Map<string, string>();
+
+function pruneStreams(): void {
+  const cutoff = Date.now() - STREAM_TTL_MS;
+  for (const [id, state] of streams.entries()) {
+    if (state.updatedAt < cutoff) {
+      streams.delete(id);
+    }
+  }
+  for (const [msgid, id] of msgidToStreamId.entries()) {
+    if (!streams.has(id)) {
+      msgidToStreamId.delete(msgid);
+    }
+  }
+}
+
+function truncateUtf8Bytes(text: string, maxBytes: number): string {
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes) return text;
+  const slice = buf.subarray(buf.length - maxBytes);
+  return slice.toString("utf8");
+}
+
+function jsonOk(res: ServerResponse, body: unknown): void {
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "text/plain; charset=utf-8");
+  res.end(JSON.stringify(body));
+}
+
+async function readJsonBody(req: IncomingMessage, maxBytes: number) {
+  const chunks: Buffer[] = [];
+  let total = 0;
+  return await new Promise<{ ok: boolean; value?: unknown; error?: string }>((resolve) => {
+    req.on("data", (chunk: Buffer) => {
+      total += chunk.length;
+      if (total > maxBytes) {
+        resolve({ ok: false, error: "payload too large" });
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      try {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        if (!raw.trim()) {
+          resolve({ ok: false, error: "empty payload" });
+          return;
+        }
+        resolve({ ok: true, value: JSON.parse(raw) as unknown });
+      } catch (err) {
+        resolve({ ok: false, error: err instanceof Error ? err.message : String(err) });
+      }
+    });
+    req.on("error", (err) => {
+      resolve({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    });
+  });
+}
+
+function buildEncryptedJsonReply(params: {
+  account: ResolvedWecomAccount;
+  plaintextJson: unknown;
+  nonce: string;
+  timestamp: string;
+}): { encrypt: string; msgsignature: string; timestamp: string; nonce: string } {
+  const plaintext = JSON.stringify(params.plaintextJson ?? {});
+  const encrypt = encryptWecomPlaintext({
+    encodingAESKey: params.account.encodingAESKey ?? "",
+    receiveId: params.account.receiveId ?? "",
+    plaintext,
+  });
+  const msgsignature = computeWecomMsgSignature({
+    token: params.account.token ?? "",
+    timestamp: params.timestamp,
+    nonce: params.nonce,
+    encrypt,
+  });
+  return {
+    encrypt,
+    msgsignature,
+    timestamp: params.timestamp,
+    nonce: params.nonce,
+  };
+}
+
+function resolveQueryParams(req: IncomingMessage): URLSearchParams {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  return url.searchParams;
+}
+
+function resolveSignatureParam(params: URLSearchParams): string {
+  return (
+    params.get("msg_signature") ??
+    params.get("msgsignature") ??
+    params.get("signature") ??
+    ""
+  );
+}
+
+function buildStreamPlaceholderReply(streamId: string): { msgtype: "stream"; stream: { id: string; finish: boolean; content: string } } {
+  return {
+    msgtype: "stream",
+    stream: {
+      id: streamId,
+      finish: false,
+      content: "1",
+    },
+  };
+}
+
+function buildStreamReplyFromState(state: StreamState): { msgtype: "stream"; stream: { id: string; finish: boolean; content: string } } {
+  const content = truncateUtf8Bytes(state.content, STREAM_MAX_BYTES);
+  return {
+    msgtype: "stream",
+    stream: {
+      id: state.streamId,
+      finish: state.finished,
+      content,
+    },
+  };
+}
+
+function createStreamId(): string {
+  return crypto.randomBytes(16).toString("hex");
+}
+
+function logVerbose(target: WecomWebhookTarget, message: string): void {
+  try {
+    const core = getWecomRuntime();
+    const should = core.logging?.shouldLogVerbose?.() ?? false;
+    if (should) {
+      target.runtime.log?.(`[wecom] ${message}`);
+    }
+  } catch {
+    // runtime not ready; skip verbose logging
+  }
+}
+
+function parseWecomPlainMessage(raw: string): WecomInboundMessage {
+  const parsed = JSON.parse(raw) as unknown;
+  if (!parsed || typeof parsed !== "object") {
+    return {};
+  }
+  return parsed as WecomInboundMessage;
+}
+
+async function waitForStreamContent(streamId: string, maxWaitMs: number): Promise<void> {
+  if (maxWaitMs <= 0) return;
+  const startedAt = Date.now();
+  await new Promise<void>((resolve) => {
+    const tick = () => {
+      const state = streams.get(streamId);
+      if (!state) return resolve();
+      if (state.error || state.finished || state.content.trim()) return resolve();
+      if (Date.now() - startedAt >= maxWaitMs) return resolve();
+      setTimeout(tick, 25);
+    };
+    tick();
+  });
+}
+
+async function startAgentForStream(params: {
+  target: WecomWebhookTarget;
+  accountId: string;
+  msg: WecomInboundMessage;
+  streamId: string;
+}): Promise<void> {
+  const { target, msg, streamId } = params;
+  const core = getWecomRuntime();
+  const config = target.config;
+  const account = target.account;
+
+  const userid = msg.from?.userid?.trim() || "unknown";
+  const chatType = msg.chattype === "group" ? "group" : "direct";
+  const chatId = msg.chattype === "group" ? (msg.chatid?.trim() || "unknown") : userid;
+  const rawBody = buildInboundBody(msg);
+
+  const route = core.channel.routing.resolveAgentRoute({
+    cfg: config,
+    channel: "wecom",
+    accountId: account.accountId,
+    peer: { kind: chatType === "group" ? "group" : "dm", id: chatId },
+  });
+
+  logVerbose(target, `starting agent processing (streamId=${streamId}, agentId=${route.agentId}, peerKind=${chatType}, peerId=${chatId})`);
+
+  const fromLabel = chatType === "group" ? `group:${chatId}` : `user:${userid}`;
+  const storePath = core.channel.session.resolveStorePath(config.session?.store, {
+    agentId: route.agentId,
+  });
+  const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(config);
+  const previousTimestamp = core.channel.session.readSessionUpdatedAt({
+    storePath,
+    sessionKey: route.sessionKey,
+  });
+  const body = core.channel.reply.formatAgentEnvelope({
+    channel: "WeCom",
+    from: fromLabel,
+    previousTimestamp,
+    envelope: envelopeOptions,
+    body: rawBody,
+  });
+
+  const ctxPayload = core.channel.reply.finalizeInboundContext({
+    Body: body,
+    RawBody: rawBody,
+    CommandBody: rawBody,
+    From: chatType === "group" ? `wecom:group:${chatId}` : `wecom:${userid}`,
+    To: `wecom:${chatId}`,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: chatType,
+    ConversationLabel: fromLabel,
+    SenderName: userid,
+    SenderId: userid,
+    Provider: "wecom",
+    Surface: "wecom",
+    MessageSid: msg.msgid,
+    OriginatingChannel: "wecom",
+    OriginatingTo: `wecom:${chatId}`,
+  });
+
+  await core.channel.session.recordInboundSession({
+    storePath,
+    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+    ctx: ctxPayload,
+    onRecordError: (err) => {
+      target.runtime.error?.(`wecom: failed updating session meta: ${String(err)}`);
+    },
+  });
+
+  const tableMode = core.channel.text.resolveMarkdownTableMode({
+    cfg: config,
+    channel: "wecom",
+    accountId: account.accountId,
+  });
+
+  await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: ctxPayload,
+    cfg: config,
+    dispatcherOptions: {
+      deliver: async (payload) => {
+        const maybeMediaUrl = (payload as any).mediaUrl as string | undefined;
+        const maybeMediaType = (payload as any).mediaType as string | undefined;
+        const canBridgeMedia = account.config.botMediaBridge !== false
+          && Boolean(account.corpId && account.corpSecret && account.agentId);
+        const toChatId = chatType === "group" ? chatId : undefined;
+
+        if (maybeMediaUrl && canBridgeMedia) {
+          try {
+            const media = await fetchMediaFromUrl(maybeMediaUrl, account);
+            const type = normalizeMediaType(maybeMediaType) ?? "file";
+            const ext = media.contentType.includes("png") ? "png"
+              : media.contentType.includes("gif") ? "gif"
+              : media.contentType.includes("jpeg") || media.contentType.includes("jpg") ? "jpg"
+              : media.contentType.includes("mp4") ? "mp4"
+              : media.contentType.includes("amr") ? "amr"
+              : media.contentType.includes("wav") ? "wav"
+              : media.contentType.includes("mp3") ? "mp3"
+              : "bin";
+            const mediaId = await uploadWecomMedia({
+              account,
+              type: type as "image" | "voice" | "video" | "file",
+              buffer: media.buffer,
+              filename: `${type}.${ext}`,
+            });
+            if (type === "image") {
+              await sendWecomImage({ account, toUser: userid, chatId: toChatId, mediaId });
+            } else if (type === "voice") {
+              await sendWecomVoice({ account, toUser: userid, chatId: toChatId, mediaId });
+            } else if (type === "video") {
+              const title = (payload as any).title as string | undefined;
+              const description = (payload as any).description as string | undefined;
+              await sendWecomVideo({ account, toUser: userid, chatId: toChatId, mediaId, title, description });
+            } else if (type === "file") {
+              await sendWecomFile({ account, toUser: userid, chatId: toChatId, mediaId });
+            }
+            const current = streams.get(streamId);
+            if (current) {
+              const note = mediaSentLabel(type);
+              const nextText = current.content ? `${current.content}\n\n${note}` : note;
+              current.content = truncateUtf8Bytes(nextText.trim(), STREAM_MAX_BYTES);
+              current.updatedAt = Date.now();
+            }
+            target.statusSink?.({ lastOutboundAt: Date.now() });
+          } catch (err) {
+            target.runtime.error?.(`[${account.accountId}] wecom bot media bridge failed: ${String(err)}`);
+          }
+        }
+
+        const text = core.channel.text.convertMarkdownTables(payload.text ?? "", tableMode);
+        const current = streams.get(streamId);
+        if (!current) return;
+        const nextText = current.content
+          ? `${current.content}\n\n${text}`.trim()
+          : text.trim();
+        current.content = truncateUtf8Bytes(nextText, STREAM_MAX_BYTES);
+        current.updatedAt = Date.now();
+        target.statusSink?.({ lastOutboundAt: Date.now() });
+      },
+      onError: (err, info) => {
+        target.runtime.error?.(`[${account.accountId}] wecom ${info.kind} reply failed: ${String(err)}`);
+      },
+    },
+  });
+
+  const current = streams.get(streamId);
+  if (current) {
+    current.finished = true;
+    current.updatedAt = Date.now();
+  }
+}
+
+function buildInboundBody(msg: WecomInboundMessage): string {
+  const msgtype = String(msg.msgtype ?? "").toLowerCase();
+  if (msgtype === "text") {
+    const content = (msg as any).text?.content;
+    return typeof content === "string" ? content : "";
+  }
+  if (msgtype === "voice") {
+    const content = (msg as any).voice?.content;
+    return typeof content === "string" ? content : "[voice]";
+  }
+  if (msgtype === "mixed") {
+    const items = (msg as any).mixed?.msg_item;
+    if (Array.isArray(items)) {
+      return items
+        .map((item: any) => {
+          const t = String(item?.msgtype ?? "").toLowerCase();
+          if (t === "text") return String(item?.text?.content ?? "");
+          if (t === "image") return `[image] ${String(item?.image?.url ?? "").trim()}`.trim();
+          return `[${t || "item"}]`;
+        })
+        .filter((part: string) => Boolean(part && part.trim()))
+        .join("\n");
+    }
+    return "[mixed]";
+  }
+  if (msgtype === "image") {
+    const url = String((msg as any).image?.url ?? "").trim();
+    return url ? `[image] ${url}` : "[image]";
+  }
+  if (msgtype === "file") {
+    const url = String((msg as any).file?.url ?? "").trim();
+    return url ? `[file] ${url}` : "[file]";
+  }
+  if (msgtype === "video") {
+    const url = String((msg as any).video?.url ?? "").trim();
+    return url ? `[video] ${url}` : "[video]";
+  }
+  if (msgtype === "event") {
+    const eventtype = String((msg as any).event?.eventtype ?? "").trim();
+    return eventtype ? `[event] ${eventtype}` : "[event]";
+  }
+  if (msgtype === "stream") {
+    const id = String((msg as any).stream?.id ?? "").trim();
+    return id ? `[stream_refresh] ${id}` : "[stream_refresh]";
+  }
+  return msgtype ? `[${msgtype}]` : "";
+}
+
+function normalizeMediaType(raw?: string): "image" | "voice" | "video" | "file" | null {
+  if (!raw) return null;
+  const value = raw.toLowerCase();
+  if (value === "image" || value === "voice" || value === "video" || value === "file") return value;
+  return null;
+}
+
+function mediaSentLabel(type: string): string {
+  if (type === "image") return "[已发送图片]";
+  if (type === "voice") return "[已发送语音]";
+  if (type === "video") return "[已发送视频]";
+  if (type === "file") return "[已发送文件]";
+  return "[已发送媒体]";
+}
+
+function shouldHandleBot(account: ResolvedWecomAccount): boolean {
+  return account.mode === "bot" || account.mode === "both";
+}
+
+export async function handleWecomBotWebhook(params: {
+  req: IncomingMessage;
+  res: ServerResponse;
+  targets: WecomWebhookTarget[];
+}): Promise<boolean> {
+  pruneStreams();
+
+  const { req, res, targets } = params;
+  const query = resolveQueryParams(req);
+  const timestamp = query.get("timestamp") ?? "";
+  const nonce = query.get("nonce") ?? "";
+  const signature = resolveSignatureParam(query);
+
+  const firstTarget = targets[0]!;
+  logVerbose(firstTarget, `incoming ${req.method} request (timestamp=${timestamp}, nonce=${nonce}, signature=${signature})`);
+
+  if (req.method === "GET") {
+    const echostr = query.get("echostr") ?? "";
+    if (!timestamp || !nonce || !signature || !echostr) {
+      return false;
+    }
+
+    const target = targets.find((candidate) => {
+      if (!shouldHandleBot(candidate.account)) return false;
+      if (!candidate.account.configured || !candidate.account.token) return false;
+      const ok = verifyWecomSignature({
+        token: candidate.account.token,
+        timestamp,
+        nonce,
+        encrypt: echostr,
+        signature,
+      });
+      return ok;
+    });
+    if (!target || !target.account.encodingAESKey) {
+      return false;
+    }
+    try {
+      const plain = decryptWecomEncrypted({
+        encodingAESKey: target.account.encodingAESKey,
+        receiveId: target.account.receiveId,
+        encrypt: echostr,
+      });
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      res.end(plain);
+      return true;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      res.statusCode = 400;
+      res.end(msg || "decrypt failed");
+      return true;
+    }
+  }
+
+  if (req.method !== "POST") {
+    return false;
+  }
+
+  const contentType = req.headers["content-type"] ?? "";
+  if (!String(contentType).toLowerCase().includes("json")) {
+    return false;
+  }
+
+  if (!timestamp || !nonce || !signature) {
+    return false;
+  }
+
+  const body = await readJsonBody(req, 1024 * 1024);
+  if (!body.ok) {
+    res.statusCode = body.error === "payload too large" ? 413 : 400;
+    res.end(body.error ?? "invalid payload");
+    return true;
+  }
+  const record = body.value && typeof body.value === "object" ? (body.value as Record<string, unknown>) : null;
+  const encrypt = record ? String(record.encrypt ?? record.Encrypt ?? "") : "";
+  if (!encrypt) {
+    res.statusCode = 400;
+    res.end("missing encrypt");
+    return true;
+  }
+
+  const target = targets.find((candidate) => {
+    if (!shouldHandleBot(candidate.account)) return false;
+    if (!candidate.account.token) return false;
+    const ok = verifyWecomSignature({
+      token: candidate.account.token,
+      timestamp,
+      nonce,
+      encrypt,
+      signature,
+    });
+    return ok;
+  });
+  if (!target) {
+    return false;
+  }
+
+  if (!target.account.configured || !target.account.token || !target.account.encodingAESKey) {
+    res.statusCode = 500;
+    res.end("wecom not configured");
+    return true;
+  }
+
+  let plain: string;
+  try {
+    plain = decryptWecomEncrypted({
+      encodingAESKey: target.account.encodingAESKey,
+      receiveId: target.account.receiveId,
+      encrypt,
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    res.statusCode = 400;
+    res.end(msg || "decrypt failed");
+    return true;
+  }
+
+  const msg = parseWecomPlainMessage(plain);
+  target.statusSink?.({ lastInboundAt: Date.now() });
+
+  const msgtype = String(msg.msgtype ?? "").toLowerCase();
+  const msgid = msg.msgid ? String(msg.msgid) : undefined;
+
+  if (msgtype === "stream") {
+    const streamId = String((msg as any).stream?.id ?? "").trim();
+    const state = streamId ? streams.get(streamId) : undefined;
+    const reply = state
+      ? buildStreamReplyFromState(state)
+      : buildStreamReplyFromState({
+          streamId: streamId || "unknown",
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+          started: true,
+          finished: true,
+          content: "",
+        });
+    jsonOk(res, buildEncryptedJsonReply({
+      account: target.account,
+      plaintextJson: reply,
+      nonce,
+      timestamp,
+    }));
+    return true;
+  }
+
+  if (msgid && msgidToStreamId.has(msgid)) {
+    const streamId = msgidToStreamId.get(msgid) ?? "";
+    const reply = buildStreamPlaceholderReply(streamId);
+    jsonOk(res, buildEncryptedJsonReply({
+      account: target.account,
+      plaintextJson: reply,
+      nonce,
+      timestamp,
+    }));
+    return true;
+  }
+
+  if (msgtype === "event") {
+    const eventtype = String((msg as any).event?.eventtype ?? "").toLowerCase();
+    if (eventtype === "enter_chat") {
+      const welcome = target.account.config.welcomeText?.trim();
+      const reply = welcome
+        ? { msgtype: "text", text: { content: welcome } }
+        : {};
+      jsonOk(res, buildEncryptedJsonReply({
+        account: target.account,
+        plaintextJson: reply,
+        nonce,
+        timestamp,
+      }));
+      return true;
+    }
+
+    jsonOk(res, buildEncryptedJsonReply({
+      account: target.account,
+      plaintextJson: {},
+      nonce,
+      timestamp,
+    }));
+    return true;
+  }
+
+  const streamId = createStreamId();
+  if (msgid) msgidToStreamId.set(msgid, streamId);
+  streams.set(streamId, {
+    streamId,
+    msgid,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    started: false,
+    finished: false,
+    content: "",
+  });
+
+  let core: PluginRuntime | null = null;
+  try {
+    core = getWecomRuntime();
+  } catch (err) {
+    logVerbose(target, `runtime not ready, skipping agent processing: ${String(err)}`);
+  }
+
+  if (core) {
+    streams.get(streamId)!.started = true;
+    const enrichedTarget: WecomWebhookTarget = { ...target, core };
+    startAgentForStream({ target: enrichedTarget, accountId: target.account.accountId, msg, streamId }).catch((err) => {
+      const state = streams.get(streamId);
+      if (state) {
+        state.error = err instanceof Error ? err.message : String(err);
+        state.content = state.content || `Error: ${state.error}`;
+        state.finished = true;
+        state.updatedAt = Date.now();
+      }
+      target.runtime.error?.(`[${target.account.accountId}] wecom agent failed: ${String(err)}`);
+    });
+  } else {
+    const state = streams.get(streamId);
+    if (state) {
+      state.finished = true;
+      state.updatedAt = Date.now();
+    }
+  }
+
+  await waitForStreamContent(streamId, 800);
+  const state = streams.get(streamId);
+  const initialReply = state && (state.content.trim() || state.error)
+    ? buildStreamReplyFromState(state)
+    : buildStreamPlaceholderReply(streamId);
+
+  jsonOk(res, buildEncryptedJsonReply({
+    account: target.account,
+    plaintextJson: initialReply,
+    nonce,
+    timestamp,
+  }));
+
+  return true;
+}