@nextclaw/channel-extension-discord 0.1.1-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NextClaw contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/index.js

@@ -0,0 +1 @@
+export {};

package/dist/main.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/main.js

@@ -0,0 +1,12 @@
+import { DiscordChannel } from "./services/discord-channel.service.js";
+import { startBusChannelExtension, warnNcpEventError } from "@nextclaw/extension-sdk";
+//#region src/main.ts
+await startBusChannelExtension({
+	channelId: "discord",
+	createChannel: ({ config, bus, channel }) => new DiscordChannel(config, bus, channel.commands),
+	onChannelStartError: warnNcpEventError("discord")
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","names":[],"sources":["../src/main.ts"],"sourcesContent":["import type { Config, MessageBus } from \"@nextclaw/core\";\nimport { startBusChannelExtension, warnNcpEventError } from \"@nextclaw/extension-sdk\";\nimport { DiscordChannel } from \"./services/discord-channel.service.js\";\n\nawait startBusChannelExtension<Config[\"channels\"][\"discord\"], MessageBus>({\n  channelId: \"discord\",\n  createChannel: ({ config, bus, channel }) => new DiscordChannel(config, bus, channel.commands),\n  onChannelStartError: warnNcpEventError(\"discord\"),\n});\n"],"mappings":";;;AAIA,MAAM,yBAAoE;CACxE,WAAW;CACX,gBAAgB,EAAE,QAAQ,KAAK,cAAc,IAAI,eAAe,QAAQ,KAAK,QAAQ,SAAS;CAC9F,qBAAqB,kBAAkB,UAAU;CAClD,CAAC"}

package/dist/services/discord-channel.service.js

@@ -0,0 +1,479 @@
+import { buildAttachmentSummary, chunkDiscordText, guessMimeFromName, resolveDiscordStreamingMode, resolveDraftChunkConfig, resolveTextChunkLimit, sanitizeAttachmentName, sendDiscordChunks } from "../utils/discord-text.utils.js";
+import { mapCommandOptions } from "../utils/discord-command.utils.js";
+import { sendDiscordDraftStreaming } from "./discord-draft-streaming.service.js";
+import { ChannelTypingController } from "@nextclaw/extension-sdk";
+import { BaseChannel, getDataPath, isTypingStopControlMessage } from "@nextclaw/core";
+import { Client, GatewayIntentBits, MessageFlags, Partials, REST, Routes } from "discord.js";
+import { ProxyAgent, fetch } from "undici";
+import { join } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+//#region src/services/discord-channel.service.ts
+const DEFAULT_MEDIA_MAX_MB = 8;
+const MEDIA_FETCH_TIMEOUT_MS = 15e3;
+const TYPING_HEARTBEAT_MS = 6e3;
+const TYPING_AUTO_STOP_MS = 12e4;
+const SLASH_GUILD_THRESHOLD = 10;
+var DiscordChannel = class extends BaseChannel {
+	name = "discord";
+	client = null;
+	typingController;
+	constructor(config, bus, commands) {
+		super(config, bus);
+		this.commands = commands;
+		this.typingController = new ChannelTypingController({
+			heartbeatMs: TYPING_HEARTBEAT_MS,
+			autoStopMs: TYPING_AUTO_STOP_MS,
+			sendTyping: async (channelId) => {
+				if (!this.client) return;
+				const channel = this.client.channels.cache.get(channelId);
+				if (!channel || !channel.isTextBased()) return;
+				await channel.sendTyping();
+			}
+		});
+	}
+	start = async () => {
+		if (!this.config.token) throw new Error("Discord token not configured");
+		this.running = true;
+		this.client = new Client({
+			intents: this.config.intents ?? GatewayIntentBits.Guilds | GatewayIntentBits.GuildMessages | GatewayIntentBits.DirectMessages,
+			partials: [Partials.Channel]
+		});
+		this.client.on("ready", () => {
+			console.log("Discord bot connected");
+			this.registerSlashCommands();
+		});
+		this.client.on("messageCreate", async (message) => {
+			await this.handleIncoming(message);
+		});
+		this.client.on("interactionCreate", async (interaction) => {
+			await this.handleInteraction(interaction);
+		});
+		await this.client.login(this.config.token);
+	};
+	stop = async () => {
+		this.running = false;
+		this.typingController.stopAll();
+		if (this.client) {
+			await this.client.destroy();
+			this.client = null;
+		}
+	};
+	handleControlMessage = async (msg) => {
+		if (!isTypingStopControlMessage(msg)) return false;
+		this.stopTyping(msg.chatId);
+		return true;
+	};
+	send = async (msg) => {
+		if (isTypingStopControlMessage(msg)) {
+			this.stopTyping(msg.chatId);
+			return;
+		}
+		if (!this.client) return;
+		const channel = await this.client.channels.fetch(msg.chatId);
+		if (!channel || !channel.isTextBased()) return;
+		this.stopTyping(msg.chatId);
+		const textChannel = channel;
+		const content = msg.content ?? "";
+		const textChunkLimit = resolveTextChunkLimit(this.config);
+		const chunks = chunkDiscordText(content, {
+			maxChars: textChunkLimit,
+			maxLines: 17
+		});
+		if (chunks.length === 0) return;
+		const flags = msg.metadata?.silent === true ? MessageFlags.SuppressNotifications : void 0;
+		const streamingMode = resolveDiscordStreamingMode(this.config);
+		if (streamingMode === "off") {
+			await sendDiscordChunks({
+				textChannel,
+				chunks,
+				replyTo: msg.replyTo ?? void 0,
+				flags
+			});
+			return;
+		}
+		await sendDiscordDraftStreaming({
+			textChannel,
+			chunks,
+			replyTo: msg.replyTo ?? void 0,
+			flags,
+			draftChunk: resolveDraftChunkConfig(this.config, textChunkLimit),
+			streamingMode
+		});
+	};
+	handleIncoming = async (message) => {
+		const context = this.resolveIncomingContext(message);
+		if (!context) return;
+		const { senderId, channelId, isGroup, mentionState } = context;
+		const payload = await this.buildIncomingPayload(message);
+		const replyTo = message.reference?.messageId ?? null;
+		this.startTyping(channelId);
+		try {
+			await this.handleMessage({
+				senderId,
+				chatId: channelId,
+				content: payload.content,
+				attachments: payload.attachments,
+				metadata: {
+					message_id: message.id,
+					channel_id: channelId,
+					guild_id: message.guildId,
+					reply_to: replyTo,
+					account_id: this.resolveAccountId(),
+					accountId: this.resolveAccountId(),
+					is_group: isGroup,
+					peer_kind: isGroup ? "channel" : "direct",
+					peer_id: isGroup ? channelId : senderId,
+					was_mentioned: mentionState.wasMentioned,
+					require_mention: mentionState.requireMention,
+					...payload.attachmentIssues.length ? { attachment_issues: payload.attachmentIssues } : {}
+				}
+			});
+		} catch (error) {
+			this.stopTyping(channelId);
+			throw error;
+		}
+	};
+	resolveIncomingContext = (message) => {
+		const selfUserId = this.client?.user?.id;
+		if (selfUserId && message.author.id === selfUserId) return null;
+		if (message.author.bot && !this.config.allowBots) return null;
+		const senderId = message.author.id;
+		const channelId = message.channelId;
+		const isGroup = Boolean(message.guildId);
+		if (!this.isAllowedByPolicy({
+			senderId,
+			channelId,
+			isGroup
+		})) return null;
+		const mentionState = this.resolveMentionState({
+			message,
+			selfUserId,
+			channelId,
+			isGroup
+		});
+		if (mentionState.requireMention && !mentionState.wasMentioned) return null;
+		return {
+			senderId,
+			channelId,
+			isGroup,
+			mentionState
+		};
+	};
+	buildIncomingPayload = async (message) => {
+		const contentParts = message.content ? [message.content] : [];
+		const { attachments, attachmentIssues } = await this.resolveIncomingAttachments(message);
+		if (!message.content && attachments.length > 0) contentParts.push(buildAttachmentSummary(attachments));
+		return {
+			content: contentParts.length ? contentParts.join("\n") : "[empty message]",
+			attachments,
+			attachmentIssues
+		};
+	};
+	resolveIncomingAttachments = async (message) => {
+		const attachments = [];
+		const attachmentIssues = [];
+		if (!message.attachments.size) return {
+			attachments,
+			attachmentIssues
+		};
+		const mediaDir = join(getDataPath(), "media");
+		mkdirSync(mediaDir, { recursive: true });
+		const maxBytes = Math.max(1, this.config.mediaMaxMb ?? DEFAULT_MEDIA_MAX_MB) * 1024 * 1024;
+		const proxy = this.resolveProxyAgent();
+		for (const attachment of message.attachments.values()) {
+			const resolved = await this.resolveInboundAttachment({
+				attachment,
+				mediaDir,
+				maxBytes,
+				proxy
+			});
+			if (resolved.attachment) attachments.push(resolved.attachment);
+			if (resolved.issue) attachmentIssues.push(resolved.issue);
+		}
+		return {
+			attachments,
+			attachmentIssues
+		};
+	};
+	handleInteraction = async (interaction) => {
+		if (!interaction.isChatInputCommand()) return;
+		await this.handleSlashCommand(interaction);
+	};
+	handleSlashCommand = async (interaction) => {
+		if (!this.commands) {
+			await this.replyInteraction(interaction, "Slash commands are not available.", true);
+			return;
+		}
+		const channelId = interaction.channelId;
+		if (!channelId) {
+			await this.replyInteraction(interaction, "Slash commands are not available in this channel.", true);
+			return;
+		}
+		const senderId = interaction.user.id;
+		const isGroup = Boolean(interaction.guildId);
+		if (!this.isAllowedByPolicy({
+			senderId,
+			channelId,
+			isGroup
+		})) {
+			await this.replyInteraction(interaction, "You are not authorized to use commands here.", true);
+			return;
+		}
+		const args = {};
+		for (const option of interaction.options.data) if (typeof option.name === "string" && option.value !== void 0) args[option.name] = option.value;
+		try {
+			await interaction.deferReply({ ephemeral: true });
+			const result = await this.commands.execute({
+				commandName: interaction.commandName,
+				args,
+				conversationId: channelId,
+				senderId,
+				metadata: {
+					message_id: interaction.id,
+					channel_id: channelId,
+					guild_id: interaction.guildId,
+					account_id: this.resolveAccountId(),
+					accountId: this.resolveAccountId(),
+					is_group: isGroup,
+					peer_kind: isGroup ? "channel" : "direct",
+					peer_id: isGroup ? channelId : senderId
+				}
+			});
+			if (result.ephemeral === false) {
+				await interaction.editReply({ content: "Command executed." });
+				await interaction.followUp({
+					content: result.content,
+					ephemeral: false
+				});
+				return;
+			}
+			await interaction.editReply({ content: result.content });
+		} catch (error) {
+			await this.replyInteraction(interaction, "Command failed to execute.", true);
+			console.error(`Discord slash command error: ${String(error)}`);
+		}
+	};
+	replyInteraction = async (interaction, content, ephemeral) => {
+		const payload = {
+			content,
+			ephemeral
+		};
+		if (interaction.deferred || interaction.replied) {
+			await interaction.followUp(payload);
+			return;
+		}
+		await interaction.reply(payload);
+	};
+	registerSlashCommands = async () => {
+		if (!this.client || !this.commands) return;
+		const appId = this.client.application?.id ?? this.client.user?.id;
+		if (!appId) return;
+		const commands = await this.buildSlashCommandPayloads();
+		if (!commands.length) return;
+		const rest = new REST({ version: "10" }).setToken(this.config.token);
+		let guildIds = [];
+		try {
+			guildIds = [...(await this.client.guilds.fetch()).keys()];
+		} catch (error) {
+			console.error(`Failed to fetch Discord guild list: ${String(error)}`);
+		}
+		try {
+			if (guildIds.length > 0 && guildIds.length <= SLASH_GUILD_THRESHOLD) {
+				for (const guildId of guildIds) await rest.put(Routes.applicationGuildCommands(appId, guildId), { body: commands });
+				console.log(`Discord slash commands registered for ${guildIds.length} guild(s).`);
+			} else {
+				await rest.put(Routes.applicationCommands(appId), { body: commands });
+				console.log("Discord slash commands registered globally.");
+			}
+		} catch (error) {
+			console.error(`Failed to register Discord slash commands: ${String(error)}`);
+		}
+	};
+	buildSlashCommandPayloads = async () => {
+		return (await this.commands?.list() ?? []).map((spec) => ({
+			name: spec.name,
+			description: spec.description,
+			options: mapCommandOptions(spec.options)
+		}));
+	};
+	resolveProxyAgent = () => {
+		const proxy = this.config.proxy?.trim();
+		if (!proxy) return null;
+		try {
+			return new ProxyAgent(proxy);
+		} catch {
+			return null;
+		}
+	};
+	resolveAccountId = () => {
+		return this.config.accountId?.trim() || "default";
+	};
+	isAllowedByPolicy = (params) => {
+		const { senderId, channelId, isGroup } = params;
+		if (!isGroup) {
+			if (this.config.dmPolicy === "disabled") return false;
+			const allowFrom = this.config.allowFrom ?? [];
+			if (this.config.dmPolicy === "allowlist" || this.config.dmPolicy === "pairing") return this.isAllowed(senderId);
+			if (allowFrom.includes("*")) return true;
+			return allowFrom.length === 0 ? true : this.isAllowed(senderId);
+		}
+		if (this.config.groupPolicy === "disabled") return false;
+		if (this.config.groupPolicy === "allowlist") {
+			const allowFrom = this.config.groupAllowFrom ?? [];
+			return allowFrom.includes("*") || allowFrom.includes(channelId);
+		}
+		return true;
+	};
+	resolveMentionState = (params) => {
+		const { message, selfUserId, channelId, isGroup } = params;
+		if (!isGroup) return {
+			wasMentioned: false,
+			requireMention: false
+		};
+		const groups = this.config.groups ?? {};
+		const groupRule = groups[channelId] ?? groups["*"];
+		const requireMention = groupRule?.requireMention ?? this.config.requireMention ?? false;
+		if (!requireMention) return {
+			wasMentioned: false,
+			requireMention: false
+		};
+		const patterns = [...this.config.mentionPatterns ?? [], ...groupRule?.mentionPatterns ?? []].map((pattern) => pattern.trim()).filter(Boolean);
+		const content = message.content ?? "";
+		const wasMentionedByUserRef = Boolean(selfUserId) && message.mentions.users.has(selfUserId ?? "");
+		const wasMentionedByText = Boolean(selfUserId) && (content.includes(`<@${selfUserId}>`) || content.includes(`<@!${selfUserId}>`));
+		const wasMentionedByPattern = patterns.some((pattern) => {
+			try {
+				return new RegExp(pattern, "i").test(content);
+			} catch {
+				return content.toLowerCase().includes(pattern.toLowerCase());
+			}
+		});
+		return {
+			wasMentioned: wasMentionedByUserRef || wasMentionedByText || wasMentionedByPattern,
+			requireMention
+		};
+	};
+	resolveInboundAttachment = async (params) => {
+		const { attachment, mediaDir, maxBytes, proxy } = params;
+		const id = attachment.id;
+		const name = attachment.name ?? "file";
+		const url = attachment.url;
+		const mimeType = attachment.contentType ?? guessMimeFromName(name) ?? void 0;
+		if (!url) return { issue: {
+			id,
+			name,
+			code: "invalid_payload",
+			message: "attachment URL missing"
+		} };
+		if (attachment.size && attachment.size > maxBytes) return {
+			attachment: {
+				id,
+				name,
+				url,
+				mimeType,
+				size: attachment.size,
+				source: "discord",
+				status: "remote-only",
+				errorCode: "too_large"
+			},
+			issue: {
+				id,
+				name,
+				url,
+				code: "too_large",
+				message: `attachment size ${attachment.size} exceeds ${maxBytes}`
+			}
+		};
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), MEDIA_FETCH_TIMEOUT_MS);
+		try {
+			const res = await fetch(url, {
+				signal: controller.signal,
+				dispatcher: proxy ?? void 0
+			});
+			if (!res.ok) return {
+				attachment: {
+					id,
+					name,
+					url,
+					mimeType,
+					size: attachment.size,
+					source: "discord",
+					status: "remote-only",
+					errorCode: "http_error"
+				},
+				issue: {
+					id,
+					name,
+					url,
+					code: "http_error",
+					message: `HTTP ${res.status}`
+				}
+			};
+			const buffer = Buffer.from(await res.arrayBuffer());
+			if (buffer.length > maxBytes) return {
+				attachment: {
+					id,
+					name,
+					url,
+					mimeType,
+					size: buffer.length,
+					source: "discord",
+					status: "remote-only",
+					errorCode: "too_large"
+				},
+				issue: {
+					id,
+					name,
+					url,
+					code: "too_large",
+					message: `downloaded payload ${buffer.length} exceeds ${maxBytes}`
+				}
+			};
+			const filePath = join(mediaDir, `${id}_${sanitizeAttachmentName(name)}`);
+			writeFileSync(filePath, buffer);
+			return { attachment: {
+				id,
+				name,
+				path: filePath,
+				url,
+				mimeType,
+				size: buffer.length,
+				source: "discord",
+				status: "ready"
+			} };
+		} catch (err) {
+			return {
+				attachment: {
+					id,
+					name,
+					url,
+					mimeType,
+					size: attachment.size,
+					source: "discord",
+					status: "remote-only",
+					errorCode: "download_failed"
+				},
+				issue: {
+					id,
+					name,
+					url,
+					code: "download_failed",
+					message: String(err)
+				}
+			};
+		} finally {
+			clearTimeout(timeoutId);
+		}
+	};
+	startTyping = (channelId) => {
+		this.typingController.start(channelId);
+	};
+	stopTyping = (channelId) => {
+		this.typingController.stop(channelId);
+	};
+};
+//#endregion
+export { DiscordChannel };
+
+//# sourceMappingURL=discord-channel.service.js.map

