@yanhaidao/wecom 2.4.120 → 2.5.110

package/src/capability/bot/local-path-delivery.ts

@@ -1,215 +0,0 @@
-import crypto from "node:crypto";
-
-import { wecomFetch } from "../../http.js";
-import { LIMITS, type StreamStore } from "../../monitor/state.js";
-import { getActiveReplyUrl, useActiveReplyOnce } from "../../transport/bot-webhook/active-reply.js";
-import type { WecomWebhookTarget } from "../../types/runtime-context.js";
-import { buildStreamReplyFromState } from "../../transport/bot-webhook/protocol.js";
-import {
-  buildFallbackPrompt,
-  extractLocalFilePathsFromText,
-  guessLocalPathContentType,
-  resolveAgentAccountOrUndefined,
-  sendAgentDmMedia,
-  sendBotFallbackPromptNow,
-} from "./fallback-delivery.js";
-import type { BotRuntimeLogger } from "./types.js";
-
-export async function handleDirectLocalPathIntent(params: {
-  streamStore: StreamStore;
-  target: WecomWebhookTarget;
-  streamId: string;
-  rawBody: string;
-  userId: string;
-  chatType: "group" | "direct";
-  logVerbose: BotRuntimeLogger;
-  looksLikeSendLocalFileIntent: (rawBody: string) => boolean;
-}): Promise<boolean> {
-  const { streamStore, target, streamId, rawBody, userId, chatType, logVerbose, looksLikeSendLocalFileIntent } = params;
-  const directLocalPaths = extractLocalFilePathsFromText(rawBody);
-  if (directLocalPaths.length) {
-    logVerbose(
-      target,
-      `local-path: 检测到用户消息包含本机路径 count=${directLocalPaths.length} intent=${looksLikeSendLocalFileIntent(rawBody)}`,
-    );
-  }
-  if (!directLocalPaths.length || !looksLikeSendLocalFileIntent(rawBody)) {
-    return false;
-  }
-
-  const fs = await import("node:fs/promises");
-  const pathModule = await import("node:path");
-  const imageExts = new Set(["png", "jpg", "jpeg", "gif", "webp", "bmp"]);
-
-  const imagePaths: string[] = [];
-  const otherPaths: string[] = [];
-  for (const p of directLocalPaths) {
-    const ext = pathModule.extname(p).slice(1).toLowerCase();
-    if (imageExts.has(ext)) imagePaths.push(p);
-    else otherPaths.push(p);
-  }
-
-  if (imagePaths.length > 0 && otherPaths.length === 0) {
-    const loaded: Array<{ base64: string; md5: string; path: string }> = [];
-    for (const p of imagePaths) {
-      try {
-        const buf = await fs.readFile(p);
-        const base64 = buf.toString("base64");
-        const md5 = crypto.createHash("md5").update(buf).digest("hex");
-        loaded.push({ base64, md5, path: p });
-      } catch (err) {
-        target.runtime.error?.(`local-path: 读取图片失败 path=${p}: ${String(err)}`);
-      }
-    }
-
-    if (loaded.length > 0) {
-      streamStore.updateStream(streamId, (s) => {
-        s.images = loaded.map(({ base64, md5 }) => ({ base64, md5 }));
-        s.content = loaded.length === 1 ? `已发送图片（${pathModule.basename(loaded[0]!.path)}）` : `已发送 ${loaded.length} 张图片`;
-        s.finished = true;
-      });
-
-      const responseUrl = getActiveReplyUrl(streamId);
-      if (responseUrl) {
-        try {
-          const finalReply = buildStreamReplyFromState(streamStore.getStream(streamId)!) as unknown as Record<string, unknown>;
-          await useActiveReplyOnce(streamId, async ({ responseUrl, proxyUrl }) => {
-            const res = await wecomFetch(
-              responseUrl,
-              {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(finalReply),
-              },
-              { proxyUrl, timeoutMs: LIMITS.REQUEST_TIMEOUT_MS },
-            );
-            if (!res.ok) throw new Error(`local-path image push failed: ${res.status}`);
-          });
-          logVerbose(target, `local-path: 已通过 Bot response_url 推送图片 frames=final images=${loaded.length}`);
-        } catch (err) {
-          target.runtime.error?.(`local-path: Bot 主动推送图片失败（将依赖 stream_refresh 拉取）: ${String(err)}`);
-        }
-      } else {
-        logVerbose(target, "local-path: 无 response_url，等待 stream_refresh 拉取最终图片");
-      }
-      streamStore.onStreamFinished(streamId);
-      return true;
-    }
-
-    const agentCfg = resolveAgentAccountOrUndefined(target.config, target.account.accountId);
-    const agentOk = Boolean(agentCfg);
-    const fallbackName = imagePaths.length === 1 ? (imagePaths[0]!.split("/").pop() || "image") : `${imagePaths.length} 张图片`;
-    const prompt = buildFallbackPrompt({
-      kind: "media",
-      agentConfigured: agentOk,
-      userId,
-      filename: fallbackName,
-      chatType,
-    });
-
-    streamStore.updateStream(streamId, (s) => {
-      s.fallbackMode = "error";
-      s.finished = true;
-      s.content = prompt;
-      s.fallbackPromptSentAt = s.fallbackPromptSentAt ?? Date.now();
-    });
-
-    try {
-      await sendBotFallbackPromptNow({ streamId, text: prompt });
-      logVerbose(target, "local-path: 图片读取失败后已推送兜底提示");
-    } catch (err) {
-      target.runtime.error?.(`local-path: 图片读取失败后的兜底提示推送失败: ${String(err)}`);
-    }
-
-    if (agentCfg && userId && userId !== "unknown") {
-      for (const p of imagePaths) {
-        const guessedType = guessLocalPathContentType(p);
-        try {
-          await sendAgentDmMedia({
-            agent: agentCfg,
-            userId,
-            mediaUrlOrPath: p,
-            contentType: guessedType,
-            filename: p.split("/").pop() || "image",
-          });
-          streamStore.updateStream(streamId, (s) => {
-            s.agentMediaKeys = Array.from(new Set([...(s.agentMediaKeys ?? []), p]));
-          });
-          logVerbose(
-            target,
-            `local-path: 图片已通过 Agent 私信发送 user=${userId} path=${p} contentType=${guessedType ?? "unknown"}`,
-          );
-        } catch (err) {
-          target.runtime.error?.(`local-path: 图片 Agent 私信兜底失败 path=${p}: ${String(err)}`);
-        }
-      }
-    }
-    streamStore.onStreamFinished(streamId);
-    return true;
-  }
-
-  if (otherPaths.length > 0) {
-    const agentCfg = resolveAgentAccountOrUndefined(target.config, target.account.accountId);
-    const agentOk = Boolean(agentCfg);
-    const filename = otherPaths.length === 1 ? otherPaths[0]!.split("/").pop()! : `${otherPaths.length} 个文件`;
-    const prompt = buildFallbackPrompt({
-      kind: "media",
-      agentConfigured: agentOk,
-      userId,
-      filename,
-      chatType,
-    });
-
-    streamStore.updateStream(streamId, (s) => {
-      s.fallbackMode = "media";
-      s.finished = true;
-      s.content = prompt;
-      s.fallbackPromptSentAt = s.fallbackPromptSentAt ?? Date.now();
-    });
-
-    try {
-      await sendBotFallbackPromptNow({ streamId, text: prompt });
-      logVerbose(target, "local-path: 文件兜底提示已推送");
-    } catch (err) {
-      target.runtime.error?.(`local-path: 文件兜底提示推送失败: ${String(err)}`);
-    }
-
-    if (!agentCfg) {
-      streamStore.onStreamFinished(streamId);
-      return true;
-    }
-    if (!userId || userId === "unknown") {
-      target.runtime.error?.("local-path: 无法识别触发者 userId，无法 Agent 私信发送文件");
-      streamStore.onStreamFinished(streamId);
-      return true;
-    }
-
-    for (const p of otherPaths) {
-      const alreadySent = streamStore.getStream(streamId)?.agentMediaKeys?.includes(p);
-      if (alreadySent) continue;
-      const guessedType = guessLocalPathContentType(p);
-      try {
-        await sendAgentDmMedia({
-          agent: agentCfg,
-          userId,
-          mediaUrlOrPath: p,
-          contentType: guessedType,
-          filename: p.split("/").pop() || "file",
-        });
-        streamStore.updateStream(streamId, (s) => {
-          s.agentMediaKeys = Array.from(new Set([...(s.agentMediaKeys ?? []), p]));
-        });
-        logVerbose(
-          target,
-          `local-path: 文件已通过 Agent 私信发送 user=${userId} path=${p} contentType=${guessedType ?? "unknown"}`,
-        );
-      } catch (err) {
-        target.runtime.error?.(`local-path: Agent 私信发送文件失败 path=${p}: ${String(err)}`);
-      }
-    }
-    streamStore.onStreamFinished(streamId);
-    return true;
-  }
-
-  return false;
-}

