@core-workspace/infoflow-openclaw-plugin 2026.3.8

package/src/adapter/outbound/reply-dispatcher.ts

@@ -0,0 +1,281 @@
+import {
+  createReplyPrefixOptions,
+  type OpenClawConfig,
+  type ReplyPayload,
+} from "openclaw/plugin-sdk";
+import { getInfoflowSendLog, formatInfoflowError, logVerbose } from "../../logging.js";
+import { prepareInfoflowImageBase64, sendInfoflowImageMessage } from "../../channel/media.js";
+import { getInfoflowRuntime } from "../../runtime.js";
+import { isLikelyLocalPath, sendInfoflowMessage } from "../../channel/outbound.js";
+import type {
+  InfoflowAtOptions,
+  InfoflowMentionIds,
+  InfoflowMessageContentItem,
+  InfoflowOutboundReply,
+} from "../../types.js";
+
+const PREVIEW_MAX_LENGTH = 100;
+
+function truncatePreview(text?: string): string {
+  if (!text) return "";
+  if (text.length <= PREVIEW_MAX_LENGTH) return text;
+  return text.slice(0, PREVIEW_MAX_LENGTH) + "...";
+}
+
+export type CreateInfoflowReplyDispatcherParams = {
+  cfg: OpenClawConfig;
+  agentId: string;
+  accountId: string;
+  /** Target: "group:<id>" for group chat, username for private chat */
+  to: string;
+  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
+  /** AT options for @mentioning members in group messages */
+  atOptions?: InfoflowAtOptions;
+  /** Mention IDs from inbound message for resolving @id in LLM output */
+  mentionIds?: InfoflowMentionIds;
+  /** Inbound message ID for outbound reply-to (group only) */
+  replyToMessageId?: string;
+  /** Preview text of the inbound message for reply context */
+  replyToPreview?: string;
+  /** IMID of the user who sent the message being replied to */
+  replyToImid?: string;
+  /**
+   * Message format for outbound text: "text" or "markdown".
+   * Note: "markdown" does not support reply-to (quote) — replyTo will be ignored when using markdown.
+   * Default: "text"
+   */
+  messageFormat?: "text" | "markdown";
+};
+
+/**
+ * Builds dispatcherOptions and replyOptions for dispatchReplyWithBufferedBlockDispatcher.
+ * Encapsulates prefix options, chunked deliver (send via Infoflow API + statusSink), and onError.
+ */
+export function createInfoflowReplyDispatcher(params: CreateInfoflowReplyDispatcherParams) {
+  const {
+    cfg,
+    agentId,
+    accountId,
+    to,
+    statusSink,
+    atOptions,
+    mentionIds,
+    replyToMessageId,
+    replyToPreview,
+    replyToImid,
+    messageFormat = "text",
+  } = params;
+  const core = getInfoflowRuntime();
+
+  const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+    cfg,
+    agentId,
+    channel: "infoflow",
+    accountId,
+  });
+
+  // Check if target is a group (format: group:<id>)
+  const isGroup = /^group:\d+$/i.test(to);
+
+  // markdown format does not support reply-to; fall back to no replyTo when using markdown
+  const effectiveReplyToMessageId = messageFormat === "markdown" ? undefined : replyToMessageId;
+
+  // Build id→type map for resolving @id in LLM output (distinguishes user vs agent)
+  const mentionIdMap = new Map<string, "user" | "agent">();
+  if (mentionIds) {
+    for (const id of mentionIds.userIds) {
+      mentionIdMap.set(id.toLowerCase(), "user");
+    }
+    for (const id of mentionIds.agentIds) {
+      mentionIdMap.set(String(id).toLowerCase(), "agent");
+    }
+  }
+
+  // Build replyTo context (only used for the first outbound message)
+  // Note: replyTo is suppressed when messageFormat is "markdown" (not supported by API)
+  logVerbose(`[DEBUG reply-dispatcher] isGroup=${isGroup}, replyToMessageId=${replyToMessageId}, replyToImid=${replyToImid}, replyToPreview=${replyToPreview?.slice(0, 50)}`);
+
+  const replyTo: InfoflowOutboundReply | undefined =
+    isGroup && effectiveReplyToMessageId
+      ? {
+          messageid: effectiveReplyToMessageId,
+          preview: truncatePreview(replyToPreview),
+          ...(replyToImid ? { imid: replyToImid } : {}),
+          replytype: "2"  // "2" = 引用模式
+        }
+      : undefined;
+  let replyApplied = false;
+
+  // Debug: Log constructed replyTo
+  logVerbose(`[DEBUG reply-dispatcher] replyTo constructed: ${JSON.stringify(replyTo)}`);
+  if (replyTo) {
+    logVerbose(`[DEBUG reply-dispatcher] Creating reply context with messageid=${replyTo.messageid}`);
+  } else {
+    logVerbose(`[DEBUG reply-dispatcher] replyTo is undefined - not creating reply context`);
+  }
+
+  const deliver = async (payload: ReplyPayload) => {
+    const text = payload.text ?? "";
+    logVerbose(`[infoflow] deliver called: to=${to}, text=${text}`);
+
+    // Normalize media URL list (same pattern as Feishu reply-dispatcher)
+    const mediaList =
+      payload.mediaUrls && payload.mediaUrls.length > 0
+        ? payload.mediaUrls
+        : payload.mediaUrl
+          ? [payload.mediaUrl]
+          : [];
+
+    logVerbose(`[infoflow] deliver called: to=${to}, text=${text}, mediaList=${JSON.stringify(mediaList)}`);
+    if (!text.trim() && mediaList.length === 0) {
+      return;
+    }
+
+    // --- Text handling (existing logic) ---
+    if (text.trim()) {
+      // Resolve @id patterns in LLM output text to user/agent IDs
+      const resolvedUserIds: string[] = [];
+      const resolvedAgentIds: number[] = [];
+      if (isGroup && mentionIdMap.size > 0) {
+        const mentionPattern = /@([\w.]+)/g;
+        let match: RegExpExecArray | null;
+        while ((match = mentionPattern.exec(text)) !== null) {
+          const id = match[1];
+          const type = mentionIdMap.get(id.toLowerCase());
+          if (type === "user" && !resolvedUserIds.includes(id)) {
+            resolvedUserIds.push(id);
+          } else if (type === "agent") {
+            const numId = Number(id);
+            if (Number.isFinite(numId) && !resolvedAgentIds.includes(numId)) {
+              resolvedAgentIds.push(numId);
+            }
+          }
+        }
+      }
+
+      // Merge atOptions user IDs (sender echo-back) with LLM-resolved user IDs
+      const atOptionIds = atOptions?.atAll ? [] : (atOptions?.atUserIds ?? []);
+      const allAtUserIds = [...atOptionIds];
+      for (const id of resolvedUserIds) {
+        if (!allAtUserIds.includes(id)) {
+          allAtUserIds.push(id);
+        }
+      }
+      const hasAtAll = atOptions?.atAll === true;
+      const hasAtUsers = allAtUserIds.length > 0;
+      const hasAtAgents = resolvedAgentIds.length > 0;
+
+      // Use the original text without prepending @ mentions
+      // AT nodes will be added to contents for notification, but text stays clean
+      let messageText = text;
+
+      // Chunk text to 4000 chars max (Infoflow limit)
+      const chunks = core.channel.text.chunkText(messageText, 4000);
+      // Only include @mentions in the first chunk (avoid duplicate @s)
+      let isFirstChunk = true;
+
+      for (const chunk of chunks) {
+        const contents: InfoflowMessageContentItem[] = [];
+
+        // Add AT content nodes for group messages (first chunk only)
+        if (isFirstChunk && isGroup) {
+          if (hasAtAll) {
+            contents.push({ type: "at", content: "all" });
+          } else if (hasAtUsers) {
+            contents.push({ type: "at", content: allAtUserIds.join(",") });
+          }
+          if (hasAtAgents) {
+            contents.push({ type: "at-agent", content: resolvedAgentIds.join(",") });
+          }
+        }
+        isFirstChunk = false;
+
+        // Add text content using configured format
+        contents.push({ type: messageFormat, content: chunk });
+
+        // Only include replyTo on the first outbound message
+        const chunkReplyTo = !replyApplied ? replyTo : undefined;
+
+        // Debug: Log when sending with replyTo
+        logVerbose(`[DEBUG deliver] chunkReplyTo: ${JSON.stringify(chunkReplyTo)}`);
+        logVerbose(`[DEBUG deliver] replyApplied=${replyApplied}, replyTo exists=${!!replyTo}`);
+
+        const result = await sendInfoflowMessage({
+          cfg,
+          to,
+          contents,
+          accountId,
+          replyTo: chunkReplyTo,
+        });
+        if (chunkReplyTo) replyApplied = true;
+
+        if (result.ok) {
+          statusSink?.({ lastOutboundAt: Date.now() });
+        } else if (result.error) {
+          getInfoflowSendLog().error(
+            `[infoflow] reply failed to=${to}, accountId=${accountId}: ${result.error}`,
+          );
+        }
+      }
+    }
+
+    // --- Media handling: send each media item as native image or fallback link ---
+    for (const mediaUrl of mediaList) {
+      const mediaReplyTo = !replyApplied ? replyTo : undefined;
+      try {
+        const paths = isLikelyLocalPath(mediaUrl)?[mediaUrl]:undefined;
+        const prepared = await prepareInfoflowImageBase64({ mediaUrl , mediaLocalRoots: paths });
+        if (prepared.isImage) {
+          const result = await sendInfoflowImageMessage({
+            cfg,
+            to,
+            base64Image: prepared.base64,
+            accountId,
+            replyTo: mediaReplyTo,
+          });
+          if (result.ok) {
+            if (mediaReplyTo) replyApplied = true;
+            statusSink?.({ lastOutboundAt: Date.now() });
+            continue;
+          }
+          logVerbose(`[infoflow] native image send failed: ${result.error}, falling back to link`);
+        }
+      } catch (err) {
+        logVerbose(`[infoflow] image prep failed, falling back to link: ${err}`);
+      }
+      // Fallback: send as link
+      await sendInfoflowMessage({
+        cfg,
+        to,
+        contents: [{ type: "link", content: mediaUrl }],
+        accountId,
+        replyTo: mediaReplyTo,
+      });
+      if (mediaReplyTo) replyApplied = true;
+    }
+  };
+
+  const onError = (err: unknown) => {
+    getInfoflowSendLog().error(
+      `[infoflow] reply error to=${to}, accountId=${accountId}: ${formatInfoflowError(err)}`,
+    );
+    // Send error hint so users know the bot didn't silently fail
+    sendInfoflowMessage({
+      cfg,
+      to,
+      contents: [{ type: "text", content: "处理出错，请稍后重试" }],
+      accountId,
+    }).catch(() => {});
+  };
+
+  return {
+    dispatcherOptions: {
+      ...prefixOptions,
+      deliver,
+      onError,
+    },
+    replyOptions: {
+      onModelSelected,
+    },
+  };
+}

