@core-workspace/infoflow-openclaw-plugin 2026.3.8

package/src/channel/channel.ts

@@ -0,0 +1,364 @@
+import {
+  applyAccountNameToChannelSection,
+  DEFAULT_ACCOUNT_ID,
+  deleteAccountFromConfigSection,
+  formatPairingApproveHint,
+  migrateBaseNameToDefaultAccount,
+  normalizeAccountId,
+  setAccountEnabledInConfigSection,
+  type ChannelPlugin,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk";
+import {
+  getChannelSection,
+  listInfoflowAccountIds,
+  resolveDefaultInfoflowAccountId,
+  resolveInfoflowAccount,
+} from "./accounts.js";
+import { infoflowMessageActions } from "../tools/actions/index.js";
+import { logVerbose } from "../logging.js";
+import { prepareInfoflowImageBase64, sendInfoflowImageMessage } from "./media.js";
+import { startInfoflowMonitor, startInfoflowWSMonitor } from "./monitor.js";
+import { getInfoflowRuntime } from "../runtime.js";
+import { sendInfoflowMessage } from "./outbound.js";
+import { normalizeInfoflowTarget, looksLikeInfoflowId } from "../adapter/outbound/target-resolver.js";
+import type { ResolvedInfoflowAccount } from "../types.js";
+
+// Re-export types and account functions for external consumers
+export type { InfoflowAccountConfig, ResolvedInfoflowAccount } from "../types.js";
+export { resolveInfoflowAccount } from "./accounts.js";
+
+// ---------------------------------------------------------------------------
+// Channel plugin
+// ---------------------------------------------------------------------------
+
+export const infoflowPlugin: ChannelPlugin<ResolvedInfoflowAccount> = {
+  id: "infoflow",
+  meta: {
+    id: "infoflow",
+    label: "Infoflow",
+    selectionLabel: "Infoflow (如流)",
+    docsPath: "/channels/infoflow",
+    blurb: "Baidu Infoflow enterprise messaging platform.",
+    showConfigured: true,
+  },
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    nativeCommands: true,
+    unsend: true,
+  },
+  reload: { configPrefixes: ["channels.infoflow"] },
+  actions: infoflowMessageActions,
+  agentPrompt: {
+    messageToolHints: () => [
+      'Infoflow group @mentions: set atAll=true to @all members, or mentionUserIds="user1,user2" (comma-separated uuapName) to @mention specific users. Only effective for group targets (group:<id>).',
+      'Infoflow supports message recall (撤回): use action="delete" to recall the most recent message, or specify messageId to recall a specific message. Works for both private and group messages.',
+    ],
+  },
+  config: {
+    listAccountIds: (cfg) => listInfoflowAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveInfoflowAccount({ cfg, accountId }),
+    defaultAccountId: (cfg) => resolveDefaultInfoflowAccountId(cfg),
+    setAccountEnabled: ({ cfg, accountId, enabled }) =>
+      setAccountEnabledInConfigSection({
+        cfg,
+        sectionKey: "infoflow",
+        accountId,
+        enabled,
+        allowTopLevel: true,
+      }),
+    deleteAccount: ({ cfg, accountId }) =>
+      deleteAccountFromConfigSection({
+        cfg,
+        sectionKey: "infoflow",
+        accountId,
+        clearBaseFields: ["checkToken", "encodingAESKey", "appKey", "appSecret", "name"],
+      }),
+    isConfigured: (account) => account.configured,
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+    }),
+  },
+  security: {
+    resolveDmPolicy: ({ cfg, accountId, account }) => {
+      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
+      const channelCfg = getChannelSection(cfg);
+      const useAccountPath = Boolean(channelCfg?.accounts?.[resolvedAccountId]);
+      const basePath = useAccountPath
+        ? `channels.infoflow.accounts.${resolvedAccountId}.`
+        : "channels.infoflow.";
+
+      return {
+        policy: ((account.config as Record<string, unknown>).dmPolicy as string) ?? "open",
+        allowFrom: ((account.config as Record<string, unknown>).allowFrom as string[]) ?? [],
+        policyPath: `${basePath}dmPolicy`,
+        allowFromPath: basePath,
+        approveHint: formatPairingApproveHint("infoflow"),
+        normalizeEntry: (raw: string) => raw.replace(/^infoflow:/i, ""),
+      };
+    },
+    collectWarnings: ({ account, cfg }) => {
+      const warnings: string[] = [];
+      const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
+      const groupPolicy =
+        ((account.config as Record<string, unknown>).groupPolicy as string) ??
+        defaultGroupPolicy ??
+        "open";
+
+      if (groupPolicy === "open") {
+        warnings.push(
+          `- Infoflow groups: groupPolicy="open" allows any group to trigger. Consider setting channels.infoflow.groupPolicy="allowlist".`,
+        );
+      }
+      return warnings;
+    },
+  },
+  groups: {
+    resolveRequireMention: ({ cfg, accountId }) => {
+      const channelCfg = getChannelSection(cfg);
+      const accountCfg =
+        accountId && accountId !== DEFAULT_ACCOUNT_ID
+          ? channelCfg?.accounts?.[accountId]
+          : channelCfg;
+      return (accountCfg as Record<string, unknown> | undefined)?.requireMention !== false;
+    },
+    resolveToolPolicy: () => {
+      // Return undefined to use global policy
+      return undefined;
+    },
+  },
+  messaging: {
+    normalizeTarget: (raw) => normalizeInfoflowTarget(raw),
+    targetResolver: {
+      looksLikeId: looksLikeInfoflowId,
+      hint: "<username|group:groupId>",
+    },
+  },
+  setup: {
+    resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+    applyAccountName: ({ cfg, accountId, name }) =>
+      applyAccountNameToChannelSection({
+        cfg,
+        channelKey: "infoflow",
+        accountId,
+        name,
+      }),
+    validateInput: ({ input }) => {
+      if (!input.token) {
+        return "Infoflow requires --token (checkToken).";
+      }
+      return null;
+    },
+    applyAccountConfig: ({ cfg, accountId, input }) => {
+      const namedConfig = applyAccountNameToChannelSection({
+        cfg,
+        channelKey: "infoflow",
+        accountId,
+        name: input.name,
+      });
+      const next =
+        accountId !== DEFAULT_ACCOUNT_ID
+          ? migrateBaseNameToDefaultAccount({ cfg: namedConfig, channelKey: "infoflow" })
+          : namedConfig;
+
+      const patch: Record<string, unknown> = {};
+      if (input.token) {
+        patch.checkToken = input.token;
+      }
+
+      const existing = (next.channels?.["infoflow"] ?? {}) as Record<string, unknown>;
+      if (accountId === DEFAULT_ACCOUNT_ID) {
+        return {
+          ...next,
+          channels: {
+            ...next.channels,
+            infoflow: {
+              ...existing,
+              enabled: true,
+              ...patch,
+            },
+          },
+        } as OpenClawConfig;
+      }
+      const existingAccounts = (existing.accounts ?? {}) as Record<string, Record<string, unknown>>;
+      return {
+        ...next,
+        channels: {
+          ...next.channels,
+          infoflow: {
+            ...existing,
+            enabled: true,
+            accounts: {
+              ...existingAccounts,
+              [accountId]: {
+                ...existingAccounts[accountId],
+                enabled: true,
+                ...patch,
+              },
+            },
+          },
+        },
+      } as OpenClawConfig;
+    },
+  },
+  outbound: {
+    deliveryMode: "direct",
+    chunkerMode: "markdown",
+    textChunkLimit: 4000,
+    chunker: (text, limit) => getInfoflowRuntime().channel.text.chunkText(text, limit),
+    sendText: async ({ cfg, to, text, accountId }) => {
+      logVerbose(`[infoflow:sendText] to=${to}, accountId=${accountId}`);
+      // Use "markdown" type even though param is named `text`: LLM outputs are often markdown,
+      // and Infoflow's markdown type handles both plain text and markdown seamlessly.
+      const result = await sendInfoflowMessage({
+        cfg,
+        to,
+        contents: [{ type: "markdown", content: text }],
+        accountId: accountId ?? undefined,
+      });
+      return {
+        channel: "infoflow",
+        messageId: result.ok ? (result.messageId ?? "sent") : "failed",
+      };
+    },
+    sendMedia: async ({ cfg, to, text, mediaUrl, accountId, mediaLocalRoots }) => {
+      logVerbose(`[infoflow:sendMedia] to=${to}, accountId=${accountId}, mediaUrl=${mediaUrl}`);
+
+      const trimmedText = text?.trim();
+
+      // Helper: send text as markdown
+      const sendText = () =>
+        sendInfoflowMessage({
+          cfg,
+          to,
+          contents: [{ type: "markdown", content: trimmedText! }],
+          accountId: accountId ?? undefined,
+        });
+
+      // Helper: attempt native image send, fall back to link
+      const sendImage = async (): Promise<{ ok: boolean; messageId?: string }> => {
+        if (!mediaUrl) return { ok: false };
+        try {
+          const prepared = await prepareInfoflowImageBase64({
+            mediaUrl,
+            mediaLocalRoots: mediaLocalRoots ?? undefined,
+          });
+          if (prepared.isImage) {
+            const result = await sendInfoflowImageMessage({
+              cfg,
+              to,
+              base64Image: prepared.base64,
+              accountId: accountId ?? undefined,
+            });
+            if (result.ok) return { ok: true, messageId: result.messageId };
+            // Native send failed, fall back to link
+            logVerbose(
+              `[infoflow:sendMedia] native image failed: ${result.error}, falling back to link`,
+            );
+          }
+        } catch (err) {
+          logVerbose(`[infoflow:sendMedia] image prep failed, falling back to link: ${err}`);
+        }
+        // Fallback: send as link
+        const linkResult = await sendInfoflowMessage({
+          cfg,
+          to,
+          contents: [{ type: "link", content: mediaUrl }],
+          accountId: accountId ?? undefined,
+        });
+        return { ok: linkResult.ok, messageId: linkResult.messageId };
+      };
+
+      // Dispatch: concurrent text + image, or text-only, or image-only
+      if (trimmedText && mediaUrl) {
+        const [, imageResult] = await Promise.all([sendText(), sendImage()]);
+        return {
+          channel: "infoflow",
+          messageId: imageResult.ok ? (imageResult.messageId ?? "sent") : "failed",
+        };
+      }
+      if (trimmedText) {
+        const result = await sendText();
+        return {
+          channel: "infoflow",
+          messageId: result.ok ? (result.messageId ?? "sent") : "failed",
+        };
+      }
+      if (mediaUrl) {
+        const result = await sendImage();
+        return {
+          channel: "infoflow",
+          messageId: result.ok ? (result.messageId ?? "sent") : "failed",
+        };
+      }
+
+      return { channel: "infoflow", messageId: "failed" };
+    },
+  },
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastError: null,
+    },
+    buildAccountSnapshot: ({ account, runtime }) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+      running: runtime?.running ?? false,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+      lastInboundAt: runtime?.lastInboundAt ?? null,
+      lastOutboundAt: runtime?.lastOutboundAt ?? null,
+    }),
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const account = ctx.account;
+      const connectionMode = account.config.connectionMode ?? "webhook";
+      ctx.log?.info(`[${account.accountId}] starting Infoflow ${connectionMode}`);
+      ctx.setStatus({
+        accountId: account.accountId,
+        running: true,
+        lastStartAt: Date.now(),
+      });
+
+      const monitorOptions = {
+        account,
+        config: ctx.cfg,
+        runtime: ctx.runtime,
+        abortSignal: ctx.abortSignal,
+        statusSink: (patch: Record<string, unknown>) =>
+          ctx.setStatus({ accountId: account.accountId, ...patch }),
+      };
+
+      const unregister =
+        connectionMode === "websocket"
+          ? await startInfoflowWSMonitor(monitorOptions)
+          : await startInfoflowMonitor(monitorOptions);
+
+      // Keep the channel alive until explicitly stopped.
+      // Without this, the promise resolves immediately and the gateway
+      // framework treats it as "channel exited", triggering auto-restart.
+      try {
+        await new Promise<void>((resolve) => {
+          ctx.abortSignal.addEventListener("abort", () => resolve(), { once: true });
+        });
+      } finally {
+        unregister?.();
+        ctx.setStatus({
+          accountId: account.accountId,
+          running: false,
+          lastStopAt: Date.now(),
+        });
+      }
+    },
+  },
+};