@junjiezhang/openclaw-wecom-plugin 1.0.0 → 1.0.2

package/src/media.ts

@@ -1,105 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import type { ClawdbotConfig } from "openclaw/plugin-sdk";
-import { fetchWithSsrFGuard } from "openclaw/plugin-sdk";
-import { resolveWeComAccount } from "./accounts.js";
-import { getWeComAccessToken } from "./client.js";
-
-export type DownloadImageResult = {
-  buffer: Buffer;
-  contentType?: string;
-  fileName?: string;
-};
-
-const WECOM_API_POLICY = { allowedHostnames: ["qyapi.weixin.qq.com"] };
-
-/**
- * Download an image from WeCom using media_id.
- * WeCom image API: GET https://qyapi.weixin.qq.com/cgi-bin/media/get?access_token=ACCESS_TOKEN&media_id=MEDIA_ID
- */
-export async function downloadImageWeCom(params: {
-  cfg: ClawdbotConfig;
-  mediaId: string;
-  accountId?: string;
-}): Promise<DownloadImageResult> {
-  const { cfg, mediaId, accountId } = params;
-  const account = resolveWeComAccount({ cfg, accountId });
-  if (!account.configured) {
-    throw new Error(`WeCom account "${account.accountId}" not configured`);
-  }
-
-  const accessToken = await getWeComAccessToken({ cfg, accountId });
-  const url = `https://qyapi.weixin.qq.com/cgi-bin/media/get?access_token=${accessToken}&media_id=${mediaId}`;
-
-  const { response, release } = await fetchWithSsrFGuard({
-    url,
-    policy: WECOM_API_POLICY,
-    auditContext: "wecom-download-image",
-  });
-  try {
-    if (!response.ok) {
-      throw new Error(`WeCom image download failed: ${response.status} ${response.statusText}`);
-    }
-
-    // Check if response is JSON error
-    const contentType = response.headers.get("content-type");
-    if (contentType?.includes("application/json")) {
-      const errorData = await response.json();
-      throw new Error(`WeCom image download error ${errorData.errcode}: ${errorData.errmsg}`);
-    }
-
-    const buffer = Buffer.from(await response.arrayBuffer());
-
-    // Try to determine file extension from content-type
-    let fileName = `image_${mediaId}`;
-    if (contentType) {
-      const ext = contentTypeToExtension(contentType);
-      if (ext) {
-        fileName = `image_${mediaId}${ext}`;
-      }
-    }
-
-    return { buffer, contentType: contentType ?? undefined, fileName };
-  } finally {
-    await release();
-  }
-}
-
-/**
- * Map content-type to file extension
- */
-function contentTypeToExtension(contentType: string): string | null {
-  const map: Record<string, string> = {
-    "image/jpeg": ".jpg",
-    "image/png": ".png",
-    "image/gif": ".gif",
-    "image/webp": ".webp",
-    "image/bmp": ".bmp",
-    "image/tiff": ".tiff",
-  };
-  return map[contentType] || null;
-}
-
-/**
- * Save image to inbound media directory
- */
-export async function saveInboundImage(params: {
-  buffer: Buffer;
-  fileName: string;
-  accountId: string;
-}): Promise<string> {
-  const { buffer, fileName, accountId } = params;
-
-  // Ensure media directory exists
-  const mediaDir = path.join(os.homedir(), ".openclaw", "media", "inbound");
-  await fs.promises.mkdir(mediaDir, { recursive: true });
-
-  // Generate unique filename
-  const uniqueName = `${accountId}_${Date.now()}_${fileName}`;
-  const filePath = path.join(mediaDir, uniqueName);
-
-  await fs.promises.writeFile(filePath, buffer);
-
-  return filePath;
-}

package/src/monitor.ts