package/src/adapter/outbound/target-resolver.ts

@@ -0,0 +1,109 @@
+/**
+ * Infoflow target resolution utilities.
+ * Handles user and group ID formats for message targeting.
+ */
+
+import { logVerbose } from "../../logging.js";
+
+// ---------------------------------------------------------------------------
+// Target Format Constants
+// ---------------------------------------------------------------------------
+
+/** Prefix for group targets: "group:123456" */
+const GROUP_PREFIX = "group:";
+
+/** Prefix for user targets (optional): "user:username" */
+const USER_PREFIX = "user:";
+
+// ---------------------------------------------------------------------------
+// Target Normalization
+// ---------------------------------------------------------------------------
+
+/**
+ * Normalizes an Infoflow target string.
+ * Strips channel prefix and normalizes format.
+ *
+ * Examples:
+ *   "infoflow:username" -> "username"
+ *   "infoflow:group:123456" -> "group:123456"
+ *   "user:username" -> "username"
+ *   "group:123456" -> "group:123456"
+ *   "username" -> "username"
+ *   "123456" -> "group:123456" (pure digits treated as group)
+ */
+export function normalizeInfoflowTarget(raw: string): string | undefined {
+  logVerbose(`[infoflow:normalizeTarget] input: "${raw}"`);
+
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    logVerbose(`[infoflow:normalizeTarget] empty input, returning undefined`);
+    return undefined;
+  }
+
+  // Strip infoflow: prefix
+  let target = trimmed.replace(/^infoflow:/i, "");
+
+  // Strip user: prefix (normalize to plain username)
+  if (target.toLowerCase().startsWith(USER_PREFIX)) {
+    target = target.slice(USER_PREFIX.length);
+  }
+
+  // Keep group: prefix as-is
+  if (target.toLowerCase().startsWith(GROUP_PREFIX)) {
+    logVerbose(`[infoflow:normalizeTarget] output: "${target}" (group)`);
+    return target;
+  }
+
+  // Pure digits -> treat as group ID
+  if (/^\d+$/.test(target)) {
+    const result = `${GROUP_PREFIX}${target}`;
+    logVerbose(`[infoflow:normalizeTarget] output: "${result}" (digits -> group)`);
+    return result;
+  }
+
+  // Otherwise it's a username
+  logVerbose(`[infoflow:normalizeTarget] output: "${target}" (username)`);
+  return target;
+}
+
+// ---------------------------------------------------------------------------
+// Target ID Detection
+// ---------------------------------------------------------------------------
+
+/**
+ * Checks if the input looks like a valid Infoflow target ID.
+ * Returns true if the system should use this value directly without directory lookup.
+ *
+ * Valid formats:
+ * - group:123456 (group ID with prefix)
+ * - user:username (user ID with prefix)
+ * - 123456789 (pure digits = group ID)
+ * - username (alphanumeric starting with letter = username/uuapName)
+ */
+export function looksLikeInfoflowId(raw: string): boolean {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return false;
+  }
+
+  // Strip infoflow: prefix for checking
+  const target = trimmed.replace(/^infoflow:/i, "");
+
+  // Explicit prefixes are always valid
+  if (/^(group|user):/i.test(target)) {
+    return true;
+  }
+
+  // Pure digits (group ID)
+  if (/^\d+$/.test(target)) {
+    return true;
+  }
+
+  // Alphanumeric starting with letter (username/uuapName)
+  // e.g., username, user123, testuser
+  if (/^[a-zA-Z][a-zA-Z0-9_]*$/.test(target)) {
+    return true;
+  }
+
+  return false;
+}

