@openclaw/whatsapp 2026.7.2-beta.7 → 2026.7.34

package/dist/targets-runtime-TMk0lGuy.js

@@ -1,299 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
-import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
-import { logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { FormatCapabilityProfile, markdownToIRWithMeta, renderMarkdownIRChunksWithinLimit, renderMarkdownWithMarkers, sliceMarkdownIR } from "openclaw/plugin-sdk/text-chunking";
-import { CONFIG_DIR, resolveUserPath as resolveUserPath$1 } from "openclaw/plugin-sdk/text-utility-runtime";
-//#region extensions/whatsapp/src/targets-runtime.ts
-const WHATSAPP_FORMAT_CAPABILITIES = FormatCapabilityProfile.define({
-	mechanism: "markdown",
-	constructs: {
-		underline: "strip",
-		spoiler: "fallback",
-		codeLanguage: "fallback",
-		linkLabel: "fallback",
-		heading: "fallback",
-		taskList: "fallback",
-		table: "fallback",
-		image: "fallback"
-	},
-	chunk: {
-		limit: 4096,
-		unit: "chars"
-	}
-});
-const WHATSAPP_STYLE_MARKERS = {
-	bold: {
-		open: "*",
-		close: "*"
-	},
-	italic: {
-		open: "_",
-		close: "_"
-	},
-	strikethrough: {
-		open: "~",
-		close: "~"
-	},
-	code: {
-		open: "```",
-		close: "```"
-	},
-	code_block: {
-		open: "```\n",
-		close: "```"
-	}
-};
-const WHATSAPP_INDENT_GUARD = "⁠";
-const WHATSAPP_MARKERS = [
-	"*",
-	"_",
-	"~",
-	"`"
-];
-function assertWebChannel(input) {
-	if (input !== "web") throw new Error("Web channel must be 'web'");
-}
-function isSelfChatMode(selfE164, allowFrom) {
-	if (!selfE164) return false;
-	if (!Array.isArray(allowFrom) || allowFrom.length === 0) return false;
-	const normalizedSelf = normalizeE164(selfE164);
-	return allowFrom.some((n) => {
-		if (n === "*") return false;
-		try {
-			return normalizeE164(String(n)) === normalizedSelf;
-		} catch {
-			return false;
-		}
-	});
-}
-function toWhatsappJid(number) {
-	const withoutPrefix = number.replace(/^whatsapp:/i, "").trim();
-	if (withoutPrefix.includes("@")) return withoutPrefix;
-	return `${normalizeE164(withoutPrefix).replace(/\D/g, "")}@s.whatsapp.net`;
-}
-function toWhatsappJidWithLid(number, opts) {
-	const stripped = number.replace(/^whatsapp:/i, "").trim();
-	if (stripped.includes("@")) return stripped;
-	const phoneDigits = normalizeE164(stripped).replace(/\D/g, "");
-	const lid = readLidForwardMapping({
-		phoneDigits,
-		opts
-	});
-	return lid ? `${lid}@lid` : `${phoneDigits}@s.whatsapp.net`;
-}
-function addUniqueString(target, value) {
-	const normalized = value?.trim();
-	if (normalized && !target.includes(normalized)) target.push(normalized);
-}
-async function tryLookupMappedJid(lookup) {
-	if (!lookup) return null;
-	try {
-		return await lookup() ?? null;
-	} catch (err) {
-		if (shouldLogVerbose()) logVerbose(`LID mapping lookup failed: ${String(err)}`);
-		return null;
-	}
-}
-const DIRECT_PN_JID_RE = /^(\d+)(?::\d+)?@(s\.whatsapp\.net|hosted)$/i;
-const DIRECT_LID_JID_RE = /^(\d+)(?::\d+)?@(lid|hosted\.lid)$/i;
-function addEquivalentDirectChatCandidate(target, jid) {
-	addUniqueString(target, jid);
-	const pnMatch = jid?.match(DIRECT_PN_JID_RE);
-	if (pnMatch) {
-		addUniqueString(target, `${pnMatch[1]}@${pnMatch[2]}`);
-		return;
-	}
-	const lidMatch = jid?.match(DIRECT_LID_JID_RE);
-	if (lidMatch) addUniqueString(target, `${lidMatch[1]}@${lidMatch[2]}`);
-}
-async function resolveEquivalentWhatsAppDirectChatJids(jid, opts) {
-	const normalized = jid?.trim();
-	if (!normalized) return [];
-	const candidates = [];
-	addEquivalentDirectChatCandidate(candidates, normalized);
-	const pnMatch = normalized.match(DIRECT_PN_JID_RE);
-	if (pnMatch) {
-		addEquivalentDirectChatCandidate(candidates, await tryLookupMappedJid(() => opts?.lidLookup?.getLIDForPN?.(normalized)));
-		const phoneDigits = pnMatch[1];
-		const pnDomain = pnMatch[2];
-		if (!phoneDigits || !pnDomain) return candidates;
-		const mappedLocalLid = readLidForwardMapping({
-			phoneDigits,
-			opts
-		});
-		const localLidDomain = pnDomain.toLowerCase() === "hosted" ? "hosted.lid" : "lid";
-		addUniqueString(candidates, mappedLocalLid ? `${mappedLocalLid}@${localLidDomain}` : null);
-		return candidates;
-	}
-	const lidMatch = normalized.match(DIRECT_LID_JID_RE);
-	if (lidMatch) {
-		addEquivalentDirectChatCandidate(candidates, await tryLookupMappedJid(() => opts?.lidLookup?.getPNForLID?.(normalized)));
-		const lidDomain = lidMatch[2];
-		if (!lidMatch[1] || !lidDomain) return candidates;
-		const e164 = jidToE164(normalized, {
-			...opts,
-			logMissing: false
-		});
-		addUniqueString(candidates, e164 && lidDomain.toLowerCase() === "hosted.lid" ? `${e164.replace(/\D/g, "")}@hosted` : e164 ? toWhatsappJid(e164) : null);
-	}
-	return candidates;
-}
-function resolveLidMappingDirs(params) {
-	const dirs = /* @__PURE__ */ new Set();
-	const addDir = (dir) => {
-		if (!dir) return;
-		dirs.add(resolveUserPath$1(dir));
-	};
-	addDir(params.opts?.authDir);
-	for (const dir of params.opts?.lidMappingDirs ?? []) addDir(dir);
-	addDir(CONFIG_DIR);
-	addDir(path.join(CONFIG_DIR, "credentials"));
-	return [...dirs];
-}
-function readLidReverseMapping(params) {
-	const mappingFilename = `lid-mapping-${params.lid}_reverse.json`;
-	const mappingDirs = resolveLidMappingDirs({ opts: params.opts });
-	for (const dir of mappingDirs) {
-		const mappingPath = path.join(dir, mappingFilename);
-		try {
-			const data = fs.readFileSync(mappingPath, "utf8");
-			const phone = JSON.parse(data);
-			if (phone === null || phone === void 0) continue;
-			return normalizeE164(String(phone));
-		} catch {}
-	}
-	return null;
-}
-function readLidForwardMapping(params) {
-	const mappingFilename = `lid-mapping-${params.phoneDigits}.json`;
-	const mappingDirs = resolveLidMappingDirs({ opts: params.opts });
-	for (const dir of mappingDirs) {
-		const mappingPath = path.join(dir, mappingFilename);
-		try {
-			const data = fs.readFileSync(mappingPath, "utf8");
-			const lid = JSON.parse(data);
-			if (lid === null || lid === void 0) continue;
-			const digits = String(lid).replace(/\D/g, "");
-			if (digits) return digits;
-		} catch {}
-	}
-	return null;
-}
-function jidToE164(jid, opts) {
-	const phoneDigits = jid.match(/^(\d+)(?::\d+)?@(s\.whatsapp\.net|hosted)$/)?.[1];
-	if (phoneDigits) return `+${phoneDigits}`;
-	const lidMatch = jid.match(/^(\d+)(?::\d+)?@(lid|hosted\.lid)$/);
-	if (!lidMatch) return null;
-	const lid = lidMatch[1];
-	if (!lid) return null;
-	const phone = readLidReverseMapping({
-		lid,
-		opts
-	});
-	if (phone) return phone;
-	if (opts?.logMissing ?? shouldLogVerbose()) logVerbose(`LID mapping not found for ${lidMatch[1]}; skipping inbound message`);
-	return null;
-}
-async function resolveJidToE164(jid, opts) {
-	if (!jid) return null;
-	const direct = jidToE164(jid, opts);
-	if (direct) return direct;
-	if (!/(@lid|@hosted\.lid)$/.test(jid) || !opts?.lidLookup?.getPNForLID) return null;
-	try {
-		const pnJid = await opts.lidLookup.getPNForLID(jid);
-		if (!pnJid) return null;
-		return jidToE164(pnJid, opts);
-	} catch (err) {
-		if (shouldLogVerbose()) logVerbose(`LID mapping lookup failed for ${jid}: ${String(err)}`);
-		return null;
-	}
-}
-function protectWhatsAppEscapedMarkers(text) {
-	const placeholders = [];
-	for (const [start, end] of [[57344, 63743], [983040, 1048573]]) for (let codePoint = start; codePoint <= end && placeholders.length < WHATSAPP_MARKERS.length; codePoint += 1) {
-		const candidate = String.fromCodePoint(codePoint);
-		if (!text.includes(candidate)) placeholders.push(candidate);
-	}
-	if (placeholders.length < WHATSAPP_MARKERS.length) throw new Error("Unable to reserve WhatsApp formatting placeholders");
-	const markers = WHATSAPP_MARKERS.map((marker, index) => ({
-		source: `\\${marker}`,
-		placeholder: placeholders[index] ?? ""
-	}));
-	let protectedText = text;
-	for (const { source, placeholder } of markers) protectedText = protectedText.replaceAll(source, placeholder);
-	return {
-		text: protectedText,
-		markers
-	};
-}
-function restoreWhatsAppEscapedMarkers(text, markers) {
-	let restored = text;
-	for (const { source, placeholder } of markers) restored = restored.replaceAll(placeholder, source);
-	return restored;
-}
-function renderWhatsAppMarkdownIR(ir, escapedMarkers) {
-	return renderMarkdownWithMarkers(ir, {
-		styleMarkers: WHATSAPP_STYLE_MARKERS,
-		escapeText: (value) => restoreWhatsAppEscapedMarkers(value, escapedMarkers)
-	}, WHATSAPP_FORMAT_CAPABILITIES);
-}
-function prepareWhatsAppMarkdown(text, tableMode) {
-	const guardedIndent = /^[\t ]/u.test(text);
-	const escaped = protectWhatsAppEscapedMarkers(text);
-	const markdown = guardedIndent ? `${WHATSAPP_INDENT_GUARD}${escaped.text}` : escaped.text;
-	const trailingWhitespace = text.match(/\s+$/u)?.[0] ?? "";
-	const { ir: parsedIr, hasTables } = markdownToIRWithMeta(markdown, {
-		linkify: false,
-		autolink: false,
-		enableSpoilers: true,
-		enableHtmlUnderline: true,
-		enableTaskLists: true,
-		headingStyle: "rich",
-		blockquotePrefix: "> ",
-		tableMode: tableMode === "block" ? "code" : tableMode,
-		preserveSourceBlockSpacing: true
-	});
-	let ir = parsedIr;
-	if (guardedIndent && ir.text.startsWith(WHATSAPP_INDENT_GUARD)) ir = sliceMarkdownIR(ir, 1, ir.text.length);
-	if (!hasTables && trailingWhitespace) ir.text = `${ir.text.trimEnd()}${trailingWhitespace}`;
-	return {
-		ir,
-		escapedMarkers: escaped.markers
-	};
-}
-function splitWhatsAppIRForChunkMode(ir, limit, chunkMode) {
-	if (chunkMode !== "newline") return [ir];
-	const chunkTexts = chunkMarkdownTextWithMode(ir.text, limit, chunkMode);
-	const chunks = [];
-	let cursor = 0;
-	for (const text of chunkTexts) {
-		const start = ir.text.indexOf(text, cursor);
-		if (start < 0) return [ir];
-		const end = start + text.length;
-		chunks.push(sliceMarkdownIR(ir, start, end));
-		cursor = end;
-	}
-	return chunks;
-}
-function markdownToWhatsAppChunks(text, limit, tableMode = "bullets", chunkMode = "length") {
-	if (!text) return [];
-	if (!text.trim()) return chunkMarkdownTextWithMode(text, limit, chunkMode);
-	const { ir, escapedMarkers } = prepareWhatsAppMarkdown(text, tableMode);
-	const render = (chunk) => renderWhatsAppMarkdownIR(chunk, escapedMarkers);
-	const rendered = render(ir);
-	let chunks = ir.styles.length === 0 && ir.links.length === 0 ? chunkMarkdownTextWithMode(rendered, limit, chunkMode) : splitWhatsAppIRForChunkMode(ir, limit, chunkMode).flatMap((source) => renderMarkdownIRChunksWithinLimit({
-		ir: source,
-		limit,
-		renderChunk: render,
-		measureRendered: (value) => value.length
-	}).map((chunk) => chunk.rendered));
-	if (chunkMode === "newline") chunks = chunks.map((chunk) => chunk.trimEnd()).filter(Boolean);
-	return chunks;
-}
-function markdownToWhatsApp(text, tableMode = "bullets") {
-	return markdownToWhatsAppChunks(text, Number.POSITIVE_INFINITY, tableMode).join("");
-}
-//#endregion
-export { markdownToWhatsAppChunks as a, toWhatsappJid as c, markdownToWhatsApp as i, toWhatsappJidWithLid as l, isSelfChatMode as n, resolveEquivalentWhatsAppDirectChatJids as o, jidToE164 as r, resolveJidToE164 as s, assertWebChannel as t };

package/dist/text-runtime-CaKLhowd.js

@@ -1,4 +0,0 @@
-import "./targets-runtime-TMk0lGuy.js";
-import { sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithProfile, stripToolCallXmlTags } from "openclaw/plugin-sdk/text-chunking";
-import { normalizeE164, resolveUserPath as resolveUserPath$1 } from "openclaw/plugin-sdk/text-utility-runtime";
-export { stripToolCallXmlTags as a, sanitizeAssistantVisibleTextWithProfile as i, resolveUserPath$1 as n, sanitizeAssistantVisibleText as r, normalizeE164 as t };

package/node_modules/baileys/node_modules/protobufjs/ext/README.md

@@ -1,70 +0,0 @@
-# protobuf.js Extensions
-
-## descriptor
-
-Optional `descriptor.proto` support for converting reflected protobuf.js roots and objects to and from descriptor messages.
-
-```js
-import protobuf from "protobufjs";
-import descriptor from "protobufjs/ext/descriptor.js";
-
-// Convert an existing root to a FileDescriptorSet message.
-const root = ...;
-const set = root.toDescriptor("proto2");
-
-// Encode descriptor buffers.
-const buffer = descriptor.FileDescriptorSet.encode(set).finish();
-
-// Convert a FileDescriptorSet message or buffer back to a root.
-const decodedRoot = protobuf.Root.fromDescriptor(buffer);
-```
-
-The extension requires reflection metadata and also works with `protobufjs/light.js` when schemas are loaded from JSON or otherwise provided as reflection objects.
-
-Importing the extension adds `.fromDescriptor(descriptor[, editionOrContext])` and `#toDescriptor([syntaxOrEdition])` methods to reflection objects and exports the bundled descriptor types from `google.protobuf`. Descriptor inputs can be decoded messages, readers, or buffers of the corresponding descriptor messages. Direct object descriptor imports accept either an edition string or a descriptor context with `edition`, `features` and `keepCase`.
-
-The conversion covers descriptor messages that correspond to protobuf.js reflection objects: files and file sets, messages, fields and map fields, oneofs, enums, services and methods. Descriptor-only metadata such as source locations, generated-code annotations and uninterpreted options remains available through the exported descriptor message types, but is not mapped onto reflection objects. File names are inferred when generating descriptors because roots do not retain exact file/package boundaries.
-
-## protojson
-
-Optional ProtoJSON support for reflected message types.
-
-> [!NOTE]
-> Specialized code generation for the `pbjs` static-module target is a potential future extension. If you need this for high-throughput JSON transcoding or REST fallbacks in production, consider getting in touch and supporting the codegen and conformance work.
-
-```js
-import protobuf from "protobufjs";
-import protojson from "protobufjs/ext/protojson.js";
-
-const root = ...;
-const MyType = root.lookupType("MyType");
-const message = protojson.fromJson(MyType, { value: 1 });
-const json = protojson.toJson(MyType, message);
-```
-
-```js
-const messageFromString = protojson.fromJsonString(MyType, '{"value":1}');
-const jsonString = protojson.toJsonString(MyType, messageFromString);
-```
-
-Importing the extension has no prototype side effects. Calling `protojson.install()` installs `fromJson`, `fromJsonString`, `toJson` and `toJsonString` convenience methods on `protobuf.Type.prototype`. It works with `protobufjs/light.js` when schemas are loaded from JSON or otherwise provided as reflection objects.
-
-Unknown fields can be ignored while parsing by passing `{ ignoreUnknownFields: true }` to `fromJson` or `fromJsonString`.
-
-## textformat
-
-Optional Text Format support for reflected message types.
-
-```js
-import protobuf from "protobufjs";
-import textformat from "protobufjs/ext/textformat.js";
-
-const root = ...;
-const MyType = root.lookupType("MyType");
-const message = textformat.fromText(MyType, "value: 1");
-const text = textformat.toText(MyType, message);
-```
-
-Importing the extension has no prototype side effects. Calling `textformat.install()` installs `fromText` and `toText` convenience methods on `protobuf.Type.prototype`. It works with `protobufjs/light.js` when schemas are loaded from JSON or otherwise provided as reflection objects.
-
-Unknown fields can be printed with numeric field names by passing `{ unknowns: true }` to `toText`.

package/node_modules/baileys/node_modules/protobufjs/ext/descriptor.d.ts

@@ -1,87 +0,0 @@
-import * as $protobuf from "..";
-import {
-    IDescriptorProto,
-    IDescriptorContext,
-    IEnumDescriptorProto,
-    IFieldDescriptorProto,
-    IFileDescriptorSet,
-    IMethodDescriptorProto,
-    IOneofDescriptorProto,
-    IServiceDescriptorProto
-} from "./descriptor.generated";
-
-export * from "./descriptor.generated";
-
-type DescriptorInput<T> = T | $protobuf.Reader | Uint8Array;
-
-declare module ".." {
-    namespace Root {
-        /** Creates a root from a descriptor set. */
-        function fromDescriptor(descriptor: DescriptorInput<IFileDescriptorSet>, options?: { keepCase?: boolean }): $protobuf.Root;
-    }
-
-    interface Root {
-        /** Converts this root to a descriptor set. */
-        toDescriptor(edition?: string): $protobuf.Message<IFileDescriptorSet> & IFileDescriptorSet;
-    }
-
-    namespace Type {
-        /** Creates a type from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.Type;
-    }
-
-    interface Type {
-        /** Converts this type to a descriptor. */
-        toDescriptor(edition?: string): $protobuf.Message<IDescriptorProto> & IDescriptorProto;
-    }
-
-    namespace Field {
-        /** Creates a field from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IFieldDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.Field;
-    }
-
-    interface Field {
-        /** Converts this field to a descriptor. */
-        toDescriptor(edition?: string): $protobuf.Message<IFieldDescriptorProto> & IFieldDescriptorProto;
-    }
-
-    namespace Enum {
-        /** Creates an enum from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IEnumDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.Enum;
-    }
-
-    interface Enum {
-        /** Converts this enum to a descriptor. */
-        toDescriptor(): $protobuf.Message<IEnumDescriptorProto> & IEnumDescriptorProto;
-    }
-
-    namespace OneOf {
-        /** Creates a oneof from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IOneofDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.OneOf;
-    }
-
-    interface OneOf {
-        /** Converts this oneof to a descriptor. */
-        toDescriptor(): $protobuf.Message<IOneofDescriptorProto> & IOneofDescriptorProto;
-    }
-
-    namespace Service {
-        /** Creates a service from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IServiceDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.Service;
-    }
-
-    interface Service {
-        /** Converts this service to a descriptor. */
-        toDescriptor(): $protobuf.Message<IServiceDescriptorProto> & IServiceDescriptorProto;
-    }
-
-    namespace Method {
-        /** Creates a method from a descriptor. */
-        function fromDescriptor(descriptor: DescriptorInput<IMethodDescriptorProto>, editionOrContext?: string | IDescriptorContext): $protobuf.Method;
-    }
-
-    interface Method {
-        /** Converts this method to a descriptor. */
-        toDescriptor(): $protobuf.Message<IMethodDescriptorProto> & IMethodDescriptorProto;
-    }
-}