package/src/capability/bot/sandbox-media.test.ts

@@ -1,221 +0,0 @@
-import path from "node:path";
-import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { stageWecomInboundMediaForSession } from "./sandbox-media.js";
-
-describe("stageWecomInboundMediaForSession", () => {
-  const root = path.join("/tmp", `wecom-sandbox-stage-${process.pid}`);
-
-  beforeEach(async () => {
-    await mkdir(root, { recursive: true });
-  });
-
-  afterEach(async () => {
-    vi.unstubAllEnvs();
-    await rm(root, { recursive: true, force: true });
-  });
-
-  it("stages inbound media into the session sandbox workspace using channels.wecom.mediaMaxMb", async () => {
-    const mediaPath = path.join(root, "openclaw-media", "inbound", "big.bin");
-    const agentWorkspace = path.join(root, "agent-workspace");
-    const sandboxRoot = path.join(root, "sandboxes");
-
-    await mkdir(path.dirname(mediaPath), { recursive: true });
-    await mkdir(agentWorkspace, { recursive: true });
-    await writeFile(mediaPath, Buffer.alloc(6 * 1024 * 1024, 7));
-
-    const staged = await stageWecomInboundMediaForSession({
-      cfg: {
-        channels: {
-          wecom: {
-            mediaMaxMb: 8,
-          },
-        },
-        agents: {
-          list: [
-            {
-              id: "ops",
-              workspace: agentWorkspace,
-              sandbox: {
-                mode: "non-main",
-                scope: "session",
-                workspaceRoot: sandboxRoot,
-                workspaceAccess: "ro",
-                docker: {
-                  workdir: "/workspace",
-                },
-              },
-            },
-          ],
-        },
-      } as any,
-      accountId: "default",
-      agentId: "ops",
-      sessionKey: "agent:ops:wecom:default:dm:zhangsan",
-      mediaPath,
-      filename: "big.bin",
-    });
-
-    expect(staged).toMatch(/^media\/inbound\/big\.bin$/);
-    const sandboxEntries = await readdir(sandboxRoot);
-    const stagedBuffer = await readFile(
-      path.join(sandboxRoot, sandboxEntries[0]!, "media", "inbound", "big.bin"),
-    );
-    expect(stagedBuffer.byteLength).toBe(6 * 1024 * 1024);
-  });
-
-  it("uses the default sandbox workspace root when workspaceRoot is omitted", async () => {
-    vi.stubEnv("OPENCLAW_STATE_DIR", root);
-    const mediaPath = path.join(root, "openclaw-media", "inbound", "default-root.bin");
-    const agentWorkspace = path.join(root, "agent-workspace");
-
-    await mkdir(path.dirname(mediaPath), { recursive: true });
-    await mkdir(agentWorkspace, { recursive: true });
-    await writeFile(mediaPath, Buffer.alloc(2 * 1024 * 1024, 5));
-
-    const staged = await stageWecomInboundMediaForSession({
-      cfg: {
-        channels: {
-          wecom: {
-            mediaMaxMb: 8,
-          },
-        },
-        agents: {
-          list: [
-            {
-              id: "ops",
-              workspace: agentWorkspace,
-              sandbox: {
-                mode: "non-main",
-                scope: "session",
-                workspaceAccess: "ro",
-                docker: {
-                  workdir: "/workspace",
-                },
-              },
-            },
-          ],
-        },
-      } as any,
-      accountId: "default",
-      agentId: "ops",
-      sessionKey: "agent:ops:wecom:default:dm:lisi",
-      mediaPath,
-      filename: "default-root.bin",
-    });
-
-    expect(staged).toMatch(/^media\/inbound\/default-root\.bin$/);
-    const sandboxEntries = await readdir(path.join(root, "sandboxes"));
-    const stagedBuffer = await readFile(
-      path.join(root, "sandboxes", sandboxEntries[0]!, "media", "inbound", "default-root.bin"),
-    );
-    expect(stagedBuffer.byteLength).toBe(2 * 1024 * 1024);
-  });
-
-  it("stages inbound media into the agent workspace for non-sandbox sessions", async () => {
-    const mediaPath = path.join(root, "openclaw-media", "inbound", "small.bin");
-    const agentWorkspace = path.join(root, "agent-workspace");
-
-    await mkdir(path.dirname(mediaPath), { recursive: true });
-    await mkdir(agentWorkspace, { recursive: true });
-    await writeFile(mediaPath, Buffer.alloc(1024, 1));
-
-    const staged = await stageWecomInboundMediaForSession({
-      cfg: {
-        channels: {
-          wecom: {
-            mediaMaxMb: 8,
-          },
-        },
-        agents: {
-          list: [
-            {
-              id: "ops",
-              workspace: agentWorkspace,
-              sandbox: {
-                mode: "off",
-                scope: "session",
-                workspaceRoot: path.join(root, "sandboxes"),
-                workspaceAccess: "ro",
-                docker: {
-                  workdir: "/workspace",
-                },
-              },
-            },
-          ],
-        },
-      } as any,
-      accountId: "default",
-      agentId: "ops",
-      sessionKey: "agent:ops:wecom:default:dm:zhangsan",
-      mediaPath,
-      filename: "small.bin",
-    });
-
-    expect(staged).toBe(path.join(agentWorkspace, "media", "inbound", "small.bin"));
-    const stagedBuffer = await readFile(staged);
-    expect(stagedBuffer.byteLength).toBe(1024);
-  });
-
-  it("allocates distinct staged filenames for concurrent same-name uploads", async () => {
-    const mediaPathA = path.join(root, "openclaw-media", "inbound", "dup-a.bin");
-    const mediaPathB = path.join(root, "openclaw-media", "inbound", "dup-b.bin");
-    const agentWorkspace = path.join(root, "agent-workspace");
-
-    await mkdir(path.dirname(mediaPathA), { recursive: true });
-    await mkdir(agentWorkspace, { recursive: true });
-    await writeFile(mediaPathA, Buffer.from("first"));
-    await writeFile(mediaPathB, Buffer.from("second"));
-
-    const cfg = {
-      channels: {
-        wecom: {
-          mediaMaxMb: 8,
-        },
-      },
-      agents: {
-        list: [
-          {
-            id: "ops",
-            workspace: agentWorkspace,
-            sandbox: {
-              mode: "off",
-              scope: "session",
-              workspaceAccess: "ro",
-              docker: {
-                workdir: "/workspace",
-              },
-            },
-          },
-        ],
-      },
-    } as any;
-
-    const [stagedA, stagedB] = await Promise.all([
-      stageWecomInboundMediaForSession({
-        cfg,
-        accountId: "default",
-        agentId: "ops",
-        sessionKey: "agent:ops:wecom:default:dm:zhangsan",
-        mediaPath: mediaPathA,
-        filename: "dup.bin",
-      }),
-      stageWecomInboundMediaForSession({
-        cfg,
-        accountId: "default",
-        agentId: "ops",
-        sessionKey: "agent:ops:wecom:default:dm:lisi",
-        mediaPath: mediaPathB,
-        filename: "dup.bin",
-      }),
-    ]);
-
-    expect(stagedA).not.toBe(stagedB);
-    expect([path.basename(stagedA), path.basename(stagedB)].sort()).toEqual(["dup-1.bin", "dup.bin"]);
-    expect((await readFile(stagedA)).toString()).toMatch(/first|second/);
-    expect((await readFile(stagedB)).toString()).toMatch(/first|second/);
-    expect((await readFile(stagedA)).toString()).not.toBe((await readFile(stagedB)).toString());
-  });
-});

