@chbo297/infoflow 2026.3.2 → 2026.3.6

package/src/media.ts

@@ -0,0 +1,367 @@
+/**
+ * Infoflow native image sending: compress, base64-encode, and POST via Infoflow API.
+ */
+
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { resolveInfoflowAccount } from "./accounts.js";
+import { recordSentMessageId } from "./infoflow-req-parse.js";
+import { getInfoflowSendLog, formatInfoflowError, logVerbose } from "./logging.js";
+import { getInfoflowRuntime } from "./runtime.js";
+import {
+  getAppAccessToken,
+  ensureHttps,
+  extractIdFromRawJson,
+  DEFAULT_TIMEOUT_MS,
+  INFOFLOW_PRIVATE_SEND_PATH,
+  INFOFLOW_GROUP_SEND_PATH,
+} from "./send.js";
+import { recordSentMessage } from "./sent-message-store.js";
+import type { ResolvedInfoflowAccount, InfoflowOutboundReply } from "./types.js";
+
+/** Infoflow API image size limit: 1MB raw bytes */
+const INFOFLOW_IMAGE_MAX_BYTES = 1 * 1024 * 1024;
+
+// Compression grid: progressively smaller maxSide and quality
+const COMPRESS_SIDES = [2048, 1536, 1280, 1024, 800];
+const COMPRESS_QUALITIES = [80, 70, 60, 50, 40];
+
+// ---------------------------------------------------------------------------
+// Image compression
+// ---------------------------------------------------------------------------
+
+/**
+ * Compresses an image buffer to fit within the Infoflow 1MB limit.
+ * Returns null if compression fails (e.g. GIF > 1MB, or all combos exceed limit).
+ */
+export async function compressImageForInfoflow(params: {
+  buffer: Buffer;
+  contentType?: string;
+}): Promise<Buffer | null> {
+  const { buffer, contentType } = params;
+
+  // Already within limit
+  if (buffer.length <= INFOFLOW_IMAGE_MAX_BYTES) {
+    return buffer;
+  }
+
+  // GIF cannot be compressed without losing animation
+  if (contentType === "image/gif") {
+    logVerbose(`[infoflow:media] GIF exceeds 1MB (${buffer.length} bytes), cannot compress`);
+    return null;
+  }
+
+  const runtime = getInfoflowRuntime();
+  let smallest: { buffer: Buffer; size: number } | null = null;
+
+  for (const side of COMPRESS_SIDES) {
+    for (const quality of COMPRESS_QUALITIES) {
+      try {
+        const out = await runtime.media.resizeToJpeg({
+          buffer,
+          maxSide: side,
+          quality,
+          withoutEnlargement: true,
+        });
+        const size = out.length;
+        if (size <= INFOFLOW_IMAGE_MAX_BYTES) {
+          logVerbose(
+            `[infoflow:media] compressed ${buffer.length} → ${size} bytes (side≤${side}, q=${quality})`,
+          );
+          return out;
+        }
+        if (!smallest || size < smallest.size) {
+          smallest = { buffer: out, size };
+        }
+      } catch {
+        // skip failed combo
+      }
+    }
+  }
+
+  logVerbose(
+    `[infoflow:media] all compression combos exceed 1MB (smallest: ${smallest?.size ?? "N/A"} bytes)`,
+  );
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Prepare image as base64
+// ---------------------------------------------------------------------------
+
+export type PrepareImageResult = { isImage: true; base64: string } | { isImage: false };
+
+/**
+ * Downloads media, checks if it's an image, compresses to 1MB, and base64-encodes.
+ */
+export async function prepareInfoflowImageBase64(params: {
+  mediaUrl: string;
+  mediaLocalRoots?: readonly string[];
+}): Promise<PrepareImageResult> {
+  const { mediaUrl, mediaLocalRoots } = params;
+  const runtime = getInfoflowRuntime();
+
+  // Download media
+  const loaded = await runtime.media.loadWebMedia(mediaUrl, {
+    maxBytes: 30 * 1024 * 1024, // 30MB download limit
+    optimizeImages: false,
+    localRoots: mediaLocalRoots?.length ? mediaLocalRoots : undefined,
+  });
+
+  // Check if it's an image
+  const kind = runtime.media.mediaKindFromMime(loaded.contentType ?? undefined);
+  if (kind !== "image") {
+    return { isImage: false };
+  }
+
+  // Compress if needed
+  const compressed = await compressImageForInfoflow({
+    buffer: loaded.buffer,
+    contentType: loaded.contentType ?? undefined,
+  });
+
+  if (!compressed) {
+    return { isImage: false }; // compression failed, fall back to link
+  }
+
+  return { isImage: true, base64: compressed.toString("base64") };
+}
+
+// ---------------------------------------------------------------------------
+// Send image messages
+// ---------------------------------------------------------------------------
+
+/**
+ * Sends a native image message to a group chat.
+ */
+export async function sendInfoflowGroupImage(params: {
+  account: ResolvedInfoflowAccount;
+  groupId: number;
+  base64Image: string;
+  replyTo?: InfoflowOutboundReply;
+  timeoutMs?: number;
+}): Promise<{ ok: boolean; error?: string; messageid?: string }> {
+  const { account, groupId, base64Image, timeoutMs = DEFAULT_TIMEOUT_MS } = params;
+  const { apiHost, appKey, appSecret } = account.config;
+
+  if (!appKey || !appSecret) {
+    return { ok: false, error: "Infoflow appKey/appSecret not configured." };
+  }
+
+  const tokenResult = await getAppAccessToken({ apiHost, appKey, appSecret, timeoutMs });
+  if (!tokenResult.ok || !tokenResult.token) {
+    getInfoflowSendLog().error(`[infoflow:sendGroupImage] token error: ${tokenResult.error}`);
+    return { ok: false, error: tokenResult.error ?? "failed to get token" };
+  }
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const controller = new AbortController();
+    timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+    const payload = {
+      message: {
+        header: {
+          toid: groupId,
+          totype: "GROUP",
+          msgtype: "IMAGE",
+          clientmsgid: Date.now(),
+          role: "robot",
+        },
+        body: [{ type: "IMAGE", content: base64Image }],
+        ...(params.replyTo
+          ? {
+              reply: {
+                messageid: params.replyTo.messageid,
+                preview: params.replyTo.preview ?? "",
+                replytype: params.replyTo.replytype ?? "1",
+              },
+            }
+          : {}),
+      },
+    };
+
+    const headers = {
+      Authorization: `Bearer-${tokenResult.token}`,
+      "Content-Type": "application/json",
+    };
+
+    logVerbose(
+      `[infoflow:sendGroupImage] POST to group ${groupId}, image size: ${base64Image.length} chars`,
+    );
+
+    const res = await fetch(`${ensureHttps(apiHost)}${INFOFLOW_GROUP_SEND_PATH}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: controller.signal,
+    });
+
+    const responseText = await res.text();
+    const data = JSON.parse(responseText) as Record<string, unknown>;
+    logVerbose(`[infoflow:sendGroupImage] response: status=${res.status}, data=${responseText}`);
+
+    const code = typeof data.code === "string" ? data.code : "";
+    if (code !== "ok") {
+      const errMsg = String(data.message ?? data.errmsg ?? `code=${code || "unknown"}`);
+      getInfoflowSendLog().error(`[infoflow:sendGroupImage] failed: ${errMsg}`);
+      return { ok: false, error: errMsg };
+    }
+
+    const innerData = data.data as Record<string, unknown> | undefined;
+    const errcode = innerData?.errcode;
+    if (errcode != null && errcode !== 0) {
+      const errMsg = String(innerData?.errmsg ?? `errcode ${errcode}`);
+      getInfoflowSendLog().error(`[infoflow:sendGroupImage] failed: ${errMsg}`);
+      return { ok: false, error: errMsg };
+    }
+
+    // Extract IDs from raw text to preserve large integer precision
+    const messageid =
+      extractIdFromRawJson(responseText, "messageid") ??
+      extractIdFromRawJson(responseText, "msgid");
+    const msgseqid = extractIdFromRawJson(responseText, "msgseqid");
+    if (messageid) {
+      recordSentMessageId(messageid);
+      try {
+        recordSentMessage(account.accountId, {
+          target: `group:${groupId}`,
+          messageid,
+          msgseqid: msgseqid ?? "",
+          digest: "image",
+          sentAt: Date.now(),
+        });
+      } catch {
+        // Do not block sending
+      }
+    }
+
+    return { ok: true, messageid };
+  } catch (err) {
+    const errMsg = formatInfoflowError(err);
+    getInfoflowSendLog().error(`[infoflow:sendGroupImage] exception: ${errMsg}`);
+    return { ok: false, error: errMsg };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * Sends a native image message to a private (DM) chat.
+ */
+export async function sendInfoflowPrivateImage(params: {
+  account: ResolvedInfoflowAccount;
+  toUser: string;
+  base64Image: string;
+  timeoutMs?: number;
+}): Promise<{ ok: boolean; error?: string; msgkey?: string }> {
+  const { account, toUser, base64Image, timeoutMs = DEFAULT_TIMEOUT_MS } = params;
+  const { apiHost, appKey, appSecret } = account.config;
+
+  if (!appKey || !appSecret) {
+    return { ok: false, error: "Infoflow appKey/appSecret not configured." };
+  }
+
+  const tokenResult = await getAppAccessToken({ apiHost, appKey, appSecret, timeoutMs });
+  if (!tokenResult.ok || !tokenResult.token) {
+    getInfoflowSendLog().error(`[infoflow:sendPrivateImage] token error: ${tokenResult.error}`);
+    return { ok: false, error: tokenResult.error ?? "failed to get token" };
+  }
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const controller = new AbortController();
+    timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+    const payload = {
+      touser: toUser,
+      msgtype: "image",
+      image: { content: base64Image },
+    };
+
+    const headers = {
+      Authorization: `Bearer-${tokenResult.token}`,
+      "Content-Type": "application/json",
+    };
+
+    logVerbose(
+      `[infoflow:sendPrivateImage] POST to user ${toUser}, image size: ${base64Image.length} chars`,
+    );
+
+    const res = await fetch(`${ensureHttps(apiHost)}${INFOFLOW_PRIVATE_SEND_PATH}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: controller.signal,
+    });
+
+    const responseText = await res.text();
+    const data = JSON.parse(responseText) as Record<string, unknown>;
+    logVerbose(`[infoflow:sendPrivateImage] response: status=${res.status}, data=${responseText}`);
+
+    if (data.errcode && data.errcode !== 0) {
+      const errMsg = String(data.errmsg ?? `errcode ${data.errcode}`);
+      getInfoflowSendLog().error(`[infoflow:sendPrivateImage] failed: ${errMsg}`);
+      return { ok: false, error: errMsg };
+    }
+
+    // Extract msgkey from raw text to preserve large integer precision
+    const msgkey =
+      extractIdFromRawJson(responseText, "msgkey") ??
+      (data.msgkey != null ? String(data.msgkey) : undefined);
+    if (msgkey) {
+      recordSentMessageId(msgkey);
+      try {
+        recordSentMessage(account.accountId, {
+          target: toUser,
+          messageid: msgkey,
+          msgseqid: "",
+          digest: "image",
+          sentAt: Date.now(),
+        });
+      } catch {
+        // Do not block sending
+      }
+    }
+
+    return { ok: true, msgkey };
+  } catch (err) {
+    const errMsg = formatInfoflowError(err);
+    getInfoflowSendLog().error(`[infoflow:sendPrivateImage] exception: ${errMsg}`);
+    return { ok: false, error: errMsg };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * Unified image message sender. Parses target and dispatches to group or private.
+ */
+export async function sendInfoflowImageMessage(params: {
+  cfg: OpenClawConfig;
+  to: string;
+  base64Image: string;
+  accountId?: string;
+  replyTo?: InfoflowOutboundReply;
+}): Promise<{ ok: boolean; error?: string; messageId?: string }> {
+  const { cfg, to, base64Image, accountId } = params;
+  const account = resolveInfoflowAccount({ cfg, accountId });
+
+  // Parse target: remove "infoflow:" prefix if present
+  const target = to.replace(/^infoflow:/i, "");
+
+  const groupMatch = target.match(/^group:(\d+)/i);
+  if (groupMatch) {
+    const groupId = Number(groupMatch[1]);
+    const result = await sendInfoflowGroupImage({
+      account,
+      groupId,
+      base64Image,
+      replyTo: params.replyTo,
+    });
+    return { ok: result.ok, error: result.error, messageId: result.messageid };
+  }
+
+  // Private message (replyTo not supported)
+  const result = await sendInfoflowPrivateImage({ account, toUser: target, base64Image });
+  return { ok: result.ok, error: result.error, messageId: result.msgkey };
+}

package/src/monitor.ts

@@ -65,7 +65,7 @@ function registerInfoflowWebhookTarget(target: WebhookTarget): () => void {
 }
 
 // ---------------------------------------------------------------------------
-// HTTP handler (registered via api.registerHttpHandler)
+// HTTP handler (registered via api.registerHttpRoute)
 // ---------------------------------------------------------------------------
 
 /**

package/src/reply-dispatcher.ts

@@ -4,9 +4,23 @@ import {
   type ReplyPayload,
 } from "openclaw/plugin-sdk";
 import { getInfoflowSendLog, formatInfoflowError, logVerbose } from "./logging.js";
+import { prepareInfoflowImageBase64, sendInfoflowImageMessage } from "./media.js";
 import { getInfoflowRuntime } from "./runtime.js";
 import { sendInfoflowMessage } from "./send.js";
-import type { InfoflowAtOptions, InfoflowMentionIds, InfoflowMessageContentItem } from "./types.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;
@@ -19,6 +33,10 @@ export type CreateInfoflowReplyDispatcherParams = {
   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;
 };
 
 /**
@@ -26,7 +44,17 @@ export type CreateInfoflowReplyDispatcherParams = {
  * 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 } = params;
+  const {
+    cfg,
+    agentId,
+    accountId,
+    to,
+    statusSink,
+    atOptions,
+    mentionIds,
+    replyToMessageId,
+    replyToPreview,
+  } = params;
   const core = getInfoflowRuntime();
 
   const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
@@ -50,91 +78,153 @@ export function createInfoflowReplyDispatcher(params: CreateInfoflowReplyDispatc
     }
   }
 
+  // Build replyTo context (only used for the first outbound message)
+  const replyTo: InfoflowOutboundReply | undefined =
+    isGroup && replyToMessageId
+      ? { messageid: replyToMessageId, preview: truncatePreview(replyToPreview) }
+      : undefined;
+  let replyApplied = false;
+
   const deliver = async (payload: ReplyPayload) => {
     const text = payload.text ?? "";
     logVerbose(`[infoflow] deliver called: to=${to}, text=${text}`);
-    if (!text.trim()) {
+
+    // Normalize media URL list (same pattern as Feishu reply-dispatcher)
+    const mediaList =
+      payload.mediaUrls && payload.mediaUrls.length > 0
+        ? payload.mediaUrls
+        : payload.mediaUrl
+          ? [payload.mediaUrl]
+          : [];
+
+    if (!text.trim() && mediaList.length === 0) {
       return;
     }
 
-    // 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);
+    // --- 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);
+      // 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;
-
-    // Prepend AT mentions to the text if needed (group messages only)
-    // Only prepend for atOptions IDs; LLM text already contains @id for resolved mentions
-    let messageText = text;
-    if (isGroup && atOptions) {
-      let atPrefix = "";
-      if (hasAtAll) {
-        atPrefix = "@all ";
-      } else if (atOptions.atUserIds?.length) {
-        atPrefix = atOptions.atUserIds.map((id) => `@${id}`).join(" ") + " ";
+      const hasAtAll = atOptions?.atAll === true;
+      const hasAtUsers = allAtUserIds.length > 0;
+      const hasAtAgents = resolvedAgentIds.length > 0;
+
+      // Prepend AT mentions to the text if needed (group messages only)
+      // Only prepend for atOptions IDs; LLM text already contains @id for resolved mentions
+      let messageText = text;
+      if (isGroup && atOptions) {
+        let atPrefix = "";
+        if (hasAtAll) {
+          atPrefix = "@all ";
+        } else if (atOptions.atUserIds?.length) {
+          atPrefix = atOptions.atUserIds.map((id) => `@${id}`).join(" ") + " ";
+        }
+        messageText = atPrefix + text;
       }
-      messageText = atPrefix + 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;
+      // 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[] = [];
+      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(",") });
+        // 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(",") });
+          }
         }
-        if (hasAtAgents) {
-          contents.push({ type: "at-agent", content: resolvedAgentIds.join(",") });
+        isFirstChunk = false;
+
+        // Add markdown content
+        contents.push({ type: "markdown", content: chunk });
+
+        // Only include replyTo on the first outbound message
+        const chunkReplyTo = !replyApplied ? replyTo : undefined;
+        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}`,
+          );
         }
       }
-      isFirstChunk = false;
-
-      // Add markdown content
-      contents.push({ type: "markdown", content: chunk });
-
-      const result = await sendInfoflowMessage({ cfg, to, contents, accountId });
+    }
 
-      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 prepared = await prepareInfoflowImageBase64({ mediaUrl });
+        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;
     }
   };