@yanhaidao/wecom 2.4.120 → 2.5.110

package/src/monitor.active.test.ts

@@ -1,245 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { sendActiveMessage, handleWecomWebhookRequest, registerWecomWebhookTarget } from "./monitor.js";
-import * as cryptoHelpers from "./crypto.js";
-import * as runtime from "./runtime.js";
-import * as agentApi from "./transport/agent-api/core.js";
-import { IncomingMessage, ServerResponse } from "node:http";
-import { Socket } from "node:net";
-import * as crypto from "node:crypto";
-
-const { undiciFetch } = vi.hoisted(() => {
-    const undiciFetch = vi.fn();
-    return { undiciFetch };
-});
-
-vi.mock("undici", () => ({
-    fetch: undiciFetch,
-    ProxyAgent: class ProxyAgent { },
-}));
-
-vi.mock("./transport/agent-api/core.js", () => ({
-    sendText: vi.fn(),
-    sendMedia: vi.fn(),
-    uploadMedia: vi.fn(),
-}));
-
-// Helpers
-function createMockRequest(bodyObj: any): IncomingMessage {
-    const socket = new Socket();
-    const req = new IncomingMessage(socket);
-    req.method = "POST";
-    req.url = "/plugins/wecom/bot/default?timestamp=123&nonce=456&signature=789";
-    req.push(JSON.stringify(bodyObj));
-    req.push(null);
-    return req;
-}
-
-function createMockResponse(): ServerResponse {
-    const req = new IncomingMessage(new Socket());
-    const res = new ServerResponse(req);
-    res.end = vi.fn() as any;
-    res.setHeader = vi.fn();
-    (res as any).statusCode = 200;
-    return res;
-}
-
-describe("Monitor Active Features", () => {
-    let capturedDeliver: ((payload: { text: string }) => Promise<void>) | undefined;
-    let unregisterTarget: (() => void) | undefined;
-    let mockCore: any;
-    let msgSeq = 0;
-    let senderUserId = "";
-    let senderChatId = "";
-    // Valid 32-byte AES Key (Base64 encoded)
-    const validKey = "jWmYm7qr5nMoCAstdRmNjt3p7vsH8HkK+qiJqQ0aaaa=";
-
-    beforeEach(() => {
-        vi.useFakeTimers();
-        capturedDeliver = undefined;
-        vi.restoreAllMocks();
-        undiciFetch.mockClear();
-        msgSeq += 1;
-        senderUserId = `zhangsan-${msgSeq}`;
-        senderChatId = `wr123-${msgSeq}`;
-
-        // Spy on crypto.randomBytes (default export in monitor.ts usage)
-        vi.spyOn(crypto.default, "randomBytes").mockImplementation((size) => {
-            return Buffer.alloc(size, 0x11);
-        });
-
-        // Mock Crypto Helpers
-        // Wespy on verifyWecomSignature to always pass
-        vi.spyOn(cryptoHelpers, "verifyWecomSignature").mockReturnValue(true);
-
-        // We spy on decryptWecomEncrypted to return our mock plaintext
-        // Note: For this to work despite direct import in monitor.ts, we rely on Vitest's
-        // module mocking capabilities or the fact that * exports might be live bindings.
-        // If this fails, we will know.
-        vi.spyOn(cryptoHelpers, "decryptWecomEncrypted").mockImplementation((opts) => {
-            return JSON.stringify({
-                msgid: `test-msg-id-${msgSeq}`,
-                aibotid: "bot-1",
-                chattype: "group",
-                chatid: senderChatId,
-                from: { userid: senderUserId },
-                msgtype: "text",
-                text: { content: "hello" },
-                response_url: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test-key"
-            });
-        });
-
-        mockCore = {
-            channel: {
-                text: {
-                    resolveMarkdownTableMode: () => "off",
-                    convertMarkdownTables: (t: string) => t.replace(/\|/g, "-")
-                },
-                commands: {
-                    shouldComputeCommandAuthorized: () => false,
-                    resolveCommandAuthorizedFromAuthorizers: () => true,
-                },
-                pairing: {
-                    readAllowFromStore: async () => [],
-                },
-                reply: {
-                    finalizeInboundContext: (c: any) => c,
-                    resolveEnvelopeFormatOptions: () => ({}),
-                    formatAgentEnvelope: () => "",
-                    dispatchReplyWithBufferedBlockDispatcher: async (opts: any) => {
-                        capturedDeliver = opts.dispatcherOptions.deliver;
-                        return;
-                    }
-                },
-                routing: { resolveAgentRoute: () => ({ agentId: "1", sessionKey: "1", accountId: "default" }) },
-                session: {
-                    resolveStorePath: () => "",
-                    readSessionUpdatedAt: () => 0,
-                    recordInboundSession: vi.fn()
-                }
-            },
-            logging: { shouldLogVerbose: () => false }
-        };
-
-        vi.spyOn(runtime, "getWecomRuntime").mockReturnValue(mockCore);
-
-        unregisterTarget = registerWecomWebhookTarget({
-            account: { accountId: "default", configured: true, token: "T", encodingAESKey: validKey, receiveId: "R", config: {} as any },
-            config: {
-                channels: {
-                    wecom: {
-                        enabled: true,
-                        agent: {
-                            corpId: "corp",
-                            corpSecret: "secret",
-                            agentId: 1000002,
-                            token: "token",
-                            encodingAESKey: "aes",
-                        },
-                    },
-                },
-            } as any,
-            runtime: { log: () => { } },
-            core: mockCore,
-            path: "/plugins/wecom/bot/default"
-        });
-    });
-
-    afterEach(() => {
-        unregisterTarget?.();
-        unregisterTarget = undefined;
-        vi.useRealTimers();
-    });
-
-    it("should protect <think> tags from table conversion", async () => {
-        const req = createMockRequest({ encrypt: "mock-encrypt" });
-        const res = createMockResponse();
-        await handleWecomWebhookRequest(req, res);
-
-        // The WeCom monitor debounces inbound messages before starting the agent.
-        // `flushPending` triggers async agent start without awaiting it, so give the
-        // microtask queue a chance to run after the timer fires.
-        await vi.runOnlyPendingTimersAsync();
-        await Promise.resolve();
-        await Promise.resolve();
-
-        expect(capturedDeliver).toBeDefined();
-
-        const payload = { text: "Out | side\n<think>Inside | Think</think>" };
-        const convertSpy = vi.spyOn(mockCore.channel.text, "convertMarkdownTables");
-
-        await capturedDeliver!(payload);
-
-        const calledArg = convertSpy.mock.calls[0][0];
-        expect(calledArg).toContain("__THINK_PLACEHOLDER_0__");
-        expect(calledArg).not.toContain("<think>");
-    });
-
-    it("should store response_url and allow active message sending", async () => {
-        const req = createMockRequest({ encrypt: "mock-encrypt" });
-        const res = createMockResponse();
-
-        // We use a real key but mocked randomBytes.
-        // However, `handleWecomWebhookRequest` calls `buildEncryptedJsonReply` -> `encryptWecomPlaintext`.
-        // `encryptWecomPlaintext` uses the key. Since it's valid, it should work fine.
-        // We don't verify the OUTPUT of handleWecomWebhookRequest, just that it runs and sets up state.
-
-        await handleWecomWebhookRequest(req, res);
-
-        const streamId = Buffer.alloc(16, 0x11).toString("hex");
-
-        undiciFetch.mockResolvedValue(new Response("ok", { status: 200 }));
-        await sendActiveMessage(streamId, "Active Hello");
-
-        expect(undiciFetch).toHaveBeenCalled();
-        const [url, init] = undiciFetch.mock.calls.at(-1)! as [string, RequestInit];
-        expect(url).toBe("https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test-key");
-        expect(init).toEqual(
-            expect.objectContaining({
-                method: "POST",
-                body: JSON.stringify({ msgtype: "text", text: { content: "Active Hello" } }),
-            }),
-        );
-        const headers = new Headers(init.headers);
-        expect(headers.get("content-type")).toBe("application/json");
-    });
-
-    it("should fallback non-image media to agent DM (and push a Chinese prompt)", async () => {
-        const { uploadMedia, sendMedia } = agentApi as any;
-        uploadMedia.mockResolvedValue("media-id-1");
-        sendMedia.mockResolvedValue(undefined);
-
-        const req = createMockRequest({ encrypt: "mock-encrypt" });
-        const res = createMockResponse();
-        await handleWecomWebhookRequest(req, res);
-
-        await vi.advanceTimersByTimeAsync(600);
-        await Promise.resolve();
-        await Promise.resolve();
-
-        expect(capturedDeliver).toBeDefined();
-
-        // Create a local PDF to force non-image content-type inference.
-        const fs = await import("node:fs/promises");
-        const os = await import("node:os");
-        const path = await import("node:path");
-        const tmp = path.join(os.tmpdir(), `wecom-test-${Date.now()}.pdf`);
-        await fs.writeFile(tmp, Buffer.from("pdf"));
-
-        undiciFetch.mockResolvedValue(new Response("ok", { status: 200 }));
-
-        await capturedDeliver!({ text: "here", mediaUrls: [tmp] } as any);
-
-        expect(uploadMedia).toHaveBeenCalled();
-        expect(sendMedia).toHaveBeenCalledWith(
-            expect.objectContaining({
-                toUser: senderUserId,
-                mediaType: "file",
-            }),
-        );
-        // Ensure we attempted to push a prompt to response_url (uses undici fetch).
-        expect(undiciFetch).toHaveBeenCalled();
-    });
-
-    // 注：本机路径（/Users/...、/tmp/...、/root/...、/home/...）短路发图逻辑属于运行态特性，
-    // 单测在 fake timers + module singleton 状态下容易引入脆弱性；这里优先覆盖更关键的兜底链路与去重逻辑。
-});

