@yanhaidao/wecom 2.4.160 → 2.5.110

package/src/agent/index.ts

@@ -1,12 +0,0 @@
-/**
- * WeCom Agent 模块导出
- */
-
-export { handleAgentWebhook, type AgentWebhookParams } from "./handler.js";
-export {
-    getAccessToken,
-    sendText,
-    uploadMedia,
-    sendMedia,
-    downloadMedia,
-} from "../transport/agent-api/core.js";

package/src/app/account-runtime.ts

@@ -1,276 +0,0 @@
-import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
-import { formatErrorMessage } from "openclaw/plugin-sdk/infra-runtime";
-import type { ResolvedRuntimeAccount } from "../config/runtime-config.js";
-import { WecomAuditLog } from "../observability/audit-log.js";
-import { WecomStatusRegistry } from "../observability/status-registry.js";
-import { summarizeTransportSessions } from "../observability/transport-session-view.js";
-import { dispatchInboundEvent } from "../runtime/dispatcher.js";
-import { WecomMediaService } from "../shared/media-service.js";
-import { InMemoryRuntimeStore } from "../store/memory-store.js";
-import type {
-  AccountRuntimeStatusSnapshot,
-  ReplyHandle,
-  ReplyPayload,
-  TransportSessionPatch,
-  TransportSessionSnapshot,
-  UnifiedInboundEvent,
-  WecomAuditCategory,
-  WecomRuntimeHealth,
-  WecomTransportKind,
-} from "../types/index.js";
-
-export class WecomAccountRuntime {
-  readonly store = new InMemoryRuntimeStore();
-  readonly mediaService: WecomMediaService;
-  readonly auditLog = new WecomAuditLog();
-  readonly statusRegistry = new WecomStatusRegistry();
-  private readonly runtimeStatus: AccountRuntimeStatusSnapshot;
-
-  constructor(
-    readonly core: PluginRuntime,
-    readonly cfg: OpenClawConfig,
-    readonly resolved: ResolvedRuntimeAccount,
-    readonly log: {
-      info?: (message: string) => void;
-      warn?: (message: string) => void;
-      error?: (message: string) => void;
-    } = {},
-    private readonly statusSink?: (snapshot: Record<string, unknown>) => void,
-  ) {
-    this.mediaService = new WecomMediaService(core, cfg);
-    this.runtimeStatus = {
-      accountId: resolved.account.accountId,
-      health: "idle",
-      ownerId: null,
-      ownerDriftAt: null,
-      lastError: null,
-      lastErrorAt: null,
-      lastInboundAt: null,
-      lastOutboundAt: null,
-      recentInboundSummary: null,
-      recentOutboundSummary: null,
-      recentIssueCategory: null,
-      recentIssueSummary: null,
-      transportSessions: [],
-    };
-  }
-
-  get account() {
-    return this.resolved.account;
-  }
-
-  async handleEvent(event: UnifiedInboundEvent, replyHandle: ReplyHandle): Promise<void> {
-    const dispatchStartedAt = Date.now();
-    this.runtimeStatus.lastInboundAt = Date.now();
-    this.runtimeStatus.recentInboundSummary = `${event.transport} ${event.inboundKind} ${event.messageId}`;
-    this.log.info?.(
-      `[wecom-runtime] inbound account=${event.accountId} transport=${event.transport} kind=${event.inboundKind} messageId=${event.messageId} peer=${event.conversation.peerKind}:${event.conversation.peerId}`,
-    );
-    this.log.info?.(
-      `[wecom-runtime] dispatch-start account=${event.accountId} transport=${event.transport} kind=${event.inboundKind} messageId=${event.messageId}`,
-    );
-    this.emitStatus();
-
-    const trackedReplyHandle: ReplyHandle = {
-      context: replyHandle.context,
-      deliver: async (payload: ReplyPayload, info) => {
-        const deliverStartedAt = Date.now();
-        const textLen = payload.text?.trim().length ?? 0;
-        const mediaCount = (payload.mediaUrls?.length ?? 0) + (payload.mediaUrl ? 1 : 0);
-        this.log.info?.(
-          `[wecom-runtime] deliver-start account=${event.accountId} transport=${replyHandle.context.transport} kind=${info.kind} messageId=${event.messageId} textLen=${textLen} mediaCount=${mediaCount} reasoning=${String(payload.isReasoning === true)}`,
-        );
-        await replyHandle.deliver(payload, info);
-        this.runtimeStatus.lastOutboundAt = Date.now();
-        const outboundSummary =
-          payload.text?.trim() || payload.mediaUrl || payload.mediaUrls?.[0] || info.kind;
-        this.runtimeStatus.recentOutboundSummary = `${replyHandle.context.transport} ${outboundSummary.slice(0, 120)}`;
-        this.log.info?.(
-          `[wecom-runtime] outbound account=${event.accountId} transport=${replyHandle.context.transport} kind=${info.kind} messageId=${event.messageId} summary=${JSON.stringify(this.runtimeStatus.recentOutboundSummary)}`,
-        );
-        this.log.info?.(
-          `[wecom-runtime] deliver-done account=${event.accountId} transport=${replyHandle.context.transport} kind=${info.kind} messageId=${event.messageId} durationMs=${Date.now() - deliverStartedAt}`,
-        );
-        this.emitStatus();
-      },
-      fail: async (error: unknown) => {
-        const formattedError = formatErrorMessage(error);
-        this.recordOperationalIssue({
-          transport: replyHandle.context.transport,
-          category: "runtime-error",
-          messageId: event.messageId,
-          raw: replyHandle.context.raw,
-          summary: `reply-fail ${formattedError}`,
-          error: formattedError,
-        });
-        this.log.error?.(
-          `[wecom-runtime] reply-fail account=${event.accountId} transport=${replyHandle.context.transport} messageId=${event.messageId} error=${formattedError}`,
-        );
-        await replyHandle.fail?.(error);
-      },
-      markExternalActivity: () => {
-        replyHandle.markExternalActivity?.();
-      },
-    };
-
-    try {
-      await dispatchInboundEvent({
-        core: this.core,
-        cfg: this.cfg,
-        store: this.store,
-        auditLog: this.auditLog,
-        mediaService: this.mediaService,
-        event,
-        replyHandle: trackedReplyHandle,
-      });
-      this.log.info?.(
-        `[wecom-runtime] dispatch-done account=${event.accountId} transport=${event.transport} kind=${event.inboundKind} messageId=${event.messageId} durationMs=${Date.now() - dispatchStartedAt}`,
-      );
-    } catch (error) {
-      this.log.error?.(
-        `[wecom-runtime] dispatch-fail account=${event.accountId} transport=${event.transport} kind=${event.inboundKind} messageId=${event.messageId} durationMs=${Date.now() - dispatchStartedAt} error=${formatErrorMessage(error)}`,
-      );
-      throw error;
-    }
-  }
-
-  updateTransportSession(snapshot: TransportSessionSnapshot): void {
-    const previous = this.store.readTransportSession(snapshot.accountId, snapshot.transport);
-    this.store.writeTransportSession(snapshot);
-    this.statusRegistry.write(snapshot);
-    this.log.info?.(
-      `[wecom-runtime] session account=${snapshot.accountId} transport=${snapshot.transport} running=${snapshot.running} owner=${snapshot.ownerId ?? "none"} connected=${String(snapshot.connected ?? false)} authenticated=${String(snapshot.authenticated ?? false)} error=${snapshot.lastError ?? "none"}`,
-    );
-    if (
-      previous?.ownerId &&
-      snapshot.ownerId &&
-      previous.ownerId !== snapshot.ownerId &&
-      previous.running
-    ) {
-      this.recordOperationalIssue({
-        transport: snapshot.transport,
-        category: "owner-drift",
-        summary: `owner drift ${previous.ownerId} -> ${snapshot.ownerId}`,
-      });
-    }
-    if (snapshot.lastError) {
-      this.runtimeStatus.lastError = snapshot.lastError;
-      this.runtimeStatus.lastErrorAt = Date.now();
-    } else if (snapshot.running) {
-      this.runtimeStatus.lastError = null;
-    }
-    this.emitStatus();
-  }
-
-  touchTransportSession(transport: WecomTransportKind, patch: TransportSessionPatch): void {
-    const current = this.store.readTransportSession(this.account.accountId, transport);
-    const next: TransportSessionSnapshot = {
-      accountId: this.account.accountId,
-      transport,
-      running: patch.running ?? current?.running ?? true,
-      ownerId: patch.ownerId ?? current?.ownerId,
-      connected: patch.connected ?? current?.connected,
-      authenticated: patch.authenticated ?? current?.authenticated,
-      lastConnectedAt: patch.lastConnectedAt ?? current?.lastConnectedAt,
-      lastDisconnectedAt: patch.lastDisconnectedAt ?? current?.lastDisconnectedAt,
-      lastInboundAt: patch.lastInboundAt ?? current?.lastInboundAt,
-      lastOutboundAt: patch.lastOutboundAt ?? current?.lastOutboundAt,
-      lastError: "lastError" in patch ? (patch.lastError ?? undefined) : current?.lastError,
-    };
-    this.updateTransportSession(next);
-  }
-
-  listTransportSessions() {
-    return this.statusRegistry.read(this.account.accountId);
-  }
-
-  listAuditEntries() {
-    return this.auditLog.list();
-  }
-
-  buildRuntimeStatus(): AccountRuntimeStatusSnapshot {
-    const sessions = this.listTransportSessions();
-    const primarySession = this.resolvePrimarySession(sessions);
-    return {
-      ...this.runtimeStatus,
-      health: this.computeHealth(sessions),
-      transport: primarySession?.transport,
-      ownerId: primarySession?.ownerId ?? this.runtimeStatus.ownerId ?? null,
-      connected: primarySession?.connected,
-      authenticated: primarySession?.authenticated,
-      lastError:
-        primarySession?.lastError ??
-        (primarySession?.running ? null : (this.runtimeStatus.lastError ?? null)),
-      transportSessions: summarizeTransportSessions(sessions),
-    };
-  }
-
-  recordOperationalIssue(params: {
-    transport: WecomTransportKind;
-    category: WecomAuditCategory;
-    summary: string;
-    messageId?: string;
-    raw?: ReplyHandle["context"]["raw"];
-    error?: string;
-  }): void {
-    this.auditLog.appendOperational({
-      accountId: this.account.accountId,
-      transport: params.transport,
-      category: params.category,
-      messageId: params.messageId,
-      summary: params.summary,
-      raw: params.raw,
-      error: params.error,
-    });
-    if (params.category === "owner-drift" || params.category === "ws-kicked") {
-      this.runtimeStatus.ownerDriftAt = Date.now();
-    }
-    this.runtimeStatus.lastError = params.error ?? params.summary;
-    this.runtimeStatus.lastErrorAt = Date.now();
-    this.runtimeStatus.recentIssueCategory = params.category;
-    this.runtimeStatus.recentIssueSummary = params.summary;
-    const sink =
-      params.category === "runtime-error" || params.category === "fallback-delivery-failed"
-        ? this.log.error
-        : this.log.warn;
-    sink?.(
-      `[wecom-runtime] issue account=${this.account.accountId} transport=${params.transport} category=${params.category} messageId=${params.messageId ?? "n/a"} summary=${params.summary}`,
-    );
-    this.emitStatus();
-  }
-
-  private emitStatus(): void {
-    this.statusSink?.(this.buildRuntimeStatus() as unknown as Record<string, unknown>);
-  }
-
-  private resolvePrimarySession(
-    sessions: TransportSessionSnapshot[],
-  ): TransportSessionSnapshot | undefined {
-    const primaryTransport = this.account.bot?.configured
-      ? this.account.bot.primaryTransport === "ws"
-        ? "bot-ws"
-        : "bot-webhook"
-      : this.account.agent?.callbackConfigured
-        ? "agent-callback"
-        : undefined;
-    if (!primaryTransport) {
-      return sessions[0];
-    }
-    return sessions.find((session) => session.transport === primaryTransport) ?? sessions[0];
-  }
-
-  private computeHealth(sessions: TransportSessionSnapshot[]): WecomRuntimeHealth {
-    if (sessions.length === 0) {
-      return this.runtimeStatus.lastError ? "down" : "idle";
-    }
-    const hasRunning = sessions.some((session) => session.running);
-    const hasError = sessions.some((session) => Boolean(session.lastError));
-    if (hasRunning && !hasError) {
-      return "healthy";
-    }
-    if (hasRunning) {
-      return "degraded";
-    }
-    return hasError ? "down" : "idle";
-  }
-}