package/dist/services/discord-channel.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discord-channel.service.js","names":[],"sources":["../../src/services/discord-channel.service.ts"],"sourcesContent":["import { BaseChannel, getDataPath, isTypingStopControlMessage, type Config, type InboundAttachment, type InboundAttachmentErrorCode, type MessageBus, type OutboundMessage, } from \"@nextclaw/core\";\nimport { ChannelTypingController, type ExtensionChannelCommands, } from \"@nextclaw/extension-sdk\";\nimport { Client, GatewayIntentBits, Partials, MessageFlags, REST, Routes, type Message as DiscordMessage, type Attachment, type ChatInputCommandInteraction, type Interaction, type TextBasedChannel, type TextBasedChannelFields } from \"discord.js\";\nimport {\n    DISCORD_MAX_LINES_PER_MESSAGE,\n    buildAttachmentSummary,\n    chunkDiscordText,\n    guessMimeFromName,\n    resolveDiscordStreamingMode,\n    resolveDraftChunkConfig,\n    resolveTextChunkLimit,\n    sanitizeAttachmentName,\n    sendDiscordChunks\n} from \"../utils/discord-text.utils.js\";\nimport { mapCommandOptions } from \"../utils/discord-command.utils.js\";\nimport { sendDiscordDraftStreaming } from \"./discord-draft-streaming.service.js\";\nimport { ProxyAgent, fetch } from \"undici\";\nimport { join } from \"node:path\";\nimport { mkdirSync, writeFileSync } from \"node:fs\";\nconst DEFAULT_MEDIA_MAX_MB = 8;\nconst MEDIA_FETCH_TIMEOUT_MS = 15000;\nconst TYPING_HEARTBEAT_MS = 6000;\nconst TYPING_AUTO_STOP_MS = 120000;\nconst SLASH_GUILD_THRESHOLD = 10;\ntype AttachmentIssue = {\n    id?: string;\n    name?: string;\n    url?: string;\n    code: InboundAttachmentErrorCode;\n    message: string;\n};\nexport class DiscordChannel extends BaseChannel<Config[\"channels\"][\"discord\"]> {\n    name = \"discord\";\n    private client: Client | null = null;\n    private readonly typingController: ChannelTypingController;\n    constructor(config: Config[\"channels\"][\"discord\"], bus: MessageBus, private readonly commands?: ExtensionChannelCommands) {\n        super(config, bus);\n        this.typingController = new ChannelTypingController({\n            heartbeatMs: TYPING_HEARTBEAT_MS,\n            autoStopMs: TYPING_AUTO_STOP_MS,\n            sendTyping: async (channelId) => {\n                if (!this.client) {\n                    return;\n                }\n                const channel = this.client.channels.cache.get(channelId);\n                if (!channel || !channel.isTextBased()) {\n                    return;\n                }\n                const textChannel = channel as TextBasedChannel & TextBasedChannelFields;\n                await textChannel.sendTyping();\n            }\n        });\n    }\n    start = async (): Promise<void> => {\n        if (!this.config.token) {\n            throw new Error(\"Discord token not configured\");\n        }\n        this.running = true;\n        this.client = new Client({\n            intents: this.config.intents ?? (GatewayIntentBits.Guilds | GatewayIntentBits.GuildMessages | GatewayIntentBits.DirectMessages),\n            partials: [Partials.Channel]\n        });\n        this.client.on(\"ready\", () => {\n            // eslint-disable-next-line no-console\n            console.log(\"Discord bot connected\");\n            void this.registerSlashCommands();\n        });\n        this.client.on(\"messageCreate\", async (message) => {\n            await this.handleIncoming(message);\n        });\n        this.client.on(\"interactionCreate\", async (interaction) => {\n            await this.handleInteraction(interaction);\n        });\n        await this.client.login(this.config.token);\n    };\n    stop = async (): Promise<void> => {\n        this.running = false;\n        this.typingController.stopAll();\n        if (this.client) {\n            await this.client.destroy();\n            this.client = null;\n        }\n    };\n    handleControlMessage = async (msg: OutboundMessage): Promise<boolean> => {\n        if (!isTypingStopControlMessage(msg)) {\n            return false;\n        }\n        this.stopTyping(msg.chatId);\n        return true;\n    };\n    send = async (msg: OutboundMessage): Promise<void> => {\n        if (isTypingStopControlMessage(msg)) {\n            this.stopTyping(msg.chatId);\n            return;\n        }\n        if (!this.client) {\n            return;\n        }\n        const channel = await this.client.channels.fetch(msg.chatId);\n        if (!channel || !channel.isTextBased()) {\n            return;\n        }\n        this.stopTyping(msg.chatId);\n        const textChannel = channel as TextBasedChannel & TextBasedChannelFields;\n        const content = msg.content ?? \"\";\n        const textChunkLimit = resolveTextChunkLimit(this.config);\n        const chunks = chunkDiscordText(content, {\n            maxChars: textChunkLimit,\n            maxLines: DISCORD_MAX_LINES_PER_MESSAGE\n        });\n        if (chunks.length === 0) {\n            return;\n        }\n        const flags = msg.metadata?.silent === true ? MessageFlags.SuppressNotifications : undefined;\n        const streamingMode = resolveDiscordStreamingMode(this.config);\n        if (streamingMode === \"off\") {\n            await sendDiscordChunks({\n                textChannel,\n                chunks,\n                replyTo: msg.replyTo ?? undefined,\n                flags\n            });\n            return;\n        }\n        await sendDiscordDraftStreaming({\n            textChannel,\n            chunks,\n            replyTo: msg.replyTo ?? undefined,\n            flags,\n            draftChunk: resolveDraftChunkConfig(this.config, textChunkLimit),\n            streamingMode\n        });\n    };\n    private handleIncoming = async (message: DiscordMessage): Promise<void> => {\n        const context = this.resolveIncomingContext(message);\n        if (!context) {\n            return;\n        }\n        const { senderId, channelId, isGroup, mentionState } = context;\n        const payload = await this.buildIncomingPayload(message);\n        const replyTo = message.reference?.messageId ?? null;\n        this.startTyping(channelId);\n        try {\n            await this.handleMessage({\n                senderId,\n                chatId: channelId,\n                content: payload.content,\n                attachments: payload.attachments,\n                metadata: {\n                    message_id: message.id,\n                    channel_id: channelId,\n                    guild_id: message.guildId,\n                    reply_to: replyTo,\n                    account_id: this.resolveAccountId(),\n                    accountId: this.resolveAccountId(),\n                    is_group: isGroup,\n                    peer_kind: isGroup ? \"channel\" : \"direct\",\n                    peer_id: isGroup ? channelId : senderId,\n                    was_mentioned: mentionState.wasMentioned,\n                    require_mention: mentionState.requireMention,\n                    ...(payload.attachmentIssues.length ? { attachment_issues: payload.attachmentIssues } : {})\n                }\n            });\n        }\n        catch (error) {\n            this.stopTyping(channelId);\n            throw error;\n        }\n    };\n    private resolveIncomingContext = (message: DiscordMessage): {\n        senderId: string;\n        channelId: string;\n        isGroup: boolean;\n        mentionState: {\n            wasMentioned: boolean;\n            requireMention: boolean;\n        };\n    } | null => {\n        const selfUserId = this.client?.user?.id;\n        if (selfUserId && message.author.id === selfUserId) {\n            return null;\n        }\n        if (message.author.bot && !this.config.allowBots) {\n            return null;\n        }\n        const senderId = message.author.id;\n        const channelId = message.channelId;\n        const isGroup = Boolean(message.guildId);\n        if (!this.isAllowedByPolicy({ senderId, channelId, isGroup })) {\n            return null;\n        }\n        const mentionState = this.resolveMentionState({ message, selfUserId, channelId, isGroup });\n        if (mentionState.requireMention && !mentionState.wasMentioned) {\n            return null;\n        }\n        return { senderId, channelId, isGroup, mentionState };\n    };\n    private buildIncomingPayload = async (message: DiscordMessage): Promise<{\n        content: string;\n        attachments: InboundAttachment[];\n        attachmentIssues: AttachmentIssue[];\n    }> => {\n        const contentParts = message.content ? [message.content] : [];\n        const { attachments, attachmentIssues } = await this.resolveIncomingAttachments(message);\n        if (!message.content && attachments.length > 0) {\n            contentParts.push(buildAttachmentSummary(attachments));\n        }\n        return {\n            content: contentParts.length ? contentParts.join(\"\\n\") : \"[empty message]\",\n            attachments,\n            attachmentIssues\n        };\n    };\n    private resolveIncomingAttachments = async (message: DiscordMessage): Promise<{\n        attachments: InboundAttachment[];\n        attachmentIssues: AttachmentIssue[];\n    }> => {\n        const attachments: InboundAttachment[] = [];\n        const attachmentIssues: AttachmentIssue[] = [];\n        if (!message.attachments.size) {\n            return { attachments, attachmentIssues };\n        }\n        const mediaDir = join(getDataPath(), \"media\");\n        mkdirSync(mediaDir, { recursive: true });\n        const maxBytes = Math.max(1, this.config.mediaMaxMb ?? DEFAULT_MEDIA_MAX_MB) * 1024 * 1024;\n        const proxy = this.resolveProxyAgent();\n        for (const attachment of message.attachments.values()) {\n            const resolved = await this.resolveInboundAttachment({ attachment, mediaDir, maxBytes, proxy });\n            if (resolved.attachment) {\n                attachments.push(resolved.attachment);\n            }\n            if (resolved.issue) {\n                attachmentIssues.push(resolved.issue);\n            }\n        }\n        return { attachments, attachmentIssues };\n    };\n    private handleInteraction = async (interaction: Interaction): Promise<void> => {\n        if (!interaction.isChatInputCommand()) {\n            return;\n        }\n        await this.handleSlashCommand(interaction);\n    };\n    private handleSlashCommand = async (interaction: ChatInputCommandInteraction): Promise<void> => {\n        if (!this.commands) {\n            await this.replyInteraction(interaction, \"Slash commands are not available.\", true);\n            return;\n        }\n        const channelId = interaction.channelId;\n        if (!channelId) {\n            await this.replyInteraction(interaction, \"Slash commands are not available in this channel.\", true);\n            return;\n        }\n        const senderId = interaction.user.id;\n        const isGroup = Boolean(interaction.guildId);\n        if (!this.isAllowedByPolicy({ senderId, channelId, isGroup })) {\n            await this.replyInteraction(interaction, \"You are not authorized to use commands here.\", true);\n            return;\n        }\n        const args: Record<string, unknown> = {};\n        for (const option of interaction.options.data) {\n            if (typeof option.name === \"string\" && option.value !== undefined) {\n                args[option.name] = option.value;\n            }\n        }\n        try {\n            await interaction.deferReply({ ephemeral: true });\n            const result = await this.commands.execute({\n                commandName: interaction.commandName,\n                args,\n                conversationId: channelId,\n                senderId,\n                metadata: {\n                    message_id: interaction.id,\n                    channel_id: channelId,\n                    guild_id: interaction.guildId,\n                    account_id: this.resolveAccountId(),\n                    accountId: this.resolveAccountId(),\n                    is_group: isGroup,\n                    peer_kind: isGroup ? \"channel\" : \"direct\",\n                    peer_id: isGroup ? channelId : senderId,\n                },\n            });\n            if (result.ephemeral === false) {\n                await interaction.editReply({ content: \"Command executed.\" });\n                await interaction.followUp({ content: result.content, ephemeral: false });\n                return;\n            }\n            await interaction.editReply({ content: result.content });\n        }\n        catch (error) {\n            await this.replyInteraction(interaction, \"Command failed to execute.\", true);\n            // eslint-disable-next-line no-console\n            console.error(`Discord slash command error: ${String(error)}`);\n        }\n    };\n    private replyInteraction = async (interaction: ChatInputCommandInteraction, content: string, ephemeral: boolean): Promise<void> => {\n        const payload = { content, ephemeral };\n        if (interaction.deferred || interaction.replied) {\n            await interaction.followUp(payload);\n            return;\n        }\n        await interaction.reply(payload);\n    };\n    private registerSlashCommands = async (): Promise<void> => {\n        if (!this.client || !this.commands) {\n            return;\n        }\n        const appId = this.client.application?.id ?? this.client.user?.id;\n        if (!appId) {\n            return;\n        }\n        const commands = await this.buildSlashCommandPayloads();\n        if (!commands.length) {\n            return;\n        }\n        const rest = new REST({ version: \"10\" }).setToken(this.config.token);\n        let guildIds: string[] = [];\n        try {\n            const guilds = await this.client.guilds.fetch();\n            guildIds = [...guilds.keys()];\n        }\n        catch (error) {\n            // eslint-disable-next-line no-console\n            console.error(`Failed to fetch Discord guild list: ${String(error)}`);\n        }\n        try {\n            if (guildIds.length > 0 && guildIds.length <= SLASH_GUILD_THRESHOLD) {\n                for (const guildId of guildIds) {\n                    await rest.put(Routes.applicationGuildCommands(appId, guildId), { body: commands });\n                }\n                // eslint-disable-next-line no-console\n                console.log(`Discord slash commands registered for ${guildIds.length} guild(s).`);\n            }\n            else {\n                await rest.put(Routes.applicationCommands(appId), { body: commands });\n                // eslint-disable-next-line no-console\n                console.log(\"Discord slash commands registered globally.\");\n            }\n        }\n        catch (error) {\n            // eslint-disable-next-line no-console\n            console.error(`Failed to register Discord slash commands: ${String(error)}`);\n        }\n    };\n    private buildSlashCommandPayloads = async (): Promise<Array<Record<string, unknown>>> => {\n        const specs = await this.commands?.list() ?? [];\n        return specs.map((spec) => ({\n            name: spec.name,\n            description: spec.description,\n            options: mapCommandOptions(spec.options)\n        }));\n    };\n    private resolveProxyAgent = (): ProxyAgent | null => {\n        const proxy = this.config.proxy?.trim();\n        if (!proxy) {\n            return null;\n        }\n        try {\n            return new ProxyAgent(proxy);\n        }\n        catch {\n            return null;\n        }\n    };\n    private resolveAccountId = (): string => {\n        const accountId = this.config.accountId?.trim();\n        return accountId || \"default\";\n    };\n    private isAllowedByPolicy = (params: {\n        senderId: string;\n        channelId: string;\n        isGroup: boolean;\n    }): boolean => {\n        const { senderId, channelId, isGroup } = params;\n        if (!isGroup) {\n            if (this.config.dmPolicy === \"disabled\") {\n                return false;\n            }\n            const allowFrom = this.config.allowFrom ?? [];\n            if (this.config.dmPolicy === \"allowlist\" || this.config.dmPolicy === \"pairing\") {\n                return this.isAllowed(senderId);\n            }\n            if (allowFrom.includes(\"*\")) {\n                return true;\n            }\n            return allowFrom.length === 0 ? true : this.isAllowed(senderId);\n        }\n        if (this.config.groupPolicy === \"disabled\") {\n            return false;\n        }\n        if (this.config.groupPolicy === \"allowlist\") {\n            const allowFrom = this.config.groupAllowFrom ?? [];\n            return allowFrom.includes(\"*\") || allowFrom.includes(channelId);\n        }\n        return true;\n    };\n    private resolveMentionState = (params: {\n        message: DiscordMessage;\n        selfUserId?: string;\n        channelId: string;\n        isGroup: boolean;\n    }): {\n        wasMentioned: boolean;\n        requireMention: boolean;\n    } => {\n        const { message, selfUserId, channelId, isGroup } = params;\n        if (!isGroup) {\n            return { wasMentioned: false, requireMention: false };\n        }\n        const groups = this.config.groups ?? {};\n        const groupRule = groups[channelId] ?? groups[\"*\"];\n        const requireMention = groupRule?.requireMention ?? this.config.requireMention ?? false;\n        if (!requireMention) {\n            return { wasMentioned: false, requireMention: false };\n        }\n        const patterns = [\n            ...(this.config.mentionPatterns ?? []),\n            ...(groupRule?.mentionPatterns ?? [])\n        ]\n            .map((pattern) => pattern.trim())\n            .filter(Boolean);\n        const content = message.content ?? \"\";\n        const wasMentionedByUserRef = Boolean(selfUserId) && message.mentions.users.has(selfUserId ?? \"\");\n        const wasMentionedByText = Boolean(selfUserId) &&\n            (content.includes(`<@${selfUserId}>`) || content.includes(`<@!${selfUserId}>`));\n        const wasMentionedByPattern = patterns.some((pattern) => {\n            try {\n                return new RegExp(pattern, \"i\").test(content);\n            }\n            catch {\n                return content.toLowerCase().includes(pattern.toLowerCase());\n            }\n        });\n        return {\n            wasMentioned: wasMentionedByUserRef || wasMentionedByText || wasMentionedByPattern,\n            requireMention\n        };\n    };\n    private resolveInboundAttachment = async (params: {\n        attachment: Attachment;\n        mediaDir: string;\n        maxBytes: number;\n        proxy: ProxyAgent | null;\n    }): Promise<{\n        attachment?: InboundAttachment;\n        issue?: AttachmentIssue;\n    }> => {\n        const { attachment, mediaDir, maxBytes, proxy } = params;\n        const id = attachment.id;\n        const name = attachment.name ?? \"file\";\n        const url = attachment.url;\n        const mimeType = attachment.contentType ?? guessMimeFromName(name) ?? undefined;\n        if (!url) {\n            return {\n                issue: {\n                    id,\n                    name,\n                    code: \"invalid_payload\",\n                    message: \"attachment URL missing\"\n                }\n            };\n        }\n        if (attachment.size && attachment.size > maxBytes) {\n            return {\n                attachment: {\n                    id,\n                    name,\n                    url,\n                    mimeType,\n                    size: attachment.size,\n                    source: \"discord\",\n                    status: \"remote-only\",\n                    errorCode: \"too_large\"\n                },\n                issue: {\n                    id,\n                    name,\n                    url,\n                    code: \"too_large\",\n                    message: `attachment size ${attachment.size} exceeds ${maxBytes}`\n                }\n            };\n        }\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), MEDIA_FETCH_TIMEOUT_MS);\n        try {\n            const fetchInit: Parameters<typeof fetch>[1] = {\n                signal: controller.signal,\n                dispatcher: proxy ?? undefined\n            };\n            const res = await fetch(url, fetchInit);\n            if (!res.ok) {\n                return {\n                    attachment: {\n                        id,\n                        name,\n                        url,\n                        mimeType,\n                        size: attachment.size,\n                        source: \"discord\",\n                        status: \"remote-only\",\n                        errorCode: \"http_error\"\n                    },\n                    issue: {\n                        id,\n                        name,\n                        url,\n                        code: \"http_error\",\n                        message: `HTTP ${res.status}`\n                    }\n                };\n            }\n            const buffer = Buffer.from(await res.arrayBuffer());\n            if (buffer.length > maxBytes) {\n                return {\n                    attachment: {\n                        id,\n                        name,\n                        url,\n                        mimeType,\n                        size: buffer.length,\n                        source: \"discord\",\n                        status: \"remote-only\",\n                        errorCode: \"too_large\"\n                    },\n                    issue: {\n                        id,\n                        name,\n                        url,\n                        code: \"too_large\",\n                        message: `downloaded payload ${buffer.length} exceeds ${maxBytes}`\n                    }\n                };\n            }\n            const filename = `${id}_${sanitizeAttachmentName(name)}`;\n            const filePath = join(mediaDir, filename);\n            writeFileSync(filePath, buffer);\n            return {\n                attachment: {\n                    id,\n                    name,\n                    path: filePath,\n                    url,\n                    mimeType,\n                    size: buffer.length,\n                    source: \"discord\",\n                    status: \"ready\"\n                }\n            };\n        }\n        catch (err) {\n            return {\n                attachment: {\n                    id,\n                    name,\n                    url,\n                    mimeType,\n                    size: attachment.size,\n                    source: \"discord\",\n                    status: \"remote-only\",\n                    errorCode: \"download_failed\"\n                },\n                issue: {\n                    id,\n                    name,\n                    url,\n                    code: \"download_failed\",\n                    message: String(err)\n                }\n            };\n        }\n        finally {\n            clearTimeout(timeoutId);\n        }\n    };\n    private startTyping = (channelId: string): void => {\n        this.typingController.start(channelId);\n    };\n    private stopTyping = (channelId: string): void => {\n        this.typingController.stop(channelId);\n    };\n}\n"],"mappings":"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"}

