@chbo297/infoflow 2026.3.18 → 2026.5.4

package/dist/src/media.js

@@ -0,0 +1,318 @@
+/**
+ * Infoflow native image sending: compress, base64-encode, and POST via Infoflow API.
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+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, buildAgentFrom } from "./sent-message-store.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) {
+    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 = 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;
+}
+function isLocalMediaUrl(url) {
+    const t = url.trim();
+    return (t.startsWith("file://") ||
+        t.startsWith("/") ||
+        t.startsWith("./") ||
+        t.startsWith("../") ||
+        t.startsWith("~"));
+}
+/**
+ * Downloads media, checks if it's an image, compresses to 1MB, and base64-encodes.
+ * For local paths, passes the file's parent directory as localRoots so any path is allowed
+ * (infoflow-only; does not change shared media layer).
+ */
+export async function prepareInfoflowImageBase64(params) {
+    const { mediaUrl, mediaLocalRoots } = params;
+    const runtime = getInfoflowRuntime();
+    let localRoots;
+    if (isLocalMediaUrl(mediaUrl)) {
+        let absPath;
+        if (mediaUrl.trim().startsWith("file://")) {
+            try {
+                absPath = fileURLToPath(mediaUrl.trim());
+            }
+            catch {
+                absPath = path.resolve(mediaUrl.replace(/^file:\/\//i, ""));
+            }
+        }
+        else {
+            absPath = path.resolve(mediaUrl.trim());
+        }
+        const dir = path.dirname(absPath);
+        if (dir && dir !== path.parse(dir).root) {
+            localRoots = [dir];
+        }
+        else {
+            localRoots = mediaLocalRoots?.length ? [...mediaLocalRoots] : undefined;
+        }
+    }
+    else {
+        localRoots = mediaLocalRoots?.length ? [...mediaLocalRoots] : undefined;
+    }
+    const loaded = await runtime.media.loadWebMedia(mediaUrl, {
+        maxBytes: 30 * 1024 * 1024, // 30MB download limit
+        optimizeImages: false,
+        localRoots: localRoots ?? 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) {
+    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;
+    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);
+        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;
+        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}`,
+                    from: buildAgentFrom(account.config.appAgentId),
+                    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) {
+    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;
+    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);
+        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,
+                    from: buildAgentFrom(account.config.appAgentId),
+                    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) {
+    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/dist/src/monitor.js

@@ -0,0 +1,145 @@
+import { parseAndDispatchInfoflowRequest, loadRawBody, } from "./infoflow-req-parse.js";
+import { getInfoflowWebhookLog, formatInfoflowError, logVerbose } from "./logging.js";
+import { getInfoflowRuntime } from "./runtime.js";
+import { InfoflowWSReceiver } from "./ws-receiver.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** webhook path for Infoflow. */
+const INFOFLOW_WEBHOOK_PATH = "/webhook/infoflow";
+// ---------------------------------------------------------------------------
+// Webhook target registry
+// ---------------------------------------------------------------------------
+const webhookTargets = new Map();
+/** Normalizes a webhook path: trim, ensure leading slash, strip trailing slash (except "/"). */
+function normalizeWebhookPath(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return "/";
+    }
+    const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    if (withSlash.length > 1 && withSlash.endsWith("/")) {
+        return withSlash.slice(0, -1);
+    }
+    return withSlash;
+}
+/** Registers a webhook target for a path. Returns an unregister function to remove it. */
+function registerInfoflowWebhookTarget(target) {
+    const key = normalizeWebhookPath(target.path);
+    const normalizedTarget = { ...target, path: key };
+    const existing = webhookTargets.get(key) ?? [];
+    const next = [...existing, normalizedTarget];
+    webhookTargets.set(key, next);
+    return () => {
+        const updated = (webhookTargets.get(key) ?? []).filter((entry) => entry !== normalizedTarget);
+        if (updated.length > 0) {
+            webhookTargets.set(key, updated);
+        }
+        else {
+            webhookTargets.delete(key);
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// HTTP handler (registered via api.registerHttpRoute)
+// ---------------------------------------------------------------------------
+/**
+ * Checks if the request path matches a registered Infoflow webhook path.
+ */
+function isInfoflowPath(requestPath) {
+    const normalized = normalizeWebhookPath(requestPath);
+    return webhookTargets.has(normalized);
+}
+/**
+ * Handles incoming Infoflow webhook HTTP requests.
+ *
+ * - Routes by path to registered targets (exact match).
+ * - Only allows POST.
+ * - Delegates body reading, echostr verification, authentication,
+ *   and message dispatch to infoflow_req_parse.
+ */
+export async function handleInfoflowWebhookRequest(req, res) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const requestPath = normalizeWebhookPath(url.pathname);
+    // Log the full request URL
+    logVerbose(`[infoflow] request: url=${url}`);
+    // Check if path matches Infoflow webhook pattern
+    if (!isInfoflowPath(requestPath)) {
+        return false;
+    }
+    // Get registered targets for the actual request path
+    const targets = webhookTargets.get(requestPath);
+    if (!targets || targets.length === 0) {
+        return false;
+    }
+    if (req.method !== "POST") {
+        res.statusCode = 405;
+        res.setHeader("Allow", "POST");
+        res.end("Method Not Allowed");
+        return true;
+    }
+    // Load raw body once
+    const bodyResult = await loadRawBody(req);
+    if (!bodyResult.ok) {
+        getInfoflowWebhookLog().error(`[infoflow] failed to read body: ${bodyResult.error}`);
+        res.statusCode = bodyResult.error === "payload too large" ? 413 : 400;
+        res.end(bodyResult.error);
+        return true;
+    }
+    let result;
+    try {
+        result = await parseAndDispatchInfoflowRequest(req, bodyResult.raw, targets);
+    }
+    catch (err) {
+        getInfoflowWebhookLog().error(`[infoflow] webhook handler error: ${formatInfoflowError(err)}`);
+        res.statusCode = 500;
+        res.end("internal error");
+        return true;
+    }
+    logVerbose(`[infoflow] dispatch result: handled=${result.handled}, status=${result.handled ? result.statusCode : "N/A"}`);
+    if (result.handled) {
+        const looksLikeJson = result.body.startsWith("{");
+        if (looksLikeJson) {
+            res.setHeader("Content-Type", "application/json");
+        }
+        res.statusCode = result.statusCode;
+        res.end(result.body);
+    }
+    else {
+        res.statusCode = 200;
+        res.end("OK");
+    }
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Monitor lifecycle
+// ---------------------------------------------------------------------------
+/** Registers this account's webhook target and returns an unregister (stop) function. */
+export async function startInfoflowMonitor(options) {
+    const core = getInfoflowRuntime();
+    const unregister = registerInfoflowWebhookTarget({
+        account: options.account,
+        config: options.config,
+        core,
+        path: INFOFLOW_WEBHOOK_PATH,
+        statusSink: options.statusSink,
+    });
+    return unregister;
+}
+/** Starts a WebSocket message receiver and returns a stop function. */
+export async function startInfoflowWSMonitor(options) {
+    const receiver = new InfoflowWSReceiver({
+        account: options.account,
+        config: options.config,
+        abortSignal: options.abortSignal,
+        statusSink: options.statusSink,
+    });
+    try {
+        await receiver.start();
+    }
+    catch (err) {
+        receiver.stop();
+        throw err;
+    }
+    return () => receiver.stop();
+}