squidclaw 3.0.13 → 3.0.14

package/dist/plugin-sdk/send-MlSZ82sA.js

@@ -0,0 +1,414 @@
+import { n as loadConfig } from "./config-FhBFLsNm.js";
+import { L as logVerbose } from "./logger-DDdrdbDu.js";
+import { F as resolveSlackBotToken, M as resolveSlackAccount, m as parseSlackTarget } from "./plugins-6NxPd6TS.js";
+import { r as withTrustedEnvProxyGuardedFetchMode, t as fetchWithSsrFGuard } from "./fetch-guard-W_A4uSz2.js";
+import { c as chunkMarkdownTextWithMode, d as resolveChunkMode, f as resolveTextChunkLimit, i as resolveMarkdownTableMode, n as markdownToIR, t as chunkMarkdownIR, v as loadWebMedia } from "./ir-JaPZ0yKH.js";
+import { t as renderMarkdownWithMarkers } from "./render-HmipMDlP.js";
+import { i as isSilentReplyText } from "./tokens-CTIYTLWu.js";
+import { WebClient } from "@slack/web-api";
+
+//#region src/slack/blocks-input.ts
+const SLACK_MAX_BLOCKS = 50;
+function parseBlocksJson(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		throw new Error("blocks must be valid JSON");
+	}
+}
+function assertBlocksArray(raw) {
+	if (!Array.isArray(raw)) throw new Error("blocks must be an array");
+	if (raw.length === 0) throw new Error("blocks must contain at least one block");
+	if (raw.length > SLACK_MAX_BLOCKS) throw new Error(`blocks cannot exceed ${SLACK_MAX_BLOCKS} items`);
+	for (const block of raw) {
+		if (!block || typeof block !== "object" || Array.isArray(block)) throw new Error("each block must be an object");
+		const type = block.type;
+		if (typeof type !== "string" || type.trim().length === 0) throw new Error("each block must include a non-empty string type");
+	}
+}
+function validateSlackBlocksArray(raw) {
+	assertBlocksArray(raw);
+	return raw;
+}
+function parseSlackBlocksInput(raw) {
+	if (raw == null) return;
+	return validateSlackBlocksArray(typeof raw === "string" ? parseBlocksJson(raw) : raw);
+}
+
+//#endregion
+//#region src/slack/client.ts
+const SLACK_DEFAULT_RETRY_OPTIONS = {
+	retries: 2,
+	factor: 2,
+	minTimeout: 500,
+	maxTimeout: 3e3,
+	randomize: true
+};
+function resolveSlackWebClientOptions(options = {}) {
+	return {
+		...options,
+		retryConfig: options.retryConfig ?? SLACK_DEFAULT_RETRY_OPTIONS
+	};
+}
+function createSlackWebClient(token, options = {}) {
+	return new WebClient(token, resolveSlackWebClientOptions(options));
+}
+
+//#endregion
+//#region src/slack/blocks-fallback.ts
+function cleanCandidate(value) {
+	if (typeof value !== "string") return;
+	const normalized = value.replace(/\s+/g, " ").trim();
+	return normalized.length > 0 ? normalized : void 0;
+}
+function readSectionText(block) {
+	return cleanCandidate(block.text?.text);
+}
+function readHeaderText(block) {
+	return cleanCandidate(block.text?.text);
+}
+function readImageText(block) {
+	return cleanCandidate(block.alt_text) ?? cleanCandidate(block.title?.text);
+}
+function readVideoText(block) {
+	return cleanCandidate(block.title?.text) ?? cleanCandidate(block.alt_text);
+}
+function readContextText(block) {
+	if (!Array.isArray(block.elements)) return;
+	const textParts = block.elements.map((element) => cleanCandidate(element.text)).filter((value) => Boolean(value));
+	return textParts.length > 0 ? textParts.join(" ") : void 0;
+}
+function buildSlackBlocksFallbackText(blocks) {
+	for (const raw of blocks) {
+		const block = raw;
+		switch (block.type) {
+			case "header": {
+				const text = readHeaderText(block);
+				if (text) return text;
+				break;
+			}
+			case "section": {
+				const text = readSectionText(block);
+				if (text) return text;
+				break;
+			}
+			case "image": {
+				const text = readImageText(block);
+				if (text) return text;
+				return "Shared an image";
+			}
+			case "video": {
+				const text = readVideoText(block);
+				if (text) return text;
+				return "Shared a video";
+			}
+			case "file": return "Shared a file";
+			case "context": {
+				const text = readContextText(block);
+				if (text) return text;
+				break;
+			}
+			default: break;
+		}
+	}
+	return "Shared a Block Kit message";
+}
+
+//#endregion
+//#region src/slack/format.ts
+function escapeSlackMrkdwnSegment(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+const SLACK_ANGLE_TOKEN_RE = /<[^>\n]+>/g;
+function isAllowedSlackAngleToken(token) {
+	if (!token.startsWith("<") || !token.endsWith(">")) return false;
+	const inner = token.slice(1, -1);
+	return inner.startsWith("@") || inner.startsWith("#") || inner.startsWith("!") || inner.startsWith("mailto:") || inner.startsWith("tel:") || inner.startsWith("http://") || inner.startsWith("https://") || inner.startsWith("slack://");
+}
+function escapeSlackMrkdwnContent(text) {
+	if (!text) return "";
+	if (!text.includes("&") && !text.includes("<") && !text.includes(">")) return text;
+	SLACK_ANGLE_TOKEN_RE.lastIndex = 0;
+	const out = [];
+	let lastIndex = 0;
+	for (let match = SLACK_ANGLE_TOKEN_RE.exec(text); match; match = SLACK_ANGLE_TOKEN_RE.exec(text)) {
+		const matchIndex = match.index ?? 0;
+		out.push(escapeSlackMrkdwnSegment(text.slice(lastIndex, matchIndex)));
+		const token = match[0] ?? "";
+		out.push(isAllowedSlackAngleToken(token) ? token : escapeSlackMrkdwnSegment(token));
+		lastIndex = matchIndex + token.length;
+	}
+	out.push(escapeSlackMrkdwnSegment(text.slice(lastIndex)));
+	return out.join("");
+}
+function escapeSlackMrkdwnText(text) {
+	if (!text) return "";
+	if (!text.includes("&") && !text.includes("<") && !text.includes(">")) return text;
+	return text.split("\n").map((line) => {
+		if (line.startsWith("> ")) return `> ${escapeSlackMrkdwnContent(line.slice(2))}`;
+		return escapeSlackMrkdwnContent(line);
+	}).join("\n");
+}
+function buildSlackLink(link, text) {
+	const href = link.href.trim();
+	if (!href) return null;
+	const trimmedLabel = text.slice(link.start, link.end).trim();
+	const comparableHref = href.startsWith("mailto:") ? href.slice(7) : href;
+	if (!(trimmedLabel.length > 0 && trimmedLabel !== href && trimmedLabel !== comparableHref)) return null;
+	const safeHref = escapeSlackMrkdwnSegment(href);
+	return {
+		start: link.start,
+		end: link.end,
+		open: `<${safeHref}|`,
+		close: ">"
+	};
+}
+function buildSlackRenderOptions() {
+	return {
+		styleMarkers: {
+			bold: {
+				open: "*",
+				close: "*"
+			},
+			italic: {
+				open: "_",
+				close: "_"
+			},
+			strikethrough: {
+				open: "~",
+				close: "~"
+			},
+			code: {
+				open: "`",
+				close: "`"
+			},
+			code_block: {
+				open: "```\n",
+				close: "```"
+			}
+		},
+		escapeText: escapeSlackMrkdwnText,
+		buildLink: buildSlackLink
+	};
+}
+function markdownToSlackMrkdwn(markdown, options = {}) {
+	return renderMarkdownWithMarkers(markdownToIR(markdown ?? "", {
+		linkify: false,
+		autolink: false,
+		headingStyle: "bold",
+		blockquotePrefix: "> ",
+		tableMode: options.tableMode
+	}), buildSlackRenderOptions());
+}
+function normalizeSlackOutboundText(markdown) {
+	return markdownToSlackMrkdwn(markdown ?? "");
+}
+function markdownToSlackMrkdwnChunks(markdown, limit, options = {}) {
+	const chunks = chunkMarkdownIR(markdownToIR(markdown ?? "", {
+		linkify: false,
+		autolink: false,
+		headingStyle: "bold",
+		blockquotePrefix: "> ",
+		tableMode: options.tableMode
+	}), limit);
+	const renderOptions = buildSlackRenderOptions();
+	return chunks.map((chunk) => renderMarkdownWithMarkers(chunk, renderOptions));
+}
+
+//#endregion
+//#region src/slack/send.ts
+const SLACK_TEXT_LIMIT = 4e3;
+const SLACK_UPLOAD_SSRF_POLICY = {
+	allowedHostnames: [
+		"*.slack.com",
+		"*.slack-edge.com",
+		"*.slack-files.com"
+	],
+	allowRfc2544BenchmarkRange: true
+};
+function hasCustomIdentity(identity) {
+	return Boolean(identity?.username || identity?.iconUrl || identity?.iconEmoji);
+}
+function isSlackCustomizeScopeError(err) {
+	if (!(err instanceof Error)) return false;
+	const maybeData = err;
+	if (maybeData.data?.error?.toLowerCase() !== "missing_scope") return false;
+	if ((maybeData.data?.needed?.toLowerCase())?.includes("chat:write.customize")) return true;
+	return [...maybeData.data?.response_metadata?.scopes ?? [], ...maybeData.data?.response_metadata?.acceptedScopes ?? []].map((scope) => scope.toLowerCase()).includes("chat:write.customize");
+}
+async function postSlackMessageBestEffort(params) {
+	const basePayload = {
+		channel: params.channelId,
+		text: params.text,
+		thread_ts: params.threadTs,
+		...params.blocks?.length ? { blocks: params.blocks } : {}
+	};
+	try {
+		if (params.identity?.iconUrl) return await params.client.chat.postMessage({
+			...basePayload,
+			...params.identity.username ? { username: params.identity.username } : {},
+			icon_url: params.identity.iconUrl
+		});
+		if (params.identity?.iconEmoji) return await params.client.chat.postMessage({
+			...basePayload,
+			...params.identity.username ? { username: params.identity.username } : {},
+			icon_emoji: params.identity.iconEmoji
+		});
+		return await params.client.chat.postMessage({
+			...basePayload,
+			...params.identity?.username ? { username: params.identity.username } : {}
+		});
+	} catch (err) {
+		if (!hasCustomIdentity(params.identity) || !isSlackCustomizeScopeError(err)) throw err;
+		logVerbose("slack send: missing chat:write.customize, retrying without custom identity");
+		return params.client.chat.postMessage(basePayload);
+	}
+}
+function resolveToken(params) {
+	const explicit = resolveSlackBotToken(params.explicit);
+	if (explicit) return explicit;
+	const fallback = resolveSlackBotToken(params.fallbackToken);
+	if (!fallback) {
+		logVerbose(`slack send: missing bot token for account=${params.accountId} explicit=${Boolean(params.explicit)} source=${params.fallbackSource ?? "unknown"}`);
+		throw new Error(`Slack bot token missing for account "${params.accountId}" (set channels.slack.accounts.${params.accountId}.botToken or SLACK_BOT_TOKEN for default).`);
+	}
+	return fallback;
+}
+function parseRecipient(raw) {
+	const target = parseSlackTarget(raw);
+	if (!target) throw new Error("Recipient is required for Slack sends");
+	return {
+		kind: target.kind,
+		id: target.id
+	};
+}
+async function resolveChannelId(client, recipient) {
+	if (!(recipient.kind === "user" || /^U[A-Z0-9]+$/i.test(recipient.id))) return { channelId: recipient.id };
+	const channelId = (await client.conversations.open({ users: recipient.id })).channel?.id;
+	if (!channelId) throw new Error("Failed to open Slack DM channel");
+	return {
+		channelId,
+		isDm: true
+	};
+}
+async function uploadSlackFile(params) {
+	const { buffer, contentType, fileName } = await loadWebMedia(params.mediaUrl, {
+		maxBytes: params.maxBytes,
+		localRoots: params.mediaLocalRoots
+	});
+	const uploadUrlResp = await params.client.files.getUploadURLExternal({
+		filename: fileName ?? "upload",
+		length: buffer.length
+	});
+	if (!uploadUrlResp.ok || !uploadUrlResp.upload_url || !uploadUrlResp.file_id) throw new Error(`Failed to get upload URL: ${uploadUrlResp.error ?? "unknown error"}`);
+	const uploadBody = new Uint8Array(buffer);
+	const { response: uploadResp, release } = await fetchWithSsrFGuard(withTrustedEnvProxyGuardedFetchMode({
+		url: uploadUrlResp.upload_url,
+		init: {
+			method: "POST",
+			...contentType ? { headers: { "Content-Type": contentType } } : {},
+			body: uploadBody
+		},
+		policy: SLACK_UPLOAD_SSRF_POLICY,
+		auditContext: "slack-upload-file"
+	}));
+	try {
+		if (!uploadResp.ok) throw new Error(`Failed to upload file: HTTP ${uploadResp.status}`);
+	} finally {
+		await release();
+	}
+	const completeResp = await params.client.files.completeUploadExternal({
+		files: [{
+			id: uploadUrlResp.file_id,
+			title: fileName ?? "upload"
+		}],
+		channel_id: params.channelId,
+		...params.caption ? { initial_comment: params.caption } : {},
+		...params.threadTs ? { thread_ts: params.threadTs } : {}
+	});
+	if (!completeResp.ok) throw new Error(`Failed to complete upload: ${completeResp.error ?? "unknown error"}`);
+	return uploadUrlResp.file_id;
+}
+async function sendMessageSlack(to, message, opts = {}) {
+	const trimmedMessage = message?.trim() ?? "";
+	if (isSilentReplyText(trimmedMessage) && !opts.mediaUrl && !opts.blocks) {
+		logVerbose("slack send: suppressed NO_REPLY token before API call");
+		return {
+			messageId: "suppressed",
+			channelId: ""
+		};
+	}
+	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
+	if (!trimmedMessage && !opts.mediaUrl && !blocks) throw new Error("Slack send requires text, blocks, or media");
+	const cfg = opts.cfg ?? loadConfig();
+	const account = resolveSlackAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	const token = resolveToken({
+		explicit: opts.token,
+		accountId: account.accountId,
+		fallbackToken: account.botToken,
+		fallbackSource: account.botTokenSource
+	});
+	const client = opts.client ?? createSlackWebClient(token);
+	const { channelId } = await resolveChannelId(client, parseRecipient(to));
+	if (blocks) {
+		if (opts.mediaUrl) throw new Error("Slack send does not support blocks with mediaUrl");
+		return {
+			messageId: (await postSlackMessageBestEffort({
+				client,
+				channelId,
+				text: trimmedMessage || buildSlackBlocksFallbackText(blocks),
+				threadTs: opts.threadTs,
+				identity: opts.identity,
+				blocks
+			})).ts ?? "unknown",
+			channelId
+		};
+	}
+	const textLimit = resolveTextChunkLimit(cfg, "slack", account.accountId);
+	const chunkLimit = Math.min(textLimit, SLACK_TEXT_LIMIT);
+	const tableMode = resolveMarkdownTableMode({
+		cfg,
+		channel: "slack",
+		accountId: account.accountId
+	});
+	const chunkMode = resolveChunkMode(cfg, "slack", account.accountId);
+	const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(trimmedMessage, chunkLimit, chunkMode) : [trimmedMessage]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode }));
+	if (!chunks.length && trimmedMessage) chunks.push(trimmedMessage);
+	const mediaMaxBytes = typeof account.config.mediaMaxMb === "number" ? account.config.mediaMaxMb * 1024 * 1024 : void 0;
+	let lastMessageId = "";
+	if (opts.mediaUrl) {
+		const [firstChunk, ...rest] = chunks;
+		lastMessageId = await uploadSlackFile({
+			client,
+			channelId,
+			mediaUrl: opts.mediaUrl,
+			mediaLocalRoots: opts.mediaLocalRoots,
+			caption: firstChunk,
+			threadTs: opts.threadTs,
+			maxBytes: mediaMaxBytes
+		});
+		for (const chunk of rest) lastMessageId = (await postSlackMessageBestEffort({
+			client,
+			channelId,
+			text: chunk,
+			threadTs: opts.threadTs,
+			identity: opts.identity
+		})).ts ?? lastMessageId;
+	} else for (const chunk of chunks.length ? chunks : [""]) lastMessageId = (await postSlackMessageBestEffort({
+		client,
+		channelId,
+		text: chunk,
+		threadTs: opts.threadTs,
+		identity: opts.identity
+	})).ts ?? lastMessageId;
+	return {
+		messageId: lastMessageId || "unknown",
+		channelId
+	};
+}
+
+//#endregion
+export { createSlackWebClient as a, validateSlackBlocksArray as c, buildSlackBlocksFallbackText as i, markdownToSlackMrkdwnChunks as n, resolveSlackWebClientOptions as o, normalizeSlackOutboundText as r, parseSlackBlocksInput as s, sendMessageSlack as t };

