clawgram 2.0.0

package/dist/helpers.js

@@ -0,0 +1,495 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SILENT_REPLY_TOKEN = void 0;
+exports.normalizeOutboundTarget = normalizeOutboundTarget;
+exports.resolveConfiguredAccountId = resolveConfiguredAccountId;
+exports.inferOutboundTargetKind = inferOutboundTargetKind;
+exports.routeKindFromChatType = routeKindFromChatType;
+exports.buildConversationTarget = buildConversationTarget;
+exports.buildScopedGroupPeerId = buildScopedGroupPeerId;
+exports.stripReplyDirectiveTags = stripReplyDirectiveTags;
+exports.readLatestAssistantFallbackFromTranscript = readLatestAssistantFallbackFromTranscript;
+exports.resolveActionTarget = resolveActionTarget;
+exports.resolveReplyToMessageIdForTarget = resolveReplyToMessageIdForTarget;
+exports.readMessageText = readMessageText;
+exports.resolveAllowFrom = resolveAllowFrom;
+exports.resolveGroupPolicy = resolveGroupPolicy;
+exports.resolveGroups = resolveGroups;
+exports.resolveGroupConfig = resolveGroupConfig;
+exports.resolveActiveUsername = resolveActiveUsername;
+exports.normalizeAllowEntry = normalizeAllowEntry;
+exports.isSenderAllowed = isSenderAllowed;
+exports.hasTelegramMention = hasTelegramMention;
+exports.toDisplayName = toDisplayName;
+exports.withTimeout = withTimeout;
+exports.stripSilentReplyToken = stripSilentReplyToken;
+exports.isSilentReplyText = isSilentReplyText;
+exports.prefixReplyTextToAddress = prefixReplyTextToAddress;
+exports.resolveReplyTarget = resolveReplyTarget;
+exports.resolveChatTarget = resolveChatTarget;
+exports.isReplyToSelfMessage = isReplyToSelfMessage;
+exports.resolveSenderProfile = resolveSenderProfile;
+exports.resolveSenderProfileWithTimeout = resolveSenderProfileWithTimeout;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const core_1 = require("openclaw/plugin-sdk/core");
+const channel_inbound_1 = require("openclaw/plugin-sdk/channel-inbound");
+const constants_1 = require("./constants");
+function resolveConfiguredAccountId(cfg, preferred) {
+    if (preferred?.trim()) {
+        return preferred.trim();
+    }
+    const accounts = cfg?.channels?.[constants_1.CHANNEL_ID]?.accounts;
+    if (!accounts || typeof accounts !== "object") {
+        return undefined;
+    }
+    return Object.keys(accounts).find((accountId) => accounts?.[accountId]?.enabled !== false);
+}
+function normalizeOutboundTarget(rawTarget) {
+    const withoutChannel = (0, core_1.stripChannelTargetPrefix)(rawTarget, constants_1.CHANNEL_ID, "tguserbot", "telegram", "tg");
+    return (0, core_1.stripTargetKindPrefix)(withoutChannel).trim();
+}
+function inferOutboundTargetKind(rawTarget, resolvedKind) {
+    if (resolvedKind) {
+        return resolvedKind;
+    }
+    const withoutChannel = (0, core_1.stripChannelTargetPrefix)(rawTarget, constants_1.CHANNEL_ID, "tguserbot", "telegram", "tg").trim();
+    const prefix = withoutChannel.match(/^(user|channel|group|conversation|room|dm):/i)?.[1]?.toLowerCase();
+    if (prefix === "group" || prefix === "room" || prefix === "conversation") {
+        return "group";
+    }
+    if (prefix === "channel") {
+        return "channel";
+    }
+    if (prefix === "user" || prefix === "dm") {
+        return "user";
+    }
+    const target = normalizeOutboundTarget(rawTarget);
+    if (target.startsWith("-")) {
+        return "group";
+    }
+    return undefined;
+}
+function routeKindFromChatType(chatType) {
+    return chatType === "group" || chatType === "channel" ? chatType : "direct";
+}
+function buildConversationTarget(chatId) {
+    return `${constants_1.CHANNEL_ID}:${chatId}`;
+}
+function buildScopedGroupPeerId(accountId, chatId) {
+    const scopedAccountId = (accountId ?? "default").trim() || "default";
+    return `${scopedAccountId}:${chatId}`;
+}
+function stripReplyDirectiveTags(text) {
+    return text
+        .replace(/\[\[\s*reply_to_current\s*\]\]/gi, " ")
+        .replace(/\[\[\s*reply_to\s*:\s*[^\]\n]+\s*\]\]/gi, " ")
+        .replace(/\[\[\s*audio_as_voice\s*\]\]/gi, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function resolveTranscriptPathFromStoreEntry(input) {
+    const sessionId = typeof input.entry?.sessionId === "string" && input.entry.sessionId.trim()
+        ? input.entry.sessionId.trim()
+        : input.sessionKey.trim();
+    if (!sessionId) {
+        return undefined;
+    }
+    const sessionsDir = node_path_1.default.dirname(node_path_1.default.resolve(input.storePath));
+    const sessionFile = typeof input.entry?.sessionFile === "string" ? input.entry.sessionFile.trim() : "";
+    const candidateFileName = sessionFile || `${sessionId}.jsonl`;
+    try {
+        return node_path_1.default.resolve(sessionsDir, candidateFileName);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readLatestAssistantFallbackFromTranscript(sessionKey, storePath) {
+    if (!storePath?.trim()) {
+        return undefined;
+    }
+    try {
+        const rawStore = (0, node_fs_1.readFileSync)(storePath, "utf8");
+        const store = JSON.parse(rawStore);
+        const sessionFile = resolveTranscriptPathFromStoreEntry({
+            storePath,
+            sessionKey,
+            entry: store?.[sessionKey],
+        });
+        if (!sessionFile) {
+            return undefined;
+        }
+        const lines = (0, node_fs_1.readFileSync)(sessionFile, "utf8")
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+        for (let index = lines.length - 1; index >= 0; index -= 1) {
+            try {
+                const entry = JSON.parse(lines[index]);
+                if (entry?.type !== "message" || entry?.message?.role !== "assistant" || !Array.isArray(entry.message.content)) {
+                    continue;
+                }
+                const textPart = entry.message.content.find((part) => part?.type === "text" && typeof part.text === "string" && part.text.trim());
+                if (!textPart?.text) {
+                    continue;
+                }
+                const cleaned = stripReplyDirectiveTags(textPart.text);
+                if (cleaned) {
+                    return cleaned;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function resolveActionTarget(params, toolContext) {
+    const explicitTo = (0, core_1.readStringParam)(params, "to") ?? (0, core_1.readStringParam)(params, "target");
+    if (explicitTo?.trim()) {
+        return explicitTo.trim();
+    }
+    const contextTarget = toolContext?.currentChannelId?.trim();
+    if (contextTarget) {
+        return contextTarget;
+    }
+    throw new Error("clawgram: message target is required");
+}
+function resolveReplyToMessageIdForTarget(rawTarget, replyToId) {
+    if (replyToId === null || replyToId === undefined || replyToId === "") {
+        return undefined;
+    }
+    const targetKind = inferOutboundTargetKind(rawTarget);
+    if (targetKind === "group" || targetKind === "channel") {
+        return Number(replyToId);
+    }
+    return undefined;
+}
+function readMessageText(params) {
+    const message = (0, core_1.readStringParam)(params, "message", { allowEmpty: true });
+    if (typeof message === "string") {
+        return message;
+    }
+    const text = (0, core_1.readStringParam)(params, "text", { allowEmpty: true });
+    if (typeof text === "string") {
+        return text;
+    }
+    return "";
+}
+function resolveAllowFrom(value) {
+    if (value === "*") {
+        return ["*"];
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        const entry = String(value).trim();
+        return entry ? [entry] : ["*"];
+    }
+    if (!Array.isArray(value)) {
+        return ["*"];
+    }
+    const entries = value.map((entry) => String(entry).trim()).filter(Boolean);
+    return entries.length > 0 ? entries : ["*"];
+}
+function resolveGroupPolicy(value) {
+    return value === "open" ? "open" : "mention";
+}
+function resolveGroups(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const entries = Object.entries(value);
+    return Object.fromEntries(entries.map(([groupId, rawConfig]) => {
+        const groupConfig = rawConfig && typeof rawConfig === "object" && !Array.isArray(rawConfig)
+            ? rawConfig
+            : {};
+        return [
+            String(groupId).trim(),
+            {
+                enabled: groupConfig.enabled !== false,
+                groupPolicy: resolveGroupPolicy(groupConfig.groupPolicy),
+                allowFrom: resolveAllowFrom(groupConfig.allowFrom),
+            },
+        ];
+    }).filter(([groupId]) => Boolean(groupId)));
+}
+function resolveGroupConfig(groups, chatId) {
+    return groups[chatId] ?? groups["*"];
+}
+function resolveActiveUsername(source) {
+    if (typeof source?.username === "string" && source.username.trim()) {
+        return source.username.trim();
+    }
+    const activeUsername = Array.isArray(source?.usernames)
+        ? source.usernames.find((entry) => entry?.active !== false && typeof entry?.username === "string")?.username
+        : undefined;
+    return typeof activeUsername === "string" && activeUsername.trim() ? activeUsername.trim() : undefined;
+}
+function normalizeAllowEntry(value) {
+    return value.trim().replace(/^@/, "").toLowerCase();
+}
+function isSenderAllowed(input) {
+    if (input.allowFrom.includes("*")) {
+        return true;
+    }
+    const senderIds = [
+        input.senderId,
+        input.senderUsername,
+        input.senderUsername ? `@${input.senderUsername}` : undefined,
+    ].filter((value) => Boolean(value)).map(normalizeAllowEntry);
+    return input.allowFrom.map(normalizeAllowEntry).some((entry) => senderIds.includes(entry));
+}
+function hasTelegramMention(input) {
+    const normalizedText = input.text.trim();
+    const message = input.message;
+    const mentionRegexes = (0, channel_inbound_1.buildMentionRegexes)(input.cfg, input.agentId);
+    const selfUsername = input.selfUsername?.replace(/^@/, "").trim();
+    const entities = Array.isArray(message?.entities) ? message.entities : [];
+    const hasAnyMention = Boolean(message?.mentioned) ||
+        entities.some((entity) => {
+            const kind = typeof entity?.className === "string" ? entity.className : entity?.type;
+            return kind === "MessageEntityMention" || kind === "mention" || kind === "MessageEntityMentionName" || kind === "InputMessageEntityMentionName";
+        }) ||
+        /(^|\s)@[a-zA-Z0-9_]{5,}\b/.test(normalizedText);
+    const entityExplicitMention = Boolean(selfUsername) && entities.some((entity) => {
+        const kind = typeof entity?.className === "string" ? entity.className : entity?.type;
+        if (kind !== "MessageEntityMention" && kind !== "mention") {
+            return false;
+        }
+        const offset = typeof entity?.offset === "number" ? entity.offset : -1;
+        const length = typeof entity?.length === "number" ? entity.length : 0;
+        if (offset < 0 || length <= 0) {
+            return false;
+        }
+        return normalizedText.slice(offset, offset + length).replace(/^@/, "").trim().toLowerCase() === selfUsername.toLowerCase();
+    });
+    const explicitlyMentioned = Boolean(selfUsername) &&
+        (message?.mentioned === true ||
+            entityExplicitMention ||
+            new RegExp(`(^|\\s)@${selfUsername?.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i").test(normalizedText));
+    return (0, channel_inbound_1.matchesMentionWithExplicit)({
+        text: normalizedText,
+        mentionRegexes,
+        explicit: {
+            hasAnyMention,
+            isExplicitlyMentioned: explicitlyMentioned,
+            canResolveExplicit: Boolean(selfUsername),
+        },
+    });
+}
+function toDisplayName(input) {
+    if (input.username) {
+        return `@${input.username}`;
+    }
+    const fullName = [input.firstName, input.lastName].filter(Boolean).join(" ").trim();
+    return fullName || input.fallback || "Telegram";
+}
+async function withTimeout(promise, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(undefined), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+/**
+ * OpenClaw's shared silent-reply sentinel. When the agent decides not to answer
+ * it returns this token instead of text, and surfaces are expected to drop the
+ * message rather than deliver the token.
+ *
+ * Core owns the canonical helpers (`SILENT_REPLY_TOKEN`, `isSilentReplyText`,
+ * `stripSilentToken` in `src/auto-reply/tokens`), but they are not re-exported
+ * through any of the public `openclaw/plugin-sdk/*` entry points, so the
+ * behaviour is mirrored here. If the SDK ever exposes them, drop this block and
+ * import instead.
+ */
+const SILENT_REPLY_TOKEN = "NO_REPLY";
+exports.SILENT_REPLY_TOKEN = SILENT_REPLY_TOKEN;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Remove leading and trailing occurrences of the silent token.
+ *
+ * Leading tokens may be glued to the following text ("NO_REPLYstill thinking"),
+ * so the match is not anchored on a word boundary, and punctuation directly
+ * after a leading token belongs to the marker rather than to the text.
+ *
+ * Only whitespace is consumed before a trailing token: punctuation there ends
+ * the preceding sentence and must survive ("Done. NO_REPLY" -> "Done.").
+ *
+ * Occurrences in the middle of a sentence are left alone: there the token is
+ * content, not a control marker.
+ *
+ * Returns the remaining visible text. An empty result means the whole payload
+ * was the token and nothing should be sent.
+ */
+function stripSilentReplyToken(text, token = SILENT_REPLY_TOKEN) {
+    const escaped = escapeRegExp(token);
+    const leading = new RegExp(`^(?:${escaped})[\\s,.:;!—-]*`, "i");
+    const trailing = new RegExp(`\\s*(?:${escaped})$`, "i");
+    let result = text.trim();
+    while (leading.test(result)) {
+        const next = result.replace(leading, "").trim();
+        if (next === result) {
+            break;
+        }
+        result = next;
+    }
+    return result.replace(trailing, "").trim();
+}
+/** True when the payload carries no visible text beyond the silent token. */
+function isSilentReplyText(text, token = SILENT_REPLY_TOKEN) {
+    const trimmed = typeof text === "string" ? text.trim() : "";
+    if (!trimmed) {
+        return false;
+    }
+    return stripSilentReplyToken(trimmed, token).length === 0;
+}
+function prefixReplyTextToAddress(text, address) {
+    const outboundText = text.trim();
+    if (!address) {
+        return outboundText;
+    }
+    const lowerText = outboundText.toLowerCase();
+    const lowerAddress = address.toLowerCase();
+    if (lowerText === lowerAddress ||
+        lowerText.startsWith(`${lowerAddress},`) ||
+        lowerText.startsWith(`${lowerAddress}:`) ||
+        lowerText.startsWith(`${lowerAddress} `)) {
+        return outboundText;
+    }
+    return `${address}, ${outboundText}`;
+}
+async function resolveReplyTarget(message) {
+    const directInputSender = typeof message?.getInputSender === "function"
+        ? await message.getInputSender().catch(() => undefined)
+        : undefined;
+    if (directInputSender) {
+        return directInputSender;
+    }
+    const sender = typeof message?.getSender === "function"
+        ? await message.getSender().catch(() => undefined)
+        : undefined;
+    if (sender) {
+        return sender;
+    }
+    const directInputChat = typeof message?.getInputChat === "function"
+        ? await message.getInputChat().catch(() => undefined)
+        : undefined;
+    if (directInputChat) {
+        return directInputChat;
+    }
+    const chat = typeof message?.getChat === "function"
+        ? await message.getChat().catch(() => undefined)
+        : undefined;
+    if (chat) {
+        return chat;
+    }
+    return message?.inputSender ?? message?._inputSender ?? message?.sender ?? message?._sender ?? message?.inputChat ?? message?._inputChat ?? message?.chat ?? message?._chat ?? message?.peerId;
+}
+async function resolveChatTarget(message) {
+    const directInputChat = typeof message?.getInputChat === "function"
+        ? await message.getInputChat().catch(() => undefined)
+        : undefined;
+    if (directInputChat) {
+        return directInputChat;
+    }
+    const chat = typeof message?.getChat === "function"
+        ? await message.getChat().catch(() => undefined)
+        : undefined;
+    if (chat) {
+        return chat;
+    }
+    return message?.inputChat ?? message?._inputChat ?? message?.chat ?? message?._chat ?? message?.peerId;
+}
+async function isReplyToSelfMessage(message, selfId) {
+    if (!selfId) {
+        return false;
+    }
+    const replyToMessageId = message?.replyTo?.replyToMsgId ?? message?.replyToMsgId;
+    if (!replyToMessageId) {
+        return false;
+    }
+    const replied = typeof message?.getReplyMessage === "function"
+        ? await message.getReplyMessage().catch(() => undefined)
+        : undefined;
+    if (!replied) {
+        return false;
+    }
+    if (replied.out === true) {
+        return true;
+    }
+    const replySenderId = replied.senderId ??
+        replied.fromId?.userId ??
+        replied.fromId?.channelId;
+    return replySenderId !== undefined && String(replySenderId) === selfId;
+}
+async function resolveSenderProfile(message, input) {
+    const pickProfile = (source) => {
+        const activeUsername = Array.isArray(source?.usernames)
+            ? source.usernames.find((entry) => entry?.active !== false && typeof entry?.username === "string")?.username
+            : undefined;
+        return {
+            username: typeof source?.username === "string" ? source.username : activeUsername,
+            firstName: typeof source?.firstName === "string" ? source.firstName : undefined,
+            lastName: typeof source?.lastName === "string" ? source.lastName : undefined,
+        };
+    };
+    const sender = typeof message?.getSender === "function"
+        ? await message.getSender().catch(() => undefined)
+        : undefined;
+    const inputSender = typeof message?.getInputSender === "function"
+        ? await message.getInputSender().catch(() => undefined)
+        : undefined;
+    const inputSenderEntity = inputSender && typeof input?.client?.getEntity === "function"
+        ? await input.client.getEntity(inputSender).catch(() => undefined)
+        : undefined;
+    const fromEntity = message?.fromId && typeof input?.client?.getEntity === "function"
+        ? await input.client.getEntity(message.fromId).catch(() => undefined)
+        : undefined;
+    const numericSenderId = input?.senderId && /^\d+$/.test(input.senderId) && Number.isSafeInteger(Number(input.senderId))
+        ? Number(input.senderId)
+        : undefined;
+    const entity = input?.senderId && typeof input?.client?.getEntity === "function"
+        ? await input.client.getEntity(numericSenderId ?? input.senderId).catch(() => undefined)
+        : undefined;
+    const profiles = [
+        pickProfile(sender),
+        pickProfile(inputSenderEntity),
+        pickProfile(fromEntity),
+        pickProfile(entity),
+        pickProfile(message?.sender),
+        pickProfile(message?._sender),
+    ];
+    const profile = profiles.find((candidate) => candidate.username) ??
+        profiles.find((candidate) => candidate.firstName || candidate.lastName);
+    const username = profile?.username;
+    const display = toDisplayName({
+        username,
+        firstName: profile?.firstName,
+        lastName: profile?.lastName,
+    });
+    return {
+        username,
+        display,
+    };
+}
+async function resolveSenderProfileWithTimeout(message, input, timeoutMs = 1500) {
+    return await withTimeout(resolveSenderProfile(message, input), timeoutMs) ?? {};
+}