package/src/monitor.inbound-filter.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { shouldProcessBotInboundMessage } from "./monitor.js";
-
-describe("shouldProcessBotInboundMessage", () => {
-  it("skips payloads without sender id", () => {
-    const result = shouldProcessBotInboundMessage({
-      msgtype: "text",
-      from: {},
-      text: { content: "hello" },
-    });
-    expect(result.shouldProcess).toBe(false);
-    expect(result.reason).toBe("missing_sender");
-  });
-
-  it("skips system sender payloads", () => {
-    const result = shouldProcessBotInboundMessage({
-      msgtype: "text",
-      from: { userid: "sys" },
-      text: { content: "hello" },
-    });
-    expect(result.shouldProcess).toBe(false);
-    expect(result.reason).toBe("system_sender");
-  });
-
-  it("skips group payloads without chatid", () => {
-    const result = shouldProcessBotInboundMessage({
-      msgtype: "text",
-      chattype: "group",
-      from: { userid: "zhangsan" },
-      text: { content: "hello" },
-    });
-    expect(result.shouldProcess).toBe(false);
-    expect(result.reason).toBe("missing_chatid");
-  });
-
-  it("accepts normal direct-user messages", () => {
-    const result = shouldProcessBotInboundMessage({
-      msgtype: "text",
-      chattype: "single",
-      from: { userid: "zhangsan" },
-      text: { content: "hello" },
-    });
-    expect(result.shouldProcess).toBe(true);
-    expect(result.reason).toBe("user_message");
-    expect(result.senderUserId).toBe("zhangsan");
-    expect(result.chatId).toBe("zhangsan");
-  });
-
-  it("accepts normal group messages with chatid", () => {
-    const result = shouldProcessBotInboundMessage({
-      msgtype: "text",
-      chattype: "group",
-      chatid: "wr123",
-      from: { userid: "zhangsan" },
-      text: { content: "hello" },
-    });
-    expect(result.shouldProcess).toBe(true);
-    expect(result.reason).toBe("user_message");
-    expect(result.senderUserId).toBe("zhangsan");
-    expect(result.chatId).toBe("wr123");
-  });
-});

