@chbo297/infoflow 2026.3.18 → 2026.5.4

package/dist/src/sent-message-store.js

@@ -0,0 +1,190 @@
+/**
+ * SQLite-backed persistent store for sent message IDs.
+ * Records messageid + msgseqid for every outbound message so that
+ * recall (撤回) can look up any sub-message, including those from split sends.
+ *
+ * Uses Node 22+ built-in `node:sqlite` (DatabaseSync, synchronous API).
+ */
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { getInfoflowRuntime } from "./runtime.js";
+const require = createRequire(import.meta.url);
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const DB_FILENAME = "sent-messages.db";
+const AUTO_CLEANUP_DAYS = 7;
+const AUTO_CLEANUP_MS = AUTO_CLEANUP_DAYS * 24 * 60 * 60 * 1000;
+// ---------------------------------------------------------------------------
+// DB singleton (lazy-init)
+// ---------------------------------------------------------------------------
+let db = null;
+function resolveDbPath() {
+    const env = process.env;
+    const stateDir = getInfoflowRuntime().state.resolveStateDir(env, os.homedir);
+    return path.join(stateDir, "infoflow", DB_FILENAME);
+}
+function getDb() {
+    if (db)
+        return db;
+    const dbPath = resolveDbPath();
+    const dir = path.dirname(dbPath);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const sqlite = require("node:sqlite");
+    db = new sqlite.DatabaseSync(dbPath);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS sent_messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      account_id TEXT NOT NULL,
+      target TEXT NOT NULL,
+      from_id TEXT NOT NULL DEFAULT '',
+      messageid TEXT NOT NULL,
+      msgseqid TEXT NOT NULL DEFAULT '',
+      digest TEXT NOT NULL DEFAULT '',
+      sent_at INTEGER NOT NULL
+    );
+  `);
+    db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_target_sent
+      ON sent_messages(account_id, target, sent_at DESC);
+  `);
+    // Migration: add from_id column to existing databases
+    try {
+        db.exec(`ALTER TABLE sent_messages ADD COLUMN from_id TEXT NOT NULL DEFAULT ''`);
+    }
+    catch {
+        // Column already exists — ignore
+    }
+    return db;
+}
+/**
+ * Records a sent message. Also runs auto-cleanup of old records.
+ * Synchronous (DatabaseSync); failures are swallowed so sending is never blocked.
+ */
+export function recordSentMessage(accountId, record) {
+    try {
+        const d = getDb();
+        d.prepare(`INSERT INTO sent_messages (account_id, target, from_id, messageid, msgseqid, digest, sent_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`).run(accountId, record.target, record.from, record.messageid, record.msgseqid, record.digest, record.sentAt);
+        // Auto-cleanup: delete records older than 7 days
+        const cutoff = Date.now() - AUTO_CLEANUP_MS;
+        d.prepare(`DELETE FROM sent_messages WHERE sent_at < ? AND account_id = ?`).run(cutoff, accountId);
+    }
+    catch {
+        // Silently ignore — do not block sending
+    }
+}
+/**
+ * Queries the most recent N sent messages for a given target, ordered by sent_at DESC.
+ */
+export function querySentMessages(accountId, params) {
+    const d = getDb();
+    const rows = d
+        .prepare(`SELECT target, from_id, messageid, msgseqid, digest, sent_at
+       FROM sent_messages
+       WHERE account_id = ? AND target = ?
+       ORDER BY sent_at DESC
+       LIMIT ?`)
+        .all(accountId, params.target, params.count);
+    return rows.map((r) => ({
+        target: r.target,
+        from: r.from_id,
+        messageid: r.messageid,
+        msgseqid: r.msgseqid,
+        digest: r.digest,
+        sentAt: r.sent_at,
+    }));
+}
+/**
+ * Finds a single sent message by messageid.
+ */
+export function findSentMessage(accountId, messageid) {
+    const d = getDb();
+    const row = d
+        .prepare(`SELECT target, from_id, messageid, msgseqid, digest, sent_at
+       FROM sent_messages
+       WHERE account_id = ? AND messageid = ?
+       LIMIT 1`)
+        .get(accountId, messageid);
+    if (!row)
+        return undefined;
+    return {
+        target: row.target,
+        from: row.from_id,
+        messageid: row.messageid,
+        msgseqid: row.msgseqid,
+        digest: row.digest,
+        sentAt: row.sent_at,
+    };
+}
+/**
+ * Removes recalled messages from the store by their messageids.
+ */
+export function removeRecalledMessages(accountId, messageids) {
+    if (messageids.length === 0)
+        return;
+    const d = getDb();
+    const placeholders = messageids.map(() => "?").join(",");
+    d.prepare(`DELETE FROM sent_messages WHERE account_id = ? AND messageid IN (${placeholders})`).run(accountId, ...messageids);
+}
+// ---------------------------------------------------------------------------
+// From-ID builder
+// ---------------------------------------------------------------------------
+/** Builds a `from` identifier for self-sent (agent) messages. */
+export function buildAgentFrom(appAgentId) {
+    return appAgentId != null ? `agent:${appAgentId}` : "agent:unknown";
+}
+// ---------------------------------------------------------------------------
+// Digest builder
+// ---------------------------------------------------------------------------
+const DIGEST_MAX_LEN = 100;
+/**
+ * Builds a short digest string from message contents.
+ * - Text/markdown/link: first 100 chars, truncated with "…"
+ * - Image only: "image"
+ * - Empty: ""
+ */
+export function buildMessageDigest(contents) {
+    const textParts = [];
+    let hasImage = false;
+    for (const item of contents) {
+        const type = item.type.toLowerCase();
+        if (type === "text" || type === "md" || type === "markdown") {
+            textParts.push(item.content);
+        }
+        else if (type === "link") {
+            textParts.push(item.content);
+        }
+        else if (type === "image") {
+            hasImage = true;
+        }
+    }
+    const merged = textParts.join(" ").trim();
+    if (merged) {
+        return merged.length > DIGEST_MAX_LEN ? merged.slice(0, DIGEST_MAX_LEN) + "…" : merged;
+    }
+    if (hasImage)
+        return "image";
+    return "";
+}
+// ---------------------------------------------------------------------------
+// Test-only exports (@internal)
+// ---------------------------------------------------------------------------
+/** @internal — Close and reset the DB singleton. Only use in tests. */
+export function _resetStore() {
+    if (db) {
+        try {
+            db.close();
+        }
+        catch {
+            // ignore
+        }
+        db = null;
+    }
+}
+/** @internal — Override the DB instance for testing. */
+export function _setDb(next) {
+    db = next;
+}