package/dist/services/discord-draft-streaming.service.js

@@ -0,0 +1,130 @@
+import { sendDiscordChunks, sendDiscordSingleChunk } from "../utils/discord-text.utils.js";
+//#region src/services/discord-draft-streaming.service.ts
+const STREAM_EDIT_MIN_INTERVAL_MS = 600;
+async function sendDiscordDraftStreaming(params) {
+	await new DiscordDraftStreamingSender(params).send();
+}
+var DiscordDraftStreamingSender = class {
+	first = true;
+	effectiveDraftChunk;
+	constructor(params) {
+		this.params = params;
+		this.effectiveDraftChunk = resolveEffectiveDraftChunk(params.draftChunk, params.streamingMode);
+	}
+	send = async () => {
+		for (const chunk of this.params.chunks) await this.sendChunk(chunk);
+	};
+	sendChunk = async (chunk) => {
+		const draftChunks = splitDraftChunks(chunk, this.effectiveDraftChunk);
+		if (draftChunks.length === 0) return;
+		if (draftChunks.length > 40) {
+			await this.sendFallbackChunk(chunk);
+			return;
+		}
+		await this.sendDraftParts(chunk, draftChunks);
+	};
+	sendDraftParts = async (chunk, draftChunks) => {
+		let draftMessage = null;
+		let current = "";
+		let lastEditAt = 0;
+		for (const draftPart of draftChunks) {
+			current += draftPart;
+			if (!draftMessage) {
+				draftMessage = await this.createDraftMessage(current);
+				lastEditAt = Date.now();
+				continue;
+			}
+			if (!await this.editDraftMessage(draftMessage, current, lastEditAt)) {
+				await this.sendFallbackChunk(chunk);
+				return;
+			}
+			lastEditAt = Date.now();
+		}
+	};
+	createDraftMessage = async (content) => {
+		const message = await sendDiscordSingleChunk({
+			textChannel: this.params.textChannel,
+			chunk: content,
+			replyTo: this.first ? this.params.replyTo : void 0,
+			flags: this.params.flags
+		});
+		this.first = false;
+		return message;
+	};
+	editDraftMessage = async (draftMessage, content, lastEditAt) => {
+		const waitMs = Math.max(0, lastEditAt + STREAM_EDIT_MIN_INTERVAL_MS - Date.now());
+		if (waitMs > 0) await sleep(waitMs);
+		try {
+			await draftMessage.edit({ content });
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	sendFallbackChunk = async (chunk) => {
+		await sendDiscordChunks({
+			textChannel: this.params.textChannel,
+			chunks: [chunk],
+			replyTo: this.first ? this.params.replyTo : void 0,
+			flags: this.params.flags
+		});
+		this.first = false;
+	};
+};
+function findDraftBreakIndex(text, start, end, preference) {
+	const slice = text.slice(start, end);
+	if (slice.length === 0) return null;
+	const preferredBreak = findPreferredDraftBreak(slice, preference);
+	if (preferredBreak !== null) return start + preferredBreak;
+	return findWhitespaceDraftBreak(slice, start);
+}
+function findPreferredDraftBreak(slice, preference) {
+	if (preference === "paragraph") {
+		const idx = slice.lastIndexOf("\n\n");
+		if (idx >= 0) return idx + 2;
+	}
+	if (preference === "paragraph" || preference === "line") {
+		const idx = slice.lastIndexOf("\n");
+		if (idx >= 0) return idx + 1;
+	}
+	return null;
+}
+function findWhitespaceDraftBreak(slice, start) {
+	for (let i = slice.length - 1; i >= 0; i -= 1) if (/\s/.test(slice[i])) return start + i + 1;
+	return null;
+}
+function splitDraftChunks(text, config) {
+	const chunks = [];
+	if (!text) return chunks;
+	let cursor = 0;
+	const length = text.length;
+	while (cursor < length) {
+		const nextEnd = resolveDraftChunkEnd(text, cursor, length, config);
+		chunks.push(text.slice(cursor, nextEnd));
+		cursor = nextEnd;
+	}
+	return chunks;
+}
+function resolveDraftChunkEnd(text, cursor, length, config) {
+	if (length - cursor <= config.maxChars) return length;
+	const minEnd = Math.min(length, cursor + config.minChars);
+	const maxEnd = Math.min(length, cursor + config.maxChars);
+	const breakIndex = findDraftBreakIndex(text, minEnd, maxEnd, config.breakPreference);
+	if (breakIndex !== null && breakIndex > cursor) return breakIndex;
+	return maxEnd;
+}
+function resolveEffectiveDraftChunk(draftChunk, streamingMode) {
+	if (streamingMode === "block") return draftChunk;
+	return {
+		...draftChunk,
+		minChars: Math.max(1, Math.floor(draftChunk.minChars / 2)),
+		maxChars: Math.max(draftChunk.minChars, Math.floor(draftChunk.maxChars / 2))
+	};
+}
+async function sleep(ms) {
+	await new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+//#endregion
+export { sendDiscordDraftStreaming };
+
+//# sourceMappingURL=discord-draft-streaming.service.js.map

package/dist/services/discord-draft-streaming.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discord-draft-streaming.service.js","names":[],"sources":["../../src/services/discord-draft-streaming.service.ts"],"sourcesContent":["import type { Message as DiscordMessage, TextBasedChannel, TextBasedChannelFields } from \"discord.js\";\nimport {\n    STREAM_MAX_UPDATES_PER_MESSAGE,\n    type DiscordStreamMode,\n    type DraftChunkConfig,\n    sendDiscordChunks,\n    sendDiscordSingleChunk\n} from \"../utils/discord-text.utils.js\";\n\nconst STREAM_EDIT_MIN_INTERVAL_MS = 600;\n\nexport async function sendDiscordDraftStreaming(params: {\n    textChannel: TextBasedChannel & TextBasedChannelFields;\n    chunks: string[];\n    replyTo?: string;\n    flags?: number;\n    draftChunk: DraftChunkConfig;\n    streamingMode: DiscordStreamMode;\n}): Promise<void> {\n    const sender = new DiscordDraftStreamingSender(params);\n    await sender.send();\n}\n\nclass DiscordDraftStreamingSender {\n    private first = true;\n\n    private readonly effectiveDraftChunk: DraftChunkConfig;\n\n    constructor(private readonly params: {\n        textChannel: TextBasedChannel & TextBasedChannelFields;\n        chunks: string[];\n        replyTo?: string;\n        flags?: number;\n        draftChunk: DraftChunkConfig;\n        streamingMode: DiscordStreamMode;\n    }) {\n        this.effectiveDraftChunk = resolveEffectiveDraftChunk(params.draftChunk, params.streamingMode);\n    }\n\n    send = async (): Promise<void> => {\n        for (const chunk of this.params.chunks) {\n            await this.sendChunk(chunk);\n        }\n    };\n\n    private sendChunk = async (chunk: string): Promise<void> => {\n        const draftChunks = splitDraftChunks(chunk, this.effectiveDraftChunk);\n        if (draftChunks.length === 0) {\n            return;\n        }\n        if (draftChunks.length > STREAM_MAX_UPDATES_PER_MESSAGE) {\n            await this.sendFallbackChunk(chunk);\n            return;\n        }\n        await this.sendDraftParts(chunk, draftChunks);\n    };\n\n    private sendDraftParts = async (chunk: string, draftChunks: string[]): Promise<void> => {\n        let draftMessage: DiscordMessage | null = null;\n        let current = \"\";\n        let lastEditAt = 0;\n        for (const draftPart of draftChunks) {\n            current += draftPart;\n            if (!draftMessage) {\n                draftMessage = await this.createDraftMessage(current);\n                lastEditAt = Date.now();\n                continue;\n            }\n            const edited = await this.editDraftMessage(draftMessage, current, lastEditAt);\n            if (!edited) {\n                await this.sendFallbackChunk(chunk);\n                return;\n            }\n            lastEditAt = Date.now();\n        }\n    };\n\n    private createDraftMessage = async (content: string): Promise<DiscordMessage> => {\n        const message = await sendDiscordSingleChunk({\n            textChannel: this.params.textChannel,\n            chunk: content,\n            replyTo: this.first ? this.params.replyTo : undefined,\n            flags: this.params.flags\n        });\n        this.first = false;\n        return message;\n    };\n\n    private editDraftMessage = async (\n        draftMessage: DiscordMessage,\n        content: string,\n        lastEditAt: number\n    ): Promise<boolean> => {\n        const waitMs = Math.max(0, lastEditAt + STREAM_EDIT_MIN_INTERVAL_MS - Date.now());\n        if (waitMs > 0) {\n            await sleep(waitMs);\n        }\n        try {\n            await draftMessage.edit({ content });\n            return true;\n        }\n        catch {\n            return false;\n        }\n    };\n\n    private sendFallbackChunk = async (chunk: string): Promise<void> => {\n        await sendDiscordChunks({\n            textChannel: this.params.textChannel,\n            chunks: [chunk],\n            replyTo: this.first ? this.params.replyTo : undefined,\n            flags: this.params.flags\n        });\n        this.first = false;\n    };\n}\n\nfunction findDraftBreakIndex(\n    text: string,\n    start: number,\n    end: number,\n    preference: DraftChunkConfig[\"breakPreference\"]\n): number | null {\n    const slice = text.slice(start, end);\n    if (slice.length === 0) {\n        return null;\n    }\n    const preferredBreak = findPreferredDraftBreak(slice, preference);\n    if (preferredBreak !== null) {\n        return start + preferredBreak;\n    }\n    return findWhitespaceDraftBreak(slice, start);\n}\n\nfunction findPreferredDraftBreak(slice: string, preference: DraftChunkConfig[\"breakPreference\"]): number | null {\n    if (preference === \"paragraph\") {\n        const idx = slice.lastIndexOf(\"\\n\\n\");\n        if (idx >= 0) {\n            return idx + 2;\n        }\n    }\n    if (preference === \"paragraph\" || preference === \"line\") {\n        const idx = slice.lastIndexOf(\"\\n\");\n        if (idx >= 0) {\n            return idx + 1;\n        }\n    }\n    return null;\n}\n\nfunction findWhitespaceDraftBreak(slice: string, start: number): number | null {\n    for (let i = slice.length - 1; i >= 0; i -= 1) {\n        if (/\\s/.test(slice[i])) {\n            return start + i + 1;\n        }\n    }\n    return null;\n}\n\nfunction splitDraftChunks(text: string, config: DraftChunkConfig): string[] {\n    const chunks: string[] = [];\n    if (!text) {\n        return chunks;\n    }\n    let cursor = 0;\n    const length = text.length;\n    while (cursor < length) {\n        const nextEnd = resolveDraftChunkEnd(text, cursor, length, config);\n        chunks.push(text.slice(cursor, nextEnd));\n        cursor = nextEnd;\n    }\n    return chunks;\n}\n\nfunction resolveDraftChunkEnd(\n    text: string,\n    cursor: number,\n    length: number,\n    config: DraftChunkConfig\n): number {\n    const remaining = length - cursor;\n    if (remaining <= config.maxChars) {\n        return length;\n    }\n    const minEnd = Math.min(length, cursor + config.minChars);\n    const maxEnd = Math.min(length, cursor + config.maxChars);\n    const breakIndex = findDraftBreakIndex(text, minEnd, maxEnd, config.breakPreference);\n    if (breakIndex !== null && breakIndex > cursor) {\n        return breakIndex;\n    }\n    return maxEnd;\n}\n\nfunction resolveEffectiveDraftChunk(\n    draftChunk: DraftChunkConfig,\n    streamingMode: DiscordStreamMode\n): DraftChunkConfig {\n    if (streamingMode === \"block\") {\n        return draftChunk;\n    }\n    return {\n        ...draftChunk,\n        minChars: Math.max(1, Math.floor(draftChunk.minChars / 2)),\n        maxChars: Math.max(draftChunk.minChars, Math.floor(draftChunk.maxChars / 2))\n    };\n}\n\nasync function sleep(ms: number): Promise<void> {\n    await new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));\n}\n"],"mappings":";;AASA,MAAM,8BAA8B;AAEpC,eAAsB,0BAA0B,QAO9B;AAEd,OADe,IAAI,4BAA4B,OAAO,CACzC,MAAM;;AAGvB,IAAM,8BAAN,MAAkC;CAC9B,QAAgB;CAEhB;CAEA,YAAY,QAOT;AAP0B,OAAA,SAAA;AAQzB,OAAK,sBAAsB,2BAA2B,OAAO,YAAY,OAAO,cAAc;;CAGlG,OAAO,YAA2B;AAC9B,OAAK,MAAM,SAAS,KAAK,OAAO,OAC5B,OAAM,KAAK,UAAU,MAAM;;CAInC,YAAoB,OAAO,UAAiC;EACxD,MAAM,cAAc,iBAAiB,OAAO,KAAK,oBAAoB;AACrE,MAAI,YAAY,WAAW,EACvB;AAEJ,MAAI,YAAY,SAAA,IAAyC;AACrD,SAAM,KAAK,kBAAkB,MAAM;AACnC;;AAEJ,QAAM,KAAK,eAAe,OAAO,YAAY;;CAGjD,iBAAyB,OAAO,OAAe,gBAAyC;EACpF,IAAI,eAAsC;EAC1C,IAAI,UAAU;EACd,IAAI,aAAa;AACjB,OAAK,MAAM,aAAa,aAAa;AACjC,cAAW;AACX,OAAI,CAAC,cAAc;AACf,mBAAe,MAAM,KAAK,mBAAmB,QAAQ;AACrD,iBAAa,KAAK,KAAK;AACvB;;AAGJ,OAAI,CADW,MAAM,KAAK,iBAAiB,cAAc,SAAS,WAAW,EAChE;AACT,UAAM,KAAK,kBAAkB,MAAM;AACnC;;AAEJ,gBAAa,KAAK,KAAK;;;CAI/B,qBAA6B,OAAO,YAA6C;EAC7E,MAAM,UAAU,MAAM,uBAAuB;GACzC,aAAa,KAAK,OAAO;GACzB,OAAO;GACP,SAAS,KAAK,QAAQ,KAAK,OAAO,UAAU,KAAA;GAC5C,OAAO,KAAK,OAAO;GACtB,CAAC;AACF,OAAK,QAAQ;AACb,SAAO;;CAGX,mBAA2B,OACvB,cACA,SACA,eACmB;EACnB,MAAM,SAAS,KAAK,IAAI,GAAG,aAAa,8BAA8B,KAAK,KAAK,CAAC;AACjF,MAAI,SAAS,EACT,OAAM,MAAM,OAAO;AAEvB,MAAI;AACA,SAAM,aAAa,KAAK,EAAE,SAAS,CAAC;AACpC,UAAO;UAEL;AACF,UAAO;;;CAIf,oBAA4B,OAAO,UAAiC;AAChE,QAAM,kBAAkB;GACpB,aAAa,KAAK,OAAO;GACzB,QAAQ,CAAC,MAAM;GACf,SAAS,KAAK,QAAQ,KAAK,OAAO,UAAU,KAAA;GAC5C,OAAO,KAAK,OAAO;GACtB,CAAC;AACF,OAAK,QAAQ;;;AAIrB,SAAS,oBACL,MACA,OACA,KACA,YACa;CACb,MAAM,QAAQ,KAAK,MAAM,OAAO,IAAI;AACpC,KAAI,MAAM,WAAW,EACjB,QAAO;CAEX,MAAM,iBAAiB,wBAAwB,OAAO,WAAW;AACjE,KAAI,mBAAmB,KACnB,QAAO,QAAQ;AAEnB,QAAO,yBAAyB,OAAO,MAAM;;AAGjD,SAAS,wBAAwB,OAAe,YAAgE;AAC5G,KAAI,eAAe,aAAa;EAC5B,MAAM,MAAM,MAAM,YAAY,OAAO;AACrC,MAAI,OAAO,EACP,QAAO,MAAM;;AAGrB,KAAI,eAAe,eAAe,eAAe,QAAQ;EACrD,MAAM,MAAM,MAAM,YAAY,KAAK;AACnC,MAAI,OAAO,EACP,QAAO,MAAM;;AAGrB,QAAO;;AAGX,SAAS,yBAAyB,OAAe,OAA8B;AAC3E,MAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,EACxC,KAAI,KAAK,KAAK,MAAM,GAAG,CACnB,QAAO,QAAQ,IAAI;AAG3B,QAAO;;AAGX,SAAS,iBAAiB,MAAc,QAAoC;CACxE,MAAM,SAAmB,EAAE;AAC3B,KAAI,CAAC,KACD,QAAO;CAEX,IAAI,SAAS;CACb,MAAM,SAAS,KAAK;AACpB,QAAO,SAAS,QAAQ;EACpB,MAAM,UAAU,qBAAqB,MAAM,QAAQ,QAAQ,OAAO;AAClE,SAAO,KAAK,KAAK,MAAM,QAAQ,QAAQ,CAAC;AACxC,WAAS;;AAEb,QAAO;;AAGX,SAAS,qBACL,MACA,QACA,QACA,QACM;AAEN,KADkB,SAAS,UACV,OAAO,SACpB,QAAO;CAEX,MAAM,SAAS,KAAK,IAAI,QAAQ,SAAS,OAAO,SAAS;CACzD,MAAM,SAAS,KAAK,IAAI,QAAQ,SAAS,OAAO,SAAS;CACzD,MAAM,aAAa,oBAAoB,MAAM,QAAQ,QAAQ,OAAO,gBAAgB;AACpF,KAAI,eAAe,QAAQ,aAAa,OACpC,QAAO;AAEX,QAAO;;AAGX,SAAS,2BACL,YACA,eACgB;AAChB,KAAI,kBAAkB,QAClB,QAAO;AAEX,QAAO;EACH,GAAG;EACH,UAAU,KAAK,IAAI,GAAG,KAAK,MAAM,WAAW,WAAW,EAAE,CAAC;EAC1D,UAAU,KAAK,IAAI,WAAW,UAAU,KAAK,MAAM,WAAW,WAAW,EAAE,CAAC;EAC/E;;AAGL,eAAe,MAAM,IAA2B;AAC5C,OAAM,IAAI,SAAS,YAAY,WAAW,SAAS,KAAK,IAAI,GAAG,GAAG,CAAC,CAAC"}

package/dist/utils/discord-command.utils.js

@@ -0,0 +1,22 @@
+import { ApplicationCommandOptionType } from "discord.js";
+//#region src/utils/discord-command.utils.ts
+function mapCommandOptions(options) {
+	if (!options || options.length === 0) return;
+	return options.map((option) => ({
+		name: option.name,
+		description: option.description,
+		type: mapCommandOptionType(option.type),
+		required: option.required ?? false
+	}));
+}
+function mapCommandOptionType(type) {
+	switch (type) {
+		case "boolean": return ApplicationCommandOptionType.Boolean;
+		case "number": return ApplicationCommandOptionType.Number;
+		default: return ApplicationCommandOptionType.String;
+	}
+}
+//#endregion
+export { mapCommandOptions };
+
+//# sourceMappingURL=discord-command.utils.js.map

package/dist/utils/discord-command.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discord-command.utils.js","names":[],"sources":["../../src/utils/discord-command.utils.ts"],"sourcesContent":["import type { ChannelCommandOption } from \"@nextclaw/extension-sdk\";\nimport { ApplicationCommandOptionType } from \"discord.js\";\n\nexport function mapCommandOptions(options?: ChannelCommandOption[]): Array<Record<string, unknown>> | undefined {\n    if (!options || options.length === 0) {\n        return undefined;\n    }\n    return options.map((option) => ({\n        name: option.name,\n        description: option.description,\n        type: mapCommandOptionType(option.type),\n        required: option.required ?? false\n    }));\n}\n\nfunction mapCommandOptionType(type: ChannelCommandOption[\"type\"]): number {\n    switch (type) {\n        case \"boolean\":\n            return ApplicationCommandOptionType.Boolean;\n        case \"number\":\n            return ApplicationCommandOptionType.Number;\n        case \"string\":\n        default:\n            return ApplicationCommandOptionType.String;\n    }\n}\n"],"mappings":";;AAGA,SAAgB,kBAAkB,SAA8E;AAC5G,KAAI,CAAC,WAAW,QAAQ,WAAW,EAC/B;AAEJ,QAAO,QAAQ,KAAK,YAAY;EAC5B,MAAM,OAAO;EACb,aAAa,OAAO;EACpB,MAAM,qBAAqB,OAAO,KAAK;EACvC,UAAU,OAAO,YAAY;EAChC,EAAE;;AAGP,SAAS,qBAAqB,MAA4C;AACtE,SAAQ,MAAR;EACI,KAAK,UACD,QAAO,6BAA6B;EACxC,KAAK,SACD,QAAO,6BAA6B;EAExC,QACI,QAAO,6BAA6B"}

