@yanhaidao/wecom 2.3.4 → 2.3.9

package/src/runtime/session-manager.ts

@@ -0,0 +1,76 @@
+import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
+
+import { resolveRuntimeRoute } from "./routing-bridge.js";
+import type { UnifiedInboundEvent } from "../types/index.js";
+import type { WecomMediaService } from "../shared/media-service.js";
+
+export type PreparedSession = {
+  route: ReturnType<typeof resolveRuntimeRoute>;
+  ctx: ReturnType<PluginRuntime["channel"]["reply"]["finalizeInboundContext"]>;
+  storePath: string;
+};
+
+export async function prepareInboundSession(params: {
+  core: PluginRuntime;
+  cfg: OpenClawConfig;
+  event: UnifiedInboundEvent;
+  mediaService: WecomMediaService;
+}): Promise<PreparedSession> {
+  const { core, cfg, event, mediaService } = params;
+  const route = resolveRuntimeRoute({ core, cfg, event });
+  const storePath = core.channel.session.resolveStorePath(cfg.session?.store, {
+    agentId: route.agentId,
+  });
+  const previousTimestamp = core.channel.session.readSessionUpdatedAt({
+    storePath,
+    sessionKey: route.sessionKey,
+  });
+  const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+  const body = core.channel.reply.formatAgentEnvelope({
+    channel: "WeCom",
+    from: `${event.conversation.peerKind}:${event.conversation.peerId}`,
+    previousTimestamp,
+    envelope: envelopeOptions,
+    body: event.text,
+  });
+
+  const firstAttachment = await mediaService.normalizeFirstAttachment(event);
+  const mediaPath = firstAttachment
+    ? await mediaService.saveInboundAttachment(event, firstAttachment)
+    : undefined;
+
+  const ctx = core.channel.reply.finalizeInboundContext({
+    Body: body,
+    RawBody: event.text,
+    CommandBody: event.text,
+    From:
+      event.conversation.peerKind === "group"
+        ? `wecom:group:${event.conversation.peerId}`
+        : `wecom:${event.conversation.senderId}`,
+    To: `wecom:${event.conversation.peerId}`,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: event.conversation.peerKind,
+    ConversationLabel: `${event.conversation.peerKind}:${event.conversation.peerId}`,
+    SenderName: event.senderName ?? event.conversation.senderId,
+    SenderId: event.conversation.senderId,
+    Provider: "wecom",
+    Surface: "wecom",
+    OriginatingChannel: "wecom",
+    OriginatingTo: `wecom:${event.conversation.peerId}`,
+    MessageSid: event.messageId,
+    CommandAuthorized: true,
+    MediaPath: mediaPath,
+    MediaUrl: mediaPath,
+    MediaType: firstAttachment?.contentType,
+  });
+
+  await core.channel.session.recordInboundSession({
+    storePath,
+    sessionKey: ctx.SessionKey ?? route.sessionKey,
+    ctx,
+    onRecordError: () => {},
+  });
+
+  return { route, ctx, storePath };
+}

package/src/runtime.ts

@@ -1,14 +1,7 @@
-import type { PluginRuntime } from "openclaw/plugin-sdk";
-
-let runtime: PluginRuntime | null = null;
-
-export function setWecomRuntime(next: PluginRuntime): void {
-  runtime = next;
-}
-
-export function getWecomRuntime(): PluginRuntime {
-  if (!runtime) {
-    throw new Error("WeCom runtime not initialized");
-  }
-  return runtime;
-}
+export {
+  getAccountRuntimeSnapshot,
+  getWecomRuntime,
+  registerAccountRuntime,
+  setWecomRuntime,
+  unregisterAccountRuntime,
+} from "./app/index.js";

package/src/shared/command-auth.ts

@@ -1,26 +1,10 @@
 import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
 
 import type { WecomAgentConfig, WecomBotConfig } from "../types/index.js";
+import { isWecomSenderAllowed, normalizeWecomAllowFromEntry } from "../domain/policies.js";
 
 type WecomCommandAuthAccountConfig = Pick<WecomBotConfig, "dm"> | Pick<WecomAgentConfig, "dm">;
 