package/src/app/bootstrap.ts

@@ -1,29 +0,0 @@
-import type { ChannelGatewayContext } from "openclaw/plugin-sdk";
-
-import { resolveWecomRuntimeAccount } from "../config/runtime-config.js";
-import type { ResolvedWecomAccount } from "../types/index.js";
-import { WecomAccountRuntime } from "./account-runtime.js";
-import { getWecomRuntime } from "./index.js";
-
-export function createAccountRuntime(ctx: ChannelGatewayContext<ResolvedWecomAccount>): WecomAccountRuntime {
-  const resolved = resolveWecomRuntimeAccount({
-    cfg: ctx.cfg,
-    accountId: ctx.accountId,
-  });
-  return new WecomAccountRuntime(
-    getWecomRuntime(),
-    ctx.cfg,
-    resolved,
-    {
-      info: (message) => ctx.log?.info(message),
-      warn: (message) => ctx.log?.warn(message),
-      error: (message) => ctx.log?.error(message),
-    },
-    (snapshot) => {
-      ctx.setStatus({
-        accountId: ctx.accountId,
-        ...snapshot,
-      });
-    },
-  );
-}

package/src/app/index.ts

@@ -1,192 +0,0 @@
-import type { PluginRuntime } from "openclaw/plugin-sdk";
-import { clearWecomSourceAccount } from "../runtime/source-registry.js";
-import type { ReplyHandle } from "../types/index.js";
-import { WecomAccountRuntime } from "./account-runtime.js";
-
-let runtime: PluginRuntime | null = null;
-const runtimes = new Map<string, WecomAccountRuntime>();
-const botWsPushHandles = new Map<string, BotWsPushHandle>();
-const activeBotWsReplyHandlesBySession = new Map<string, ReplyHandle>();
-const activeBotWsReplyHandlesByPeer = new Map<string, ReplyHandle>();
-
-export type BotWsPushHandle = {
-  isConnected: () => boolean;
-  sendMarkdown: (chatId: string, content: string) => Promise<void>;
-  replyCommand: (params: {
-    cmd: string;
-    body?: Record<string, unknown>;
-    headers?: ({ req_id?: string } & Record<string, string>) | undefined;
-  }) => Promise<Record<string, unknown>>;
-  sendMedia: (params: {
-    chatId: string;
-    mediaUrl: string;
-    text?: string;
-    mediaLocalRoots?: readonly string[];
-    maxBytes?: number;
-  }) => Promise<{
-    ok: boolean;
-    messageId?: string;
-    rejected?: boolean;
-    rejectReason?: string;
-    error?: string;
-  }>;
-};
-
-function normalizeOptional(value: string | null | undefined): string | undefined {
-  const trimmed = String(value ?? "").trim();
-  return trimmed || undefined;
-}
-
-function normalizePeerId(value: string | null | undefined): string | undefined {
-  const trimmed = normalizeOptional(value);
-  return trimmed ? trimmed.toLowerCase() : undefined;
-}
-
-function buildSessionHandleKey(accountId: string, sessionKey: string): string {
-  return `${accountId}::session::${sessionKey}`;
-}
-
-function buildPeerHandleKey(
-  accountId: string,
-  peerKind: "direct" | "group",
-  peerId: string,
-): string {
-  return `${accountId}::peer::${peerKind}::${peerId}`;
-}
-
-export function setWecomRuntime(next: PluginRuntime): void {
-  runtime = next;
-}
-
-export function getWecomRuntime(): PluginRuntime {
-  if (!runtime) {
-    throw new Error("WeCom runtime not initialized");
-  }
-  return runtime;
-}
-
-export function registerAccountRuntime(accountRuntime: WecomAccountRuntime): void {
-  runtimes.set(accountRuntime.account.accountId, accountRuntime);
-  console.log(`[wecom-runtime] register account=${accountRuntime.account.accountId}`);
-}
-
-export function getAccountRuntime(accountId: string): WecomAccountRuntime | undefined {
-  return runtimes.get(accountId);
-}
-
-export function getAccountRuntimeSnapshot(accountId: string) {
-  return runtimes.get(accountId)?.buildRuntimeStatus();
-}
-
-export function registerBotWsPushHandle(accountId: string, handle: BotWsPushHandle): void {
-  botWsPushHandles.set(accountId, handle);
-}
-
-export function getBotWsPushHandle(accountId: string): BotWsPushHandle | undefined {
-  return botWsPushHandles.get(accountId);
-}
-
-export function registerActiveBotWsReplyHandle(params: {
-  accountId: string;
-  sessionKey?: string | null;
-  peerKind?: "direct" | "group" | null;
-  peerId?: string | null;
-  handle: ReplyHandle;
-}): void {
-  const accountId = normalizeOptional(params.accountId);
-  const sessionKey = normalizeOptional(params.sessionKey);
-  const peerId = normalizePeerId(params.peerId);
-  if (!accountId) {
-    return;
-  }
-  if (sessionKey) {
-    activeBotWsReplyHandlesBySession.set(
-      buildSessionHandleKey(accountId, sessionKey),
-      params.handle,
-    );
-  }
-  if ((params.peerKind === "direct" || params.peerKind === "group") && peerId) {
-    activeBotWsReplyHandlesByPeer.set(
-      buildPeerHandleKey(accountId, params.peerKind, peerId),
-      params.handle,
-    );
-  }
-}
-
-export function getActiveBotWsReplyHandle(params: {
-  accountId: string;
-  sessionKey?: string | null;
-  peerKind?: "direct" | "group" | null;
-  peerId?: string | null;
-}): ReplyHandle | undefined {
-  const accountId = normalizeOptional(params.accountId);
-  const sessionKey = normalizeOptional(params.sessionKey);
-  const peerId = normalizePeerId(params.peerId);
-  if (!accountId) {
-    return undefined;
-  }
-  if (sessionKey) {
-    const handle = activeBotWsReplyHandlesBySession.get(
-      buildSessionHandleKey(accountId, sessionKey),
-    );
-    if (handle) {
-      return handle;
-    }
-  }
-  if ((params.peerKind === "direct" || params.peerKind === "group") && peerId) {
-    return activeBotWsReplyHandlesByPeer.get(
-      buildPeerHandleKey(accountId, params.peerKind, peerId),
-    );
-  }
-  return undefined;
-}
-
-export function unregisterActiveBotWsReplyHandle(params: {
-  accountId: string;
-  sessionKey?: string | null;
-  peerKind?: "direct" | "group" | null;
-  peerId?: string | null;
-  handle?: ReplyHandle;
-}): void {
-  const accountId = normalizeOptional(params.accountId);
-  const sessionKey = normalizeOptional(params.sessionKey);
-  const peerId = normalizePeerId(params.peerId);
-  if (!accountId) {
-    return;
-  }
-  if (sessionKey) {
-    const key = buildSessionHandleKey(accountId, sessionKey);
-    const current = activeBotWsReplyHandlesBySession.get(key);
-    if (!params.handle || current === params.handle) {
-      activeBotWsReplyHandlesBySession.delete(key);
-    }
-  }
-  if ((params.peerKind === "direct" || params.peerKind === "group") && peerId) {
-    const key = buildPeerHandleKey(accountId, params.peerKind, peerId);
-    const current = activeBotWsReplyHandlesByPeer.get(key);
-    if (!params.handle || current === params.handle) {
-      activeBotWsReplyHandlesByPeer.delete(key);
-    }
-  }
-}
-
-export function unregisterBotWsPushHandle(accountId: string): void {
-  botWsPushHandles.delete(accountId);
-}
-
-export function unregisterAccountRuntime(accountId: string): void {
-  runtimes.delete(accountId);
-  botWsPushHandles.delete(accountId);
-  for (const key of activeBotWsReplyHandlesBySession.keys()) {
-    if (key.startsWith(`${accountId}::`)) {
-      activeBotWsReplyHandlesBySession.delete(key);
-    }
-  }
-  for (const key of activeBotWsReplyHandlesByPeer.keys()) {
-    if (key.startsWith(`${accountId}::`)) {
-      activeBotWsReplyHandlesByPeer.delete(key);
-    }
-  }
-  clearWecomSourceAccount(accountId);
-  console.log(`[wecom-runtime] unregister account=${accountId}`);
-}