package/dist/utils/discord-text.utils.js

@@ -0,0 +1,229 @@
+import "discord.js";
+//#region src/utils/discord-text.utils.ts
+const DISCORD_TEXT_LIMIT = 2e3;
+const FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+function sanitizeAttachmentName(name) {
+	return name.replace(/[\\/:*?"<>|]/g, "_");
+}
+function guessMimeFromName(name) {
+	const lower = name.toLowerCase();
+	if (lower.endsWith(".png")) return "image/png";
+	if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+	if (lower.endsWith(".gif")) return "image/gif";
+	if (lower.endsWith(".webp")) return "image/webp";
+	if (lower.endsWith(".bmp")) return "image/bmp";
+	if (lower.endsWith(".tif") || lower.endsWith(".tiff")) return "image/tiff";
+	return null;
+}
+function buildAttachmentSummary(attachments) {
+	const count = attachments.length;
+	if (count === 0) return "";
+	if (attachments.every((entry) => isImageAttachment(entry))) return `<media:image> (${count} ${count === 1 ? "image" : "images"})`;
+	return `<media:document> (${count} ${count === 1 ? "file" : "files"})`;
+}
+function chunkDiscordText(text, opts = {}) {
+	const maxChars = Math.max(1, Math.floor(opts.maxChars ?? 2e3));
+	const maxLines = Math.max(1, Math.floor(opts.maxLines ?? 17));
+	const body = text ?? "";
+	if (!body) return [];
+	if (body.length <= maxChars && countLines(body) <= maxLines) return [body];
+	return new DiscordTextChunker({
+		maxChars,
+		maxLines
+	}).chunk(body);
+}
+function resolveTextChunkLimit(config) {
+	return clampInt(typeof config.textChunkLimit === "number" ? config.textChunkLimit : DISCORD_TEXT_LIMIT, 1, DISCORD_TEXT_LIMIT);
+}
+function resolveDiscordStreamingMode(config) {
+	const raw = config.streaming;
+	if (raw === true) return "partial";
+	if (raw === false || raw === void 0 || raw === null) return "off";
+	if (raw === "progress") return "partial";
+	if (raw === "partial" || raw === "block" || raw === "off") return raw;
+	return "off";
+}
+function resolveDraftChunkConfig(config, textChunkLimit) {
+	const raw = config.draftChunk ?? {};
+	const minChars = clampInt(raw.minChars ?? 200, 1, textChunkLimit);
+	return {
+		minChars,
+		maxChars: clampInt(raw.maxChars ?? 800, minChars, textChunkLimit),
+		breakPreference: raw.breakPreference === "line" || raw.breakPreference === "none" ? raw.breakPreference : "paragraph"
+	};
+}
+async function sendDiscordChunks(params) {
+	const { textChannel, chunks, replyTo, flags } = params;
+	let first = true;
+	for (const chunk of chunks) {
+		await sendDiscordSingleChunk({
+			textChannel,
+			chunk,
+			replyTo: first ? replyTo : void 0,
+			flags
+		});
+		first = false;
+	}
+}
+var DiscordTextChunker = class {
+	chunks = [];
+	current = "";
+	currentLines = 0;
+	openFence = null;
+	constructor(limits) {
+		this.limits = limits;
+	}
+	chunk = (body) => {
+		for (const line of body.split("\n")) this.appendLine(line);
+		this.flush();
+		return this.chunks;
+	};
+	appendLine = (line) => {
+		const fenceInfo = parseFenceLine(line);
+		const wasInsideFence = this.openFence !== null;
+		const nextOpenFence = this.nextFence(fenceInfo);
+		const { charLimit, lineLimit } = this.resolveLimits(nextOpenFence);
+		const prefixLength = this.current.length > 0 ? this.current.length + 1 : 0;
+		const segments = splitLongLine(line, Math.max(1, charLimit - prefixLength), { preserveWhitespace: wasInsideFence });
+		this.appendSegments({
+			segments,
+			charLimit,
+			lineLimit
+		});
+		this.openFence = nextOpenFence;
+	};
+	appendSegments = (params) => {
+		const { segments, charLimit, lineLimit } = params;
+		segments.forEach((segment, index) => {
+			this.appendSegment({
+				segment,
+				isContinuation: index > 0,
+				charLimit,
+				lineLimit
+			});
+		});
+	};
+	appendSegment = (params) => {
+		const { segment, isContinuation, charLimit, lineLimit } = params;
+		const addition = `${isContinuation ? "" : this.current.length > 0 ? "\n" : ""}${segment}`;
+		const nextLength = this.current.length + addition.length;
+		const nextLineCount = this.currentLines + (isContinuation ? 0 : 1);
+		if ((nextLength > charLimit || nextLineCount > lineLimit) && this.current.length > 0) this.flush();
+		this.addToCurrent(segment, addition, isContinuation);
+	};
+	addToCurrent = (segment, addition, isContinuation) => {
+		if (this.current.length > 0) {
+			this.current += addition;
+			this.currentLines += isContinuation ? 0 : 1;
+			return;
+		}
+		this.current = segment;
+		this.currentLines = 1;
+	};
+	nextFence = (fenceInfo) => {
+		if (!fenceInfo) return this.openFence;
+		if (!this.openFence) return fenceInfo;
+		return this.openFence.markerChar === fenceInfo.markerChar && fenceInfo.markerLen >= this.openFence.markerLen ? null : this.openFence;
+	};
+	resolveLimits = (nextOpenFence) => {
+		const reserveChars = nextOpenFence ? closeFenceLine(nextOpenFence).length + 1 : 0;
+		const reserveLines = nextOpenFence ? 1 : 0;
+		return {
+			charLimit: Math.max(1, this.limits.maxChars - reserveChars),
+			lineLimit: Math.max(1, this.limits.maxLines - reserveLines)
+		};
+	};
+	flush = () => {
+		if (!this.current) return;
+		const payload = closeFenceIfNeeded(this.current, this.openFence);
+		if (payload.trim().length) this.chunks.push(payload);
+		this.current = "";
+		this.currentLines = 0;
+		if (this.openFence) {
+			this.current = this.openFence.openLine;
+			this.currentLines = 1;
+		}
+	};
+};
+function isImageAttachment(attachment) {
+	if (attachment.mimeType?.startsWith("image/")) return true;
+	return Boolean(attachment.name && guessMimeFromName(attachment.name));
+}
+function countLines(text) {
+	if (!text) return 0;
+	return text.split("\n").length;
+}
+function parseFenceLine(line) {
+	const match = line.match(FENCE_RE);
+	if (!match) return null;
+	const indent = match[1] ?? "";
+	const marker = match[2] ?? "";
+	return {
+		indent,
+		markerChar: marker[0] ?? "`",
+		markerLen: marker.length,
+		openLine: line
+	};
+}
+function closeFenceLine(openFence) {
+	return `${openFence.indent}${openFence.markerChar.repeat(openFence.markerLen)}`;
+}
+function closeFenceIfNeeded(text, openFence) {
+	if (!openFence) return text;
+	const closeLine = closeFenceLine(openFence);
+	if (!text) return closeLine;
+	if (!text.endsWith("\n")) return `${text}\n${closeLine}`;
+	return `${text}${closeLine}`;
+}
+function splitLongLine(line, maxChars, opts) {
+	const limit = Math.max(1, Math.floor(maxChars));
+	if (line.length <= limit) return [line];
+	return new LongLineSplitter({
+		line,
+		limit,
+		preserveWhitespace: opts.preserveWhitespace
+	}).split();
+}
+var LongLineSplitter = class {
+	chunks = [];
+	remaining;
+	constructor(params) {
+		this.params = params;
+		this.remaining = params.line;
+	}
+	split = () => {
+		while (this.remaining.length > this.params.limit) this.pushNextChunk();
+		if (this.remaining.length) this.chunks.push(this.remaining);
+		return this.chunks;
+	};
+	pushNextChunk = () => {
+		if (this.params.preserveWhitespace) {
+			this.chunks.push(this.remaining.slice(0, this.params.limit));
+			this.remaining = this.remaining.slice(this.params.limit);
+			return;
+		}
+		const breakIndex = this.resolveBreakIndex();
+		this.chunks.push(this.remaining.slice(0, breakIndex));
+		this.remaining = this.remaining.slice(breakIndex);
+	};
+	resolveBreakIndex = () => {
+		const window = this.remaining.slice(0, this.params.limit);
+		for (let index = window.length - 1; index >= 0; index -= 1) if (/\s/.test(window[index])) return index > 0 ? index : this.params.limit;
+		return this.params.limit;
+	};
+};
+function clampInt(value, min, max) {
+	if (Number.isNaN(value)) return min;
+	return Math.min(max, Math.max(min, Math.floor(value)));
+}
+async function sendDiscordSingleChunk(params) {
+	const { textChannel, chunk, replyTo, flags } = params;
+	const payload = { content: chunk };
+	if (replyTo) payload.reply = { messageReference: replyTo };
+	if (flags !== void 0) payload.flags = flags;
+	return await textChannel.send(payload);
+}
+//#endregion
+export { buildAttachmentSummary, chunkDiscordText, guessMimeFromName, resolveDiscordStreamingMode, resolveDraftChunkConfig, resolveTextChunkLimit, sanitizeAttachmentName, sendDiscordChunks, sendDiscordSingleChunk };
+
+//# sourceMappingURL=discord-text.utils.js.map

package/dist/utils/discord-text.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discord-text.utils.js","names":[],"sources":["../../src/utils/discord-text.utils.ts"],"sourcesContent":["import type { Config, InboundAttachment } from \"@nextclaw/core\";\nimport {\n    type Message as DiscordMessage,\n    type TextBasedChannel,\n    type TextBasedChannelFields\n} from \"discord.js\";\n\nexport const DISCORD_TEXT_LIMIT = 2000;\nexport const DISCORD_MAX_LINES_PER_MESSAGE = 17;\nexport const STREAM_MAX_UPDATES_PER_MESSAGE = 40;\n\nconst FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;\n\ntype OpenFence = {\n    indent: string;\n    markerChar: string;\n    markerLen: number;\n    openLine: string;\n};\n\nexport type DraftChunkConfig = {\n    minChars: number;\n    maxChars: number;\n    breakPreference: \"paragraph\" | \"line\" | \"none\";\n};\n\nexport type DiscordStreamMode = \"off\" | \"partial\" | \"block\";\n\nexport function sanitizeAttachmentName(name: string): string {\n    return name.replace(/[\\\\/:*?\"<>|]/g, \"_\");\n}\n\nexport function guessMimeFromName(name: string): string | null {\n    const lower = name.toLowerCase();\n    if (lower.endsWith(\".png\"))\n        return \"image/png\";\n    if (lower.endsWith(\".jpg\") || lower.endsWith(\".jpeg\"))\n        return \"image/jpeg\";\n    if (lower.endsWith(\".gif\"))\n        return \"image/gif\";\n    if (lower.endsWith(\".webp\"))\n        return \"image/webp\";\n    if (lower.endsWith(\".bmp\"))\n        return \"image/bmp\";\n    if (lower.endsWith(\".tif\") || lower.endsWith(\".tiff\"))\n        return \"image/tiff\";\n    return null;\n}\n\nexport function buildAttachmentSummary(attachments: InboundAttachment[]): string {\n    const count = attachments.length;\n    if (count === 0) {\n        return \"\";\n    }\n    const allImages = attachments.every((entry) => isImageAttachment(entry));\n    if (allImages) {\n        return `<media:image> (${count} ${count === 1 ? \"image\" : \"images\"})`;\n    }\n    return `<media:document> (${count} ${count === 1 ? \"file\" : \"files\"})`;\n}\n\nexport function chunkDiscordText(text: string, opts: {\n    maxChars?: number;\n    maxLines?: number;\n} = {}): string[] {\n    const maxChars = Math.max(1, Math.floor(opts.maxChars ?? DISCORD_TEXT_LIMIT));\n    const maxLines = Math.max(1, Math.floor(opts.maxLines ?? DISCORD_MAX_LINES_PER_MESSAGE));\n    const body = text ?? \"\";\n    if (!body) {\n        return [];\n    }\n    if (body.length <= maxChars && countLines(body) <= maxLines) {\n        return [body];\n    }\n    return new DiscordTextChunker({ maxChars, maxLines }).chunk(body);\n}\n\nexport function resolveTextChunkLimit(config: Config[\"channels\"][\"discord\"]): number {\n    const configured = typeof config.textChunkLimit === \"number\" ? config.textChunkLimit : DISCORD_TEXT_LIMIT;\n    return clampInt(configured, 1, DISCORD_TEXT_LIMIT);\n}\n\nexport function resolveDiscordStreamingMode(config: Config[\"channels\"][\"discord\"]): DiscordStreamMode {\n    const raw = config.streaming;\n    if (raw === true) {\n        return \"partial\";\n    }\n    if (raw === false || raw === undefined || raw === null) {\n        return \"off\";\n    }\n    if (raw === \"progress\") {\n        return \"partial\";\n    }\n    if (raw === \"partial\" || raw === \"block\" || raw === \"off\") {\n        return raw;\n    }\n    return \"off\";\n}\n\nexport function resolveDraftChunkConfig(\n    config: Config[\"channels\"][\"discord\"],\n    textChunkLimit: number\n): DraftChunkConfig {\n    const raw = config.draftChunk ?? {};\n    const minChars = clampInt((raw as DraftChunkConfig).minChars ?? 200, 1, textChunkLimit);\n    const maxChars = clampInt((raw as DraftChunkConfig).maxChars ?? 800, minChars, textChunkLimit);\n    const breakPreference = (raw as DraftChunkConfig).breakPreference === \"line\" || (raw as DraftChunkConfig).breakPreference === \"none\"\n        ? (raw as DraftChunkConfig).breakPreference\n        : \"paragraph\";\n    return { minChars, maxChars, breakPreference };\n}\n\nexport async function sendDiscordChunks(params: {\n    textChannel: TextBasedChannel & TextBasedChannelFields;\n    chunks: string[];\n    replyTo?: string;\n    flags?: number;\n}): Promise<void> {\n    const { textChannel, chunks, replyTo, flags } = params;\n    let first = true;\n    for (const chunk of chunks) {\n        await sendDiscordSingleChunk({\n            textChannel,\n            chunk,\n            replyTo: first ? replyTo : undefined,\n            flags\n        });\n        first = false;\n    }\n}\n\nclass DiscordTextChunker {\n    private readonly chunks: string[] = [];\n    private current = \"\";\n    private currentLines = 0;\n    private openFence: OpenFence | null = null;\n\n    constructor(private readonly limits: {\n        maxChars: number;\n        maxLines: number;\n    }) { }\n\n    chunk = (body: string): string[] => {\n        for (const line of body.split(\"\\n\")) {\n            this.appendLine(line);\n        }\n        this.flush();\n        return this.chunks;\n    };\n\n    private appendLine = (line: string): void => {\n        const fenceInfo = parseFenceLine(line);\n        const wasInsideFence = this.openFence !== null;\n        const nextOpenFence = this.nextFence(fenceInfo);\n        const { charLimit, lineLimit } = this.resolveLimits(nextOpenFence);\n        const prefixLength = this.current.length > 0 ? this.current.length + 1 : 0;\n        const segments = splitLongLine(line, Math.max(1, charLimit - prefixLength), {\n            preserveWhitespace: wasInsideFence\n        });\n        this.appendSegments({ segments, charLimit, lineLimit });\n        this.openFence = nextOpenFence;\n    };\n\n    private appendSegments = (params: {\n        segments: string[];\n        charLimit: number;\n        lineLimit: number;\n    }): void => {\n        const { segments, charLimit, lineLimit } = params;\n        segments.forEach((segment, index) => {\n            this.appendSegment({\n                segment,\n                isContinuation: index > 0,\n                charLimit,\n                lineLimit\n            });\n        });\n    };\n\n    private appendSegment = (params: {\n        segment: string;\n        isContinuation: boolean;\n        charLimit: number;\n        lineLimit: number;\n    }): void => {\n        const { segment, isContinuation, charLimit, lineLimit } = params;\n        const delimiter = isContinuation ? \"\" : this.current.length > 0 ? \"\\n\" : \"\";\n        const addition = `${delimiter}${segment}`;\n        const nextLength = this.current.length + addition.length;\n        const nextLineCount = this.currentLines + (isContinuation ? 0 : 1);\n        if ((nextLength > charLimit || nextLineCount > lineLimit) && this.current.length > 0) {\n            this.flush();\n        }\n        this.addToCurrent(segment, addition, isContinuation);\n    };\n\n    private addToCurrent = (segment: string, addition: string, isContinuation: boolean): void => {\n        if (this.current.length > 0) {\n            this.current += addition;\n            this.currentLines += isContinuation ? 0 : 1;\n            return;\n        }\n        this.current = segment;\n        this.currentLines = 1;\n    };\n\n    private nextFence = (fenceInfo: OpenFence | null): OpenFence | null => {\n        if (!fenceInfo) {\n            return this.openFence;\n        }\n        if (!this.openFence) {\n            return fenceInfo;\n        }\n        const closesCurrent = this.openFence.markerChar === fenceInfo.markerChar &&\n            fenceInfo.markerLen >= this.openFence.markerLen;\n        return closesCurrent ? null : this.openFence;\n    };\n\n    private resolveLimits = (nextOpenFence: OpenFence | null): {\n        charLimit: number;\n        lineLimit: number;\n    } => {\n        const reserveChars = nextOpenFence ? closeFenceLine(nextOpenFence).length + 1 : 0;\n        const reserveLines = nextOpenFence ? 1 : 0;\n        return {\n            charLimit: Math.max(1, this.limits.maxChars - reserveChars),\n            lineLimit: Math.max(1, this.limits.maxLines - reserveLines)\n        };\n    };\n\n    private flush = (): void => {\n        if (!this.current) {\n            return;\n        }\n        const payload = closeFenceIfNeeded(this.current, this.openFence);\n        if (payload.trim().length) {\n            this.chunks.push(payload);\n        }\n        this.current = \"\";\n        this.currentLines = 0;\n        if (this.openFence) {\n            this.current = this.openFence.openLine;\n            this.currentLines = 1;\n        }\n    };\n}\n\nfunction isImageAttachment(attachment: InboundAttachment): boolean {\n    if (attachment.mimeType?.startsWith(\"image/\")) {\n        return true;\n    }\n    return Boolean(attachment.name && guessMimeFromName(attachment.name));\n}\n\nfunction countLines(text: string): number {\n    if (!text) {\n        return 0;\n    }\n    return text.split(\"\\n\").length;\n}\n\nfunction parseFenceLine(line: string): OpenFence | null {\n    const match = line.match(FENCE_RE);\n    if (!match) {\n        return null;\n    }\n    const indent = match[1] ?? \"\";\n    const marker = match[2] ?? \"\";\n    return {\n        indent,\n        markerChar: marker[0] ?? \"`\",\n        markerLen: marker.length,\n        openLine: line\n    };\n}\n\nfunction closeFenceLine(openFence: OpenFence): string {\n    return `${openFence.indent}${openFence.markerChar.repeat(openFence.markerLen)}`;\n}\n\nfunction closeFenceIfNeeded(text: string, openFence: OpenFence | null): string {\n    if (!openFence) {\n        return text;\n    }\n    const closeLine = closeFenceLine(openFence);\n    if (!text) {\n        return closeLine;\n    }\n    if (!text.endsWith(\"\\n\")) {\n        return `${text}\\n${closeLine}`;\n    }\n    return `${text}${closeLine}`;\n}\n\nfunction splitLongLine(line: string, maxChars: number, opts: {\n    preserveWhitespace: boolean;\n}): string[] {\n    const limit = Math.max(1, Math.floor(maxChars));\n    if (line.length <= limit) {\n        return [line];\n    }\n    return new LongLineSplitter({ line, limit, preserveWhitespace: opts.preserveWhitespace }).split();\n}\n\nclass LongLineSplitter {\n    private readonly chunks: string[] = [];\n\n    private remaining: string;\n\n    constructor(private readonly params: {\n        line: string;\n        limit: number;\n        preserveWhitespace: boolean;\n    }) {\n        this.remaining = params.line;\n    }\n\n    split = (): string[] => {\n        while (this.remaining.length > this.params.limit) {\n            this.pushNextChunk();\n        }\n        if (this.remaining.length) {\n            this.chunks.push(this.remaining);\n        }\n        return this.chunks;\n    };\n\n    private pushNextChunk = (): void => {\n        if (this.params.preserveWhitespace) {\n            this.chunks.push(this.remaining.slice(0, this.params.limit));\n            this.remaining = this.remaining.slice(this.params.limit);\n            return;\n        }\n        const breakIndex = this.resolveBreakIndex();\n        this.chunks.push(this.remaining.slice(0, breakIndex));\n        this.remaining = this.remaining.slice(breakIndex);\n    };\n\n    private resolveBreakIndex = (): number => {\n        const window = this.remaining.slice(0, this.params.limit);\n        for (let index = window.length - 1; index >= 0; index -= 1) {\n            if (/\\s/.test(window[index])) {\n                return index > 0 ? index : this.params.limit;\n            }\n        }\n        return this.params.limit;\n    };\n}\n\nfunction clampInt(value: number, min: number, max: number): number {\n    if (Number.isNaN(value)) {\n        return min;\n    }\n    return Math.min(max, Math.max(min, Math.floor(value)));\n}\n\nexport async function sendDiscordSingleChunk(params: {\n    textChannel: TextBasedChannel & TextBasedChannelFields;\n    chunk: string;\n    replyTo?: string;\n    flags?: number;\n}): Promise<DiscordMessage> {\n    const { textChannel, chunk, replyTo, flags } = params;\n    const payload: {\n        content: string;\n        reply?: {\n            messageReference: string;\n        };\n        flags?: number;\n    } = {\n        content: chunk\n    };\n    if (replyTo) {\n        payload.reply = { messageReference: replyTo };\n    }\n    if (flags !== undefined) {\n        payload.flags = flags;\n    }\n    return await textChannel.send(payload as unknown as Parameters<TextBasedChannelFields[\"send\"]>[0]) as DiscordMessage;\n}\n"],"mappings":"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"}