package/src/capability/bot/sandbox-media.ts

@@ -1,176 +0,0 @@
-import crypto from "node:crypto";
-import { constants } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { copyFile, mkdir, stat } from "node:fs/promises";
-
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { resolveAgentConfig, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
-
-import { resolveWecomMediaMaxBytes } from "../../config/index.js";
-
-function expandHomeDir(input: string): string {
-  if (input === "~") return os.homedir();
-  if (input.startsWith("~/")) return path.join(os.homedir(), input.slice(2));
-  return input;
-}
-
-function resolveOpenClawStateDir(): string {
-  const override = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim();
-  if (override) {
-    return path.resolve(expandHomeDir(override));
-  }
-  return path.join(os.homedir(), ".openclaw");
-}
-
-function normalizeAgentId(agentId: string): string {
-  return agentId.trim().toLowerCase() || "main";
-}
-
-function normalizeMainKey(mainKey: unknown): string {
-  return typeof mainKey === "string" && mainKey.trim() ? mainKey.trim().toLowerCase() : "main";
-}
-
-function buildAgentMainSessionKey(cfg: OpenClawConfig, agentId: string): string {
-  if (cfg.session?.scope === "global") {
-    return "global";
-  }
-  return `agent:${normalizeAgentId(agentId)}:${normalizeMainKey(cfg.session?.mainKey)}`;
-}
-
-function slugifySessionKey(value: string): string {
-  const trimmed = value.trim() || "session";
-  const hash = crypto.createHash("sha256").update(trimmed).digest("hex").slice(0, 8);
-  const prefix =
-    trimmed
-      .toLowerCase()
-      .replace(/[^a-z0-9._-]+/g, "-")
-      .replace(/^-+|-+$/g, "")
-      .slice(0, 32) || "session";
-  return `${prefix}-${hash}`;
-}
-
-function isSandboxedSession(params: {
-  cfg: OpenClawConfig;
-  agentId: string;
-  sessionKey: string;
-}): boolean {
-  const sandbox = resolveAgentConfig(params.cfg, params.agentId)?.sandbox;
-  if (!sandbox || sandbox.mode === "off") {
-    return false;
-  }
-  if (sandbox.mode === "all") {
-    return true;
-  }
-  return params.sessionKey.trim().toLowerCase() !== buildAgentMainSessionKey(params.cfg, params.agentId);
-}
-
-function resolveSessionWorkspaceTarget(params: {
-  cfg: OpenClawConfig;
-  agentId: string;
-  sessionKey: string;
-}): { workspaceDir: string; sandboxed: boolean } {
-  const sandbox = resolveAgentConfig(params.cfg, params.agentId)?.sandbox;
-  const agentWorkspaceDirRaw = resolveAgentWorkspaceDir(params.cfg, params.agentId);
-  const agentWorkspaceDir = path.resolve(expandHomeDir(agentWorkspaceDirRaw || process.cwd()));
-  if (!sandbox || !isSandboxedSession(params)) {
-    return {
-      workspaceDir: agentWorkspaceDir,
-      sandboxed: false,
-    };
-  }
-  if (sandbox.workspaceAccess === "rw" || !sandbox.workspaceRoot) {
-    if (sandbox.workspaceAccess === "rw") {
-      return {
-        workspaceDir: agentWorkspaceDir,
-        sandboxed: true,
-      };
-    }
-    return {
-      workspaceDir: path.join(resolveOpenClawStateDir(), "sandboxes", slugifySessionKey(params.sessionKey.trim() || "main")),
-      sandboxed: true,
-    };
-  }
-
-  const workspaceRoot = path.resolve(expandHomeDir(sandbox.workspaceRoot));
-  const scopeKey =
-    sandbox.scope === "shared"
-      ? "shared"
-      : sandbox.scope === "session"
-        ? params.sessionKey.trim() || "main"
-        : `agent:${normalizeAgentId(params.agentId)}`;
-  if (sandbox.scope === "shared") {
-    return {
-      workspaceDir: workspaceRoot,
-      sandboxed: true,
-    };
-  }
-  return {
-    workspaceDir: path.join(workspaceRoot, slugifySessionKey(scopeKey)),
-    sandboxed: true,
-  };
-}
-
-function buildStagedFilenameCandidate(parsed: path.ParsedPath, suffix: number): string {
-  if (suffix === 0) {
-    return parsed.base || "attachment";
-  }
-  return `${parsed.name || "attachment"}-${suffix}${parsed.ext}`;
-}
-
-async function copyIntoWorkspaceInbound(params: {
-  sourcePath: string;
-  workspaceDir: string;
-  filename: string;
-}): Promise<{ absolutePath: string; relativePath: string }> {
-  const inboundDir = path.join(params.workspaceDir, "media", "inbound");
-  await mkdir(inboundDir, { recursive: true });
-
-  const parsed = path.parse(params.filename);
-  for (let suffix = 0; ; suffix += 1) {
-    const candidate = buildStagedFilenameCandidate(parsed, suffix);
-    const absolutePath = path.join(inboundDir, candidate);
-    try {
-      await copyFile(params.sourcePath, absolutePath, constants.COPYFILE_EXCL);
-      return {
-        absolutePath,
-        relativePath: path.posix.join("media", "inbound", candidate),
-      };
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException)?.code === "EEXIST") {
-        continue;
-      }
-      throw error;
-    }
-  }
-}
-
-export async function stageWecomInboundMediaForSession(params: {
-  cfg: OpenClawConfig;
-  accountId: string;
-  agentId: string;
-  sessionKey: string;
-  mediaPath: string;
-  filename?: string;
-}): Promise<string> {
-  const target = resolveSessionWorkspaceTarget({
-    cfg: params.cfg,
-    agentId: params.agentId,
-    sessionKey: params.sessionKey,
-  });
-
-  const maxBytes = resolveWecomMediaMaxBytes(params.cfg, params.accountId);
-  const sourceStat = await stat(params.mediaPath);
-  if (sourceStat.size > maxBytes) {
-    throw new Error(
-      `Inbound media size ${(sourceStat.size / (1024 * 1024)).toFixed(2)}MB exceeds channels.wecom.mediaMaxMb ${(maxBytes / (1024 * 1024)).toFixed(2)}MB before workspace staging`,
-    );
-  }
-
-  const staged = await copyIntoWorkspaceInbound({
-    sourcePath: params.mediaPath,
-    workspaceDir: target.workspaceDir,
-    filename: params.filename || path.basename(params.mediaPath),
-  });
-  return target.sandboxed ? staged.relativePath : staged.absolutePath;
-}

