@max1874/openclaw-wecom 0.1.0

package/src/webhook.ts

@@ -0,0 +1,171 @@
+import { createServer, type Server, type IncomingMessage, type ServerResponse } from "http";
+import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk";
+import type { WecomConfig, WecomWebhookEvent } from "./types.js";
+import { handleWecomMessage } from "./bot.js";
+
+export type WebhookServerOptions = {
+  cfg: ClawdbotConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  chatHistories: Map<string, HistoryEntry[]>;
+};
+
+/**
+ * Parse request body as JSON.
+ */
+async function parseBody(req: IncomingMessage): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      try {
+        const body = Buffer.concat(chunks).toString("utf-8");
+        resolve(body ? JSON.parse(body) : {});
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+/**
+ * Send JSON response.
+ */
+function sendJson(res: ServerResponse, status: number, data: unknown): void {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+
+/**
+ * Create and start the webhook HTTP server.
+ */
+export async function startWebhookServer(options: WebhookServerOptions): Promise<Server> {
+  const { cfg, runtime, abortSignal, chatHistories } = options;
+  const wecomCfg = cfg.channels?.wecom as WecomConfig | undefined;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+
+  const webhookPath = wecomCfg?.webhookPath ?? "/webhooks/wechat";
+  const port = wecomCfg?.webhookPort ?? 3000;
+
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    const path = url.pathname;
+
+    log(`wecom webhook: ${req.method} ${path}`);
+
+    // Health check endpoint
+    if (path === "/health" || path === `${webhookPath}/health`) {
+      sendJson(res, 200, { status: "ok", channel: "wecom" });
+      return;
+    }
+
+    // Only accept POST requests to webhook paths
+    if (req.method !== "POST") {
+      sendJson(res, 405, { error: "Method not allowed" });
+      return;
+    }
+
+    // Check if this is a webhook event path
+    if (!path.startsWith(webhookPath)) {
+      sendJson(res, 404, { error: "Not found" });
+      return;
+    }
+
+    try {
+      const body = await parseBody(req);
+      const eventPath = path.slice(webhookPath.length);
+
+      log(`wecom webhook: event path=${eventPath}, body=${JSON.stringify(body).slice(0, 200)}`);
+
+      // Route by event path
+      if (eventPath === "/events/message" || eventPath === "") {
+        // Main message event
+        const event = body as WecomWebhookEvent;
+
+        // Validate required fields
+        if (!event.chatId || !event.contactId) {
+          sendJson(res, 400, { error: "Missing required fields: chatId, contactId" });
+          return;
+        }
+
+        // Respond immediately to avoid timeout
+        sendJson(res, 200, { status: "received" });
+
+        // Process message asynchronously
+        handleWecomMessage({
+          cfg,
+          event,
+          runtime,
+          chatHistories,
+        }).catch((err) => {
+          error(`wecom webhook: failed to handle message: ${String(err)}`);
+        });
+        return;
+      }
+
+      if (eventPath === "/events/room/joined") {
+        // Room join event - log and acknowledge
+        log(`wecom webhook: room join event: ${JSON.stringify(body)}`);
+        sendJson(res, 200, { status: "received" });
+        return;
+      }
+
+      if (eventPath === "/events/chatroom/loaded") {
+        // Chatroom loaded event - log and acknowledge
+        log(`wecom webhook: chatroom loaded event: ${JSON.stringify(body)}`);
+        sendJson(res, 200, { status: "received" });
+        return;
+      }
+
+      if (eventPath === "/events/chatroom/joined") {
+        // Chatroom joined event - log and acknowledge
+        log(`wecom webhook: chatroom joined event: ${JSON.stringify(body)}`);
+        sendJson(res, 200, { status: "received" });
+        return;
+      }
+
+      // Unknown event path - still acknowledge
+      log(`wecom webhook: unknown event path: ${eventPath}`);
+      sendJson(res, 200, { status: "received" });
+    } catch (err) {
+      error(`wecom webhook: error processing request: ${String(err)}`);
+      sendJson(res, 500, { error: "Internal server error" });
+    }
+  });
+
+  // Handle abort signal
+  if (abortSignal) {
+    abortSignal.addEventListener("abort", () => {
+      log(`wecom webhook: abort signal received, closing server`);
+      server.close();
+    });
+  }
+
+  // Start listening
+  return new Promise((resolve, reject) => {
+    server.on("error", (err) => {
+      error(`wecom webhook: server error: ${String(err)}`);
+      reject(err);
+    });
+
+    server.listen(port, () => {
+      log(`wecom webhook: server listening on port ${port}`);
+      log(`wecom webhook: message endpoint: http://localhost:${port}${webhookPath}/events/message`);
+      resolve(server);
+    });
+  });
+}
+
+/**
+ * Stop the webhook server.
+ */
+export function stopWebhookServer(server: Server): Promise<void> {
+  return new Promise((resolve, reject) => {
+    server.close((err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}