package/src/monitor.integration.test.ts

@@ -1,208 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { handleWecomWebhookRequest, registerWecomWebhookTarget } from "./monitor.js";
-import { encryptWecomPlaintext, computeWecomMsgSignature, WECOM_PKCS7_BLOCK_SIZE } from "./crypto.js";
-import * as runtime from "./runtime.js";
-import crypto from "node:crypto";
-import { IncomingMessage, ServerResponse } from "node:http";
-import { Socket } from "node:net";
-
-const { undiciFetch } = vi.hoisted(() => {
-    const undiciFetch = vi.fn();
-    return { undiciFetch };
-});
-
-vi.mock("undici", () => ({
-    fetch: undiciFetch,
-    ProxyAgent: class ProxyAgent { },
-}));
-
-// Helpers to simulate HTTP request
-function createMockRequest(bodyObj: any, query: URLSearchParams): IncomingMessage {
-    const socket = new Socket();
-    const req = new IncomingMessage(socket);
-    req.method = "POST";
-    req.url = `/plugins/wecom/bot/default?${query.toString()}`;
-    req.push(JSON.stringify(bodyObj));
-    req.push(null);
-    return req;
-}
-
-function createMockResponse(): ServerResponse & { _getData: () => string, _getStatusCode: () => number } {
-    const req = new IncomingMessage(new Socket());
-    const res = new ServerResponse(req);
-    let data = "";
-    res.write = (chunk: any) => { data += chunk; return true; };
-    res.end = (chunk: any) => { if (chunk) data += chunk; return res; };
-    (res as any)._getData = () => data;
-    (res as any)._getStatusCode = () => res.statusCode;
-    return res as any;
-}
-
-// PKCS7 Pad Helper for manual encryption
-function pkcs7Pad(buf: Buffer, blockSize: number): Buffer {
-    const mod = buf.length % blockSize;
-    const pad = mod === 0 ? blockSize : blockSize - mod;
-    const padByte = Buffer.from([pad]);
-    return Buffer.concat([buf, Buffer.alloc(pad, padByte[0]!)]);
-}
-
-describe("Monitor Integration: Inbound Image", () => {
-    const token = "MY_TOKEN";
-    const encodingAESKey = "jWmYm7qr5nMoCAstdRmNjt3p7vsH8HkK+qiJqQ0aaaa="; // 32 bytes key
-    const receiveId = "MY_CORPID";
-    let unregisterTarget: (() => void) | null = null;
-
-    // Mock Core Runtime
-    const mockDeliver = vi.fn();
-    const mockCore = {
-        channel: {
-            routing: { resolveAgentRoute: () => ({ agentId: "agent-1", sessionKey: "sess-1", accountId: "acc-1" }) },
-            commands: {
-                shouldComputeCommandAuthorized: () => false,
-                resolveCommandAuthorizedFromAuthorizers: () => true,
-            },
-            pairing: {
-                readAllowFromStore: async () => [],
-            },
-            session: {
-                resolveStorePath: () => "store/path",
-                readSessionUpdatedAt: () => 0,
-                recordInboundSession: vi.fn(),
-            },
-            reply: {
-                formatAgentEnvelope: () => "formatted-body",
-                finalizeInboundContext: (ctx: any) => ctx,
-                resolveEnvelopeFormatOptions: () => ({}),
-                dispatchReplyWithBufferedBlockDispatcher: async (opts: any) => {
-                    // Simulate Agent processing by calling deliver immediately or later
-                    // For this test, verifying the Inbound Body is enough.
-                    // The delivery payload is what the AGENT sees.
-                    // But wait, dispatchReply... is for OUTBOUND streaming replies.
-                    // startAgentForStream calls it. 
-                    // We really want to spy on what `rawBody` was passed to startAgentForStream context.
-
-                    // Actually `recordInboundSession` receives `ctx` which contains `RawBody`.
-                    return;
-                },
-            },
-            text: { resolveMarkdownTableMode: () => "off", convertMarkdownTables: (t: string) => t },
-        },
-        logging: { shouldLogVerbose: () => true },
-    };
-
-    beforeEach(() => {
-        vi.spyOn(runtime, "getWecomRuntime").mockReturnValue(mockCore as any);
-
-        unregisterTarget?.();
-        unregisterTarget = registerWecomWebhookTarget({
-            account: {
-                accountId: "test-acc",
-                name: "Test",
-                configured: true,
-                token,
-                encodingAESKey,
-                receiveId,
-                config: {} as any
-            },
-            config: {} as any,
-            runtime: { log: console.log, error: console.error },
-            core: mockCore as any,
-            path: "/plugins/wecom/bot/default"
-        });
-    });
-
-    afterEach(() => {
-        unregisterTarget?.();
-        unregisterTarget = null;
-        vi.restoreAllMocks();
-    });
-
-    // Mock media saving
-    const mockSaveMediaBuffer = vi.fn().mockResolvedValue({ path: "/tmp/saved-image.jpg", contentType: "image/jpeg" });
-    (mockCore.channel as any).media = { saveMediaBuffer: mockSaveMediaBuffer };
-
-    it("should decrypt inbound image, save it, and inject into context", async () => {
-        // 1. Prepare Encrypted Media (The "File" on WeCom Server)
-        const fileContent = Buffer.from("fake-image-data");
-        const aesKey = Buffer.from(encodingAESKey + "=", "base64");
-        const iv = aesKey.subarray(0, 16);
-
-        // Encrypt content (WeCom does this)
-        const cipher = crypto.createCipheriv("aes-256-cbc", aesKey, iv);
-        cipher.setAutoPadding(false);
-        const encryptedMedia = Buffer.concat([cipher.update(pkcs7Pad(fileContent, WECOM_PKCS7_BLOCK_SIZE)), cipher.final()]);
-
-        // Mock HTTP fetch to return this encrypted media
-        undiciFetch.mockResolvedValue(new Response(encryptedMedia));
-
-        // 2. Prepare Inbound Message (The Webhook JSON)
-        const imageUrl = "http://wecom.server/media/123";
-        const inboundMsg = {
-            msgtype: "image",
-            image: { url: imageUrl },
-            from: { userid: "yanhaidao" }
-        };
-
-        // 3. Encrypt the *Inbound Message* Payload (The Envelope)
-        const timestamp = String(Math.floor(Date.now() / 1000));
-        const nonce = "123456";
-        const encrypt = encryptWecomPlaintext({
-            encodingAESKey,
-            receiveId,
-            plaintext: JSON.stringify(inboundMsg)
-        });
-        const msgSignature = computeWecomMsgSignature({ token, timestamp, nonce, encrypt });
-
-        const query = new URLSearchParams({
-            msg_signature: msgSignature,
-            timestamp,
-            nonce
-        });
-
-        const bodyObj = {
-            touser: receiveId,
-            agentid: "10001",
-            encrypt, // Standard WeCom POST body structure
-        };
-
-        // 4. Send Request
-        const req = createMockRequest(bodyObj, query);
-        const res = createMockResponse();
-
-        await handleWecomWebhookRequest(req, res);
-
-        // Wait for debounce timer to trigger agent (DEFAULT_DEBOUNCE_MS = 500ms)
-        await new Promise(resolve => setTimeout(resolve, 600));
-
-        // 5. Verify
-        // Check recordInboundSession was called with correct RawBody and Media Context
-        expect(mockCore.channel.session.recordInboundSession).toHaveBeenCalled();
-        const recordCall = (mockCore.channel.session.recordInboundSession as any).mock.calls[0][0];
-        const ctx = recordCall.ctx;
-
-        // Expect: [image]
-        expect(ctx.RawBody).toBe("[image]");
-
-        // Expect media to be saved
-        expect(mockSaveMediaBuffer).toHaveBeenCalledWith(
-            expect.any(Buffer), // The decrypted buffer
-            "image/jpeg",
-            "inbound",
-            expect.any(Number), // maxBytes
-            "image.jpg"
-        );
-        const savedBuffer = mockSaveMediaBuffer.mock.calls[0][0];
-        expect(savedBuffer.toString()).toBe("fake-image-data");
-
-        // Expect Context Injection
-        expect(ctx.MediaPath).toBe("/tmp/saved-image.jpg");
-        expect(ctx.MediaType).toBe("image/jpeg");
-        expect(ctx.Surface).toBe("wecom");
-        expect(ctx.OriginatingChannel).toBe("wecom");
-
-        expect(undiciFetch).toHaveBeenCalledWith(
-            imageUrl,
-            expect.objectContaining({ signal: expect.anything() }),
-        );
-    });
-});