package/src/capability/bot/service.ts

@@ -1,56 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-
-import type { WecomRuntimeEnv } from "../../types/runtime-context.js";
-import type { WecomAccountRuntime } from "../../app/account-runtime.js";
-import { BotWsSdkAdapter } from "../../transport/bot-ws/sdk-adapter.js";
-import { startBotWebhookTransport } from "../../transport/bot-webhook/http-handler.js";
-
-export class WecomBotCapabilityService {
-  private wsAdapter?: BotWsSdkAdapter;
-  private stopTransport?: () => void;
-
-  constructor(
-    private readonly runtime: WecomAccountRuntime,
-    private readonly cfg: OpenClawConfig,
-    private readonly runtimeEnv: WecomRuntimeEnv,
-  ) {}
-
-  start(): { transport: "bot-ws" | "bot-webhook"; descriptors: string[] } | undefined {
-    const bot = this.runtime.account.bot;
-    if (!bot?.configured) {
-      return undefined;
-    }
-
-    if (bot.primaryTransport === "ws") {
-      this.wsAdapter = new BotWsSdkAdapter(this.runtime, {
-        info: this.runtimeEnv.log,
-        warn: this.runtimeEnv.log,
-        error: this.runtimeEnv.error,
-      });
-      this.wsAdapter.start();
-      this.stopTransport = () => this.wsAdapter?.stop();
-      return {
-        transport: "bot-ws",
-        descriptors: ["ws:primary"],
-      };
-    }
-
-    const webhook = startBotWebhookTransport({
-      account: bot,
-      cfg: this.cfg,
-      runtime: this.runtime,
-      runtimeEnv: this.runtimeEnv,
-    });
-    this.stopTransport = webhook.stop;
-    return {
-      transport: "bot-webhook",
-      descriptors: webhook.paths,
-    };
-  }
-
-  stop(): void {
-    this.stopTransport?.();
-    this.stopTransport = undefined;
-    this.wsAdapter = undefined;
-  }
-}