package/nextclaw.extension.json

@@ -0,0 +1,46 @@
+{
+  "id": "nextclaw-channel-extension-discord",
+  "name": "NextClaw Discord Channel Extension",
+  "version": "0.1.0",
+  "server": {
+    "type": "stdio",
+    "command": "node",
+    "args": ["dist/main.js"]
+  },
+  "contributes": {
+    "channels": [
+      {
+        "id": "discord",
+        "name": "Discord",
+        "description": "Discord bot channel",
+        "configSchema": {
+          "type": "object",
+          "additionalProperties": true,
+          "properties": {
+            "enabled": { "type": "boolean" },
+            "token": { "type": "string" },
+            "allowBots": { "type": "boolean" },
+            "gatewayUrl": { "type": "string" },
+            "intents": { "type": "number" },
+            "proxy": { "type": ["string", "null"] },
+            "mediaMaxMb": { "type": "number" },
+            "streaming": {},
+            "textChunkLimit": { "type": "number" },
+            "accountId": { "type": "string" },
+            "dmPolicy": { "type": "string" },
+            "groupPolicy": { "type": "string" },
+            "requireMention": { "type": "boolean" },
+            "allowFrom": {
+              "type": "array",
+              "items": { "type": "string" }
+            },
+            "groupAllowFrom": {
+              "type": "array",
+              "items": { "type": "string" }
+            }
+          }
+        }
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@nextclaw/channel-extension-discord",
+  "version": "0.1.1-beta.0",
+  "private": false,
+  "description": "NextClaw Discord channel extension process.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "nextclaw.extension.json"
+  ],
+  "dependencies": {
+    "discord.js": "^14.16.3",
+    "undici": "^6.21.0",
+    "@nextclaw/core": "0.12.25-beta.0",
+    "@nextclaw/extension-sdk": "0.1.12-beta.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.6",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts src/main.ts --dts.sourcemap --clean --target es2022 --no-fixedExtension --unbundle",
+    "lint": "eslint src --max-warnings=0",
+    "tsc": "tsc -p tsconfig.json"
+  }
+}