package/src/channel/accounts.ts

@@ -0,0 +1,164 @@
+/**
+ * Infoflow account resolution and configuration helpers.
+ * Handles multi-account support with config merging.
+ */
+
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, type OpenClawConfig } from "openclaw/plugin-sdk";
+import type { InfoflowAccountConfig, InfoflowConnectionMode, ResolvedInfoflowAccount } from "../types.js";
+
+// ---------------------------------------------------------------------------
+// Config Access Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Get the raw Infoflow channel section from config.
+ */
+export function getChannelSection(cfg: OpenClawConfig): InfoflowAccountConfig | undefined {
+  return cfg.channels?.["infoflow"] as InfoflowAccountConfig | undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Account ID Resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * List all configured Infoflow account IDs.
+ * Returns [DEFAULT_ACCOUNT_ID] if no accounts are configured (backward compatibility).
+ */
+export function listInfoflowAccountIds(cfg: OpenClawConfig): string[] {
+  const accounts = getChannelSection(cfg)?.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  const ids = Object.keys(accounts).filter(Boolean);
+  return ids.length === 0 ? [DEFAULT_ACCOUNT_ID] : ids.toSorted((a, b) => a.localeCompare(b));
+}
+
+/**
+ * Resolve the default account ID for Infoflow.
+ */
+export function resolveDefaultInfoflowAccountId(cfg: OpenClawConfig): string {
+  const channel = getChannelSection(cfg);
+  if (channel?.defaultAccount?.trim()) {
+    return channel.defaultAccount.trim();
+  }
+  const ids = listInfoflowAccountIds(cfg);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+
+// ---------------------------------------------------------------------------
+// Config Merging
+// ---------------------------------------------------------------------------
+
+/**
+ * Merge top-level Infoflow config with account-specific overrides.
+ * Account fields override base fields.
+ */
+function mergeInfoflowAccountConfig(
+  cfg: OpenClawConfig,
+  accountId: string,
+): {
+  apiHost: string;
+  checkToken: string;
+  encodingAESKey: string;
+  appKey: string;
+  appSecret: string;
+  enabled?: boolean;
+  name?: string;
+  connectionMode?: InfoflowConnectionMode;
+  wsGateway?: string;
+  robotName?: string;
+  requireMention?: boolean;
+  watchMentions?: string[];
+  watchRegex?: string;
+  appAgentId?: number;
+  dmMessageFormat?: "text" | "markdown";
+  groupMessageFormat?: "text" | "markdown";
+  dmPolicy?: string;
+  allowFrom?: string[];
+  groupPolicy?: string;
+  groupAllowFrom?: string[];
+} {
+  const raw = getChannelSection(cfg) ?? {};
+  const { accounts: _ignored, defaultAccount: _ignored2, ...base } = raw;
+  const account = raw.accounts?.[accountId] ?? {};
+  return { ...base, ...account } as {
+    apiHost: string;
+    checkToken: string;
+    encodingAESKey: string;
+    appKey: string;
+    appSecret: string;
+    enabled?: boolean;
+    name?: string;
+    connectionMode?: InfoflowConnectionMode;
+    wsGateway?: string;
+    robotName?: string;
+    requireMention?: boolean;
+    watchMentions?: string[];
+    watchRegex?: string;
+    appAgentId?: number;
+    dmMessageFormat?: "text" | "markdown";
+    groupMessageFormat?: "text" | "markdown";
+    dmPolicy?: string;
+    allowFrom?: string[];
+    groupPolicy?: string;
+    groupAllowFrom?: string[];
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Account Resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve a complete Infoflow account with merged config.
+ */
+export function resolveInfoflowAccount(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): ResolvedInfoflowAccount {
+  const accountId = normalizeAccountId(params.accountId);
+  const baseEnabled = getChannelSection(params.cfg)?.enabled !== false;
+  const merged = mergeInfoflowAccountConfig(params.cfg, accountId);
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const apiHost = merged.apiHost ?? "";
+  const checkToken = merged.checkToken ?? "";
+  const encodingAESKey = merged.encodingAESKey ?? "";
+  const appKey = merged.appKey ?? "";
+  const appSecret = merged.appSecret ?? "";
+  const configured =
+    Boolean(checkToken) && Boolean(encodingAESKey) && Boolean(appKey) && Boolean(appSecret);
+
+  return {
+    accountId,
+    name: merged.name?.trim() || undefined,
+    enabled,
+    configured,
+    config: {
+      enabled: merged.enabled,
+      name: merged.name,
+      apiHost,
+      checkToken,
+      encodingAESKey,
+      appKey,
+      appSecret,
+      connectionMode: merged.connectionMode,
+      wsGateway: merged.wsGateway,
+      robotName: merged.robotName?.trim() || undefined,
+      requireMention: merged.requireMention,
+      watchMentions: merged.watchMentions,
+      watchRegex: merged.watchRegex,
+      appAgentId: merged.appAgentId,
+      dmMessageFormat: merged.dmMessageFormat,
+      groupMessageFormat: merged.groupMessageFormat,
+      dmPolicy: merged.dmPolicy,
+      allowFrom: merged.allowFrom,
+      groupPolicy: merged.groupPolicy,
+      groupAllowFrom: merged.groupAllowFrom,
+    },
+  };
+}