@@ -1,344 +0,0 @@
-import * as crypto from "crypto";
-import * as http from "http";
-import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk";
-import { installRequestBodyLimitGuard } from "openclaw/plugin-sdk";
-import { resolveWeComAccount } from "./accounts.js";
-import { handleWeComMessage, type WeComMessageEvent } from "./bot.js";
-import { probeWeCom } from "./probe.js";
-import type { ResolvedWeComAccount } from "./types.js";
-
-export type MonitorWeComOpts = {
-  config?: ClawdbotConfig;
-  runtime?: RuntimeEnv;
-  abortSignal?: AbortSignal;
-  accountId?: string;
-};
-
-const httpServers = new Map<string, http.Server>();
-const chatHistoriesMap = new Map<string, Map<string, HistoryEntry[]>>();
-const WECOM_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
-const WECOM_WEBHOOK_BODY_TIMEOUT_MS = 30_000;
-
-/**
- * Verify WeCom webhook signature
- */
-function verifyWeComSignature(
-  signature: string,
-  timestamp: string,
-  nonce: string,
-  body: string,
-  token: string,
-): boolean {
-  const arr = [token, timestamp, nonce, body].sort();
-  const str = arr.join("");
-  const hash = crypto.createHash("sha1").update(str).digest("hex");
-  return hash === signature;
-}
-
-/**
- * Decrypt WeCom message
- */
-function decryptWeComMessage(
-  encrypt: string,
-  encodingAESKey: string,
-): { message: string; corpId: string } {
-  const key = Buffer.from(encodingAESKey + "=", "base64");
-  const encryptBuffer = Buffer.from(encrypt, "base64");
-
-  // Decrypt using key as IV (WeCom uses the key itself as IV)
-  const decipher = crypto.createDecipheriv("aes-256-cbc", key, key.slice(0, 16));
-  decipher.setAutoPadding(false);
-  let decrypted = Buffer.concat([decipher.update(encryptBuffer), decipher.final()]);
-
-  // Remove PKCS7 padding
-  const pad = decrypted[decrypted.length - 1];
-  decrypted = decrypted.slice(0, decrypted.length - pad);
-
-  // Message structure: random(16) + msg_len(4) + msg(msg_len) + corpId
-  // Skip random 16 bytes, read msg_len as network byte order (big-endian)
-  const msgLen = decrypted.readUInt32BE(16);
-  const message = decrypted.slice(20, 20 + msgLen).toString("utf8");
-  const corpId = decrypted.slice(20 + msgLen).toString("utf8");
-
-  return { message, corpId };
-}
-
-/**
- * Monitor WeCom webhook
- */
-async function monitorWeComWebhook({
-  cfg,
-  account,
-  runtime,
-  abortSignal,
-}: {
-  cfg: ClawdbotConfig;
-  account: ResolvedWeComAccount;
-  runtime?: RuntimeEnv;
-  abortSignal?: AbortSignal;
-}): Promise<void> {
-  const { accountId } = account;
-  const log = runtime?.log ?? console.log;
-  const error = runtime?.error ?? console.error;
-
-  const port = account.config?.webhookPort ?? 3000;
-  const path = account.config?.webhookPath ?? "/wecom/events";
-  const host = account.config?.webhookHost ?? "127.0.0.1";
-  const token = account.config?.token;
-  const encodingAESKey = account.config?.encodingAESKey;
-
-  if (!token || !encodingAESKey) {
-    throw new Error(`WeCom account "${accountId}" requires token and encodingAESKey`);
-  }
-
-  log(`wecom[${accountId}]: starting Webhook server on ${host}:${port}, path ${path}...`);
-
-  // Get or create chatHistories for this account
-  let chatHistories = chatHistoriesMap.get(accountId);
-  if (!chatHistories) {
-    chatHistories = new Map<string, HistoryEntry[]>();
-    chatHistoriesMap.set(accountId, chatHistories);
-  }
-
-  const server = http.createServer();
-
-  server.on("request", async (req, res) => {
-    // Extract pathname from URL (ignore query parameters)
-    const urlPath = req.url?.split("?")[0];
-    if (urlPath !== path) {
-      res.statusCode = 404;
-      res.end("Not Found");
-      return;
-    }
-
-    // Handle URL verification (GET request)
-    if (req.method === "GET") {
-      // Parse URL and get URL-decoded parameters
-      const url = new URL(req.url!, `http://${req.headers.host}`);
-      const msgSignature = url.searchParams.get("msg_signature");
-      const timestamp = url.searchParams.get("timestamp");
-      const nonce = url.searchParams.get("nonce");
-      const echostr = url.searchParams.get("echostr");
-
-      if (!msgSignature || !timestamp || !nonce || !echostr) {
-        res.statusCode = 400;
-        res.end("Bad Request");
-        return;
-      }
-
-      try {
-        // Verify signature using URL-decoded echostr
-        if (!verifyWeComSignature(msgSignature, timestamp, nonce, echostr, token)) {
-          error(`wecom[${accountId}]: signature verification failed`);
-          res.statusCode = 401;
-          res.end("Unauthorized");
-          return;
-        }
-
-        // Decrypt echostr
-        const { message, corpId } = decryptWeComMessage(echostr, encodingAESKey);
-
-        // Verify corpId matches configuration
-        const expectedCorpId = account.corpId;
-        if (corpId !== expectedCorpId) {
-          error(`wecom[${accountId}]: corpId mismatch, expected=${expectedCorpId}, got=${corpId}`);
-          res.statusCode = 403;
-          res.end("Forbidden");
-          return;
-        }
-
-        // Return plain text without quotes, BOM, or newlines
-        res.statusCode = 200;
-        res.setHeader("Content-Type", "text/plain; charset=utf-8");
-        res.end(message);
-        log(`wecom[${accountId}]: URL verification successful`);
-      } catch (err) {
-        error(`wecom[${accountId}]: URL verification error: ${String(err)}`);
-        res.statusCode = 500;
-        res.end("Internal Server Error");
-      }
-      return;
-    }
-
-    // Handle message events (POST request)
-    if (req.method === "POST") {
-      const guard = installRequestBodyLimitGuard(req, res, {
-        maxBytes: WECOM_WEBHOOK_MAX_BODY_BYTES,
-        timeoutMs: WECOM_WEBHOOK_BODY_TIMEOUT_MS,
-        responseFormat: "text",
-      });
-
-      if (guard.isTripped()) {
-        return;
-      }
-
-      const chunks: Buffer[] = [];
-      req.on("data", (chunk) => chunks.push(chunk));
-      req.on("end", async () => {
-        try {
-          const body = Buffer.concat(chunks).toString("utf8");
-
-          // Parse XML to extract Encrypt field
-          const encryptMatch = body.match(/<Encrypt><!\[CDATA\[(.*?)\]\]><\/Encrypt>/);
-          if (!encryptMatch) {
-            error(`wecom[${accountId}]: failed to extract Encrypt from XML body`);
-            res.statusCode = 400;
-            res.end("Bad Request");
-            return;
-          }
-          const encrypt = encryptMatch[1];
-
-          const url = new URL(req.url!, `http://${req.headers.host}`);
-          const msgSignature = url.searchParams.get("msg_signature");
-          const timestamp = url.searchParams.get("timestamp");
-          const nonce = url.searchParams.get("nonce");
-
-          if (!msgSignature || !timestamp || !nonce) {
-            res.statusCode = 400;
-            res.end("Bad Request");
-            return;
-          }
-
-          // Verify signature
-          if (!verifyWeComSignature(msgSignature, timestamp, nonce, encrypt, token)) {
-            error(`wecom[${accountId}]: signature verification failed`);
-            res.statusCode = 401;
-            res.end("Unauthorized");
-            return;
-          }
-
-          // Decrypt message
-          const { message } = decryptWeComMessage(encrypt, encodingAESKey);
-
-          // Parse decrypted XML message
-          const event: WeComMessageEvent = {
-            ToUserName: message.match(/<ToUserName><!\[CDATA\[(.*?)\]\]><\/ToUserName>/)?.[1] || "",
-            FromUserName:
-              message.match(/<FromUserName><!\[CDATA\[(.*?)\]\]><\/FromUserName>/)?.[1] || "",
-            CreateTime: Number.parseInt(
-              message.match(/<CreateTime>(\d+)<\/CreateTime>/)?.[1] || "0",
-            ),
-            MsgType: message.match(/<MsgType><!\[CDATA\[(.*?)\]\]><\/MsgType>/)?.[1] || "",
-            Content: message.match(/<Content><!\[CDATA\[(.*?)\]\]><\/Content>/)?.[1],
-            MsgId: message.match(/<MsgId>(\d+)<\/MsgId>/)?.[1] || "",
-            AgentID: message.match(/<AgentID>(\d+)<\/AgentID>/)?.[1] || "",
-            PicUrl: message.match(/<PicUrl><!\[CDATA\[(.*?)\]\]><\/PicUrl>/)?.[1],
-            MediaId: message.match(/<MediaId><!\[CDATA\[(.*?)\]\]><\/MediaId>/)?.[1],
-            Title: message.match(/<Title><!\[CDATA\[(.*?)\]\]><\/Title>/)?.[1],
-            Description: message.match(/<Description><!\[CDATA\[(.*?)\]\]><\/Description>/)?.[1],
-            FileKey: message.match(/<FileKey><!\[CDATA\[(.*?)\]\]><\/FileKey>/)?.[1],
-            Location_X: message.match(/<Location_X>(.*?)<\/Location_X>/)?.[1],
-            Location_Y: message.match(/<Location_Y>(.*?)<\/Location_Y>/)?.[1],
-            Scale: message.match(/<Scale>(\d+)<\/Scale>/)?.[1],
-            Label: message.match(/<Label><!\[CDATA\[(.*?)\]\]><\/Label>/)?.[1],
-            Url: message.match(/<Url><!\[CDATA\[(.*?)\]\]><\/Url>/)?.[1],
-            ChatId: message.match(/<ChatId><!\[CDATA\[(.*?)\]\]><\/ChatId>/)?.[1],
-            ChatType: message.match(/<ChatType><!\[CDATA\[(.*?)\]\]><\/ChatType>/)?.[1],
-          };
-
-          log(
-            `wecom[${accountId}]: received message from ${event.FromUserName}, type=${event.MsgType}`,
-          );
-
-          // Handle message (fire and forget to avoid blocking response).
-          // handleWeComMessage has its own try/catch and sends error replies internally.
-          handleWeComMessage({
-            cfg,
-            event,
-            runtime,
-            chatHistories,
-            accountId: accountId,
-          }).catch((err) => {
-            error(`wecom[${accountId}]: unexpected error handling message: ${String(err)}`);
-          });
-
-          res.statusCode = 200;
-          res.end("success");
-        } catch (err) {
-          if (!guard.isTripped()) {
-            error(`wecom[${accountId}]: webhook handler error: ${String(err)}`);
-            res.statusCode = 500;
-            res.end("Internal Server Error");
-          }
-        } finally {
-          guard.dispose();
-        }
-      });
-      return;
-    }
-
-    res.statusCode = 405;
-    res.end("Method Not Allowed");
-  });
-
-  httpServers.set(accountId, server);
-
-  return new Promise((resolve, reject) => {
-    const cleanup = (callback?: () => void) => {
-      server.close(() => {
-        httpServers.delete(accountId);
-        callback?.();
-      });
-    };
-
-    const handleAbort = () => {
-      log(`wecom[${accountId}]: abort signal received, stopping`);
-      cleanup(() => resolve());
-    };
-
-    if (abortSignal?.aborted) {
-      cleanup(() => resolve());
-      return;
-    }
-
-    abortSignal?.addEventListener("abort", handleAbort, { once: true });
-
-    // Attach error handler before listen() so async bind failures (e.g. EADDRINUSE) are caught.
-    server.on("error", (err) => {
-      error(`wecom[${accountId}]: server error: ${String(err)}`);
-      abortSignal?.removeEventListener("abort", handleAbort);
-      cleanup(() => reject(err));
-    });
-
-    server.listen(port, host, () => {
-      log(`wecom[${accountId}]: Webhook server listening on ${host}:${port}${path}`);
-    });
-  });
-}
-
-/**
- * Monitor WeCom provider
- */
-export async function monitorWeComProvider(opts: MonitorWeComOpts): Promise<() => void> {
-  const { config, runtime, abortSignal, accountId } = opts;
-
-  if (!config) {
-    throw new Error("Config is required");
-  }
-
-  const account = resolveWeComAccount({ cfg: config, accountId });
-
-  if (!account.configured) {
-    throw new Error(`WeCom account "${account.accountId}" is not configured`);
-  }
-
-  const log = runtime?.log ?? console.log;
-  log(`wecom[${account.accountId}]: starting monitor...`);
-
-  // Start webhook server and wait for it to be ready
-  await monitorWeComWebhook({
-    cfg: config,
-    account,
-    runtime,
-    abortSignal,
-  });
-
-  // Return cleanup function
-  return () => {
-    const server = httpServers.get(account.accountId);
-    if (server) {
-      server.close();
-      httpServers.delete(account.accountId);
-    }
-  };
-}

