@max1874/openclaw-wecom 0.1.0

package/src/send.ts

@@ -0,0 +1,250 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type {
+  WecomConfig,
+  WecomSendResult,
+  WecomSendRequest,
+  WecomSendResponse,
+  SendTextPayload,
+  SendImagePayload,
+  SendFilePayload,
+  SendLinkPayload,
+} from "./types.js";
+import { normalizeWecomTarget } from "./targets.js";
+
+const STRIDE_API_URL = "https://stride-bg.dpclouds.com/stream-api/message/send";
+
+/**
+ * Send a message via Stride API.
+ */
+async function sendStrideMessage(request: WecomSendRequest): Promise<WecomSendResponse> {
+  const response = await fetch(STRIDE_API_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(request),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Stride API error: ${response.status} ${response.statusText}`);
+  }
+
+  return (await response.json()) as WecomSendResponse;
+}
+
+export type SendWecomMessageParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  text: string;
+};
+
+/**
+ * Send a text message.
+ */
+export async function sendMessageWecom(params: SendWecomMessageParams): Promise<WecomSendResult> {
+  const { cfg, to, text } = params;
+  const wecomCfg = cfg.channels?.wecom as WecomConfig | undefined;
+
+  if (!wecomCfg?.token) {
+    throw new Error("WeChat channel not configured (token required)");
+  }
+
+  const chatId = normalizeWecomTarget(to) ?? wecomCfg.chatId;
+  if (!chatId) {
+    throw new Error(`Invalid WeChat target: ${to}`);
+  }
+
+  const payload: SendTextPayload = { text };
+
+  const request: WecomSendRequest = {
+    token: wecomCfg.token,
+    chatId,
+    messageType: 0,
+    payload,
+  };
+
+  try {
+    const response = await sendStrideMessage(request);
+    if (response.code !== 0) {
+      return {
+        chatId,
+        success: false,
+        error: response.message ?? `Error code: ${response.code}`,
+      };
+    }
+    return { chatId, success: true };
+  } catch (err) {
+    return {
+      chatId,
+      success: false,
+      error: String(err),
+    };
+  }
+}
+
+export type SendWecomImageParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  imageUrl: string;
+};
+
+/**
+ * Send an image message.
+ */
+export async function sendImageWecom(params: SendWecomImageParams): Promise<WecomSendResult> {
+  const { cfg, to, imageUrl } = params;
+  const wecomCfg = cfg.channels?.wecom as WecomConfig | undefined;
+
+  if (!wecomCfg?.token) {
+    throw new Error("WeChat channel not configured (token required)");
+  }
+
+  const chatId = normalizeWecomTarget(to) ?? wecomCfg.chatId;
+  if (!chatId) {
+    throw new Error(`Invalid WeChat target: ${to}`);
+  }
+
+  const payload: SendImagePayload = {
+    imageUrl,
+    url: imageUrl,
+  };
+
+  const request: WecomSendRequest = {
+    token: wecomCfg.token,
+    chatId,
+    messageType: 1,
+    payload,
+  };
+
+  try {
+    const response = await sendStrideMessage(request);
+    if (response.code !== 0) {
+      return {
+        chatId,
+        success: false,
+        error: response.message ?? `Error code: ${response.code}`,
+      };
+    }
+    return { chatId, success: true };
+  } catch (err) {
+    return {
+      chatId,
+      success: false,
+      error: String(err),
+    };
+  }
+}
+
+export type SendWecomFileParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  fileUrl: string;
+  fileName: string;
+  fileSize?: number;
+};
+
+/**
+ * Send a file message.
+ */
+export async function sendFileWecom(params: SendWecomFileParams): Promise<WecomSendResult> {
+  const { cfg, to, fileUrl, fileName, fileSize } = params;
+  const wecomCfg = cfg.channels?.wecom as WecomConfig | undefined;
+
+  if (!wecomCfg?.token) {
+    throw new Error("WeChat channel not configured (token required)");
+  }
+
+  const chatId = normalizeWecomTarget(to) ?? wecomCfg.chatId;
+  if (!chatId) {
+    throw new Error(`Invalid WeChat target: ${to}`);
+  }
+
+  const payload: SendFilePayload = {
+    name: fileName,
+    url: fileUrl,
+    size: fileSize,
+  };
+
+  const request: WecomSendRequest = {
+    token: wecomCfg.token,
+    chatId,
+    messageType: 3,
+    payload,
+  };
+
+  try {
+    const response = await sendStrideMessage(request);
+    if (response.code !== 0) {
+      return {
+        chatId,
+        success: false,
+        error: response.message ?? `Error code: ${response.code}`,
+      };
+    }
+    return { chatId, success: true };
+  } catch (err) {
+    return {
+      chatId,
+      success: false,
+      error: String(err),
+    };
+  }
+}
+
+export type SendWecomLinkParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  title: string;
+  url: string;
+  summary?: string;
+  imageUrl?: string;
+};
+
+/**
+ * Send a link message.
+ */
+export async function sendLinkWecom(params: SendWecomLinkParams): Promise<WecomSendResult> {
+  const { cfg, to, title, url, summary, imageUrl } = params;
+  const wecomCfg = cfg.channels?.wecom as WecomConfig | undefined;
+
+  if (!wecomCfg?.token) {
+    throw new Error("WeChat channel not configured (token required)");
+  }
+
+  const chatId = normalizeWecomTarget(to) ?? wecomCfg.chatId;
+  if (!chatId) {
+    throw new Error(`Invalid WeChat target: ${to}`);
+  }
+
+  const payload: SendLinkPayload = {
+    title,
+    sourceUrl: url,
+    summary,
+    imageUrl,
+  };
+
+  const request: WecomSendRequest = {
+    token: wecomCfg.token,
+    chatId,
+    messageType: 2,
+    payload,
+  };
+
+  try {
+    const response = await sendStrideMessage(request);
+    if (response.code !== 0) {
+      return {
+        chatId,
+        success: false,
+        error: response.message ?? `Error code: ${response.code}`,
+      };
+    }
+    return { chatId, success: true };
+  } catch (err) {
+    return {
+      chatId,
+      success: false,
+      error: String(err),
+    };
+  }
+}

package/src/targets.ts

@@ -0,0 +1,66 @@
+/**
+ * Normalize a target string to a raw ID.
+ * Supported formats:
+ * - "chat:<chatId>" -> chatId
+ * - "user:<contactId>" -> contactId
+ * - "room:<roomId>" -> roomId
+ * - raw ID (no prefix)
+ */
+export function normalizeWecomTarget(raw: string): string | null {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+
+  const lowered = trimmed.toLowerCase();
+  if (lowered.startsWith("chat:")) {
+    return trimmed.slice("chat:".length).trim() || null;
+  }
+  if (lowered.startsWith("user:")) {
+    return trimmed.slice("user:".length).trim() || null;
+  }
+  if (lowered.startsWith("room:")) {
+    return trimmed.slice("room:".length).trim() || null;
+  }
+
+  return trimmed;
+}
+
+/**
+ * Format a target ID with type prefix for display.
+ */
+export function formatWecomTarget(id: string, type?: "chat" | "user" | "room"): string {
+  const trimmed = id.trim();
+  if (type === "chat") return `chat:${trimmed}`;
+  if (type === "user") return `user:${trimmed}`;
+  if (type === "room") return `room:${trimmed}`;
+  return trimmed;
+}
+
+/**
+ * Check if a string looks like a WeChat/Stride ID.
+ */
+export function looksLikeWecomId(raw: string): boolean {
+  const trimmed = raw.trim();
+  if (!trimmed) return false;
+  if (/^(chat|user|room):/i.test(trimmed)) return true;
+  // Stride chatId format: 24-char hex
+  if (/^[a-f0-9]{24}$/.test(trimmed)) return true;
+  // WeChat wxid format: numeric string
+  if (/^\d{10,20}$/.test(trimmed)) return true;
+  // Room ID format: R:xxxxx
+  if (/^R:\d+$/.test(trimmed)) return true;
+  return false;
+}
+
+/**
+ * Detect the type of an ID based on its format.
+ */
+export function detectIdType(id: string): "chat" | "room" | "user" | null {
+  const trimmed = id.trim();
+  // Stride chatId: 24-char hex
+  if (/^[a-f0-9]{24}$/.test(trimmed)) return "chat";
+  // Room ID: R:xxxxx
+  if (/^R:\d+$/.test(trimmed)) return "room";
+  // WeChat wxid: numeric
+  if (/^\d{10,20}$/.test(trimmed)) return "user";
+  return null;
+}

package/src/types.ts

@@ -0,0 +1,257 @@
+import type { WecomConfigSchema, WecomGroupSchema, z } from "./config-schema.js";
+
+export type WecomConfig = z.infer<typeof WecomConfigSchema>;
+export type WecomGroupConfig = z.infer<typeof WecomGroupSchema>;
+
+export type ResolvedWecomAccount = {
+  accountId: string;
+  enabled: boolean;
+  configured: boolean;
+  token?: string;
+  chatId?: string;
+};
+
+// --- Stride Webhook Event Types ---
+
+/**
+ * Common sender/room information present in all webhook events
+ */
+export type WecomEventMeta = {
+  contactName: string;
+  contactId: string;
+  avatar?: string;
+  roomTopic?: string;
+  roomId?: string;
+  chatId: string;
+  mentionSelf: boolean;
+  isSelf: boolean;
+};
+
+/**
+ * Inbound message types (from webhook)
+ */
+export type InboundMessageType = 1 | 2 | 4 | 6 | 7 | 12 | 10000 | 10001;
+
+// Type 1: File message
+export type FilePayload = {
+  fileUrl: string;
+  name: string;
+  size?: number;
+  md5?: string;
+};
+
+// Type 2: Voice message (with transcription)
+export type VoicePayload = {
+  voiceUrl: string;
+  duration?: number;
+  text?: string; // Transcribed text from Stride
+  md5?: string;
+  wxVoiceUrl?: string;
+};
+
+// Type 4: Chat history (merged forward)
+export type ChatHistoryItem = {
+  type: number;
+  avatar?: string;
+  senderName?: string;
+  corpName?: string;
+  time?: number;
+  message: {
+    content?: string;
+    imageUrl?: string;
+    name?: string;
+    fileUrl?: string;
+    link?: {
+      title?: string;
+      des?: string;
+      thumbnailUrl?: string;
+      link?: string;
+    };
+  };
+};
+
+export type ChatHistoryPayload = {
+  content: string;
+  chatHistoryList: ChatHistoryItem[];
+};
+
+// Type 6: Image message
+export type ImagePayload = {
+  imageUrl: string;
+  size?: number;
+  width?: number;
+  height?: number;
+};
+
+// Type 7: Text message
+export type TextPayload = {
+  text: string;
+  mention?: string[];
+  pureText?: string;
+};
+
+// Type 12: Link message
+export type LinkPayload = {
+  title: string;
+  description?: string;
+  url: string;
+  thumbnailUrl?: string;
+};
+
+// Type 10000: System message (join notification)
+export type SystemJoinPayload = {
+  type: number;
+  subPayload: {
+    memberNames?: string[];
+    inviterName?: string;
+  };
+};
+
+// Type 10001: System message (member list)
+export type SystemMemberListPayload = {
+  subPayload: {
+    inviteeList?: Array<{
+      displayName: string;
+      wxid: string;
+      isSelf: boolean;
+    }>;
+    inviter?: {
+      displayName: string;
+      wxid: string;
+      isSelf: boolean;
+    };
+  };
+};
+
+/**
+ * Union type for all inbound message payloads
+ */
+export type InboundPayload =
+  | FilePayload
+  | VoicePayload
+  | ChatHistoryPayload
+  | ImagePayload
+  | TextPayload
+  | LinkPayload
+  | SystemJoinPayload
+  | SystemMemberListPayload;
+
+/**
+ * Inbound webhook event structure
+ */
+export type WecomWebhookEvent = WecomEventMeta & {
+  type: InboundMessageType;
+  payload: InboundPayload;
+};
+
+// --- Outbound Message Types (for sending) ---
+
+export type OutboundMessageType = 0 | 1 | 2 | 3 | 4 | 5 | 7 | 8 | 9 | 10;
+
+// messageType 0: Text
+export type SendTextPayload = {
+  text: string;
+};
+
+// messageType 1: Image
+export type SendImagePayload = {
+  imageUrl: string;
+  url: string;
+};
+
+// messageType 2: Link
+export type SendLinkPayload = {
+  title: string;
+  summary?: string;
+  sourceUrl: string;
+  imageUrl?: string;
+};
+
+// messageType 3: File
+export type SendFilePayload = {
+  name: string;
+  url: string;
+  size?: number;
+};
+
+// messageType 5: Video
+export type SendVideoPayload = {
+  url: string; // mp4 only
+};
+
+// messageType 8: Voice
+export type SendVoicePayload = {
+  voiceUrl: string; // silk only
+  duration?: number;
+};
+
+// messageType 9: Emoji
+export type SendEmojiPayload = {
+  imageUrl: string;
+};
+
+/**
+ * Union type for all outbound message payloads
+ */
+export type OutboundPayload =
+  | SendTextPayload
+  | SendImagePayload
+  | SendLinkPayload
+  | SendFilePayload
+  | SendVideoPayload
+  | SendVoicePayload
+  | SendEmojiPayload;
+
+/**
+ * Outbound message request structure
+ */
+export type WecomSendRequest = {
+  token: string;
+  chatId: string;
+  externalRequestId?: string;
+  messageType: OutboundMessageType;
+  payload: OutboundPayload;
+};
+
+/**
+ * Outbound API response
+ */
+export type WecomSendResponse = {
+  code: number;
+  message?: string;
+  data?: unknown;
+};
+
+// --- Internal Types ---
+
+export type WecomMessageContext = {
+  chatId: string;
+  contactId: string;
+  contactName: string;
+  roomId?: string;
+  roomTopic?: string;
+  chatType: "dm" | "group";
+  mentionedBot: boolean;
+  content: string;
+  contentType: string;
+  mediaUrl?: string;
+  mediaType?: string;
+};
+
+export type WecomSendResult = {
+  chatId: string;
+  success: boolean;
+  error?: string;
+};
+
+export type WecomProbeResult = {
+  ok: boolean;
+  error?: string;
+  chatId?: string;
+};
+
+export type WecomMediaInfo = {
+  url: string;
+  contentType?: string;
+  placeholder: string;
+};