libp2p-mesh 2026.5.13 → 2026.5.14

package/src/types.ts

@@ -1,3 +1,22 @@
+export interface InstanceIdentity {
+  /** Full InstanceID string, e.g. "alice-mac@AQIDBAUGBweI.7a3f9e2b" */
+  id: string;
+  /** Human-readable instance name */
+  name: string;
+  /** Base64url-encoded Ed25519 public key */
+  pubkey: string;
+  /** Hex SHA-256 binding hash of environment dimensions */
+  binding: string;
+  /** Components that contributed to the binding hash */
+  bindingComponents: {
+    username: string;
+    hostname: string;
+    platform: string;
+  };
+  /** Timestamp when the identity was created */
+  createdAt: number;
+}
+
 export interface P2PMessage {
   id: string;
   type: "direct" | "broadcast" | "agent-sync";
@@ -6,6 +25,12 @@ export interface P2PMessage {
   topic?: string;
   payload: string;
   timestamp: number;
+  /** Instance identity of the sender (for cross-instance authentication) */
+  instanceId?: string;
+  /** Base64url-encoded Ed25519 public key of the sender (allows direct verification without DHT lookup) */
+  pubkey?: string;
+  /** Ed25519 signature of the message payload, verifiable with instance pubkey */
+  signature?: string;
 }
 
 export interface MeshConfig {
@@ -16,6 +41,70 @@ export interface MeshConfig {
   enableAgentSync?: boolean;
   enableWebSocket?: boolean;
   peerIdPath?: string;
+  instanceName?: string;
+  /** Enable DHT for WAN peer discovery and pubkey registry (default: true when discovery=dht, false otherwise) */
+  enableDHT?: boolean;
+
+  // ---------------------------------------------------------------------
+  // NAT traversal (all opt-in, on by default; safe to leave at defaults
+  // when both peers already have a routable address)
+  // ---------------------------------------------------------------------
+
+  /**
+   * Master switch for the NAT traversal stack. When `false` none of the
+   * NAT-related services are wired in, restoring the pre-2026.5.16
+   * behaviour. Default `true`.
+   */
+  enableNATTraversal?: boolean;
+  /** Run the libp2p identify protocol (required by AutoNAT/DCUtR). Default `true` when NAT traversal is on. */
+  enableIdentify?: boolean;
+  /** AutoNAT detects whether we are reachable from the public internet. Default `true` when NAT traversal is on. */
+  enableAutoNAT?: boolean;
+  /** Attempt UPnP/PMP port mapping on the local gateway. Default `true` when NAT traversal is on. */
+  enableUPnP?: boolean;
+  /** Circuit Relay v2 transport — required to dial peers via a relay. Default `true` when NAT traversal is on. */
+  enableCircuitRelay?: boolean;
+  /**
+   * Act as a Circuit Relay v2 server for other peers. Default `false` —
+   * only enable on a node with a public, routable address (e.g. a cloud VM)
+   * because relayed traffic is forwarded through this process.
+   */
+  enableCircuitRelayServer?: boolean;
+  /** Direct Connection Upgrade through Relay (hole punching). Default `true` when NAT traversal is on. */
+  enableDCUtR?: boolean;
+  /**
+   * Explicit relay multiaddrs to reserve a slot on. Each entry should be a
+   * full multiaddr ending in `/p2p/<peer-id>`. The node will keep a
+   * reservation open with each one so other peers can dial us through them.
+   */
+  relayList?: string[];
+  /**
+   * Number of relays to auto-discover via content routing. Requires DHT.
+   * Default `0` (disabled). Set to e.g. `2` to look up public relays.
+   */
+  discoverRelays?: number;
+  /**
+   * Multiaddrs to announce to the network on top of the auto-detected
+   * listen/observed addresses. Useful when running behind a known port
+   * forward where AutoNAT cannot probe (e.g. behind a cloud LB).
+   */
+  announceAddrs?: string[];
+}
+
+export interface NATTraversalStatus {
+  /** Which NAT-traversal services were wired in at start() */
+  enabled: {
+    identify: boolean;
+    autoNAT: boolean;
+    upnp: boolean;
+    circuitRelay: boolean;
+    circuitRelayServer: boolean;
+    dcutr: boolean;
+  };
+  /** Relay multiaddrs we have an active reservation on */
+  reservedRelays: string[];
+  /** Whether at least one circuit-relay address has been advertised as a listen address */
+  hasRelayedListenAddr: boolean;
 }
 
 export interface MeshNetwork {
@@ -27,6 +116,12 @@ export interface MeshNetwork {
   subscribeToTopic(topic: string, handler: (msg: string) => void): Promise<void>;
   getLocalPeerId(): string;
   getConnectedPeers(): string[];
+  getMultiaddrs(): string[];
+  dial(multiaddr: string): Promise<void>;
+  /** Get the OpenClaw instance identity (lightweight BAID-inspired ID) */
+  getInstanceIdentity(): InstanceIdentity | undefined;
+  /** Inspect which NAT-traversal services are running and whether any relay reservations are active */
+  getNATStatus(): NATTraversalStatus;
 }
 
 export type MeshAccount = {

package/src/agent-tools-feishu.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { buildFeishuTools } from "./agent-tools.js";
-
-describe("buildFeishuTools", () => {
-  it("should return empty array when feishuClient is null", () => {
-    const tools = buildFeishuTools(null);
-    expect(tools).toEqual([]);
-  });
-
-  it("should return array with one tool when feishuClient is provided", () => {
-    const mockClient = {
-      sendMessage: vi.fn(),
-    } as any;
-    const tools = buildFeishuTools(mockClient);
-    expect(tools).toHaveLength(1);
-    expect(tools[0].name).toBe("feishu_send_message");
-  });
-
-  describe("feishu_send_message tool", () => {
-    let tools: ReturnType<typeof buildFeishuTools>;
-    let mockClient: any;
-
-    beforeEach(() => {
-      mockClient = {
-        sendMessage: vi.fn(),
-      };
-      tools = buildFeishuTools(mockClient);
-    });
-
-    it("should require openId and message parameters", () => {
-      const tool = tools[0];
-      expect(tool.parameters.required).toEqual(["openId", "message"]);
-    });
-
-    it("should return success result on successful send", async () => {
-      mockClient.sendMessage.mockResolvedValue({
-        success: true,
-        messageId: "msg-789",
-      });
-
-      const result = await tools[0].execute("call-1", {
-        openId: "ou-test",
-        message: "hello",
-      });
-
-      expect(result.isError).toBeUndefined();
-      expect(result.details.sent).toBe(true);
-      expect(result.details.openId).toBe("ou-test");
-      expect(mockClient.sendMessage).toHaveBeenCalledWith("ou-test", "hello");
-    });
-
-    it("should return error result on failed send", async () => {
-      mockClient.sendMessage.mockResolvedValue({
-        success: false,
-        error: "rate limited",
-      });
-
-      const result = await tools[0].execute("call-1", {
-        openId: "ou-test",
-        message: "hello",
-      });
-
-      expect(result.isError).toBe(true);
-      expect(result.details.sent).toBe(false);
-      expect(result.details.error).toBe("rate limited");
-    });
-  });
-});

package/src/config-schema.test.ts

@@ -1,63 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createLibp2pMeshConfigSchema } from "./index.js";
-
-describe("createLibp2pMeshConfigSchema - Feishu config", () => {
-  const schema = createLibp2pMeshConfigSchema()!;
-
-  it("should include feishu in jsonSchema properties", () => {
-    const props = (schema as any).jsonSchema.properties as Record<string, any>;
-    expect(props).toHaveProperty("feishu");
-  });
-
-  it("feishu should be an object type with correct properties", () => {
-    const props = (schema as any).jsonSchema.properties as Record<string, any>;
-    const feishu = props.feishu;
-    expect(feishu.type).toBe("object");
-    expect(feishu.properties).toHaveProperty("appId");
-    expect(feishu.properties).toHaveProperty("appSecret");
-    expect(feishu.properties).toHaveProperty("webhookPort");
-    expect(feishu.properties).toHaveProperty("webhookPath");
-  });
-
-  it("feishu.webhookPort should default to 9222", () => {
-    const props = (schema as any).jsonSchema.properties as Record<string, any>;
-    expect(props.feishu.properties.webhookPort.default).toBe(9222);
-  });
-
-  it("feishu.webhookPath should default to /webhook/feishu", () => {
-    const props = (schema as any).jsonSchema.properties as Record<string, any>;
-    expect(props.feishu.properties.webhookPath.default).toBe("/webhook/feishu");
-  });
-
-  it("feishu.appId and appSecret should be string type without default", () => {
-    const props = (schema as any).jsonSchema.properties as Record<string, any>;
-    expect(props.feishu.properties.appId.type).toBe("string");
-    expect(props.feishu.properties.appSecret.type).toBe("string");
-    expect(props.feishu.properties.appId.default).toBeUndefined();
-    expect(props.feishu.properties.appSecret.default).toBeUndefined();
-  });
-
-  it("should parse config with feishu fields", () => {
-    const result = (schema as any).safeParse({
-      listenAddrs: ["/ip4/0.0.0.0/tcp/0"],
-      feishu: {
-        appId: "cli-123",
-        appSecret: "secret-456",
-        webhookPort: 9999,
-        webhookPath: "/custom/path",
-      },
-    });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.feishu.appId).toBe("cli-123");
-      expect(result.data.feishu.webhookPort).toBe(9999);
-    }
-  });
-
-  it("should parse config without feishu (feishu is optional)", () => {
-    const result = (schema as any).safeParse({
-      listenAddrs: ["/ip4/0.0.0.0/tcp/0"],
-    });
-    expect(result.success).toBe(true);
-  });
-});

package/src/feishu-channel.test.ts

@@ -1,191 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { createFeishuChannel, handleFeishuWebhook } from "./feishu-channel.js";
-import type { FeishuChannelConfig } from "./feishu-types.js";
-import type { FeishuApiClient, SendResult } from "./feishu-client.js";
-
-const MOCK_CONFIG: FeishuChannelConfig = {
-  appId: "test-app-id",
-  appSecret: "test-app-secret",
-  webhookPort: 9222,
-  webhookPath: "/webhook/feishu",
-};
-
-const MOCK_CLIENT: FeishuApiClient = {
-  isConfigured: () => true,
-  getTenantAccessToken: vi.fn().mockResolvedValue("t-valid"),
-  sendMessage: vi.fn().mockResolvedValue({ success: true, messageId: "msg-123" }),
-} as unknown as FeishuApiClient;
-
-describe("createFeishuChannel", () => {
-  it("should return a ChannelPlugin with correct base properties", () => {
-    const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
-    expect(channel.base.id).toBe("feishu");
-    expect((channel.base.meta as Record<string, string>).label).toBe("Feishu");
-    expect((channel.base.capabilities as Record<string, unknown>).chatTypes).toEqual(["direct"]);
-  });
-
-  it("should set targetResolver hint to openId", () => {
-    const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
-    const messaging = channel.base.messaging as Record<string, unknown>;
-    const resolver = messaging.targetResolver as Record<string, unknown>;
-    expect(resolver.hint).toBe("openId");
-  });
-
-  it("should set deliveryMode to gateway", () => {
-    const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
-    const outbound = channel.base.outbound as Record<string, string> | undefined;
-    expect(outbound?.deliveryMode).toBe("gateway");
-  });
-
-  it("should delegate sendText to feishuClient", async () => {
-    const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
-    const outbound = channel.base.outbound as {
-      sendText: (params: { to: string; text: string }) => Promise<
-        { channel: string; messageId: string } |
-        { channel: string; messageId: string; meta: { error: string } }
-      >;
-    };
-    const result = await outbound.sendText({ to: "ou-user", text: "hello" });
-    expect(result.channel).toBe("feishu");
-    expect(result.messageId).toBe("msg-123");
-    expect(MOCK_CLIENT.sendMessage).toHaveBeenCalledWith("ou-user", "hello");
-  });
-
-  it("should return error meta when sendMessage fails", async () => {
-    const failClient = {
-      ...MOCK_CLIENT,
-      sendMessage: vi.fn().mockResolvedValue({ success: false, error: "API error" }),
-    } as unknown as FeishuApiClient;
-    const channel = createFeishuChannel(MOCK_CONFIG, {}, failClient);
-    const outbound = channel.base.outbound as {
-      sendText: (params: { to: string; text: string }) => Promise<
-        { channel: string; messageId: string } |
-        { channel: string; messageId: string; meta: { error: string } }
-      >;
-    };
-    const result = await outbound.sendText({ to: "ou-user", text: "hello" });
-    expect("meta" in result && result.meta?.error).toBe("API error");
-  });
-
-  it("should reflect configured status from feishuClient", () => {
-    const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
-    const config = channel.base.config as { isConfigured: () => boolean };
-    expect(config.isConfigured()).toBe(true);
-  });
-});
-
-describe("handleFeishuWebhook", () => {
-  it("should respond to challenge verification", async () => {
-    const { handler } = handleFeishuWebhook(MOCK_CONFIG, MOCK_CLIENT, {});
-    const req = new Request("http://localhost:9222/webhook/feishu?challenge=abc123");
-    const resp = await handler(req);
-    const body = (await resp.json()) as { challenge: string };
-    expect(body.challenge).toBe("abc123");
-  });
-
-  it("should reject request with invalid signature", async () => {
-    const { handler } = handleFeishuWebhook(MOCK_CONFIG, MOCK_CLIENT, {});
-    const req = new Request("http://localhost:9222/webhook/feishu", {
-      method: "POST",
-      headers: { "x-lark-signature": "invalid-sig" },
-      body: JSON.stringify({ type: "url_verification" }),
-    });
-    const resp = await handler(req);
-    expect(resp.status).toBe(400);
-  });
-
-  it("should extract openId and message from im.message.receive_v1 event", async () => {
-    const { handler } = handleFeishuWebhook(MOCK_CONFIG, MOCK_CLIENT, {});
-    const eventBody = {
-      schema: "2.0",
-      header: {
-        eventId: "evt-1",
-        eventType: "im.message.receive_v1",
-        createTime: "1234567890000",
-        token: "v-token",
-        appId: "app-123",
-        tenantKey: "tk-123",
-      },
-      event: {
-        sender: { senderId: { openId: "ou-sender-1" } },
-        message: {
-          messageId: "msg-1",
-          msgType: "text",
-          createTime: "1234567890000",
-          chatId: "chat-1",
-          chatType: "p2p",
-          content: '{"text":"hello from feishu"}',
-        },
-      },
-    };
-    const body = JSON.stringify(eventBody);
-    const sig = 'Tk4MriFS/RRZ9zfM0EHVMKk45vyHMPqTNwc6stjTOxo=';
-    const req = new Request("http://localhost:9222/webhook/feishu", {
-      method: "POST",
-      headers: { "content-type": "application/json", "x-lark-signature": sig },
-      body,
-    });
-    const resp = await handler(req);
-    expect(resp.status).toBe(200);
-  });
-
-  it("should ignore non-im.message.receive_v1 events", async () => {
-    const { handler } = handleFeishuWebhook(MOCK_CONFIG, MOCK_CLIENT, {});
-    const eventBody = {
-      schema: "2.0",
-      header: {
-        eventId: "evt-2",
-        eventType: "im.chat.member.bot.added_v1",
-        createTime: "1234567890000",
-        token: "v-token",
-        appId: "app-123",
-        tenantKey: "tk-123",
-      },
-      event: {},
-    };
-    const body = JSON.stringify(eventBody);
-    const sig = 'fS/7P4Dm1/UjN5vIolDq4Vgc8welngorAiRmo6tk4H8=';
-    const req = new Request("http://localhost:9222/webhook/feishu", {
-      method: "POST",
-      headers: { "content-type": "application/json", "x-lark-signature": sig },
-      body,
-    });
-    const resp = await handler(req);
-    expect(resp.status).toBe(200);
-  });
-
-  it("should extract plain text from JSON content field", async () => {
-    const { handler } = handleFeishuWebhook(MOCK_CONFIG, MOCK_CLIENT, {});
-    const eventBody = {
-      schema: "2.0",
-      header: {
-        eventId: "evt-3",
-        eventType: "im.message.receive_v1",
-        createTime: "1234567890000",
-        token: "v-token",
-        appId: "app-123",
-        tenantKey: "tk-123",
-      },
-      event: {
-        sender: { senderId: { openId: "ou-sender" } },
-        message: {
-          messageId: "msg-3",
-          msgType: "text",
-          createTime: "1234567890000",
-          chatId: "chat-1",
-          chatType: "p2p",
-          content: '{"text":"邀请用户B吃饭"}',
-        },
-      },
-    };
-    const body = JSON.stringify(eventBody);
-    const sig = 'cV4wR/Bd4TkU7oaZJis9LNpBTFWEjRRkGdpkNeljEi8=';
-    const req = new Request("http://localhost:9222/webhook/feishu", {
-      method: "POST",
-      headers: { "content-type": "application/json", "x-lark-signature": sig },
-      body,
-    });
-    const resp = await handler(req);
-    expect(resp.status).toBe(200);
-  });
-});

package/src/feishu-channel.ts

@@ -1,253 +0,0 @@
-import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
-import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
-import { createHmac } from "node:crypto";
-import { FeishuApiClient } from "./feishu-client.js";
-import type { FeishuChannelConfig } from "./feishu-types.js";
-
-export interface FeishuChannelDeps {
-  logger?: {
-    info?: (msg: string) => void;
-    warn?: (msg: string) => void;
-    error?: (msg: string) => void;
-  };
-}
-
-/** Plugin type with a base wrapper for test compatibility */
-export interface FeishuChannelPlugin extends ChannelPlugin {
-  base: Record<string, unknown>;
-}
-
-export function createFeishuChannel(
-  config: FeishuChannelConfig,
-  deps?: FeishuChannelDeps,
-  feishuClient?: FeishuApiClient,
-): FeishuChannelPlugin {
-  const client = feishuClient ?? new FeishuApiClient(config, deps);
-
-  const raw = createChatChannelPlugin<{ accountId?: string }>({
-    base: {
-      id: "feishu",
-      meta: {
-        id: "feishu",
-        label: "Feishu",
-        selectionLabel: "Feishu",
-        docsPath: "/channels/feishu",
-        docsLabel: "feishu",
-        blurb: "Feishu integration for user interaction.",
-        systemImage: "message" as string | undefined,
-      },
-      capabilities: {
-        chatTypes: ["direct"],
-        media: false,
-        blockStreaming: true,
-      },
-      configSchema: {
-        schema: {
-          type: "object",
-          additionalProperties: false,
-          properties: {
-            appId: { type: "string" },
-            appSecret: { type: "string" },
-            webhookPort: { type: "number" },
-            webhookPath: { type: "string" },
-          },
-        },
-      },
-      config: {
-        listAccountIds: () => ["default"],
-        resolveAccount: () => ({
-          accountId: "default",
-          configured: client.isConfigured(),
-          enabled: true,
-        }),
-        isConfigured: () => client.isConfigured(),
-        isEnabled: () => true,
-        describeAccount: () => ({
-          accountId: "default",
-          name: "default",
-          configured: client.isConfigured(),
-          enabled: true,
-        }),
-      },
-      messaging: {
-        normalizeTarget: (raw: string) => raw.trim(),
-        targetResolver: {
-          looksLikeId: () => true,
-          hint: "openId",
-        },
-      },
-    },
-    outbound: {
-      deliveryMode: "gateway",
-      sendText: async ({ to, text }) => {
-        try {
-          const result = await client.sendMessage(to, text);
-          if (result.success && result.messageId) {
-            return { channel: "feishu", messageId: result.messageId };
-          }
-          return {
-            channel: "feishu",
-            messageId: `feishu-${Date.now()}`,
-            meta: { error: result.error ?? "send failed" },
-          };
-        } catch (err) {
-          return {
-            channel: "feishu",
-            messageId: `feishu-${Date.now()}`,
-            meta: { error: String(err) },
-          };
-        }
-      },
-    },
-  });
-
-  // Attach base wrapper so tests can access channel.base.* (mirrors the nested input structure)
-  const plugin = raw as FeishuChannelPlugin;
-  plugin.base = {
-    id: plugin.id,
-    meta: {
-      ...plugin.meta,
-      systemImage: (plugin.meta as Record<string, unknown>).systemImage ?? "message",
-    },
-    capabilities: plugin.capabilities,
-    outbound: plugin.outbound,
-    config: plugin.config,
-    messaging: plugin.messaging,
-  };
-
-  return plugin;
-}
-
-export function handleFeishuWebhook(
-  config: FeishuChannelConfig,
-  feishuClient: FeishuApiClient,
-  deps: FeishuChannelDeps,
-): {
-  startServer: () => Promise<() => Promise<void>>;
-  handler: (req: Request) => Promise<Response>;
-} {
-  const { webhookPort, webhookPath, appSecret } = config;
-
-  function verifySignature(body: string, signature: string | null): boolean {
-    if (!signature) return false;
-    const expected = createHmac("sha256", appSecret)
-      .update(body)
-      .digest("base64");
-    return signature === expected;
-  }
-
-  async function handler(req: Request): Promise<Response> {
-    const url = new URL(req.url);
-
-    // Challenge verification (GET)
-    if (req.method === "GET") {
-      const challenge = url.searchParams.get("challenge");
-      if (challenge) {
-        return new Response(JSON.stringify({ challenge }), {
-          status: 200,
-          headers: { "content-type": "application/json" },
-        });
-      }
-      return new Response("Not Found", { status: 404 });
-    }
-
-    // Event handling (POST)
-    if (req.method === "POST") {
-      const body = await req.text();
-      const signature = req.headers.get("x-lark-signature");
-
-      if (!verifySignature(body, signature)) {
-        return new Response("Invalid signature", { status: 400 });
-      }
-
-      try {
-        const event = JSON.parse(body);
-
-        // Only process im.message.receive_v1 events
-        const eventType = event.header?.eventType;
-        if (eventType !== "im.message.receive_v1") {
-          return new Response(null, { status: 200 });
-        }
-
-        const message = event.event?.message;
-        const openId = event.event?.sender?.senderId?.openId;
-
-        if (message && openId && message.msgType === "text") {
-          try {
-            const content = JSON.parse(message.content) as { text?: string };
-            const text = content.text?.trim();
-            if (text) {
-              await feishuClient.sendMessage(openId, text);
-            }
-          } catch {
-            deps.logger?.warn?.(
-              `Failed to parse message content: ${message.content}`,
-            );
-          }
-        }
-
-        return new Response(null, { status: 200 });
-      } catch {
-        return new Response("Invalid JSON", { status: 400 });
-      }
-    }
-
-    return new Response("Method Not Allowed", { status: 405 });
-  }
-
-  async function startServer(): Promise<() => Promise<void>> {
-    const httpModule = await import("node:http");
-    const server = httpModule.createServer(
-      async (req, res) => {
-        try {
-          const host = req.headers.host ?? "localhost";
-          const reqUrl = req.url ?? "/";
-          const url = new URL(reqUrl, `http://${host}`);
-          // Convert Node.js IncomingMessage to a Web API-like Request for handler
-          const request = new Request(url.toString(), {
-            method: req.method,
-            headers: Object.fromEntries(
-              Object.entries(req.headers as Record<string, string>),
-            ),
-            body: req.method !== "GET" && req.method !== "HEAD"
-              ? await new Promise<string>((resolve) => {
-                  const chunks: Buffer[] = [];
-                  req.on("data", (chunk: Buffer) => chunks.push(chunk));
-                  req.on("end", () => resolve(Buffer.concat(chunks).toString()));
-                })
-              : undefined,
-          });
-
-          const response = await handler(request);
-          res.statusCode = response.status;
-          // Forward response headers to Node.js response
-          const headersObj = Object.fromEntries(
-            (response.headers as unknown as Iterable<[string, string]>),
-          ) as Record<string, string>;
-          for (const [key, value] of Object.entries(headersObj)) {
-            res.setHeader(key, value);
-          }
-          const responseBody = await response.text();
-          res.end(responseBody);
-        } catch (err) {
-          deps.logger?.error?.(`Webhook handler error: ${err}`);
-          res.statusCode = 500;
-          res.end("Internal Server Error");
-        }
-      },
-    );
-
-    await new Promise<void>((resolve) => {
-      server.listen(webhookPort, () => {
-        resolve();
-      });
-    });
-
-    return () =>
-      new Promise<void>((resolve) => {
-        server.close(() => resolve());
-      });
-  }
-
-  return { startServer, handler };
-}