package/src/outbound.ts

@@ -1,26 +0,0 @@
-import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
-import { sendMessageWeCom } from "./send.js";
-
-export const wecomOutbound: ChannelOutboundAdapter = {
-  deliveryMode: "direct",
-  sendText: async ({ cfg, to, text, accountId }) => {
-    const result = await sendMessageWeCom({
-      cfg,
-      to,
-      text,
-      accountId: accountId ?? undefined,
-    });
-    return { channel: "wecom", ...result };
-  },
-  sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
-    // WeCom media upload not yet implemented; send text + URL fallback
-    const content = [text?.trim(), mediaUrl].filter(Boolean).join("\n");
-    const result = await sendMessageWeCom({
-      cfg,
-      to,
-      text: content || "(media)",
-      accountId: accountId ?? undefined,
-    });
-    return { channel: "wecom", ...result };
-  },
-};

package/src/policy.ts

@@ -1,108 +0,0 @@
-import type {
-  AllowlistMatch,
-  ChannelGroupContext,
-  GroupToolPolicyConfig,
-} from "openclaw/plugin-sdk";
-import { normalizeWeComTarget } from "./targets.js";
-import type { WeComConfig, WeComGroupConfig } from "./types.js";
-
-export type WeComAllowlistMatch = AllowlistMatch<"wildcard" | "id">;
-
-function normalizeWeComAllowEntry(raw: string): string {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return "";
-  }
-  if (trimmed === "*") {
-    return "*";
-  }
-  const withoutProviderPrefix = trimmed.replace(/^wecom:/i, "");
-  const normalized = normalizeWeComTarget(withoutProviderPrefix) ?? withoutProviderPrefix;
-  return normalized.trim().toLowerCase();
-}
-
-export function resolveWeComAllowlistMatch(params: {
-  allowFrom: Array<string | number>;
-  senderId: string;
-  senderIds?: Array<string | null | undefined>;
-  senderName?: string | null;
-}): WeComAllowlistMatch {
-  const allowFrom = params.allowFrom
-    .map((entry) => normalizeWeComAllowEntry(String(entry)))
-    .filter(Boolean);
-  if (allowFrom.length === 0) {
-    return { allowed: false };
-  }
-  if (allowFrom.includes("*")) {
-    return { allowed: true, matchKey: "*", matchSource: "wildcard" };
-  }
-
-  // WeCom allowlists are ID-based
-  const senderCandidates = [params.senderId, ...(params.senderIds ?? [])]
-    .map((entry) => normalizeWeComAllowEntry(String(entry ?? "")))
-    .filter(Boolean);
-
-  for (const senderId of senderCandidates) {
-    if (allowFrom.includes(senderId)) {
-      return { allowed: true, matchKey: senderId, matchSource: "id" };
-    }
-  }
-
-  return { allowed: false };
-}
-
-export function resolveWeComGroupConfig(params: {
-  cfg?: WeComConfig;
-  groupId?: string | null;
-}): WeComGroupConfig | undefined {
-  // WeCom doesn't have per-group config yet, return undefined
-  return undefined;
-}
-
-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;
-}
-
-export function isWeComGroupAllowed(params: {
-  groupPolicy: "open" | "allowlist" | "disabled";
-  allowFrom: Array<string | number>;
-  senderId: string;
-  senderIds?: Array<string | null | undefined>;
-  senderName?: string | null;
-}): boolean {
-  const { groupPolicy } = params;
-  if (groupPolicy === "disabled") {
-    return false;
-  }
-  if (groupPolicy === "open") {
-    return true;
-  }
-  return resolveWeComAllowlistMatch(params).allowed;
-}
-
-export function resolveWeComReplyPolicy(params: {
-  isDirectMessage: boolean;
-  globalConfig?: WeComConfig;
-  groupConfig?: WeComGroupConfig;
-}): { requireMention: boolean } {
-  if (params.isDirectMessage) {
-    return { requireMention: false };
-  }
-
-  const requireMention =
-    params.groupConfig?.requireMention ?? params.globalConfig?.requireMention ?? false;
-
-  return { requireMention };
-}