-function normalizeWecomAllowFromEntry(raw: string): string {
-  return raw
-    .trim()
-    .toLowerCase()
-    .replace(/^wecom:/, "")
-    .replace(/^user:/, "")
-    .replace(/^userid:/, "");
-}
-
-function isWecomSenderAllowed(senderUserId: string, allowFrom: string[]): boolean {
-  const list = allowFrom.map((entry) => normalizeWecomAllowFromEntry(entry)).filter(Boolean);
-  if (list.includes("*")) return true;
-  const normalizedSender = normalizeWecomAllowFromEntry(senderUserId);
-  if (!normalizedSender) return false;
-  return list.includes(normalizedSender);
-}
-
 export async function resolveWecomCommandAuthorization(params: {
   core: PluginRuntime;
   cfg: OpenClawConfig;

package/src/shared/media-service.ts

@@ -0,0 +1,36 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+import type { NormalizedMediaAttachment } from "./media-types.js";
+import type { UnifiedInboundEvent } from "../types/index.js";
+
+export class WecomMediaService {
+  constructor(private readonly core: PluginRuntime) {}
+
+  async downloadRemoteMedia(params: { url: string }): Promise<NormalizedMediaAttachment> {
+    const loaded = await this.core.channel.media.fetchRemoteMedia({ url: params.url });
+    return {
+      buffer: loaded.buffer,
+      contentType: loaded.contentType,
+      filename: loaded.fileName,
+    };
+  }
+
+  async saveInboundAttachment(event: UnifiedInboundEvent, attachment: NormalizedMediaAttachment): Promise<string> {
+    const saved = await this.core.channel.media.saveMediaBuffer(
+      attachment.buffer,
+      attachment.contentType,
+      "inbound",
+      undefined,
+      attachment.filename,
+    );
+    return saved.path;
+  }
+
+  async normalizeFirstAttachment(event: UnifiedInboundEvent): Promise<NormalizedMediaAttachment | undefined> {
+    const first = event.attachments?.[0];
+    if (!first?.remoteUrl) {
+      return undefined;
+    }
+    return this.downloadRemoteMedia({ url: first.remoteUrl });
+  }
+}

package/src/shared/media-types.ts

@@ -0,0 +1,5 @@
+export type NormalizedMediaAttachment = {
+  filename?: string;
+  contentType?: string;
+  buffer: Buffer;
+};

package/src/store/active-reply-store.ts

@@ -0,0 +1,42 @@
+import { LIMITS } from "../monitor/limits.js";
+import type { ActiveReplyState } from "../types/legacy-stream.js";
+
+export class ActiveReplyStore {
+  private activeReplies = new Map<string, ActiveReplyState>();
+
+  constructor(private policy: "once" | "multi" = "once") {}
+
+  store(streamId: string, responseUrl?: string, proxyUrl?: string): void {
+    const url = responseUrl?.trim();
+    if (!url) return;
+    this.activeReplies.set(streamId, { response_url: url, proxyUrl, createdAt: Date.now() });
+  }
+
+  getUrl(streamId: string): string | undefined {
+    return this.activeReplies.get(streamId)?.response_url;
+  }
+
+  async use(streamId: string, fn: (params: { responseUrl: string; proxyUrl?: string }) => Promise<void>): Promise<void> {
+    const state = this.activeReplies.get(streamId);
+    if (!state?.response_url) return;
+    if (this.policy === "once" && state.usedAt) {
+      throw new Error(`response_url already used for stream ${streamId} (Policy: once)`);
+    }
+    try {
+      await fn({ responseUrl: state.response_url, proxyUrl: state.proxyUrl });
+      state.usedAt = Date.now();
+    } catch (err: unknown) {
+      state.lastError = err instanceof Error ? err.message : String(err);
+      throw err;
+    }
+  }
+
+  prune(now: number = Date.now()): void {
+    const cutoff = now - LIMITS.ACTIVE_REPLY_TTL_MS;
+    for (const [id, state] of this.activeReplies.entries()) {
+      if (state.createdAt < cutoff) {
+        this.activeReplies.delete(id);
+      }
+    }
+  }
+}

package/src/store/interfaces.ts

@@ -0,0 +1,11 @@
+import type { DeliveryTask, ReplyContext, TransportSessionSnapshot, UnifiedInboundEvent } from "../types/index.js";
+
+export type RuntimeStore = {
+  markInboundSeen: (event: UnifiedInboundEvent) => boolean;
+  readReplyContext: (messageId: string) => ReplyContext | undefined;
+  writeReplyContext: (messageId: string, context: ReplyContext) => void;
+  readTransportSession: (accountId: string, transport: TransportSessionSnapshot["transport"]) => TransportSessionSnapshot | undefined;
+  writeTransportSession: (snapshot: TransportSessionSnapshot) => void;
+  writeDeliveryTask: (task: DeliveryTask) => void;
+  readDeliveryTask: (messageId: string) => DeliveryTask | undefined;
+};

package/src/store/memory-store.ts

@@ -0,0 +1,43 @@
+import type { RuntimeStore } from "./interfaces.js";
+import type { DeliveryTask, ReplyContext, TransportSessionSnapshot, UnifiedInboundEvent } from "../types/index.js";
+import { buildDedupKey } from "../domain/policies.js";
+
+export class InMemoryRuntimeStore implements RuntimeStore {
+  private readonly seen = new Set<string>();
+  private readonly replyContexts = new Map<string, ReplyContext>();
+  private readonly transportSessions = new Map<string, TransportSessionSnapshot>();
+  private readonly deliveryTasks = new Map<string, DeliveryTask>();
+
+  markInboundSeen(event: UnifiedInboundEvent): boolean {
+    const key = buildDedupKey(event);
+    if (this.seen.has(key)) {
+      return false;
+    }
+    this.seen.add(key);
+    return true;
+  }
+
+  readReplyContext(messageId: string): ReplyContext | undefined {
+    return this.replyContexts.get(messageId);
+  }
+
+  writeReplyContext(messageId: string, context: ReplyContext): void {
+    this.replyContexts.set(messageId, context);
+  }
+
+  readTransportSession(accountId: string, transport: TransportSessionSnapshot["transport"]): TransportSessionSnapshot | undefined {
+    return this.transportSessions.get(`${accountId}:${transport}`);
+  }
+
+  writeTransportSession(snapshot: TransportSessionSnapshot): void {
+    this.transportSessions.set(`${snapshot.accountId}:${snapshot.transport}`, snapshot);
+  }
+
+  writeDeliveryTask(task: DeliveryTask): void {
+    this.deliveryTasks.set(task.messageId, task);
+  }
+
+  readDeliveryTask(messageId: string): DeliveryTask | undefined {
+    return this.deliveryTasks.get(messageId);
+  }
+}

package/src/store/stream-batch-store.ts

@@ -0,0 +1,350 @@
+import crypto from "node:crypto";
+
+import { LIMITS } from "../monitor/limits.js";
+import type { PendingInbound, StreamState } from "../types/legacy-stream.js";
+import type { WecomBotInboundMessage as WecomInboundMessage } from "../types/index.js";
+import type { WecomWebhookTarget } from "../types/runtime-context.js";
+
+export class StreamStore {
+  private streams = new Map<string, StreamState>();
+  private msgidToStreamId = new Map<string, string>();
+  private pendingInbounds = new Map<string, PendingInbound>();
+  private conversationState = new Map<string, { activeBatchKey: string; queue: string[]; nextSeq: number }>();
+  private streamIdToBatchKey = new Map<string, string>();
+  private batchKeyToStreamIds = new Map<string, Set<string>>();
+  private batchStreamIdToAckStreamIds = new Map<string, string[]>();
+  private onFlush?: (pending: PendingInbound) => void;
+
+  public setFlushHandler(handler: (pending: PendingInbound) => void) {
+    this.onFlush = handler;
+  }
+
+  private linkStreamToBatch(streamId: string, batchKey?: string): void {
+    const key = String(batchKey ?? "").trim();
+    if (!key) return;
+    this.streamIdToBatchKey.set(streamId, key);
+    const linked = this.batchKeyToStreamIds.get(key) ?? new Set<string>();
+    linked.add(streamId);
+    this.batchKeyToStreamIds.set(key, linked);
+  }
+
+  private unlinkStreamFromBatch(streamId: string, batchKey?: string): void {
+    const key = String(batchKey ?? this.streamIdToBatchKey.get(streamId) ?? "").trim();
+    this.streamIdToBatchKey.delete(streamId);
+    if (!key) return;
+    const linked = this.batchKeyToStreamIds.get(key);
+    if (!linked) return;
+    linked.delete(streamId);
+    if (linked.size === 0) {
+      this.batchKeyToStreamIds.delete(key);
+    } else {
+      this.batchKeyToStreamIds.set(key, linked);
+    }
+  }
+
+  private hasLiveBatchKey(batchKey: string): boolean {
+    const key = batchKey.trim();
+    if (!key) return false;
+    return this.pendingInbounds.has(key) || (this.batchKeyToStreamIds.get(key)?.size ?? 0) > 0;
+  }
+
+  private clearPendingTimer(pending?: PendingInbound): void {
+    if (!pending?.timeout) return;
+    clearTimeout(pending.timeout);
+    pending.timeout = null;
+  }
+
+  private removePendingBatch(batchKey: string): PendingInbound | undefined {
+    const pending = this.pendingInbounds.get(batchKey);
+    if (!pending) return undefined;
+    this.pendingInbounds.delete(batchKey);
+    this.clearPendingTimer(pending);
+    pending.readyToFlush = false;
+    return pending;
+  }
+
+  private removeStreamRecord(streamId: string, state?: StreamState): void {
+    const current = state ?? this.streams.get(streamId);
+    if (!current) return;
+    this.streams.delete(streamId);
+    this.unlinkStreamFromBatch(streamId, current.batchKey);
+    if (current.msgid && this.msgidToStreamId.get(current.msgid) === streamId) {
+      this.msgidToStreamId.delete(current.msgid);
+    }
+  }
+
+  private pruneAckStreamMappings(): void {
+    for (const [batchStreamId, ackIds] of this.batchStreamIdToAckStreamIds.entries()) {
+      if (!this.streams.has(batchStreamId)) {
+        this.batchStreamIdToAckStreamIds.delete(batchStreamId);
+        continue;
+      }
+      const nextAckIds = ackIds.filter((ackId) => this.streams.has(ackId));
+      if (nextAckIds.length === 0) {
+        this.batchStreamIdToAckStreamIds.delete(batchStreamId);
+        continue;
+      }
+      this.batchStreamIdToAckStreamIds.set(batchStreamId, nextAckIds);
+    }
+  }
+
+  private pruneConversationState(): void {
+    for (const [convKey, conv] of this.conversationState.entries()) {
+      conv.queue = conv.queue.filter((batchKey) => this.pendingInbounds.has(batchKey));
+      if (!this.hasLiveBatchKey(conv.activeBatchKey)) {
+        const next = conv.queue.shift();
+        if (!next) {
+          this.conversationState.delete(convKey);
+          continue;
+        }
+        conv.activeBatchKey = next;
+      }
+      this.conversationState.set(convKey, conv);
+    }
+  }
+
+  createStream(params: { msgid?: string; conversationKey?: string; batchKey?: string }): string {
+    const streamId = crypto.randomBytes(16).toString("hex");
+    if (params.msgid) {
+      this.msgidToStreamId.set(String(params.msgid), streamId);
+    }
+    this.streams.set(streamId, {
+      streamId,
+      msgid: params.msgid,
+      conversationKey: params.conversationKey,
+      batchKey: params.batchKey,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      started: false,
+      finished: false,
+      content: "",
+    });
+    this.linkStreamToBatch(streamId, params.batchKey);
+    return streamId;
+  }
+
+  getStream(streamId: string): StreamState | undefined {
+    return this.streams.get(streamId);
+  }
+
+  getStreamByMsgId(msgid: string): string | undefined {
+    return this.msgidToStreamId.get(String(msgid));
+  }
+
+  setStreamIdForMsgId(msgid: string, streamId: string): void {
+    const key = String(msgid).trim();
+    const value = String(streamId).trim();
+    if (!key || !value) return;
+    this.msgidToStreamId.set(key, value);
+  }
+
+  addAckStreamForBatch(params: { batchStreamId: string; ackStreamId: string }): void {
+    const batchStreamId = params.batchStreamId.trim();
+    const ackStreamId = params.ackStreamId.trim();
+    if (!batchStreamId || !ackStreamId) return;
+    const list = this.batchStreamIdToAckStreamIds.get(batchStreamId) ?? [];
+    list.push(ackStreamId);
+    this.batchStreamIdToAckStreamIds.set(batchStreamId, list);
+  }
+
+  drainAckStreamsForBatch(batchStreamId: string): string[] {
+    const key = batchStreamId.trim();
+    if (!key) return [];
+    const list = this.batchStreamIdToAckStreamIds.get(key) ?? [];
+    this.batchStreamIdToAckStreamIds.delete(key);
+    return list;
+  }
+
+  updateStream(streamId: string, mutator: (state: StreamState) => void): void {
+    const state = this.streams.get(streamId);
+    if (state) {
+      mutator(state);
+      state.updatedAt = Date.now();
+    }
+  }
+
+  markStarted(streamId: string): void {
+    this.updateStream(streamId, (s) => {
+      s.started = true;
+    });
+  }
+
+  markFinished(streamId: string): void {
+    this.updateStream(streamId, (s) => {
+      s.finished = true;
+    });
+  }
+
+  addPendingMessage(params: {
+    conversationKey: string;
+    target: WecomWebhookTarget;
+    msg: WecomInboundMessage;
+    msgContent: string;
+    nonce: string;
+    timestamp: string;
+    debounceMs?: number;
+  }): { streamId: string; status: "active_new" | "active_merged" | "queued_new" | "queued_merged" } {
+    const { conversationKey, target, msg, msgContent, nonce, timestamp, debounceMs } = params;
+    const effectiveDebounceMs = debounceMs ?? LIMITS.DEFAULT_DEBOUNCE_MS;
+
+    const state = this.conversationState.get(conversationKey);
+    if (!state) {
+      const batchKey = conversationKey;
+      const streamId = this.createStream({ msgid: msg.msgid, conversationKey, batchKey });
+      const pending: PendingInbound = {
+        streamId,
+        conversationKey,
+        batchKey,
+        target,
+        msg,
+        contents: [msgContent],
+        msgids: msg.msgid ? [msg.msgid] : [],
+        nonce,
+        timestamp,
+        createdAt: Date.now(),
+        timeout: setTimeout(() => {
+          this.requestFlush(batchKey);
+        }, effectiveDebounceMs),
+      };
+      this.pendingInbounds.set(batchKey, pending);
+      this.conversationState.set(conversationKey, { activeBatchKey: batchKey, queue: [], nextSeq: 1 });
+      return { streamId, status: "active_new" };
+    }
+
+    const activeBatchKey = state.activeBatchKey;
+    const activeIsInitial = activeBatchKey === conversationKey;
+    const activePending = this.pendingInbounds.get(activeBatchKey);
+    if (activePending && !activeIsInitial) {
+      const activeStream = this.streams.get(activePending.streamId);
+      const activeStarted = Boolean(activeStream?.started);
+      if (!activeStarted) {
+        activePending.contents.push(msgContent);
+        if (msg.msgid) {
+          activePending.msgids.push(msg.msgid);
+        }
+        if (activePending.timeout) clearTimeout(activePending.timeout);
+        activePending.timeout = setTimeout(() => {
+          this.requestFlush(activeBatchKey);
+        }, effectiveDebounceMs);
+        return { streamId: activePending.streamId, status: "active_merged" };
+      }
+    }
+
+    const queuedBatchKey = state.queue[0];
+    if (queuedBatchKey) {
+      const existingQueued = this.pendingInbounds.get(queuedBatchKey);
+      if (existingQueued) {
+        existingQueued.contents.push(msgContent);
+        if (msg.msgid) {
+          existingQueued.msgids.push(msg.msgid);
+        }
+        if (existingQueued.timeout) clearTimeout(existingQueued.timeout);
+        existingQueued.timeout = setTimeout(() => {
+          this.requestFlush(queuedBatchKey);
+        }, effectiveDebounceMs);
+        return { streamId: existingQueued.streamId, status: "queued_merged" };
+      }
+    }
+
+    const seq = state.nextSeq++;
+    const batchKey = `${conversationKey}#q${seq}`;
+    state.queue = [batchKey];
+    const streamId = this.createStream({ msgid: msg.msgid, conversationKey, batchKey });
+    const pending: PendingInbound = {
+      streamId,
+      conversationKey,
+      batchKey,
+      target,
+      msg,
+      contents: [msgContent],
+      msgids: msg.msgid ? [msg.msgid] : [],
+      nonce,
+      timestamp,
+      createdAt: Date.now(),
+      timeout: setTimeout(() => {
+        this.requestFlush(batchKey);
+      }, effectiveDebounceMs),
+    };
+    this.pendingInbounds.set(batchKey, pending);
+    this.conversationState.set(conversationKey, state);
+    return { streamId, status: "queued_new" };
+  }
+
+  private requestFlush(batchKey: string): void {
+    const pending = this.pendingInbounds.get(batchKey);
+    if (!pending) return;
+
+    const state = this.conversationState.get(pending.conversationKey);
+    const isActive = state?.activeBatchKey === batchKey;
+    if (!isActive) {
+      if (pending.timeout) {
+        clearTimeout(pending.timeout);
+        pending.timeout = null;
+      }
+      pending.readyToFlush = true;
+      return;
+    }
+    this.flushPending(batchKey);
+  }
+
+  private flushPending(pendingKey: string): void {
+    const pending = this.removePendingBatch(pendingKey);
+    if (!pending) return;
+
+    if (this.onFlush) {
+      this.onFlush(pending);
+    }
+  }
+
+  onStreamFinished(streamId: string): void {
+    const batchKey = this.streamIdToBatchKey.get(streamId);
+    const state = batchKey ? this.streams.get(streamId) : undefined;
+    const conversationKey = state?.conversationKey;
+    if (!batchKey || !conversationKey) return;
+
+    this.unlinkStreamFromBatch(streamId, batchKey);
+
+    const conv = this.conversationState.get(conversationKey);
+    if (!conv) return;
+    if (conv.activeBatchKey !== batchKey) return;
+
+    const next = conv.queue.shift();
+    if (!next) {
+      this.conversationState.delete(conversationKey);
+      return;
+    }
+    conv.activeBatchKey = next;
+    this.conversationState.set(conversationKey, conv);
+
+    const pending = this.pendingInbounds.get(next);
+    if (!pending) return;
+    if (pending.readyToFlush) {
+      this.flushPending(next);
+    }
+  }
+
+  prune(now: number = Date.now()): void {
+    const streamCutoff = now - LIMITS.STREAM_TTL_MS;
+
+    for (const [id, state] of this.streams.entries()) {
+      if (state.updatedAt < streamCutoff) {
+        this.removeStreamRecord(id, state);
+      }
+    }
+
+    for (const [msgid, id] of this.msgidToStreamId.entries()) {
+      if (!this.streams.has(id)) {
+        this.msgidToStreamId.delete(msgid);
+      }
+    }
+
+    for (const [key, pending] of this.pendingInbounds.entries()) {
+      if (now - pending.createdAt > LIMITS.STREAM_TTL_MS) {
+        this.removePendingBatch(key);
+      }
+    }
+
+    this.pruneAckStreamMappings();
+    this.pruneConversationState();
+  }
+}

package/src/target.ts

@@ -20,6 +20,12 @@ export interface WecomTarget {
     chatid?: string;
 }
 
+export interface ScopedWecomTarget {
+    accountId?: string;
+    target: WecomTarget;
+    rawTarget: string;
+}
+
 /**
  * Parses a raw target string into a WeComTarget object.
  * 解析原始目标字符串为 WeComTarget 对象。
@@ -78,3 +84,25 @@ export function resolveWecomTarget(raw: string | undefined): WecomTarget | undef
     // Default to User (默认为用户)
     return { touser: clean };
 }
+
+export function resolveScopedWecomTarget(raw: string | undefined, defaultAccountId?: string): ScopedWecomTarget | undefined {
+    if (!raw?.trim()) return undefined;
+
+    const trimmed = raw.trim();
+    const agentScoped = trimmed.match(/^wecom-agent:([^:]+):(.+)$/i);
+    if (agentScoped) {
+        const accountId = agentScoped[1]?.trim() || defaultAccountId;
+        const rawTarget = agentScoped[2]?.trim() || "";
+        const target = resolveWecomTarget(rawTarget);
+        return target ? { accountId, target, rawTarget } : undefined;
+    }
+
+    const target = resolveWecomTarget(trimmed);
+    return target
+        ? {
+            accountId: defaultAccountId,
+            target,
+            rawTarget: trimmed,
+        }
+        : undefined;
+}