package/dist/src/targets.js

@@ -0,0 +1,90 @@
+/**
+ * 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:chengbo05" */
+const USER_PREFIX = "user:";
+// ---------------------------------------------------------------------------
+// Target Normalization
+// ---------------------------------------------------------------------------
+/**
+ * Normalizes an Infoflow target string.
+ * Strips channel prefix and normalizes format.
+ *
+ * Examples:
+ *   "infoflow:chengbo05" -> "chengbo05"
+ *   "infoflow:group:123456" -> "group:123456"
+ *   "user:chengbo05" -> "chengbo05"
+ *   "group:123456" -> "group:123456"
+ *   "chengbo05" -> "chengbo05"
+ *   "123456" -> "group:123456" (pure digits treated as group)
+ */
+export function normalizeInfoflowTarget(raw) {
+    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:chengbo05 (user ID with prefix)
+ * - 123456789 (pure digits = group ID)
+ * - chengbo05 (alphanumeric starting with letter = username/uuapName)
+ */
+export function looksLikeInfoflowId(raw) {
+    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., chengbo05, zhangsan, user123
+    if (/^[a-zA-Z][a-zA-Z0-9_]*$/.test(target)) {
+        return true;
+    }
+    return false;
+}

package/dist/src/types.js

@@ -0,0 +1,4 @@
+/**
+ * Infoflow channel type definitions.
+ */
+export {};

package/dist/src/ws-receiver.js

@@ -0,0 +1,378 @@
+/**
+ * WebSocket inbound receiver: wraps SDK WSClient for long-lived message delivery.
+ * Normalizes events into the same msgData shape as the webhook path, then calls
+ * handleGroupChatMessage / handlePrivateChatMessage.
+ */
+import { checkBotMentioned, handleGroupChatMessage, handlePrivateChatMessage, } from "./bot.js";
+import { formatInfoflowError, getInfoflowWebhookLog, logVerbose } from "./logging.js";
+import { isDuplicateMessage } from "./infoflow-req-parse.js";
+import { extractIdFromRawJson } from "./send.js";
+const GROUP_INBOUND_TTL_MS = 5 * 60 * 1000;
+const GROUP_INBOUND_MAX_SIZE = 2048;
+const groupInboundSeen = new Map();
+function pruneGroupInboundSeen(now) {
+    for (const [key, value] of groupInboundSeen) {
+        if (now - value.seenAt > GROUP_INBOUND_TTL_MS) {
+            groupInboundSeen.delete(key);
+        }
+    }
+    if (groupInboundSeen.size <= GROUP_INBOUND_MAX_SIZE)
+        return;
+    const overflow = groupInboundSeen.size - GROUP_INBOUND_MAX_SIZE;
+    const oldest = [...groupInboundSeen.entries()]
+        .sort((a, b) => a[1].seenAt - b[1].seenAt)
+        .slice(0, overflow);
+    for (const [key] of oldest) {
+        groupInboundSeen.delete(key);
+    }
+}
+function shouldSkipDuplicateGroupEvent(dedupKey, incomingKind) {
+    const now = Date.now();
+    pruneGroupInboundSeen(now);
+    const existing = groupInboundSeen.get(dedupKey);
+    if (!existing) {
+        groupInboundSeen.set(dedupKey, { kind: incomingKind, seenAt: now });
+        return false;
+    }
+    if (incomingKind === "forward") {
+        existing.seenAt = now;
+        return true;
+    }
+    if (existing.kind === "mention") {
+        existing.seenAt = now;
+        return true;
+    }
+    groupInboundSeen.set(dedupKey, { kind: "mention", seenAt: now });
+    return false;
+}
+function botMentionIdentity(account) {
+    return {
+        robotName: account.config.robotName,
+        appAgentId: account.config.appAgentId,
+        robotId: account.config.robotId?.trim() || undefined,
+    };
+}
+export class InfoflowWSReceiver {
+    wsClient = null;
+    options;
+    stopped = false;
+    handleGroupEventRef = null;
+    handlePrivateEventRef = null;
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        let WSClient;
+        try {
+            ({ WSClient } = await import("@baidu/infoflow-sdk-nodejs"));
+        }
+        catch (err) {
+            throw new Error(`Infoflow WebSocket mode requires @baidu/infoflow-sdk-nodejs (install from the Baidu npm registry). ${formatInfoflowError(err)}`);
+        }
+        const { appKey, appSecret } = this.options.account.config;
+        const wsGateway = this.options.account.config.wsGateway;
+        const wsConnectDomain = this.options.account.config.wsConnectDomain;
+        this.wsClient = new WSClient({
+            appId: appKey,
+            appSecret: appSecret,
+            wsGateway,
+            ...(wsConnectDomain ? { wsConnectDomain } : {}),
+            endpointTimeout: 15_000,
+        });
+        const client = this.wsClient;
+        const dispatcher = client.eventDispatcher;
+        if (dispatcher && typeof dispatcher.normalizePrivateMessage === "function") {
+            const original = dispatcher.normalizePrivateMessage.bind(dispatcher);
+            dispatcher.normalizePrivateMessage = (payload) => {
+                const normalized = original(payload);
+                normalized.originalMessage = payload;
+                return normalized;
+            };
+        }
+        const frameCodec = client.frameCodec;
+        if (frameCodec && typeof frameCodec.parsePayload === "function") {
+            const originalParse = frameCodec.parsePayload.bind(frameCodec);
+            frameCodec.parsePayload = (frame) => {
+                const f = frame;
+                const result = originalParse(frame);
+                if (result && typeof result === "object" && f.payload) {
+                    try {
+                        result._rawJson = f.payload.toString("utf-8");
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+                const method = f.method ?? "?";
+                getInfoflowWebhookLog().info(`[ws:frame] method=${method}, payloadLen=${f.payload?.length ?? 0}`);
+                return result;
+            };
+        }
+        const rawHandleDisconnect = client.handleDisconnect;
+        if (typeof rawHandleDisconnect === "function") {
+            const originalHandleDisconnect = rawHandleDisconnect.bind(client);
+            client.handleDisconnect = (...args) => {
+                if (this.stopped) {
+                    try {
+                        client.stopHeartbeat?.();
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    client.state = "disconnected";
+                    return;
+                }
+                return originalHandleDisconnect(...args);
+            };
+        }
+        getInfoflowWebhookLog().info(`[ws:init] WSClient created: appKey=${appKey.slice(0, 4)}***, gateway=${wsGateway}, endpointTimeout=15000ms`);
+        const handleGroupEvent = async (...args) => {
+            const event = args[0];
+            getInfoflowWebhookLog().info(`[ws:inbound] group event received, type=${event?.type ?? event?.data?.msgType ?? "?"}`);
+            if (this.stopped) {
+                getInfoflowWebhookLog().warn(`[ws:inbound] group event dropped (receiver stopped)`);
+                return;
+            }
+            try {
+                const data = (event?.data ?? event);
+                await this.handleGroupEvent(data);
+            }
+            catch (err) {
+                getInfoflowWebhookLog().error(`[ws:inbound] group handler error: ${formatInfoflowError(err)}`);
+            }
+        };
+        this.wsClient.on("group.*", handleGroupEvent);
+        this.handleGroupEventRef = handleGroupEvent;
+        const handlePrivateEvent = async (...args) => {
+            const event = args[0];
+            getInfoflowWebhookLog().info(`[ws:inbound] private event received, type=${event?.type ?? event?.data?.msgType ?? "?"}`);
+            if (this.stopped) {
+                getInfoflowWebhookLog().warn(`[ws:inbound] private event dropped (receiver stopped)`);
+                return;
+            }
+            try {
+                const data = (event?.data ?? event);
+                await this.handlePrivateEvent(data);
+            }
+            catch (err) {
+                getInfoflowWebhookLog().error(`[ws:inbound] private handler error: ${formatInfoflowError(err)}`);
+            }
+        };
+        this.wsClient.on("private.*", handlePrivateEvent);
+        this.handlePrivateEventRef = handlePrivateEvent;
+        this.wsClient.on("connected", (...args) => {
+            const event = args[0];
+            getInfoflowWebhookLog().info(`[ws:connect] websocket connected, connection_id=${event?.connectionId ?? "?"}`);
+        });
+        this.wsClient.on("disconnected", (...args) => {
+            const event = args[0];
+            getInfoflowWebhookLog().warn(`[ws:disconnect] websocket disconnected, connection_id=${event?.connectionId ?? "?"}`);
+        });
+        this.wsClient.on("error", (...args) => {
+            const event = args[0];
+            const msg = event?.error?.message ?? String(event?.error ?? event ?? "unknown");
+            getInfoflowWebhookLog().error(`[ws:error] websocket error: ${msg}`);
+        });
+        getInfoflowWebhookLog().info(`[ws:connect] connecting to ${wsGateway}`);
+        await this.wsClient.connect();
+        getInfoflowWebhookLog().info(`[ws:connect] initial connection established`);
+        this.options.abortSignal.addEventListener("abort", () => {
+            this.stop();
+        }, { once: true });
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        const client = this.wsClient;
+        if (this.handleGroupEventRef && client?.off) {
+            try {
+                client.off("group.*", this.handleGroupEventRef);
+            }
+            catch {
+                /* ignore */
+            }
+            this.handleGroupEventRef = null;
+        }
+        if (this.handlePrivateEventRef && client?.off) {
+            try {
+                client.off("private.*", this.handlePrivateEventRef);
+            }
+            catch {
+                /* ignore */
+            }
+            this.handlePrivateEventRef = null;
+        }
+        if (!client)
+            return;
+        getInfoflowWebhookLog().info(`[ws:disconnect] stopping ws receiver`);
+        try {
+            client.stopHeartbeat?.();
+            if (client.serverConfig && typeof client.serverConfig === "object") {
+                client.serverConfig = {
+                    ...client.serverConfig,
+                    reconnect_count: 0,
+                };
+            }
+            client.maxReconnectAttempts = 0;
+            client.reconnectAttempts = 0;
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            client.disconnect();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    async handleGroupEvent(data) {
+        if (!data)
+            return;
+        this.options.statusSink?.({ lastInboundAt: Date.now() });
+        const payload = (data.raw ?? data);
+        const originalMessage = (payload.originalMessage ?? payload);
+        const message = (payload.message ?? originalMessage.message ?? {});
+        const header = (message.header ?? originalMessage.header ?? {});
+        const rawJson = payload._rawJson;
+        const preciseMessageId = (rawJson && extractIdFromRawJson(rawJson, "messageid")) ??
+            (header.messageid != null ? String(header.messageid) : undefined);
+        const preciseClientMsgId = (rawJson && extractIdFromRawJson(rawJson, "clientmsgid")) ??
+            (header.clientmsgid != null ? String(header.clientmsgid) : undefined);
+        const preciseMsgId2 = (rawJson && extractIdFromRawJson(rawJson, "msgid2")) ??
+            (payload.msgid2 != null
+                ? String(payload.msgid2)
+                : originalMessage.msgid2 != null
+                    ? String(originalMessage.msgid2)
+                    : undefined);
+        const rawEventType = String(payload.eventtype ??
+            payload.eventType ??
+            originalMessage.eventtype ??
+            originalMessage.eventType ??
+            "MESSAGE_RECEIVE");
+        const bodyItems = (message.body ?? payload.body ?? data.body ?? []);
+        const isMentionEvent = rawEventType === "MESSAGE_RECEIVE"
+            ? true
+            : checkBotMentioned(bodyItems, botMentionIdentity(this.options.account));
+        getInfoflowWebhookLog().info(`[ws:inbound] group eventtype=${rawEventType}, wasMentioned=${isMentionEvent}`);
+        const msgData = {
+            eventtype: rawEventType,
+            groupid: payload.groupid ?? payload.groupId ?? data.groupId,
+            fromid: payload.fromid,
+            msgid2: preciseMsgId2,
+            wasMentioned: isMentionEvent,
+            message: {
+                header: {
+                    fromuserid: header.fromuserid ?? payload.fromUserId ?? data.fromUserId ?? "",
+                    toid: payload.groupid ?? payload.groupId ?? data.groupId,
+                    totype: "GROUP",
+                    msgtype: header.msgtype ?? data.msgType ?? "text",
+                    messageid: preciseMessageId,
+                    clientmsgid: preciseClientMsgId,
+                    servertime: header.servertime,
+                    clienttime: header.clienttime,
+                    at: header.at ?? { atrobotids: [] },
+                },
+                body: bodyItems.length > 0
+                    ? bodyItems
+                    : data.content != null && String(data.content).length > 0
+                        ? [{ type: "TEXT", content: String(data.content) }]
+                        : [],
+            },
+        };
+        const dedupKey = preciseClientMsgId ?? preciseMessageId;
+        const dedupKind = isMentionEvent ? "mention" : "forward";
+        if (dedupKey && shouldSkipDuplicateGroupEvent(dedupKey, dedupKind)) {
+            logVerbose(`[infoflow:ws] duplicate group message skipped: key=${dedupKey}, kind=${dedupKind}`);
+            return;
+        }
+        logVerbose(`[infoflow:ws] group message: from=${header.fromuserid}, msgType=${header.msgtype}, groupId=${payload.groupid ?? payload.groupId}`);
+        await handleGroupChatMessage({
+            cfg: this.options.config,
+            msgData,
+            accountId: this.options.account.accountId,
+            statusSink: this.options.statusSink,
+        });
+    }
+    async handlePrivateEvent(data) {
+        if (!data)
+            return;
+        this.options.statusSink?.({ lastInboundAt: Date.now() });
+        const payload = (data.raw ?? data);
+        const originalMessage = (payload.originalMessage ?? payload);
+        const rawJson = (payload._rawJson ?? originalMessage._rawJson);
+        const preciseMsgId = (rawJson &&
+            (extractIdFromRawJson(rawJson, "MsgId") ?? extractIdFromRawJson(rawJson, "msgId"))) ??
+            (() => {
+                const raw = payload.MsgId ?? payload.msgId ?? data.msgId ?? originalMessage.MsgId;
+                return raw != null ? String(raw) : undefined;
+            })();
+        const preciseMsgId2 = (rawJson &&
+            (extractIdFromRawJson(rawJson, "MsgId2") ??
+                extractIdFromRawJson(rawJson, "msgid2") ??
+                extractIdFromRawJson(rawJson, "msgId2"))) ??
+            (() => {
+                const raw = payload.MsgId2 ??
+                    payload.msgId2 ??
+                    payload.msgid2 ??
+                    data.MsgId2 ??
+                    data.msgid2 ??
+                    originalMessage.MsgId2;
+                return raw != null ? String(raw) : undefined;
+            })();
+        const msgData = {
+            FromUserId: payload.FromUserId ??
+                payload.fromUserId ??
+                data.fromUserId ??
+                originalMessage.FromUserId ??
+                "",
+            FromUserName: payload.FromUserName ??
+                payload.fromUserName ??
+                data.fromUserName ??
+                originalMessage.FromUserName,
+            Content: payload.Content ?? payload.content ?? data.content ?? originalMessage.Content ?? "",
+            MsgType: payload.MsgType ?? payload.msgType ?? data.msgType ?? originalMessage.MsgType ?? "text",
+            CreateTime: payload.CreateTime ??
+                payload.createTime ??
+                data.createTime ??
+                originalMessage.CreateTime ??
+                String(Date.now()),
+            PicUrl: payload.PicUrl ?? payload.picUrl ?? data.picUrl ?? originalMessage.PicUrl ?? "",
+            VoiceUrl: payload.VoiceUrl ?? payload.voiceUrl ?? data.voiceUrl ?? originalMessage.VoiceUrl ?? "",
+            FromPlatform: payload.FromPlatform ??
+                payload.fromPlatform ??
+                data.fromPlatform ??
+                originalMessage.FromPlatform ??
+                "",
+            agentId: payload.agentId ?? data.agentId ?? originalMessage.agentId ?? "",
+            OpenCode: payload.OpenCode ?? payload.openCode ?? data.openCode ?? originalMessage.OpenCode ?? "",
+            MsgId: preciseMsgId,
+            MsgId2: preciseMsgId2,
+            FromId: payload.FromId ?? payload.fromid ?? data.FromId ?? data.fromid ?? originalMessage.FromId,
+            Reply: payload.Reply ??
+                payload.reply ??
+                data.Reply ??
+                data.reply ??
+                originalMessage.Reply ??
+                undefined,
+            FileId: payload.FileId ?? payload.fileId ?? data.fileId ?? originalMessage.FileId,
+            Name: payload.Name ?? payload.name ?? data.name ?? originalMessage.Name,
+            FileSize: payload.FileSize ?? payload.fileSize ?? data.fileSize ?? originalMessage.FileSize,
+            FileType: payload.FileType ?? payload.fileType ?? data.fileType ?? originalMessage.FileType,
+            CardType: payload.CardType ?? payload.cardType ?? data.CardType ?? originalMessage.CardType,
+            Title: payload.Title ?? payload.title ?? data.Title ?? originalMessage.Title,
+        };
+        if (isDuplicateMessage(msgData)) {
+            logVerbose("[infoflow:ws] duplicate private message, skipping");
+            return;
+        }
+        logVerbose(`[infoflow:ws] private message: from=${msgData.FromUserId}, msgType=${msgData.MsgType}`);
+        await handlePrivateChatMessage({
+            cfg: this.options.config,
+            msgData,
+            accountId: this.options.account.accountId,
+            statusSink: this.options.statusSink,
+        });
+    }
+}