@gaodefa/daocore 2026.5.51 → 2026.5.53

package/dist/send-BETlETJ5.d.ts

@@ -0,0 +1,231 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { S as MarkdownTableMode } from "./types.base-tQh4FMBR.js";
+import { t as OutboundMediaAccess } from "./load-options-CTuppEe4.js";
+import { n as PollInput } from "./polls-CfHkU59X.js";
+import { f as ChunkMode } from "./outbound.types-B2wXms-j.js";
+import { t as RetryConfig } from "./retry-CrxGEpqH.js";
+import { Et as APIRole, I as APIGuildMember, S as APIMessage, it as APIChannel, kt as Snowflake } from "./payload-U2icqU80.js";
+import { a as APIGuildScheduledEventRecurrenceRule, i as APIGuildScheduledEventEntityMetadata, n as APIVoiceState, o as GuildScheduledEventEntityType, r as APIGuildScheduledEvent, s as GuildScheduledEventPrivacyLevel } from "./voice-Damkqy6G.js";
+import { t as RequestClient } from "./rest-CE8PF7Nu.js";
+import { S as DiscordTimeoutTarget, a as DiscordEmojiUpload, b as DiscordThreadCreate, c as DiscordModerationTarget, f as DiscordReactionSummary, g as DiscordSearchQuery, i as DiscordChannelPermissionSet, l as DiscordPermissionsSummary, m as DiscordRoleChange, n as DiscordChannelEdit, o as DiscordMessageEdit, r as DiscordChannelMove, s as DiscordMessageQuery, t as DiscordChannelCreate, u as DiscordReactOpts, v as DiscordSendResult, x as DiscordThreadList, y as DiscordStickerUpload } from "./send.types-D_3tsfSL.js";
+import { n as DiscordSendEmbeds, t as DiscordSendComponents } from "./send.shared-DFtuanuS.js";
+
+//#region node_modules/discord-api-types/rest/v10/guildScheduledEvent.d.ts
+/**
+ * @see {@link https://discord.com/developers/docs/resources/guild-scheduled-event#create-guild-scheduled-event}
+ */
+interface RESTPostAPIGuildScheduledEventJSONBody {
+  /**
+   * The stage channel id of the guild event
+   */
+  channel_id?: Snowflake | undefined;
+  /**
+   * The name of the guild event
+   */
+  name: string;
+  /**
+   * The privacy level of the guild event
+   */
+  privacy_level: GuildScheduledEventPrivacyLevel;
+  /**
+   * The time to schedule the guild event at
+   */
+  scheduled_start_time: string;
+  /**
+   * The time when the scheduled event is scheduled to end
+   */
+  scheduled_end_time?: string | undefined;
+  /**
+   * The description of the guild event
+   */
+  description?: string | undefined;
+  /**
+   * The scheduled entity type of the guild event
+   */
+  entity_type: GuildScheduledEventEntityType;
+  /**
+   * The entity metadata of the scheduled event
+   */
+  entity_metadata?: APIGuildScheduledEventEntityMetadata | undefined;
+  /**
+   * The cover image of the scheduled event
+   */
+  image?: string | null | undefined;
+  /**
+   * The definition for how often this event should recur
+   */
+  recurrence_rule?: APIGuildScheduledEventRecurrenceRule | undefined;
+}
+//#endregion
+//#region extensions/discord/src/send.channels.d.ts
+declare function createChannelDiscord(payload: DiscordChannelCreate, opts: DiscordReactOpts): Promise<APIChannel>;
+declare function editChannelDiscord(payload: DiscordChannelEdit, opts: DiscordReactOpts): Promise<APIChannel>;
+declare function deleteChannelDiscord(channelId: string, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+  channelId: string;
+}>;
+declare function moveChannelDiscord(payload: DiscordChannelMove, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+declare function setChannelPermissionDiscord(payload: DiscordChannelPermissionSet, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+declare function removeChannelPermissionDiscord(channelId: string, targetId: string, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+//#endregion
+//#region extensions/discord/src/send.emojis-stickers.d.ts
+declare function listGuildEmojisDiscord(guildId: string, opts: DiscordReactOpts): Promise<unknown>;
+declare function uploadEmojiDiscord(payload: DiscordEmojiUpload, opts: DiscordReactOpts): Promise<unknown>;
+declare function uploadStickerDiscord(payload: DiscordStickerUpload, opts: DiscordReactOpts): Promise<unknown>;
+//#endregion
+//#region extensions/discord/src/send.guild.d.ts
+declare function fetchMemberInfoDiscord(guildId: string, userId: string, opts: DiscordReactOpts): Promise<APIGuildMember>;
+declare function fetchRoleInfoDiscord(guildId: string, opts: DiscordReactOpts): Promise<APIRole[]>;
+declare function addRoleDiscord(payload: DiscordRoleChange, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+declare function removeRoleDiscord(payload: DiscordRoleChange, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+declare function fetchChannelInfoDiscord(channelId: string, opts: DiscordReactOpts): Promise<APIChannel>;
+declare function listGuildChannelsDiscord(guildId: string, opts: DiscordReactOpts): Promise<APIChannel[]>;
+declare function fetchVoiceStatusDiscord(guildId: string, userId: string, opts: DiscordReactOpts): Promise<APIVoiceState>;
+declare function listScheduledEventsDiscord(guildId: string, opts: DiscordReactOpts): Promise<APIGuildScheduledEvent[]>;
+declare function resolveEventCoverImage(imageUrl: string, opts?: {
+  localRoots?: readonly string[];
+}): Promise<string>;
+declare function createScheduledEventDiscord(guildId: string, payload: RESTPostAPIGuildScheduledEventJSONBody, opts: DiscordReactOpts): Promise<APIGuildScheduledEvent>;
+declare function timeoutMemberDiscord(payload: DiscordTimeoutTarget, opts: DiscordReactOpts): Promise<APIGuildMember>;
+declare function kickMemberDiscord(payload: DiscordModerationTarget, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+declare function banMemberDiscord(payload: DiscordModerationTarget & {
+  deleteMessageDays?: number;
+}, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+//#endregion
+//#region extensions/discord/src/send.messages.d.ts
+declare function readMessagesDiscord(channelId: string, query: DiscordMessageQuery | undefined, opts: DiscordReactOpts): Promise<APIMessage[]>;
+declare function fetchMessageDiscord(channelId: string, messageId: string, opts: DiscordReactOpts): Promise<APIMessage>;
+declare function editMessageDiscord(channelId: string, messageId: string, payload: DiscordMessageEdit, opts: DiscordReactOpts): Promise<APIMessage>;
+declare function deleteMessageDiscord(channelId: string, messageId: string, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+declare function pinMessageDiscord(channelId: string, messageId: string, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+declare function unpinMessageDiscord(channelId: string, messageId: string, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+declare function listPinsDiscord(channelId: string, opts: DiscordReactOpts): Promise<APIMessage[]>;
+declare function createThreadDiscord(channelId: string, payload: DiscordThreadCreate, opts: DiscordReactOpts): Promise<APIChannel>;
+declare function listThreadsDiscord(payload: DiscordThreadList, opts: DiscordReactOpts): Promise<unknown>;
+declare function searchMessagesDiscord(query: DiscordSearchQuery, opts: DiscordReactOpts): Promise<unknown>;
+//#endregion
+//#region extensions/discord/src/send.outbound.d.ts
+type DiscordSendOpts = {
+  cfg: DaoCoreConfig;
+  token?: string;
+  accountId?: string;
+  mediaUrl?: string;
+  filename?: string;
+  mediaAccess?: OutboundMediaAccess;
+  mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  verbose?: boolean;
+  rest?: RequestClient;
+  replyTo?: string;
+  retry?: RetryConfig;
+  textLimit?: number;
+  maxLinesPerMessage?: number;
+  tableMode?: MarkdownTableMode;
+  chunkMode?: ChunkMode;
+  components?: DiscordSendComponents;
+  embeds?: DiscordSendEmbeds;
+  silent?: boolean;
+  suppressEmbeds?: boolean;
+};
+declare function sendMessageDiscord(to: string, text: string, opts: DiscordSendOpts): Promise<DiscordSendResult>;
+declare function sendStickerDiscord(to: string, stickerIds: string[], opts: DiscordSendOpts & {
+  content?: string;
+}): Promise<DiscordSendResult>;
+declare function sendPollDiscord(to: string, poll: PollInput, opts: DiscordSendOpts & {
+  content?: string;
+}): Promise<DiscordSendResult>;
+//#endregion
+//#region extensions/discord/src/send.webhook.d.ts
+type DiscordWebhookSendOpts = {
+  cfg: DaoCoreConfig;
+  webhookId: string;
+  webhookToken: string;
+  accountId?: string;
+  threadId?: string | number;
+  replyTo?: string;
+  username?: string;
+  avatarUrl?: string;
+  wait?: boolean;
+};
+declare function sendWebhookMessageDiscord(text: string, opts: DiscordWebhookSendOpts): Promise<DiscordSendResult>;
+//#endregion
+//#region extensions/discord/src/send.voice.d.ts
+type VoiceMessageOpts = {
+  cfg: DaoCoreConfig;
+  token?: string;
+  accountId?: string;
+  verbose?: boolean;
+  rest?: RequestClient;
+  replyTo?: string;
+  retry?: RetryConfig;
+  silent?: boolean;
+};
+/**
+ * Send a voice message to Discord.
+ *
+ * Voice messages are a special Discord feature that displays audio with a waveform
+ * visualization. They require OGG/Opus format and cannot include text content.
+ *
+ * @param to - Recipient (user ID for DM or channel ID)
+ * @param audioPath - Path to local audio file (will be converted to OGG/Opus if needed)
+ * @param opts - Send options
+ */
+declare function sendVoiceMessageDiscord(to: string, audioPath: string, opts: VoiceMessageOpts): Promise<DiscordSendResult>;
+//#endregion
+//#region extensions/discord/src/send.typing.d.ts
+declare function sendTypingDiscord(channelId: string, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+  channelId: string;
+}>;
+//#endregion
+//#region extensions/discord/src/send.permissions.d.ts
+/**
+ * Fetch guild-level permissions for a user. This does not include channel-specific overwrites.
+ */
+declare function fetchMemberGuildPermissionsDiscord(guildId: string, userId: string, opts: DiscordReactOpts): Promise<bigint | null>;
+/**
+ * Returns true when the user has ADMINISTRATOR or any required permission bit.
+ */
+declare function hasAnyGuildPermissionDiscord(guildId: string, userId: string, requiredPermissions: bigint[], opts: DiscordReactOpts): Promise<boolean>;
+/**
+ * Returns true when the user has ADMINISTRATOR or all required permission bits.
+ */
+declare function hasAllGuildPermissionsDiscord(guildId: string, userId: string, requiredPermissions: bigint[], opts: DiscordReactOpts): Promise<boolean>;
+declare function fetchChannelPermissionsDiscord(channelId: string, opts: DiscordReactOpts): Promise<DiscordPermissionsSummary>;
+//#endregion
+//#region extensions/discord/src/send.reactions.d.ts
+declare function reactMessageDiscord(channelId: string, messageId: string, emoji: string, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+declare function removeReactionDiscord(channelId: string, messageId: string, emoji: string, opts: DiscordReactOpts): Promise<{
+  ok: boolean;
+}>;
+declare function removeOwnReactionsDiscord(channelId: string, messageId: string, opts: DiscordReactOpts): Promise<{
+  ok: true;
+  removed: string[];
+}>;
+declare function fetchReactionsDiscord(channelId: string, messageId: string, opts: DiscordReactOpts & {
+  limit?: number;
+}): Promise<DiscordReactionSummary[]>;
+//#endregion
+export { fetchRoleInfoDiscord as A, uploadStickerDiscord as B, searchMessagesDiscord as C, createScheduledEventDiscord as D, banMemberDiscord as E, removeRoleDiscord as F, removeChannelPermissionDiscord as G, deleteChannelDiscord as H, resolveEventCoverImage as I, setChannelPermissionDiscord as K, timeoutMemberDiscord as L, kickMemberDiscord as M, listGuildChannelsDiscord as N, fetchChannelInfoDiscord as O, listScheduledEventsDiscord as P, listGuildEmojisDiscord as R, readMessagesDiscord as S, addRoleDiscord as T, editChannelDiscord as U, createChannelDiscord as V, moveChannelDiscord as W, editMessageDiscord as _, fetchChannelPermissionsDiscord as a, listThreadsDiscord as b, hasAnyGuildPermissionDiscord as c, sendWebhookMessageDiscord as d, sendMessageDiscord as f, deleteMessageDiscord as g, createThreadDiscord as h, removeReactionDiscord as i, fetchVoiceStatusDiscord as j, fetchMemberInfoDiscord as k, sendTypingDiscord as l, sendStickerDiscord as m, reactMessageDiscord as n, fetchMemberGuildPermissionsDiscord as o, sendPollDiscord as p, removeOwnReactionsDiscord as r, hasAllGuildPermissionsDiscord as s, fetchReactionsDiscord as t, sendVoiceMessageDiscord as u, fetchMessageDiscord as v, unpinMessageDiscord as w, pinMessageDiscord as x, listPinsDiscord as y, uploadEmojiDiscord as z };

package/dist/send-BN-3u18j.js

@@ -0,0 +1,2 @@
+import { a as editMessageTelegram, c as renameForumTopicTelegram, d as sendPollTelegram, f as sendStickerTelegram, i as editMessageReplyMarkupTelegram, l as resetTelegramClientOptionsCacheForTests, m as unpinMessageTelegram, n as deleteMessageTelegram, o as pinMessageTelegram, p as sendTypingTelegram, r as editForumTopicTelegram, s as reactMessageTelegram, t as createForumTopicTelegram, u as sendMessageTelegram, x as buildInlineKeyboard } from "./send-Ar9e_pA3.js";
+export { buildInlineKeyboard, createForumTopicTelegram, deleteMessageTelegram, editForumTopicTelegram, editMessageReplyMarkupTelegram, editMessageTelegram, pinMessageTelegram, reactMessageTelegram, renameForumTopicTelegram, resetTelegramClientOptionsCacheForTests, sendMessageTelegram, sendPollTelegram, sendStickerTelegram, sendTypingTelegram, unpinMessageTelegram };

package/dist/send-BYlEXkEO.js

@@ -0,0 +1,143 @@
+import { i as formatErrorMessage } from "./errors-D_oyTIw2.js";
+import { t as createMessageReceiptFromOutboundResults } from "./receipt-vrVTwZtS.js";
+import "./error-runtime--zM-GsR-.js";
+import "./channel-message-YAmKOwAT.js";
+import { a as resolveZaloToken, i as resolveZaloAccount } from "./accounts-DdAZRSd-.js";
+import { c as sendMessage, l as sendPhoto, t as resolveZaloProxyFetch } from "./proxy-CVYWu1-7.js";
+//#region extensions/zalo/src/send.ts
+function createZaloSendReceipt(params) {
+	const messageId = params.messageId?.trim();
+	return createMessageReceiptFromOutboundResults({
+		results: messageId ? [{
+			channel: "zalo",
+			messageId,
+			chatId: params.chatId
+		}] : [],
+		kind: params.kind
+	});
+}
+function toZaloSendResult(response, params) {
+	if (response.ok && response.result) return {
+		ok: true,
+		messageId: response.result.message_id,
+		receipt: createZaloSendReceipt({
+			messageId: response.result.message_id,
+			chatId: params.chatId,
+			kind: params.kind
+		})
+	};
+	return {
+		ok: false,
+		error: "Failed to send message",
+		receipt: createZaloSendReceipt({
+			chatId: params.chatId,
+			kind: params.kind
+		})
+	};
+}
+async function runZaloSend(failureMessage, params, send) {
+	try {
+		const result = toZaloSendResult(await send(), params);
+		return result.ok ? result : {
+			ok: false,
+			error: failureMessage,
+			receipt: result.receipt
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: formatErrorMessage(err),
+			receipt: createZaloSendReceipt({
+				chatId: params.chatId,
+				kind: params.kind
+			})
+		};
+	}
+}
+function resolveSendContext(options) {
+	if (options.cfg) {
+		const account = resolveZaloAccount({
+			cfg: options.cfg,
+			accountId: options.accountId
+		});
+		return {
+			token: options.token || account.token,
+			fetcher: resolveZaloProxyFetch(options.proxy ?? account.config.proxy)
+		};
+	}
+	const token = options.token ?? resolveZaloToken(void 0, options.accountId).token;
+	const proxy = options.proxy;
+	return {
+		token,
+		fetcher: resolveZaloProxyFetch(proxy)
+	};
+}
+function resolveValidatedSendContext(chatId, options) {
+	const { token, fetcher } = resolveSendContext(options);
+	if (!token) return {
+		ok: false,
+		error: "No Zalo bot token configured"
+	};
+	const trimmedChatId = chatId?.trim();
+	if (!trimmedChatId) return {
+		ok: false,
+		error: "No chat_id provided"
+	};
+	return {
+		ok: true,
+		chatId: trimmedChatId,
+		token,
+		fetcher
+	};
+}
+function resolveSendContextOrFailure(chatId, options) {
+	const context = resolveValidatedSendContext(chatId, options);
+	return context.ok ? { context } : { failure: {
+		ok: false,
+		error: context.error,
+		receipt: createZaloSendReceipt({
+			chatId,
+			kind: "unknown"
+		})
+	} };
+}
+async function sendMessageZalo(chatId, text, options = {}) {
+	const resolved = resolveSendContextOrFailure(chatId, options);
+	if ("failure" in resolved) return resolved.failure;
+	const { context } = resolved;
+	if (options.mediaUrl) return sendPhotoZalo(context.chatId, options.mediaUrl, {
+		...options,
+		token: context.token,
+		caption: text || options.caption
+	});
+	return await runZaloSend("Failed to send message", {
+		chatId: context.chatId,
+		kind: "text"
+	}, () => sendMessage(context.token, {
+		chat_id: context.chatId,
+		text: text.slice(0, 2e3)
+	}, context.fetcher));
+}
+async function sendPhotoZalo(chatId, photoUrl, options = {}) {
+	const resolved = resolveSendContextOrFailure(chatId, options);
+	if ("failure" in resolved) return resolved.failure;
+	const { context } = resolved;
+	if (!photoUrl?.trim()) return {
+		ok: false,
+		error: "No photo URL provided",
+		receipt: createZaloSendReceipt({
+			chatId: context.chatId,
+			kind: "media"
+		})
+	};
+	return await runZaloSend("Failed to send photo", {
+		chatId: context.chatId,
+		kind: "media"
+	}, () => (async () => sendPhoto(context.token, {
+		chat_id: context.chatId,
+		photo: photoUrl.trim(),
+		caption: options.caption?.slice(0, 2e3)
+	}, context.fetcher))());
+}
+//#endregion
+export { sendMessageZalo as t };

package/dist/send-BusufuyP.js

@@ -0,0 +1,192 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DyL154ka.js";
+import { c as kindFromMime } from "./mime-DppuT-pZ.js";
+import { t as createMessageReceiptFromOutboundResults } from "./receipt-vrVTwZtS.js";
+import { t as resolveOutboundAttachmentFromUrl } from "./outbound-attachment-yKJo7CPT.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { t as resolveMarkdownTableMode } from "./markdown-tables-BEjHxS3n.js";
+import { t as requireRuntimeConfig } from "./plugin-config-runtime-BhkqZ7bA.js";
+import "./media-runtime-CPXTkSQr.js";
+import "./markdown-table-runtime-CGhR5c0i.js";
+import "./channel-message-YAmKOwAT.js";
+import { i as resolveSignalAccount } from "./accounts-Cya7YPL4.js";
+import { t as markdownToSignalText } from "./format-R_ipGi2b.js";
+import { n as signalRpcRequest } from "./client-adapter-PXk4JoQR.js";
+import { t as resolveSignalRpcContext } from "./rpc-context-D3-lLVdI.js";
+//#region extensions/signal/src/send.ts
+async function resolveSignalRpcAccountInfo(opts) {
+	if (opts.baseUrl?.trim() && opts.account?.trim()) return;
+	if (!opts.cfg) throw new Error("Signal RPC account resolution requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
+	return resolveSignalAccount({
+		cfg: requireRuntimeConfig(opts.cfg, "Signal RPC account resolution"),
+		accountId: opts.accountId
+	});
+}
+function parseTarget(raw) {
+	let value = raw.trim();
+	if (!value) throw new Error("Signal recipient is required");
+	if (normalizeLowercaseStringOrEmpty(value).startsWith("signal:")) value = value.slice(7).trim();
+	const normalized = normalizeLowercaseStringOrEmpty(value);
+	if (normalized.startsWith("group:")) return {
+		type: "group",
+		groupId: value.slice(6).trim()
+	};
+	if (normalized.startsWith("username:")) return {
+		type: "username",
+		username: value.slice(9).trim()
+	};
+	if (normalized.startsWith("u:")) return {
+		type: "username",
+		username: value.trim()
+	};
+	return {
+		type: "recipient",
+		recipient: value
+	};
+}
+function buildTargetParams(target, allow) {
+	if (target.type === "recipient") {
+		if (!allow.recipient) return null;
+		return { recipient: [target.recipient] };
+	}
+	if (target.type === "group") {
+		if (!allow.group) return null;
+		return { groupId: target.groupId };
+	}
+	if (target.type === "username") {
+		if (!allow.username) return null;
+		return { username: [target.username] };
+	}
+	return null;
+}
+function createSignalSendReceipt(params) {
+	const messageId = params.messageId.trim();
+	const results = messageId && messageId !== "unknown" ? [{
+		channel: "signal",
+		messageId,
+		meta: { targetType: params.target.type }
+	}] : [];
+	if (results[0]) {
+		if (params.timestamp != null) results[0].timestamp = params.timestamp;
+		if (params.target.type === "group") results[0].chatId = params.target.groupId;
+		else if (params.target.type === "recipient") results[0].toJid = params.target.recipient;
+		else results[0].toJid = params.target.username;
+	}
+	return createMessageReceiptFromOutboundResults({
+		results,
+		kind: params.kind
+	});
+}
+async function sendMessageSignal(to, text, opts) {
+	const cfg = requireRuntimeConfig(opts.cfg, "Signal send");
+	const apiMode = cfg.channels?.signal?.apiMode;
+	const accountInfo = resolveSignalAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	const { baseUrl, account } = resolveSignalRpcContext(opts, accountInfo);
+	const target = parseTarget(to);
+	let message = text ?? "";
+	let messageFromPlaceholder = false;
+	let textStyles = [];
+	const textMode = opts.textMode ?? "markdown";
+	const maxBytes = (() => {
+		if (typeof opts.maxBytes === "number") return opts.maxBytes;
+		if (typeof accountInfo.config.mediaMaxMb === "number") return accountInfo.config.mediaMaxMb * 1024 * 1024;
+		if (typeof cfg.agents?.defaults?.mediaMaxMb === "number") return cfg.agents.defaults.mediaMaxMb * 1024 * 1024;
+		return 8 * 1024 * 1024;
+	})();
+	let attachments;
+	if (opts.mediaUrl?.trim()) {
+		const resolved = await resolveOutboundAttachmentFromUrl(opts.mediaUrl.trim(), maxBytes, {
+			mediaAccess: opts.mediaAccess,
+			localRoots: opts.mediaLocalRoots,
+			readFile: opts.mediaReadFile
+		});
+		attachments = [resolved.path];
+		const kind = kindFromMime(resolved.contentType ?? void 0);
+		if (!message && kind) {
+			message = kind === "image" ? "<media:image>" : `<media:${kind}>`;
+			messageFromPlaceholder = true;
+		}
+	}
+	if (message.trim() && !messageFromPlaceholder) if (textMode === "plain") textStyles = opts.textStyles ?? [];
+	else {
+		const tableMode = resolveMarkdownTableMode({
+			cfg,
+			channel: "signal",
+			accountId: accountInfo.accountId
+		});
+		const formatted = markdownToSignalText(message, { tableMode });
+		message = formatted.text;
+		textStyles = formatted.styles;
+	}
+	if (!message.trim() && (!attachments || attachments.length === 0)) throw new Error("Signal send requires text or media");
+	const params = { message };
+	if (textStyles.length > 0) params["text-style"] = textStyles.map((style) => `${style.start}:${style.length}:${style.style}`);
+	if (account) params.account = account;
+	if (attachments && attachments.length > 0) params.attachments = attachments;
+	const targetParams = buildTargetParams(target, {
+		recipient: true,
+		group: true,
+		username: true
+	});
+	if (!targetParams) throw new Error("Signal recipient is required");
+	Object.assign(params, targetParams);
+	const timestamp = (await signalRpcRequest("send", params, {
+		baseUrl,
+		timeoutMs: opts.timeoutMs,
+		apiMode
+	}))?.timestamp;
+	const messageId = timestamp ? String(timestamp) : "unknown";
+	return {
+		messageId,
+		timestamp,
+		receipt: createSignalSendReceipt({
+			messageId,
+			target,
+			kind: attachments && attachments.length > 0 ? "media" : "text",
+			...timestamp != null ? { timestamp } : {}
+		})
+	};
+}
+async function sendTypingSignal(to, opts) {
+	const accountInfo = await resolveSignalRpcAccountInfo(opts);
+	const cfg = requireRuntimeConfig(opts.cfg, "Signal typing");
+	const { baseUrl, account } = resolveSignalRpcContext(opts, accountInfo);
+	const targetParams = buildTargetParams(parseTarget(to), {
+		recipient: true,
+		group: true
+	});
+	if (!targetParams) return false;
+	const params = { ...targetParams };
+	if (account) params.account = account;
+	if (opts.stop) params.stop = true;
+	await signalRpcRequest("sendTyping", params, {
+		baseUrl,
+		timeoutMs: opts.timeoutMs,
+		apiMode: cfg.channels?.signal?.apiMode
+	});
+	return true;
+}
+async function sendReadReceiptSignal(to, targetTimestamp, opts) {
+	if (!Number.isFinite(targetTimestamp) || targetTimestamp <= 0) return false;
+	const accountInfo = await resolveSignalRpcAccountInfo(opts);
+	const cfg = requireRuntimeConfig(opts.cfg, "Signal read receipt");
+	const { baseUrl, account } = resolveSignalRpcContext(opts, accountInfo);
+	const targetParams = buildTargetParams(parseTarget(to), { recipient: true });
+	if (!targetParams) return false;
+	const params = {
+		...targetParams,
+		targetTimestamp,
+		type: opts.type ?? "read"
+	};
+	if (account) params.account = account;
+	await signalRpcRequest("sendReceipt", params, {
+		baseUrl,
+		timeoutMs: opts.timeoutMs,
+		apiMode: cfg.channels?.signal?.apiMode
+	});
+	return true;
+}
+//#endregion
+export { sendReadReceiptSignal as n, sendTypingSignal as r, sendMessageSignal as t };

package/dist/send-CpcmWYrM.d.ts

@@ -0,0 +1,104 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { S as MarkdownTableMode } from "./types.base-tQh4FMBR.js";
+import { m as ResolvedReactionLevel, p as ReactionLevel } from "./types.channels-DYoH0RJo.js";
+import { n as RuntimeEnv } from "./runtime-Bxifh4bY.js";
+import { P as MessageReceipt } from "./types-CYvxspyL.js";
+import { y as ChannelMessageActionAdapter } from "./types.core-DpVp9PoP.js";
+import { y as BackoffPolicy } from "./wsl-DGjWf35r.js";
+import { r as waitForTransportReady } from "./transport-ready-CRskTZ8O.js";
+//#region extensions/signal/src/format.d.ts
+type SignalTextStyle = "BOLD" | "ITALIC" | "STRIKETHROUGH" | "MONOSPACE" | "SPOILER";
+type SignalTextStyleRange = {
+  start: number;
+  length: number;
+  style: SignalTextStyle;
+};
+type SignalFormattedText = {
+  text: string;
+  styles: SignalTextStyleRange[];
+};
+type SignalMarkdownOptions = {
+  tableMode?: MarkdownTableMode;
+};
+declare function markdownToSignalText(markdown: string, options?: SignalMarkdownOptions): SignalFormattedText;
+declare function markdownToSignalTextChunks(markdown: string, limit: number, options?: SignalMarkdownOptions): SignalFormattedText[];
+//#endregion
+//#region extensions/signal/src/message-actions.d.ts
+declare const signalMessageActions: ChannelMessageActionAdapter;
+//#endregion
+//#region extensions/signal/src/monitor.d.ts
+type MonitorSignalOpts = {
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  account?: string;
+  accountId?: string;
+  config?: DaoCoreConfig;
+  baseUrl?: string;
+  autoStart?: boolean;
+  startupTimeoutMs?: number;
+  cliPath?: string;
+  httpHost?: string;
+  httpPort?: number;
+  receiveMode?: "on-start" | "manual";
+  ignoreAttachments?: boolean;
+  ignoreStories?: boolean;
+  sendReadReceipts?: boolean;
+  allowFrom?: Array<string | number>;
+  groupAllowFrom?: Array<string | number>;
+  mediaMaxMb?: number;
+  reconnectPolicy?: Partial<BackoffPolicy>;
+  waitForTransportReady?: typeof waitForTransportReady;
+};
+declare function monitorSignalProvider(opts?: MonitorSignalOpts): Promise<void>;
+//#endregion
+//#region extensions/signal/src/reaction-level.d.ts
+type SignalReactionLevel = ReactionLevel;
+type ResolvedSignalReactionLevel = ResolvedReactionLevel;
+/**
+ * Resolve the effective reaction level and its implications for Signal.
+ *
+ * Levels:
+ * - "off": No reactions at all
+ * - "ack": Only automatic ack reactions (👀 when processing), no agent reactions
+ * - "minimal": Agent can react, but sparingly (default)
+ * - "extensive": Agent can react liberally
+ */
+declare function resolveSignalReactionLevel(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string;
+}): ResolvedSignalReactionLevel;
+//#endregion
+//#region extensions/signal/src/send.d.ts
+type SignalSendOpts = {
+  cfg: DaoCoreConfig;
+  baseUrl?: string;
+  account?: string;
+  accountId?: string;
+  mediaUrl?: string;
+  mediaAccess?: {
+    localRoots?: readonly string[];
+    readFile?: (filePath: string) => Promise<Buffer>;
+  };
+  mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  maxBytes?: number;
+  timeoutMs?: number;
+  textMode?: "markdown" | "plain";
+  textStyles?: SignalTextStyleRange[];
+};
+type SignalSendResult = {
+  messageId: string;
+  timestamp?: number;
+  receipt: MessageReceipt;
+};
+type SignalRpcOpts = Pick<SignalSendOpts, "cfg" | "baseUrl" | "account" | "accountId" | "timeoutMs">;
+type SignalReceiptType = "read" | "viewed";
+declare function sendMessageSignal(to: string, text: string, opts: SignalSendOpts): Promise<SignalSendResult>;
+declare function sendTypingSignal(to: string, opts: SignalRpcOpts & {
+  stop?: boolean;
+}): Promise<boolean>;
+declare function sendReadReceiptSignal(to: string, targetTimestamp: number, opts: SignalRpcOpts & {
+  type?: SignalReceiptType;
+}): Promise<boolean>;
+//#endregion
+export { markdownToSignalTextChunks as _, sendMessageSignal as a, ResolvedSignalReactionLevel as c, MonitorSignalOpts as d, monitorSignalProvider as f, markdownToSignalText as g, SignalTextStyleRange as h, SignalSendResult as i, SignalReactionLevel as l, SignalFormattedText as m, SignalRpcOpts as n, sendReadReceiptSignal as o, signalMessageActions as p, SignalSendOpts as r, sendTypingSignal as s, SignalReceiptType as t, resolveSignalReactionLevel as u };