package/src/capability/agent/delivery-service.ts

@@ -1,87 +0,0 @@
-import type { ResolvedAgentAccount } from "../../types/index.js";
-import { resolveScopedWecomTarget } from "../../target.js";
-import { deliverAgentApiMedia, deliverAgentApiText } from "../../transport/agent-api/delivery.js";
-import { canUseAgentApiDelivery } from "./fallback-policy.js";
-import { getWecomRuntime } from "../../runtime.js";
-
-export class WecomAgentDeliveryService {
-  constructor(private readonly agent: ResolvedAgentAccount) { }
-
-  assertAvailable(): void {
-    if (!canUseAgentApiDelivery(this.agent)) {
-      throw new Error(
-        `WeCom outbound requires channels.wecom.accounts.<accountId>.agent.agentId (or legacy channels.wecom.agent.agentId) for account=${this.agent.accountId}.`,
-      );
-    }
-  }
-
-  resolveTargetOrThrow(to: string | undefined) {
-    const scoped = resolveScopedWecomTarget(to, this.agent.accountId);
-    if (!scoped) {
-      console.error(`[wecom-agent-delivery] missing target account=${this.agent.accountId}`);
-      throw new Error("WeCom outbound requires a target (userid, partyid, tagid or chatid).");
-    }
-    if (scoped.accountId && scoped.accountId !== this.agent.accountId) {
-      console.error(
-        `[wecom-agent-delivery] account mismatch current=${this.agent.accountId} targetAccount=${scoped.accountId} raw=${String(to ?? "")}`,
-      );
-      throw new Error(
-        `WeCom outbound account mismatch: target belongs to account=${scoped.accountId}, current account=${this.agent.accountId}.`,
-      );
-    }
-    const target = scoped.target;
-    if (target.chatid) {
-      console.warn(
-        `[wecom-agent-delivery] blocked chat target account=${this.agent.accountId} chatId=${target.chatid}`,
-      );
-      throw new Error(
-        `企业微信（WeCom）Agent 主动发送不支持向群 chatId 发送（chatId=${target.chatid}）。` +
-        `该路径在实际环境中经常失败（例如 86008：无权限访问该会话/会话由其他应用创建）。` +
-        `请改为发送给用户（userid / user:xxx），或由 Bot 模式在群内交付。`,
-      );
-    }
-    return target;
-  }
-
-  async sendText(params: { to: string | undefined; text: string }): Promise<void> {
-    this.assertAvailable();
-    const target = this.resolveTargetOrThrow(params.to);
-    console.log(
-      `[wecom-agent-delivery] sendText account=${this.agent.accountId} to=${String(params.to ?? "")} len=${params.text.length}`,
-    );
-
-    const runtime = getWecomRuntime();
-    const chunks = runtime.channel.text.chunkText(params.text, 2048);
-
-    for (const chunk of chunks) {
-      if (!chunk.trim()) continue;
-      await deliverAgentApiText({
-        agent: this.agent,
-        target,
-        text: chunk,
-      });
-    }
-  }
-
-  async sendMedia(params: {
-    to: string | undefined;
-    text?: string;
-    buffer: Buffer;
-    filename: string;
-    contentType: string;
-  }): Promise<void> {
-    this.assertAvailable();
-    const target = this.resolveTargetOrThrow(params.to);
-    console.log(
-      `[wecom-agent-delivery] sendMedia account=${this.agent.accountId} to=${String(params.to ?? "")} filename=${params.filename} contentType=${params.contentType}`,
-    );
-    await deliverAgentApiMedia({
-      agent: this.agent,
-      target,
-      buffer: params.buffer,
-      filename: params.filename,
-      contentType: params.contentType,
-      text: params.text,
-    });
-  }
-}