package/dist/plugin-sdk/session-DFy97tfW.js

@@ -0,0 +1,169 @@
+import { f as readCredsJsonRaw, g as resolveWebCredsPath, h as resolveWebCredsBackupPath, m as resolveDefaultWebAuthDir, u as maybeRestoreCredsFromBackup } from "./accounts-C-BT6Po7.js";
+import { Pr as formatCliCommand, Xr as VERSION } from "./config-FhBFLsNm.js";
+import { B as success, E as resolveUserPath, F as danger, G as getChildLogger, g as ensureDir, q as toPinoLikeLogger } from "./logger-DDdrdbDu.js";
+import fs from "node:fs";
+import { randomUUID } from "node:crypto";
+import { DisconnectReason, fetchLatestBaileysVersion, makeCacheableSignalKeyStore, makeWASocket, useMultiFileAuthState } from "@whiskeysockets/baileys";
+import qrcode from "qrcode-terminal";
+
+//#region src/web/session.ts
+let credsSaveQueue = Promise.resolve();
+function enqueueSaveCreds(authDir, saveCreds, logger) {
+	credsSaveQueue = credsSaveQueue.then(() => safeSaveCreds(authDir, saveCreds, logger)).catch((err) => {
+		logger.warn({ error: String(err) }, "WhatsApp creds save queue error");
+	});
+}
+async function safeSaveCreds(authDir, saveCreds, logger) {
+	try {
+		const credsPath = resolveWebCredsPath(authDir);
+		const backupPath = resolveWebCredsBackupPath(authDir);
+		const raw = readCredsJsonRaw(credsPath);
+		if (raw) try {
+			JSON.parse(raw);
+			fs.copyFileSync(credsPath, backupPath);
+			try {
+				fs.chmodSync(backupPath, 384);
+			} catch {}
+		} catch {}
+	} catch {}
+	try {
+		await Promise.resolve(saveCreds());
+		try {
+			fs.chmodSync(resolveWebCredsPath(authDir), 384);
+		} catch {}
+	} catch (err) {
+		logger.warn({ error: String(err) }, "failed saving WhatsApp creds");
+	}
+}
+/**
+* Create a Baileys socket backed by the multi-file auth store we keep on disk.
+* Consumers can opt into QR printing for interactive login flows.
+*/
+async function createWaSocket(printQr, verbose, opts = {}) {
+	const logger = toPinoLikeLogger(getChildLogger({ module: "baileys" }, { level: verbose ? "info" : "silent" }), verbose ? "info" : "silent");
+	const authDir = resolveUserPath(opts.authDir ?? resolveDefaultWebAuthDir());
+	await ensureDir(authDir);
+	const sessionLogger = getChildLogger({ module: "web-session" });
+	maybeRestoreCredsFromBackup(authDir);
+	const { state, saveCreds } = await useMultiFileAuthState(authDir);
+	const { version } = await fetchLatestBaileysVersion();
+	const sock = makeWASocket({
+		auth: {
+			creds: state.creds,
+			keys: makeCacheableSignalKeyStore(state.keys, logger)
+		},
+		version,
+		logger,
+		printQRInTerminal: false,
+		browser: [
+			"squidclaw",
+			"cli",
+			VERSION
+		],
+		syncFullHistory: false,
+		markOnlineOnConnect: false
+	});
+	sock.ev.on("creds.update", () => enqueueSaveCreds(authDir, saveCreds, sessionLogger));
+	sock.ev.on("connection.update", (update) => {
+		try {
+			const { connection, lastDisconnect, qr } = update;
+			if (qr) {
+				opts.onQr?.(qr);
+				if (printQr) {
+					console.log("Scan this QR in WhatsApp (Linked Devices):");
+					qrcode.generate(qr, { small: true });
+				}
+			}
+			if (connection === "close") {
+				if (getStatusCode(lastDisconnect?.error) === DisconnectReason.loggedOut) console.error(danger(`WhatsApp session logged out. Run: ${formatCliCommand("squidclaw channels login")}`));
+			}
+			if (connection === "open" && verbose) console.log(success("WhatsApp Web connected."));
+		} catch (err) {
+			sessionLogger.error({ error: String(err) }, "connection.update handler error");
+		}
+	});
+	if (sock.ws && typeof sock.ws.on === "function") sock.ws.on("error", (err) => {
+		sessionLogger.error({ error: String(err) }, "WebSocket error");
+	});
+	return sock;
+}
+async function waitForWaConnection(sock) {
+	return new Promise((resolve, reject) => {
+		const evWithOff = sock.ev;
+		const handler = (...args) => {
+			const update = args[0] ?? {};
+			if (update.connection === "open") {
+				evWithOff.off?.("connection.update", handler);
+				resolve();
+			}
+			if (update.connection === "close") {
+				evWithOff.off?.("connection.update", handler);
+				reject(update.lastDisconnect ?? /* @__PURE__ */ new Error("Connection closed"));
+			}
+		};
+		sock.ev.on("connection.update", handler);
+	});
+}
+function getStatusCode(err) {
+	return err?.output?.statusCode ?? err?.status;
+}
+function safeStringify(value, limit = 800) {
+	try {
+		const seen = /* @__PURE__ */ new WeakSet();
+		const raw = JSON.stringify(value, (_key, v) => {
+			if (typeof v === "bigint") return v.toString();
+			if (typeof v === "function") {
+				const maybeName = v.name;
+				return `[Function ${typeof maybeName === "string" && maybeName.length > 0 ? maybeName : "anonymous"}]`;
+			}
+			if (typeof v === "object" && v) {
+				if (seen.has(v)) return "[Circular]";
+				seen.add(v);
+			}
+			return v;
+		}, 2);
+		if (!raw) return String(value);
+		return raw.length > limit ? `${raw.slice(0, limit)}…` : raw;
+	} catch {
+		return String(value);
+	}
+}
+function extractBoomDetails(err) {
+	if (!err || typeof err !== "object") return null;
+	const output = err?.output;
+	if (!output || typeof output !== "object") return null;
+	const payload = output.payload;
+	const statusCode = typeof output.statusCode === "number" ? output.statusCode : typeof payload?.statusCode === "number" ? payload.statusCode : void 0;
+	const error = typeof payload?.error === "string" ? payload.error : void 0;
+	const message = typeof payload?.message === "string" ? payload.message : void 0;
+	if (!statusCode && !error && !message) return null;
+	return {
+		statusCode,
+		error,
+		message
+	};
+}
+function formatError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	if (!err || typeof err !== "object") return String(err);
+	const boom = extractBoomDetails(err) ?? extractBoomDetails(err?.error) ?? extractBoomDetails(err?.lastDisconnect?.error);
+	const status = boom?.statusCode ?? getStatusCode(err);
+	const code = err?.code;
+	const codeText = typeof code === "string" || typeof code === "number" ? String(code) : void 0;
+	const message = [
+		boom?.message,
+		typeof err?.message === "string" ? err.message : void 0,
+		typeof err?.error?.message === "string" ? err.error?.message : void 0
+	].filter((v) => Boolean(v && v.trim().length > 0))[0];
+	const pieces = [];
+	if (typeof status === "number") pieces.push(`status=${status}`);
+	if (boom?.error) pieces.push(boom.error);
+	if (message) pieces.push(message);
+	if (codeText) pieces.push(`code=${codeText}`);
+	if (pieces.length > 0) return pieces.join(" ");
+	return safeStringify(err);
+}
+
+//#endregion
+export { waitForWaConnection as i, formatError as n, getStatusCode as r, createWaSocket as t };

package/dist/plugin-sdk/signal.js

@@ -4,7 +4,7 @@ import chalk, { Chalk } from "chalk";
 import fs, { constants, createWriteStream } from "node:fs";
 import { Logger } from "tslog";
 import os from "node:os";
-import JSON5 from "json5";
+import json5 from "json5";
 import { promisify } from "node:util";
 import fs$1 from "node:fs/promises";
 import "@clack/prompts";
@@ -766,7 +766,7 @@ function readLoggingConfig() {
 	try {
 		if (!fs.existsSync(configPath)) return;
 		const raw = fs.readFileSync(configPath, "utf-8");
-		const logging = JSON5.parse(raw)?.logging;
+		const logging = json5.parse(raw)?.logging;
 		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
 		return logging;
 	} catch {