twinny 0.0.0-dev.260525150705

package/dist/lark/filters.js

@@ -0,0 +1,678 @@
+export function normalizeIncomingLarkMessage(raw, options = {}) {
+    const result = normalizeIncomingLarkMessageWithReason(raw, options);
+    return result.kind === "message" ? result.message : null;
+}
+export function normalizeIncomingLarkMessageWithReason(raw, options = {}) {
+    const event = unwrapReceiveEvent(raw);
+    if (!isRecord(event) || !isRecord(event.sender) || !isRecord(event.message)) {
+        return ignored("malformed_event", raw);
+    }
+    const sender = event.sender;
+    const senderId = isRecord(sender.sender_id) ? sender.sender_id : {};
+    const senderOpenId = stringValue(senderId.open_id);
+    if (!senderOpenId) {
+        return ignored("missing_sender_open_id", raw);
+    }
+    const senderType = stringValue(sender.sender_type)?.toLowerCase();
+    if (senderType === "app" || senderType === "bot" || senderOpenId === options.botOpenId) {
+        return ignored("bot_self_message", raw);
+    }
+    const senderName = firstStringValue(sender.name, sender.sender_name, sender.display_name, sender.sender_display_name);
+    const message = event.message;
+    const chatType = normalizeChatType(stringValue(message.chat_type));
+    if (!chatType) {
+        return ignored("unsupported_chat_type", raw);
+    }
+    const messageType = stringValue(message.message_type) ?? "unknown";
+    const messageId = stringValue(message.message_id);
+    if (!messageId) {
+        return ignored("missing_message_id", raw);
+    }
+    const chatId = chatType === "p2p" ? senderOpenId : stringValue(message.chat_id);
+    if (!chatId) {
+        return ignored("malformed_event", raw);
+    }
+    const content = normalizeLarkMessageContent(messageType, message.content);
+    const resources = content.resources;
+    const shouldUseRaw = content.text === null || (content.text.length === 0 && resources.length === 0);
+    const text = shouldUseRaw ? stringifyRawLarkMessageForCodex(message) : (content.text ?? "");
+    const rawForCodex = content.rawForCodex || shouldUseRaw;
+    return {
+        kind: "message",
+        message: {
+            eventId: stringValue(event.event_id) ??
+                stringValue(event.uuid) ??
+                stringValue(isRecord(raw) && isRecord(raw.header) ? raw.header.event_id : undefined) ??
+                messageId,
+            messageId,
+            chatId,
+            chatType,
+            messageType,
+            senderOpenId,
+            senderName,
+            larkGroupId: chatType === "p2p" ? undefined : chatId,
+            larkThreadId: larkThreadIdForMessage(message, messageId, chatType),
+            larkRootMessageId: firstStringValue(message.root_id),
+            larkParentMessageId: firstStringValue(message.parent_id),
+            mentions: normalizeMentions(message.mentions),
+            resources: resources.length > 0 ? resources : undefined,
+            rawForCodex: rawForCodex ? true : undefined,
+            text,
+            createTime: parseEpochMs(message.create_time ?? event.create_time),
+            raw
+        }
+    };
+}
+export function normalizeLarkBotMenuWithReason(raw) {
+    if (!isRecord(raw)) {
+        return ignoredBotMenu("malformed_event", raw);
+    }
+    const header = eventHeader(raw);
+    const event = eventPayload(raw);
+    const eventKey = stringValue(event.event_key);
+    if (!eventKey) {
+        return ignoredBotMenu("missing_event_key", raw);
+    }
+    const action = botMenuActionForEventKey(eventKey);
+    if (!action) {
+        return ignoredBotMenu("unsupported_event_key", raw);
+    }
+    const operator = isRecord(event.operator) ? event.operator : {};
+    const operatorId = isRecord(operator.operator_id) ? operator.operator_id : {};
+    const operatorOpenId = stringValue(operatorId.open_id);
+    if (!operatorOpenId) {
+        return ignoredBotMenu("missing_operator_open_id", raw);
+    }
+    return {
+        kind: "bot_menu",
+        action: {
+            eventId: firstStringValue(header.event_id, raw.event_id, raw.uuid, `${eventKey}:${operatorOpenId}`) ?? `${eventKey}:${operatorOpenId}`,
+            eventKey,
+            action,
+            operatorOpenId,
+            operatorName: stringValue(operator.operator_name),
+            chatId: chatIdFromBotMenuEvent(event),
+            timestamp: parseEpochMs(event.timestamp ?? header.create_time ?? raw.create_time),
+            raw
+        }
+    };
+}
+export function normalizeLarkMessageRecallWithReason(raw) {
+    if (!isRecord(raw)) {
+        return ignoredMessageChange("malformed_event", raw);
+    }
+    const header = eventHeader(raw);
+    const event = eventPayload(raw);
+    const messageId = stringValue(event.message_id);
+    if (!messageId) {
+        return ignoredMessageChange("missing_message_id", raw);
+    }
+    return {
+        kind: "recall",
+        recall: {
+            eventId: firstStringValue(header.event_id, raw.event_id, raw.uuid, messageId) ?? messageId,
+            messageId,
+            chatId: stringValue(event.chat_id) ?? chatIdFromChatInfo(event.chat_info),
+            recallTime: parseEpochMs(event.recall_time),
+            raw
+        }
+    };
+}
+export function normalizeLarkMessageContent(messageType, content) {
+    if (messageType === "text") {
+        return {
+            text: normalizeTextContent(content),
+            resources: [],
+            rawForCodex: false
+        };
+    }
+    if (messageType === "post") {
+        const post = normalizePostContent(content);
+        if (post) {
+            return {
+                ...post,
+                rawForCodex: false
+            };
+        }
+    }
+    if (messageType === "interactive") {
+        const card = normalizeInteractiveCardContent(content);
+        if (card) {
+            return {
+                ...card,
+                rawForCodex: false
+            };
+        }
+    }
+    const resources = extractMessageResources(messageType, content);
+    return {
+        text: resources.length === 0 ? null : fallbackResourceText(resources),
+        resources,
+        rawForCodex: resources.length === 0
+    };
+}
+export function stringifyRawLarkMessageForCodex(message) {
+    const body = isRecord(message.body) ? message.body : {};
+    const compact = {
+        message_type: stringValue(message.message_type) ?? stringValue(message.msg_type) ?? "unknown",
+        content: message.content ?? body.content ?? null
+    };
+    try {
+        return JSON.stringify(compact) ?? "";
+    }
+    catch {
+        return String(message);
+    }
+}
+function fallbackResourceText(resources) {
+    if (resources.length === 0) {
+        return null;
+    }
+    return resources
+        .map((resource) => `收到一个文件，资源 key：${resource.fileKey}`)
+        .join("\n");
+}
+function normalizePostContent(content) {
+    const parsed = parseContentObject(content);
+    const post = parsed ? getPostContent(parsed) : null;
+    if (!post) {
+        return null;
+    }
+    const resources = [];
+    const parts = [];
+    const title = stringValue(post.title)?.trim();
+    if (title) {
+        parts.push(`# ${escapeMarkdownText(title)}`);
+    }
+    const paragraphs = Array.isArray(post.content) ? post.content : [];
+    for (const paragraph of paragraphs) {
+        if (!Array.isArray(paragraph)) {
+            continue;
+        }
+        const rendered = renderPostParagraph(paragraph, resources).trim();
+        if (rendered) {
+            parts.push(rendered);
+        }
+    }
+    return {
+        text: parts.join("\n\n"),
+        resources
+    };
+}
+function getPostContent(content) {
+    if (Array.isArray(content.content)) {
+        return content;
+    }
+    for (const locale of ["zh_cn", "en_us", "ja_jp"]) {
+        const value = content[locale];
+        if (isRecord(value) && Array.isArray(value.content)) {
+            return value;
+        }
+    }
+    for (const value of Object.values(content)) {
+        if (isRecord(value) && Array.isArray(value.content)) {
+            return value;
+        }
+    }
+    return null;
+}
+function normalizeInteractiveCardContent(content) {
+    const resolved = resolveInteractiveCardContent(content);
+    if (!resolved) {
+        return null;
+    }
+    const resources = [];
+    const attributes = [];
+    const header = isRecord(resolved.header) ? resolved.header : {};
+    const title = cardHeaderTextContent(header, "title");
+    const subtitle = cardHeaderTextContent(header, "subtitle");
+    if (title) {
+        attributes.push(["title", title]);
+    }
+    if (subtitle) {
+        attributes.push(["subtitle", subtitle]);
+    }
+    const bodyParts = [];
+    const body = isRecord(resolved.body) ? resolved.body : {};
+    renderCardElements(cardChildElements(body), resources, bodyParts);
+    const openTag = attributes.length > 0
+        ? `<card ${attributes.map(([name, value]) => `${name}="${escapeXmlAttribute(value)}"`).join(" ")}>`
+        : "<card>";
+    return {
+        text: [openTag, ...bodyParts, "</card>"].join("\n"),
+        resources
+    };
+}
+function resolveInteractiveCardContent(content) {
+    const card = parseContentObject(content);
+    if (!card) {
+        return null;
+    }
+    if (isJson2InteractiveCard(card)) {
+        return card;
+    }
+    const userDsl = parseContentObject(card.user_dsl);
+    if (userDsl && isJson2InteractiveCard(userDsl)) {
+        return userDsl;
+    }
+    return null;
+}
+function isJson2InteractiveCard(card) {
+    return stringValue(card.schema) === "2.0";
+}
+function renderCardElements(elements, resources, parts) {
+    if (!Array.isArray(elements)) {
+        return;
+    }
+    for (const element of elements) {
+        renderCardElement(element, resources, parts);
+    }
+}
+function renderCardElement(element, resources, parts) {
+    if (!isRecord(element)) {
+        return;
+    }
+    const tag = stringValue(element.tag);
+    if (tag === "markdown") {
+        pushNonEmpty(parts, cardMarkdownContent(element));
+        return;
+    }
+    if (tag === "div") {
+        pushNonEmpty(parts, cardTextContent(element.text));
+        return;
+    }
+    if (tag === "plain_text") {
+        pushNonEmpty(parts, cardTextContent(element));
+        return;
+    }
+    if (tag === "img") {
+        const imageKey = cardImageKey(element);
+        if (imageKey) {
+            const placeholder = resourcePlaceholder(resources.length);
+            resources.push({
+                resourceType: "image",
+                fileKey: imageKey,
+                codexTag: "file",
+                textPlaceholder: placeholder
+            });
+            parts.push(placeholder);
+        }
+        return;
+    }
+    if (tag === "media") {
+        const fileKey = stringValue(element.file_key);
+        if (fileKey) {
+            const placeholder = resourcePlaceholder(resources.length);
+            resources.push({
+                resourceType: "file",
+                fileKey,
+                codexTag: "file",
+                textPlaceholder: placeholder
+            });
+            parts.push(placeholder);
+        }
+        return;
+    }
+    if (isDiscardedCardElementTag(tag)) {
+        return;
+    }
+    if (tag === "collapsible_panel") {
+        if (isRecord(element.header)) {
+            pushNonEmpty(parts, cardHeaderTextContent(element.header, "title"));
+        }
+        renderCardElements(cardChildElements(element), resources, parts);
+        return;
+    }
+    if (tag === "column_set") {
+        renderCardColumns(element.columns, resources, parts);
+        return;
+    }
+    if (isCardContainerTag(tag)) {
+        renderCardElements(cardChildElements(element), resources, parts);
+    }
+}
+function renderCardColumns(columns, resources, parts) {
+    if (!Array.isArray(columns)) {
+        return;
+    }
+    for (const column of columns) {
+        if (isRecord(column)) {
+            renderCardElements(cardChildElements(column), resources, parts);
+        }
+    }
+}
+function cardMarkdownContent(element) {
+    return stringValue(element.content);
+}
+function cardHeaderTextContent(header, key) {
+    return cardTextContent(header[key]);
+}
+function cardChildElements(element) {
+    return element.elements;
+}
+function cardTextContent(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return stringValue(value.content);
+}
+function cardImageKey(element) {
+    return stringValue(element.img_key) ?? stringValue(element.image_key);
+}
+function pushNonEmpty(parts, value) {
+    if (value !== undefined && value.trim() !== "") {
+        parts.push(value);
+    }
+}
+function isCardContainerTag(tag) {
+    return tag === "column" || tag === "form" || tag === "interactive_container";
+}
+function isDiscardedCardElementTag(tag) {
+    return tag === "button" ||
+        tag === "select_static" ||
+        tag === "multi_select_static" ||
+        tag === "select_person" ||
+        tag === "multi_select_person" ||
+        tag === "input" ||
+        tag === "chart" ||
+        tag === "date_picker" ||
+        tag === "picker_time" ||
+        tag === "picker_datetime" ||
+        tag === "checker" ||
+        tag === "overflow" ||
+        tag === "table";
+}
+function renderPostParagraph(paragraph, resources) {
+    return paragraph.map((node) => renderPostNode(node, resources)).join("");
+}
+function renderPostNode(node, resources) {
+    if (!isRecord(node)) {
+        return "";
+    }
+    const tag = stringValue(node.tag);
+    if (tag === "text") {
+        return renderStyledMarkdownText(stringValue(node.text) ?? "", node.style);
+    }
+    if (tag === "a") {
+        const text = renderStyledMarkdownText(stringValue(node.text) ?? stringValue(node.href) ?? "", node.style);
+        const href = stringValue(node.href);
+        return href ? `[${text}](${escapeMarkdownUrl(href)})` : text;
+    }
+    if (tag === "at") {
+        const displayName = stringValue(node.user_name) ?? stringValue(node.user_id) ?? "unknown";
+        return renderStyledMarkdownText(`@${displayName}`, node.style);
+    }
+    if (tag === "img") {
+        const imageKey = stringValue(node.image_key);
+        if (!imageKey) {
+            return renderUnsupportedPostNode(node);
+        }
+        const placeholder = resourcePlaceholder(resources.length);
+        resources.push({
+            resourceType: "image",
+            fileKey: imageKey,
+            codexTag: "img",
+            textPlaceholder: placeholder
+        });
+        return placeholder;
+    }
+    if (tag === "media") {
+        const fileKey = stringValue(node.file_key);
+        if (!fileKey) {
+            return renderUnsupportedPostNode(node);
+        }
+        const placeholder = resourcePlaceholder(resources.length);
+        resources.push({
+            resourceType: "file",
+            fileKey,
+            codexTag: "video",
+            textPlaceholder: placeholder
+        });
+        return placeholder;
+    }
+    if (tag === "emotion") {
+        const emojiType = stringValue(node.emoji_type);
+        return emojiType ? `:${escapeMarkdownText(emojiType)}:` : "";
+    }
+    if (tag === "hr") {
+        return "---";
+    }
+    if (tag === "code_block") {
+        const language = (stringValue(node.language) ?? "").toLowerCase();
+        return `\`\`\`${language}\n${stringValue(node.text) ?? ""}\n\`\`\``;
+    }
+    if (tag === "md") {
+        return stringValue(node.text) ?? "";
+    }
+    return renderUnsupportedPostNode(node);
+}
+function renderStyledMarkdownText(text, style) {
+    let rendered = escapeMarkdownText(text);
+    const styles = Array.isArray(style) ? style.filter((value) => typeof value === "string") : [];
+    if (styles.includes("underline")) {
+        rendered = `<u>${rendered}</u>`;
+    }
+    if (styles.includes("lineThrough")) {
+        rendered = `~~${rendered}~~`;
+    }
+    if (styles.includes("bold") && styles.includes("italic")) {
+        return `***${rendered}***`;
+    }
+    if (styles.includes("bold")) {
+        rendered = `**${rendered}**`;
+    }
+    if (styles.includes("italic")) {
+        rendered = `*${rendered}*`;
+    }
+    return rendered;
+}
+function renderUnsupportedPostNode(node) {
+    try {
+        return `\`${JSON.stringify(node).replaceAll("`", "\\`")}\``;
+    }
+    catch {
+        return "";
+    }
+}
+function resourcePlaceholder(index) {
+    return `{{TWINNY_LARK_RESOURCE_${index}}}`;
+}
+function escapeMarkdownText(value) {
+    return value.replace(/([\\`*_{}\[\]()#+.!|>~-])/g, "\\$1");
+}
+function escapeMarkdownUrl(value) {
+    return value.replace(/\)/g, "%29");
+}
+function escapeXmlAttribute(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/"/g, "&quot;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+function extractMessageResources(messageType, content) {
+    const parsed = parseContentObject(content);
+    if (!parsed) {
+        return [];
+    }
+    if (messageType === "image") {
+        const imageKey = stringValue(parsed.image_key);
+        return imageKey ? [{ resourceType: "image", fileKey: imageKey }] : [];
+    }
+    if (messageType === "file" || messageType === "audio" || messageType === "media" || messageType === "video") {
+        const fileKey = stringValue(parsed.file_key);
+        return fileKey
+            ? [
+                {
+                    resourceType: "file",
+                    fileKey,
+                    fileName: stringValue(parsed.file_name)
+                }
+            ]
+            : [];
+    }
+    return [];
+}
+function parseContentObject(content) {
+    if (isRecord(content)) {
+        return content;
+    }
+    if (typeof content !== "string") {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(content);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeTextContent(content) {
+    if (typeof content !== "string") {
+        if (isRecord(content) && typeof content.text === "string") {
+            return content.text;
+        }
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(content);
+        if (isRecord(parsed) && typeof parsed.text === "string") {
+            return parsed.text;
+        }
+    }
+    catch {
+        // Some event sources emit already-decoded text; raw SDK events emit JSON strings.
+    }
+    return content;
+}
+function unwrapReceiveEvent(raw) {
+    if (isRecord(raw) && isRecord(raw.event)) {
+        return raw.event;
+    }
+    return raw;
+}
+function normalizeChatType(chatType) {
+    if (!chatType) {
+        return undefined;
+    }
+    switch (chatType.toLowerCase()) {
+        case "p2p":
+        case "p2p_chat":
+        case "private":
+        case "private_chat":
+            return "p2p";
+        case "group":
+        case "group_chat":
+            return "group";
+        case "topic_group":
+        case "topic":
+            return "topic_group";
+        default:
+            return undefined;
+    }
+}
+function larkThreadIdForMessage(message, messageId, chatType) {
+    const explicitThreadId = firstStringValue(message.thread_id);
+    if (explicitThreadId) {
+        return explicitThreadId;
+    }
+    if (chatType !== "topic_group") {
+        return undefined;
+    }
+    return firstStringValue(message.root_id, message.parent_id, messageId) ?? messageId;
+}
+function normalizeMentions(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const mentions = [];
+    for (const item of value) {
+        if (!isRecord(item)) {
+            continue;
+        }
+        const key = stringValue(item.key);
+        const id = isRecord(item.id) ? item.id : {};
+        const openId = stringValue(id.open_id) ?? stringValue(item.open_id);
+        const userId = stringValue(id.user_id) ?? stringValue(item.user_id);
+        const unionId = stringValue(id.union_id) ?? stringValue(item.union_id);
+        const name = stringValue(item.name);
+        if (!key && !openId && !userId && !unionId) {
+            continue;
+        }
+        mentions.push({
+            key: key ?? "",
+            openId,
+            userId,
+            unionId,
+            name
+        });
+    }
+    return mentions.length > 0 ? mentions : undefined;
+}
+function parseEpochMs(value) {
+    if (typeof value !== "string" && typeof value !== "number") {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function ignored(reason, raw) {
+    return { kind: "ignored", reason, raw };
+}
+function ignoredMessageChange(reason, raw) {
+    return { kind: "ignored", reason, raw };
+}
+function ignoredBotMenu(reason, raw) {
+    return { kind: "ignored", reason, raw };
+}
+function botMenuActionForEventKey(eventKey) {
+    const normalized = eventKey.trim().toLowerCase();
+    switch (normalized) {
+        case "stop":
+        case "new":
+        case "queue":
+        case "status":
+        case "help":
+            return normalized;
+        case "new_session":
+        case "new-session":
+        case "new session":
+        case "new_conversation":
+        case "new-conversation":
+            return "new_session";
+        default:
+            return undefined;
+    }
+}
+function eventPayload(raw) {
+    return isRecord(raw.event) ? raw.event : raw;
+}
+function eventHeader(raw) {
+    return isRecord(raw.header) ? raw.header : {};
+}
+function chatIdFromChatInfo(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return stringValue(value.chat_id);
+}
+function chatIdFromBotMenuEvent(event) {
+    return firstStringValue(event.chat_id, event.open_chat_id, isRecord(event.chat) ? event.chat.chat_id : undefined, isRecord(event.chat) ? event.chat.open_chat_id : undefined, chatIdFromChatInfo(event.chat_info), isRecord(event.operator) ? event.operator.chat_id : undefined, isRecord(event.operator) ? event.operator.open_chat_id : undefined);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function firstStringValue(...values) {
+    for (const value of values) {
+        const string = stringValue(value);
+        if (string) {
+            return string;
+        }
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=filters.js.map