cclawd 1.0.2 → 1.0.4

package/dist/plugin-sdk/manager-runtime-C70EkEr7.js

@@ -0,0 +1,11 @@
+import "./paths-BtVqCdw4.js";
+import "./config-B9ODwgpz.js";
+import "./paths-eFexkPEh.js";
+import "./github-copilot-token-Cxf8QYZb.js";
+import "./logger-D6zRubj0.js";
+import "./env-b9k1PHMI.js";
+import "./fetch-guard-4UVSZ0uS.js";
+import "./api-key-rotation-CimGYMBc.js";
+import "./sqlite-CJE3X7Mv.js";
+import { n as closeAllMemoryIndexManagers, t as MemoryIndexManager } from "./manager-CHy8IclH.js";
+export { MemoryIndexManager, closeAllMemoryIndexManagers };

package/dist/plugin-sdk/outbound-Wzs2iN7X.js

@@ -0,0 +1,216 @@
+import { Sl as redactIdentifier, Ua as resolveWhatsAppMediaMaxBytes, Va as resolveWhatsAppAccount, r as loadConfig, ts as generateSecureUuid } from "./config-B9ODwgpz.js";
+import { K as getChildLogger, N as toWhatsappJid, a as createSubsystemLogger, v as escapeRegExp } from "./logger-D6zRubj0.js";
+import { n as normalizePollInput } from "./polls-CL1LDouN.js";
+import { i as resolveMarkdownTableMode, v as loadWebMedia } from "./ir-CugsqGH8.js";
+import { t as convertMarkdownTables } from "./tables-D5VgpTmm.js";
+import { n as requireActiveWebListener } from "./active-listener-CN-tMEvN.js";
+//#region src/markdown/whatsapp.ts
+/**
+* Convert standard Markdown formatting to WhatsApp-compatible markup.
+*
+* WhatsApp uses its own formatting syntax:
+*   bold:          *text*
+*   italic:        _text_
+*   strikethrough: ~text~
+*   monospace:     ```text```
+*
+* Standard Markdown uses:
+*   bold:          **text** or __text__
+*   italic:        *text* or _text_
+*   strikethrough: ~~text~~
+*   code:          `text` (inline) or ```text``` (block)
+*
+* The conversion preserves fenced code blocks and inline code,
+* then converts bold and strikethrough markers.
+*/
+/** Placeholder tokens used during conversion to protect code spans. */
+const FENCE_PLACEHOLDER = "\0FENCE";
+const INLINE_CODE_PLACEHOLDER = "\0CODE";
+/**
+* Convert standard Markdown bold/italic/strikethrough to WhatsApp formatting.
+*
+* Order of operations matters:
+* 1. Protect fenced code blocks (```...```) — already WhatsApp-compatible
+* 2. Protect inline code (`...`) — leave as-is
+* 3. Convert **bold** → *bold* and __bold__ → *bold*
+* 4. Convert ~~strike~~ → ~strike~
+* 5. Restore protected spans
+*
+* Italic *text* and _text_ are left alone since WhatsApp uses _text_ for italic
+* and single * is already WhatsApp bold — no conversion needed for single markers.
+*/
+function markdownToWhatsApp(text) {
+	if (!text) return text;
+	const fences = [];
+	let result = text.replace(/```[\s\S]*?```/g, (match) => {
+		fences.push(match);
+		return `${FENCE_PLACEHOLDER}${fences.length - 1}`;
+	});
+	const inlineCodes = [];
+	result = result.replace(/`[^`\n]+`/g, (match) => {
+		inlineCodes.push(match);
+		return `${INLINE_CODE_PLACEHOLDER}${inlineCodes.length - 1}`;
+	});
+	result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
+	result = result.replace(/__(.+?)__/g, "*$1*");
+	result = result.replace(/~~(.+?)~~/g, "~$1~");
+	result = result.replace(new RegExp(`${escapeRegExp(INLINE_CODE_PLACEHOLDER)}(\\d+)`, "g"), (_, idx) => inlineCodes[Number(idx)] ?? "");
+	result = result.replace(new RegExp(`${escapeRegExp(FENCE_PLACEHOLDER)}(\\d+)`, "g"), (_, idx) => fences[Number(idx)] ?? "");
+	return result;
+}
+//#endregion
+//#region src/web/outbound.ts
+const outboundLog = createSubsystemLogger("gateway/channels/whatsapp").child("outbound");
+async function sendMessageWhatsApp(to, body, options) {
+	let text = body;
+	const correlationId = generateSecureUuid();
+	const startedAt = Date.now();
+	const { listener: active, accountId: resolvedAccountId } = requireActiveWebListener(options.accountId);
+	const cfg = options.cfg ?? loadConfig();
+	const account = resolveWhatsAppAccount({
+		cfg,
+		accountId: resolvedAccountId ?? options.accountId
+	});
+	const tableMode = resolveMarkdownTableMode({
+		cfg,
+		channel: "whatsapp",
+		accountId: resolvedAccountId ?? options.accountId
+	});
+	text = convertMarkdownTables(text ?? "", tableMode);
+	text = markdownToWhatsApp(text);
+	const redactedTo = redactIdentifier(to);
+	const logger = getChildLogger({
+		module: "web-outbound",
+		correlationId,
+		to: redactedTo
+	});
+	try {
+		const jid = toWhatsappJid(to);
+		const redactedJid = redactIdentifier(jid);
+		let mediaBuffer;
+		let mediaType;
+		let documentFileName;
+		if (options.mediaUrl) {
+			const media = await loadWebMedia(options.mediaUrl, {
+				maxBytes: resolveWhatsAppMediaMaxBytes(account),
+				localRoots: options.mediaLocalRoots
+			});
+			const caption = text || void 0;
+			mediaBuffer = media.buffer;
+			mediaType = media.contentType;
+			if (media.kind === "audio") mediaType = media.contentType === "audio/ogg" ? "audio/ogg; codecs=opus" : media.contentType ?? "application/octet-stream";
+			else if (media.kind === "video") text = caption ?? "";
+			else if (media.kind === "image") text = caption ?? "";
+			else {
+				text = caption ?? "";
+				documentFileName = media.fileName;
+			}
+		}
+		outboundLog.info(`Sending message -> ${redactedJid}${options.mediaUrl ? " (media)" : ""}`);
+		logger.info({
+			jid: redactedJid,
+			hasMedia: Boolean(options.mediaUrl)
+		}, "sending message");
+		await active.sendComposingTo(to);
+		const accountId = Boolean(options.accountId?.trim()) ? resolvedAccountId : void 0;
+		const sendOptions = options.gifPlayback || accountId || documentFileName ? {
+			...options.gifPlayback ? { gifPlayback: true } : {},
+			...documentFileName ? { fileName: documentFileName } : {},
+			accountId
+		} : void 0;
+		const messageId = (sendOptions ? await active.sendMessage(to, text, mediaBuffer, mediaType, sendOptions) : await active.sendMessage(to, text, mediaBuffer, mediaType))?.messageId ?? "unknown";
+		const durationMs = Date.now() - startedAt;
+		outboundLog.info(`Sent message ${messageId} -> ${redactedJid}${options.mediaUrl ? " (media)" : ""} (${durationMs}ms)`);
+		logger.info({
+			jid: redactedJid,
+			messageId
+		}, "sent message");
+		return {
+			messageId,
+			toJid: jid
+		};
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			to: redactedTo,
+			hasMedia: Boolean(options.mediaUrl)
+		}, "failed to send via web session");
+		throw err;
+	}
+}
+async function sendReactionWhatsApp(chatJid, messageId, emoji, options) {
+	const correlationId = generateSecureUuid();
+	const { listener: active } = requireActiveWebListener(options.accountId);
+	const redactedChatJid = redactIdentifier(chatJid);
+	const logger = getChildLogger({
+		module: "web-outbound",
+		correlationId,
+		chatJid: redactedChatJid,
+		messageId
+	});
+	try {
+		const redactedJid = redactIdentifier(toWhatsappJid(chatJid));
+		outboundLog.info(`Sending reaction "${emoji}" -> message ${messageId}`);
+		logger.info({
+			chatJid: redactedJid,
+			messageId,
+			emoji
+		}, "sending reaction");
+		await active.sendReaction(chatJid, messageId, emoji, options.fromMe ?? false, options.participant);
+		outboundLog.info(`Sent reaction "${emoji}" -> message ${messageId}`);
+		logger.info({
+			chatJid: redactedJid,
+			messageId,
+			emoji
+		}, "sent reaction");
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			chatJid: redactedChatJid,
+			messageId,
+			emoji
+		}, "failed to send reaction via web session");
+		throw err;
+	}
+}
+async function sendPollWhatsApp(to, poll, options) {
+	const correlationId = generateSecureUuid();
+	const startedAt = Date.now();
+	const { listener: active } = requireActiveWebListener(options.accountId);
+	const redactedTo = redactIdentifier(to);
+	const logger = getChildLogger({
+		module: "web-outbound",
+		correlationId,
+		to: redactedTo
+	});
+	try {
+		const jid = toWhatsappJid(to);
+		const redactedJid = redactIdentifier(jid);
+		const normalized = normalizePollInput(poll, { maxOptions: 12 });
+		outboundLog.info(`Sending poll -> ${redactedJid}`);
+		logger.info({
+			jid: redactedJid,
+			optionCount: normalized.options.length,
+			maxSelections: normalized.maxSelections
+		}, "sending poll");
+		const messageId = (await active.sendPoll(to, normalized))?.messageId ?? "unknown";
+		const durationMs = Date.now() - startedAt;
+		outboundLog.info(`Sent poll ${messageId} -> ${redactedJid} (${durationMs}ms)`);
+		logger.info({
+			jid: redactedJid,
+			messageId
+		}, "sent poll");
+		return {
+			messageId,
+			toJid: jid
+		};
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			to: redactedTo
+		}, "failed to send poll via web session");
+		throw err;
+	}
+}
+//#endregion
+export { markdownToWhatsApp as i, sendPollWhatsApp as n, sendReactionWhatsApp as r, sendMessageWhatsApp as t };

package/dist/plugin-sdk/outbound-attachment-khXJwucX.js

@@ -0,0 +1,17 @@
+import { ws as saveMediaBuffer } from "./config-B9ODwgpz.js";
+import { t as buildOutboundMediaLoadOptions } from "./load-options-CE0_U2E0.js";
+import { v as loadWebMedia } from "./ir-CugsqGH8.js";
+//#region src/media/outbound-attachment.ts
+async function resolveOutboundAttachmentFromUrl(mediaUrl, maxBytes, options) {
+	const media = await loadWebMedia(mediaUrl, buildOutboundMediaLoadOptions({
+		maxBytes,
+		mediaLocalRoots: options?.localRoots
+	}));
+	const saved = await saveMediaBuffer(media.buffer, media.contentType ?? void 0, "outbound", maxBytes);
+	return {
+		path: saved.path,
+		contentType: saved.contentType
+	};
+}
+//#endregion
+export { resolveOutboundAttachmentFromUrl as t };