package/src/probe.ts

@@ -1,13 +0,0 @@
-import type { ResolvedWeComAccount } from "./types.js";
-
-export async function probeWeCom(account: ResolvedWeComAccount): Promise<{
-  ok: boolean;
-  error?: string;
-}> {
-  if (!account.configured) {
-    return { ok: false, error: "Not configured" };
-  }
-
-  // TODO: Implement actual probe (e.g., test API call)
-  return { ok: true };
-}

package/src/reply-dispatcher.ts

@@ -1,78 +0,0 @@
-import {
-  createReplyPrefixContext,
-  type ClawdbotConfig,
-  type ReplyPayload,
-  type RuntimeEnv,
-} from "openclaw/plugin-sdk";
-import { resolveWeComAccount } from "./accounts.js";
-import { getWeComRuntime } from "./runtime.js";
-import { sendMessageWeCom, sendGroupMessageWeCom } from "./send.js";
-
-export type CreateWeComReplyDispatcherParams = {
-  cfg: ClawdbotConfig;
-  agentId: string;
-  runtime: RuntimeEnv;
-  userId?: string;
-  chatId?: string;
-  isGroupChat: boolean;
-  accountId?: string;
-};
-
-export function createWeComReplyDispatcher(params: CreateWeComReplyDispatcherParams) {
-  const core = getWeComRuntime();
-  const { cfg, agentId, userId, chatId, isGroupChat, accountId } = params;
-  const account = resolveWeComAccount({ cfg, accountId });
-  const prefixContext = createReplyPrefixContext({ cfg, agentId });
-
-  const textChunkLimit = core.channel.text.resolveTextChunkLimit(cfg, "wecom", accountId, {
-    fallbackLimit: 2000,
-  });
-  const chunkMode = core.channel.text.resolveChunkMode(cfg, "wecom");
-
-  const { dispatcher, replyOptions, markDispatchIdle } =
-    core.channel.reply.createReplyDispatcherWithTyping({
-      responsePrefix: prefixContext.responsePrefix,
-      responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
-      humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
-      deliver: async (payload: ReplyPayload) => {
-        const text = payload.text ?? "";
-        if (!text.trim()) {
-          return;
-        }
-
-        for (const chunk of core.channel.text.chunkTextWithMode(text, textChunkLimit, chunkMode)) {
-          if (isGroupChat && chatId) {
-            await sendGroupMessageWeCom({
-              cfg,
-              chatId,
-              text: chunk,
-              accountId,
-            });
-          } else if (userId) {
-            await sendMessageWeCom({
-              cfg,
-              to: userId,
-              text: chunk,
-              accountId,
-            });
-          }
-        }
-      },
-      onError: async (error, info) => {
-        params.runtime.error?.(
-          `wecom[${account.accountId}] ${info.kind} reply failed: ${String(error)}`,
-        );
-      },
-      onIdle: async () => {},
-      onCleanup: () => {},
-    });
-
-  return {
-    dispatcher,
-    replyOptions: {
-      ...replyOptions,
-      onModelSelected: prefixContext.onModelSelected,
-    },
-    markDispatchIdle,
-  };
-}

package/src/runtime.ts

@@ -1,14 +0,0 @@
-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("WeCom runtime not initialized");
-  }
-  return runtime;
-}