package/src/monitor.ts

@@ -1,121 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-import { getWecomRuntime } from "./runtime.js";
-import { handleWecomHttpRequest } from "./transport/http/request-handler.js";
-import { registerAgentWebhookTarget, registerWecomWebhookTarget } from "./transport/http/registry.js";
-import { sendActiveMessage } from "./transport/bot-webhook/active-reply.js";
-import { createBotWebhookRequestHandler } from "./transport/bot-webhook/request-handler.js";
-import {
-  shouldProcessBotInboundMessage,
-  type BotInboundProcessDecision,
-} from "./transport/bot-webhook/message-shape.js";
-
-/**
- * Legacy compatibility bridge for the old monitor entrypoints.
- *
- * Bot webhook parsing and stream orchestration now live in
- * `transport/bot-webhook/*` and `capability/bot/*`.
- */
-
-import type {
-  WecomRuntimeAuditEvent,
-  WecomWebhookTarget,
-} from "./types/runtime-context.js";
-import { monitorState } from "./monitor/state.js";
-import { createBotStreamOrchestrator } from "./capability/bot/stream-orchestrator.js";
-
-const streamStore = monitorState.streamStore;
-
-function recordWebhookOperationalEvent(
-  target:
-    | Pick<WecomWebhookTarget, "account" | "auditSink">
-    | { agent: { accountId: string }; auditSink?: (event: WecomRuntimeAuditEvent) => void },
-  event: WecomRuntimeAuditEvent,
-): void {
-  const accountId = "account" in target ? target.account.accountId : target.agent.accountId;
-  monitorState.operationalEvents.append({
-    accountId,
-    transport: event.transport,
-    category: event.category,
-    summary: event.summary,
-    messageId: event.messageId,
-  });
-  target.auditSink?.(event);
-}
-
-function recordBotOperationalEvent(
-  target: Pick<WecomWebhookTarget, "account" | "auditSink">,
-  event: Omit<WecomRuntimeAuditEvent, "transport">,
-): void {
-  recordWebhookOperationalEvent(target, {
-    transport: "bot-webhook",
-    ...event,
-  });
-}
-
-function logVerbose(target: WecomWebhookTarget, message: string): void {
-  const should =
-    target.core.logging?.shouldLogVerbose?.() ??
-    (() => {
-      try {
-        return getWecomRuntime().logging.shouldLogVerbose();
-      } catch {
-        return false;
-      }
-    })();
-  if (!should) return;
-  target.runtime.log?.(`[wecom] ${message}`);
-}
-
-function logInfo(target: WecomWebhookTarget, message: string): void {
-  target.runtime.log?.(`[wecom] ${message}`);
-}
-
-const botStreamOrchestrator = createBotStreamOrchestrator({
-  streamStore,
-  recordBotOperationalEvent,
-});
-
-const { flushPending, startAgentForStream } = botStreamOrchestrator;
-
-monitorState.streamStore.setFlushHandler((pending) => void flushPending(pending));
-
-const handleBotWebhookRequest = createBotWebhookRequestHandler({
-  streamStore,
-  logInfo,
-  logVerbose,
-  recordBotOperationalEvent,
-  startAgentForStream,
-});
-
-export { registerAgentWebhookTarget, registerWecomWebhookTarget };
-export { sendActiveMessage, shouldProcessBotInboundMessage };
-export type { BotInboundProcessDecision };
-
-/**
- * **handleWecomWebhookRequest (HTTP 请求入口)**
- * 
- * 处理来自企业微信的所有 Webhook 请求。
- * 职责：
- * 1. 路由分发：优先按 `/plugins/wecom/{bot|agent}/{accountId}` 分流，并兼容历史 `/wecom/*` 路径。
- * 2. 安全校验：验证企业微信签名 (Signature)。
- * 3. 消息解密：处理企业微信的加密包。
- * 4. 响应处理：
- *    - GET 请求：处理 EchoStr 验证。
- *    - POST 请求：接收消息，放入 StreamStore，返回流式 First Chunk。
- */
-export async function handleWecomWebhookRequest(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
-  return handleWecomHttpRequest({
-    req,
-    res,
-    handleBotWebhookRequest,
-  });
-}
-
-export async function handleLegacyWecomWebhookRequest(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
-  return handleWecomHttpRequest({
-    req,
-    res,
-    handleBotWebhookRequest,
-  });
-}