package/src/capability/agent/fallback-policy.ts

@@ -1,13 +0,0 @@
-import type { ResolvedAgentAccount } from "../../types/index.js";
-
-export function canUseAgentApiDelivery(agent: ResolvedAgentAccount | undefined): boolean {
-  return Boolean(agent?.apiConfigured && typeof agent.agentId === "number");
-}
-
-export function shouldFallbackToAgentApi(params: {
-  agent: ResolvedAgentAccount | undefined;
-  hasText?: boolean;
-  hasMedia?: boolean;
-}): boolean {
-  return canUseAgentApiDelivery(params.agent) && Boolean(params.hasText || params.hasMedia);
-}

package/src/capability/agent/ingress-service.ts

@@ -1,38 +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 { startAgentCallbackTransport } from "../../transport/agent-callback/http-handler.js";
-
-export class WecomAgentIngressService {
-  private stopTransport?: () => void;
-
-  constructor(
-    private readonly runtime: WecomAccountRuntime,
-    private readonly cfg: OpenClawConfig,
-    private readonly runtimeEnv: WecomRuntimeEnv,
-  ) {}
-
-  start(): { transport: "agent-callback"; descriptors: string[] } | undefined {
-    const agent = this.runtime.account.agent;
-    if (!agent?.callbackConfigured) {
-      return undefined;
-    }
-    const callback = startAgentCallbackTransport({
-      account: agent,
-      cfg: this.cfg,
-      runtime: this.runtime,
-      runtimeEnv: this.runtimeEnv,
-    });
-    this.stopTransport = callback.stop;
-    return {
-      transport: "agent-callback",
-      descriptors: callback.paths,
-    };
-  }
-
-  stop(): void {
-    this.stopTransport?.();
-    this.stopTransport = undefined;
-  }
-}