clawmini 0.0.3 → 0.0.5

package/dist/adapter-discord/index.mjs

@@ -1,21 +1,21 @@
 #!/usr/bin/env node
-import { l as getSocketPath, o as getClawminiDir, u as getWorkspaceRoot } from "../workspace-DjoNjhW0.mjs";
+import { c as getClawminiDir, d as getSocketPath, f as getWorkspaceRoot } from "../workspace-BJmJBfKi.mjs";
 import { t as createUnixSocketFetch } from "../fetch-Cn1XNyiO.mjs";
+import { a as createUnixSocketEventSource, i as shouldDisplayMessage, n as handleAdapterCommand, r as formatMessage, t as handleRoutingCommand } from "../routing-D8rTxtaV.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
-import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import { createTRPCClient, httpLink, httpSubscriptionLink, splitLink } from "@trpc/client";
-import http from "node:http";
-import { Client, Events, GatewayIntentBits, Partials } from "discord.js";
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, Client, Colors, EmbedBuilder, Events, GatewayIntentBits, ModalBuilder, Partials, TextInputBuilder, TextInputStyle } from "discord.js";
 
 //#region src/adapter-discord/config.ts
 const DiscordConfigSchema = z.looseObject({
 	botToken: z.string().min(1, "Discord Bot Token is required."),
 	authorizedUserId: z.string().min(1, "Authorized Discord User ID is required."),
 	chatId: z.string().default("default"),
-	maxAttachmentSizeMB: z.number().default(25).optional()
+	maxAttachmentSizeMB: z.number().default(25),
+	requireMention: z.boolean().default(false)
 });
 function getDiscordConfigPath(startDir = process.cwd()) {
 	return path.join(getClawminiDir(startDir), "adapters", "discord", "config.json");
@@ -25,14 +25,10 @@ async function readDiscordConfig(startDir = process.cwd()) {
 	try {
 		const data = await fs$1.readFile(configPath, "utf-8");
 		const parsed = JSON.parse(data);
-		const result = DiscordConfigSchema.safeParse(parsed);
-		if (!result.success) {
-			console.error("Invalid Discord configuration:", result.error.format());
-			return null;
-		}
-		return result.data;
-	} catch {
-		return null;
+		return DiscordConfigSchema.parse(parsed);
+	} catch (err) {
+		if (err.code === "ENOENT") return null;
+		throw err;
 	}
 }
 async function initDiscordConfig(startDir = process.cwd()) {
@@ -51,98 +47,174 @@ async function initDiscordConfig(startDir = process.cwd()) {
 	console.log(`Created template configuration file at ${configPath}`);
 	console.log("Please update it with your actual Discord Bot Token and User ID.");
 }
-function isAuthorized(userId, authorizedUserId) {
+function isAuthorized$1(userId, authorizedUserId) {
 	return userId === authorizedUserId;
 }
 
 //#endregion
-//#region src/shared/event-source.ts
-function createUnixSocketEventSource(socketPath) {
-	return class UnixSocketEventSource {
-		readyState = 0;
-		CONNECTING = 0;
-		OPEN = 1;
-		CLOSED = 2;
-		req = null;
-		listeners = {};
-		constructor(url, init) {
-			const parsedUrl = new URL(url);
-			const options = {
-				socketPath,
-				path: parsedUrl.pathname + parsedUrl.search,
-				method: "GET",
-				headers: {
-					Accept: "text/event-stream",
-					"Cache-Control": "no-cache",
-					...init?.headers
-				}
-			};
-			this.req = http.request(options, (res) => {
-				if (res.statusCode === 200) {
-					this.readyState = this.OPEN;
-					this.dispatchEvent({ type: "open" });
-				} else {
-					this.readyState = this.CLOSED;
-					this.dispatchEvent({
-						type: "error",
-						message: `Unexpected status code: ${res.statusCode}`
-					});
-					return;
-				}
-				let buffer = "";
-				res.on("data", (chunk) => {
-					buffer += chunk.toString("utf-8");
-					const lines = buffer.split(/\r?\n\r?\n/);
-					buffer = lines.pop() || "";
-					for (const block of lines) this.parseBlock(block);
-				});
-				res.on("end", () => {
-					if (buffer) this.parseBlock(buffer);
-					this.readyState = this.CLOSED;
-					this.dispatchEvent({ type: "close" });
-				});
+//#region src/adapter-discord/state.ts
+const DiscordStateSchema = z.object({
+	lastSyncedMessageIds: z.record(z.string(), z.string()).optional(),
+	channelChatMap: z.record(z.string(), z.object({
+		chatId: z.string().nullable().optional(),
+		requireMention: z.boolean().optional()
+	})).optional(),
+	filters: z.record(z.string(), z.boolean()).optional()
+});
+function getDiscordStatePath(startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "adapters", "discord", "state.json");
+}
+async function readDiscordState(startDir = process.cwd()) {
+	const statePath = getDiscordStatePath(startDir);
+	try {
+		const data = await fs$1.readFile(statePath, "utf-8");
+		const parsed = JSON.parse(data);
+		if (parsed.lastSyncedMessageId && !parsed.lastSyncedMessageIds) parsed.lastSyncedMessageIds = { default: parsed.lastSyncedMessageId };
+		if (parsed.channelChatMap) {
+			for (const [key, value] of Object.entries(parsed.channelChatMap)) if (typeof value === "string") parsed.channelChatMap[key] = { chatId: value };
+		}
+		return DiscordStateSchema.parse(parsed);
+	} catch (err) {
+		if (err.code === "ENOENT") return {};
+		throw err;
+	}
+}
+async function writeDiscordState(state, startDir = process.cwd()) {
+	const statePath = getDiscordStatePath(startDir);
+	const dir = path.dirname(statePath);
+	try {
+		await fs$1.mkdir(dir, { recursive: true });
+		await fs$1.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+	} catch (err) {
+		console.error(`Failed to write Discord state to ${statePath}:`, err);
+	}
+}
+let stateUpdatePromise = Promise.resolve();
+function updateDiscordState(updates, startDir = process.cwd()) {
+	return new Promise((resolve, reject) => {
+		stateUpdatePromise = stateUpdatePromise.then(async () => {
+			try {
+				const currentState = await readDiscordState(startDir);
+				const resolvedUpdates = typeof updates === "function" ? updates(currentState) : updates;
+				const newState = {
+					...currentState,
+					...resolvedUpdates
+				};
+				await writeDiscordState(newState, startDir);
+				resolve(newState);
+			} catch (err) {
+				console.error(`Failed to write Discord state:`, err);
+				reject(err);
+			}
+		});
+	});
+}
+
+//#endregion
+//#region src/adapter-discord/interactions.ts
+function isAuthorized(userId, authorizedUserId) {
+	return userId === authorizedUserId;
+}
+async function handleDiscordInteraction(interaction, config, trpc) {
+	if (!interaction.isButton() && !interaction.isModalSubmit()) return;
+	if (!isAuthorized(interaction.user.id, config.authorizedUserId)) {
+		if (interaction.isRepliable()) await interaction.reply({
+			content: "You are not authorized to perform this action.",
+			ephemeral: true
+		});
+		return;
+	}
+	if (interaction.isButton()) {
+		if (interaction.customId.startsWith("approve_") || interaction.customId.startsWith("approve|")) {
+			let policyId, explicitChatId;
+			if (interaction.customId.startsWith("approve|")) {
+				const parts = interaction.customId.split("|");
+				policyId = parts[1];
+				explicitChatId = parts[2] || void 0;
+			} else policyId = interaction.customId.replace("approve_", "");
+			await interaction.update({ components: [] });
+			await interaction.followUp({
+				content: `Approving policy ${policyId}...`,
+				ephemeral: true
 			});
-			this.req.on("error", (err) => {
-				this.readyState = this.CLOSED;
-				this.dispatchEvent({
-					type: "error",
-					error: err
+			try {
+				const currentState = await readDiscordState();
+				const targetChatId = explicitChatId || (interaction.channelId ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId : config.chatId);
+				await trpc.sendMessage.mutate({
+					type: "send-message",
+					client: "cli",
+					data: {
+						message: `/approve ${policyId}`,
+						chatId: targetChatId,
+						adapter: "discord",
+						noWait: true
+					}
 				});
-			});
-			this.req.end();
+			} catch (error) {
+				console.error("Failed to send approve command to daemon:", error);
+				await interaction.followUp({
+					content: `Failed to approve policy ${policyId}.`,
+					ephemeral: true
+				});
+			}
+		} else if (interaction.customId.startsWith("reject_") || interaction.customId.startsWith("reject|")) {
+			let policyId, explicitChatId;
+			if (interaction.customId.startsWith("reject|")) {
+				const parts = interaction.customId.split("|");
+				policyId = parts[1];
+				explicitChatId = parts[2] || "";
+			} else {
+				policyId = interaction.customId.replace("reject_", "");
+				explicitChatId = "";
+			}
+			const modal = new ModalBuilder().setCustomId(`modal_reject|${policyId}|${explicitChatId}`).setTitle("Reject Policy");
+			const rationaleInput = new TextInputBuilder().setCustomId("rationale").setLabel("Rationale (optional)").setStyle(TextInputStyle.Paragraph).setRequired(false);
+			const actionRow = new ActionRowBuilder().addComponents(rationaleInput);
+			modal.addComponents(actionRow);
+			await interaction.showModal(modal);
 		}
-		parseBlock(block) {
-			if (!block.trim()) return;
-			const lines = block.split(/\r?\n/);
-			let eventType = "message";
-			let data = "";
-			let id = "";
-			for (const line of lines) if (line.startsWith("event: ")) eventType = line.slice(7).trim();
-			else if (line.startsWith("data: ")) data += (data ? "\n" : "") + line.slice(6);
-			else if (line.startsWith("id: ")) id = line.slice(4).trim();
-			if (data) this.dispatchEvent({
-				type: eventType,
-				data,
-				lastEventId: id
+	} else if (interaction.isModalSubmit()) {
+		if (interaction.customId.startsWith("modal_reject_") || interaction.customId.startsWith("modal_reject|")) {
+			let policyId, explicitChatId;
+			if (interaction.customId.startsWith("modal_reject|")) {
+				const parts = interaction.customId.split("|");
+				policyId = parts[1];
+				explicitChatId = parts[2] || void 0;
+			} else policyId = interaction.customId.replace("modal_reject_", "");
+			const rationale = interaction.fields.getTextInputValue("rationale");
+			const command = rationale ? `/reject ${policyId} ${rationale}` : `/reject ${policyId}`;
+			if (interaction.isFromMessage()) {
+				await interaction.update({ components: [] });
+				await interaction.followUp({
+					content: `Rejecting policy ${policyId}...`,
+					ephemeral: true
+				});
+			} else await interaction.reply({
+				content: `Rejecting policy ${policyId}...`,
+				ephemeral: true
 			});
+			try {
+				const currentState = await readDiscordState();
+				const targetChatId = explicitChatId || (interaction.channelId ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId : config.chatId);
+				await trpc.sendMessage.mutate({
+					type: "send-message",
+					client: "cli",
+					data: {
+						message: command,
+						chatId: targetChatId,
+						adapter: "discord",
+						noWait: true
+					}
+				});
+			} catch (error) {
+				console.error("Failed to send reject command to daemon:", error);
+				await interaction.followUp({
+					content: `Failed to reject policy ${policyId}.`,
+					ephemeral: true
+				});
+			}
 		}
-		addEventListener(type, listener) {
-			if (!this.listeners[type]) this.listeners[type] = [];
-			this.listeners[type].push(listener);
-		}
-		removeEventListener(type, listener) {
-			if (!this.listeners[type]) return;
-			this.listeners[type] = this.listeners[type].filter((l) => l !== listener);
-		}
-		dispatchEvent(event) {
-			const type = event.type;
-			if (this.listeners[type]) for (const listener of this.listeners[type]) listener(event);
-		}
-		close() {
-			this.readyState = this.CLOSED;
-			if (this.req) this.req.destroy();
-		}
-	};
+	}
 }
 
 //#endregion
@@ -173,65 +245,66 @@ function getTRPCClient(options = {}) {
 }
 
 //#endregion
-//#region src/adapter-discord/state.ts
-const DiscordStateSchema = z.object({ lastSyncedMessageId: z.string().optional() });
-function getDiscordStatePath(startDir = process.cwd()) {
-	return path.join(getClawminiDir(startDir), "adapters", "discord", "state.json");
-}
-async function readDiscordState(startDir = process.cwd()) {
-	const statePath = getDiscordStatePath(startDir);
-	try {
-		const data = await fs$1.readFile(statePath, "utf-8");
-		const parsed = JSON.parse(data);
-		const result = DiscordStateSchema.safeParse(parsed);
-		if (!result.success) return { lastSyncedMessageId: void 0 };
-		return result.data;
-	} catch {
-		return { lastSyncedMessageId: void 0 };
+//#region src/adapter-discord/forwarder.ts
+async function resolveDiscordDestination(client, discordUserId, chatId) {
+	const channelChatMap = (await readDiscordState()).channelChatMap || {};
+	let targetDiscordChannelId;
+	for (const [channelId, mappedChatId] of Object.entries(channelChatMap)) if (mappedChatId?.chatId === chatId) {
+		targetDiscordChannelId = channelId;
+		break;
 	}
-}
-async function writeDiscordState(state, startDir = process.cwd()) {
-	const statePath = getDiscordStatePath(startDir);
-	const dir = path.dirname(statePath);
-	try {
-		await fs$1.mkdir(dir, { recursive: true });
-		await fs$1.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
-	} catch (err) {
-		console.error(`Failed to write Discord state to ${statePath}:`, err);
+	if (targetDiscordChannelId) try {
+		const channel = await client.channels.fetch(targetDiscordChannelId);
+		if (channel && channel.isTextBased() && !channel.isDMBased()) return channel;
+	} catch (error) {
+		console.warn(`Failed to fetch mapped channel ${targetDiscordChannelId} for chat ${chatId}, falling back to DM.`, error);
 	}
+	return (await client.users.fetch(discordUserId)).createDM();
 }
-
-//#endregion
-//#region src/adapter-discord/forwarder.ts
-async function startDaemonToDiscordForwarder(client, trpc, discordUserId, chatId = "default", signal) {
-	let lastMessageId = (await readDiscordState()).lastSyncedMessageId;
-	if (!lastMessageId) try {
-		const messages = await trpc.getMessages.query({
-			chatId,
-			limit: 1
-		});
-		if (Array.isArray(messages) && messages.length > 0) {
-			const lastMsg = messages[messages.length - 1];
-			if (lastMsg) {
-				lastMessageId = lastMsg.id;
-				await writeDiscordState({ lastSyncedMessageId: lastMessageId });
+async function startDaemonToDiscordForwarder(client, trpc, discordUserId, options = {}) {
+	const defaultChatId = options.chatId ?? "default";
+	const signal = options.signal;
+	const config = options.config ?? {};
+	const activeSubscriptions = /* @__PURE__ */ new Map();
+	const activeTypingSubscriptions = /* @__PURE__ */ new Map();
+	let currentLastSyncedMessageIds = (await readDiscordState()).lastSyncedMessageIds || {};
+	const saveLastMessageId = async (chatId, id) => {
+		currentLastSyncedMessageIds = {
+			...currentLastSyncedMessageIds,
+			[chatId]: id
+		};
+		return updateDiscordState((state) => ({ lastSyncedMessageIds: {
+			...state.lastSyncedMessageIds,
+			...currentLastSyncedMessageIds
+		} }));
+	};
+	const startSubscriptionForChat = async (chatId) => {
+		if (activeSubscriptions.has(chatId)) return;
+		if (signal?.aborted) return;
+		let lastMessageId = currentLastSyncedMessageIds[chatId];
+		if (!lastMessageId) try {
+			const messages = await trpc.getMessages.query({
+				chatId,
+				limit: 1
+			});
+			if (Array.isArray(messages) && messages.length > 0) {
+				const lastMsg = messages[messages.length - 1];
+				if (lastMsg) {
+					await saveLastMessageId(chatId, lastMsg.id);
+					lastMessageId = lastMsg.id;
+				}
 			}
+		} catch (error) {
+			if (signal?.aborted) return;
+			console.error(`Failed to fetch initial messages from daemon for ${chatId}:`, error);
 		}
-	} catch (error) {
-		if (signal?.aborted) return;
-		console.error("Failed to fetch initial messages from daemon:", error);
-	}
-	console.log(`Starting daemon-to-discord forwarder for chat ${chatId}, lastMessageId: ${lastMessageId}`);
-	let retryDelay = 1e3;
-	const maxRetryDelay = 3e4;
-	return new Promise((resolve) => {
+		console.log(`Starting daemon-to-discord forwarder for chat ${chatId}, lastMessageId: ${lastMessageId}`);
+		let retryDelay = 1e3;
+		const maxRetryDelay = 3e4;
 		let subscription = null;
 		let messageQueue = Promise.resolve();
 		const connect = () => {
-			if (signal?.aborted) {
-				resolve();
-				return;
-			}
+			if (signal?.aborted || !activeSubscriptions.has(chatId)) return;
 			subscription = trpc.waitForMessages.subscribe({
 				chatId,
 				lastMessageId
@@ -241,61 +314,83 @@ async function startDaemonToDiscordForwarder(client, trpc, discordUserId, chatId
 					if (!Array.isArray(messages) || messages.length === 0) return;
 					messageQueue = messageQueue.then(async () => {
 						for (const rawMessage of messages) {
-							if (signal?.aborted) break;
+							if (signal?.aborted || !activeSubscriptions.has(chatId)) break;
 							const message = rawMessage;
-							if (message.role === "log") {
+							if (shouldDisplayMessage(message, config)) {
 								const logMessage = message;
-								if (logMessage.level === "verbose") {
+								if (logMessage.role === "policy" && logMessage.status === "pending") {
+									try {
+										const dm = await resolveDiscordDestination(client, discordUserId, chatId);
+										const embed = new EmbedBuilder().setTitle("Action Required: Policy Request").setDescription(logMessage.content || "A pending policy request requires your attention.").setColor(Colors.Yellow);
+										const policyId = "requestId" in logMessage && logMessage.requestId || logMessage.id;
+										const row = new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(`approve|${policyId}|${chatId}`).setLabel("Approve").setStyle(ButtonStyle.Success), new ButtonBuilder().setCustomId(`reject|${policyId}|${chatId}`).setLabel("Reject").setStyle(ButtonStyle.Danger));
+										const optionsMsg = {
+											embeds: [embed],
+											components: [row]
+										};
+										try {
+											await dm.send(optionsMsg);
+										} catch (richError) {
+											console.warn(`Failed to send rich message to Discord user ${discordUserId}, falling back to plain text:`, richError);
+											await dm.send({ content: `Action Required: Policy Request\n\n${logMessage.content || "A pending policy request requires your attention."}\n\nApprove: \`/approve ${policyId}\`\nReject: \`/reject ${policyId} <optional_rationale>\`` });
+										}
+									} catch (error) {
+										console.error(`Failed to send message to Discord user ${discordUserId}:`, error);
+									}
+									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
+									lastMessageId = logMessage.id;
+									continue;
+								}
+								if ("level" in logMessage && logMessage.level === "verbose") {
+									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
 									lastMessageId = logMessage.id;
-									await writeDiscordState({ lastSyncedMessageId: lastMessageId }).catch(console.error);
 									continue;
 								}
 								const hasContent = !!logMessage.content?.trim();
-								const hasFiles = Array.isArray(logMessage.files) && logMessage.files.length > 0;
+								const files = "files" in logMessage ? logMessage.files : void 0;
+								const hasFiles = Array.isArray(files) && files.length > 0;
 								let absoluteFiles = [];
-								if (hasFiles) {
+								if (hasFiles && files) {
 									const workspaceRoot = getWorkspaceRoot(process.cwd());
-									absoluteFiles = logMessage.files.map((f) => path.resolve(workspaceRoot, f));
+									absoluteFiles = files.map((f) => path.resolve(workspaceRoot, f));
 								}
 								if (!hasContent && !hasFiles) {
+									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
 									lastMessageId = logMessage.id;
-									await writeDiscordState({ lastSyncedMessageId: lastMessageId }).catch(console.error);
 									continue;
 								}
 								try {
-									const dm = await (await client.users.fetch(discordUserId)).createDM();
-									if (hasContent && logMessage.content.length > 2e3) {
-										const chunks = chunkString(logMessage.content, 2e3);
+									const dm = await resolveDiscordDestination(client, discordUserId, chatId);
+									const formattedContent = formatMessage(message);
+									if (formattedContent && formattedContent.length > 2e3) {
+										const chunks = chunkString(formattedContent, 2e3);
 										for (let i = 0; i < chunks.length; i++) {
-											if (signal?.aborted) break;
+											if (signal?.aborted || !activeSubscriptions.has(chatId)) break;
 											const chunkOptions = { content: chunks[i] };
 											if (i === chunks.length - 1 && hasFiles) chunkOptions.files = absoluteFiles;
 											await dm.send(chunkOptions);
 										}
 									} else {
-										const options = {};
-										if (hasContent) options.content = logMessage.content;
-										if (hasFiles) options.files = absoluteFiles;
-										await dm.send(options);
+										const optionsMsg = {};
+										if (formattedContent) optionsMsg.content = formattedContent;
+										if (hasFiles) optionsMsg.files = absoluteFiles;
+										await dm.send(optionsMsg);
 									}
 								} catch (error) {
 									console.error(`Failed to send message to Discord user ${discordUserId}:`, error);
 									break;
 								}
 							}
+							await saveLastMessageId(chatId, message.id).catch(console.error);
 							lastMessageId = message.id;
-							await writeDiscordState({ lastSyncedMessageId: lastMessageId }).catch(console.error);
 						}
 					});
 				},
 				onError: (error) => {
-					console.error(`Error in daemon-to-discord forwarder subscription. Retrying in ${retryDelay}ms.`, error);
+					console.error(`Error in daemon-to-discord forwarder subscription for ${chatId}. Retrying in ${retryDelay}ms.`, error);
 					subscription?.unsubscribe();
 					subscription = null;
-					if (signal?.aborted) {
-						resolve();
-						return;
-					}
+					if (signal?.aborted || !activeSubscriptions.has(chatId)) return;
 					setTimeout(() => {
 						retryDelay = Math.min(retryDelay * 2, maxRetryDelay);
 						connect();
@@ -303,30 +398,30 @@ async function startDaemonToDiscordForwarder(client, trpc, discordUserId, chatId
 				},
 				onComplete: () => {
 					subscription = null;
-					if (!signal?.aborted) setTimeout(() => connect(), retryDelay);
-					else resolve();
+					if (!signal?.aborted && activeSubscriptions.has(chatId)) setTimeout(() => connect(), retryDelay);
 				}
 			});
 		};
 		let typingSubscription = null;
 		let typingRetryDelay = 1e3;
 		const connectTyping = () => {
-			if (signal?.aborted) return;
+			if (signal?.aborted || !activeSubscriptions.has(chatId)) return;
 			typingSubscription = trpc.waitForTyping.subscribe({ chatId }, {
 				onData: async (event) => {
 					typingRetryDelay = 1e3;
 					if (!event) return;
 					try {
-						await (await (await client.users.fetch(discordUserId)).createDM()).sendTyping();
+						const dm = await resolveDiscordDestination(client, discordUserId, chatId);
+						if (dm.sendTyping) await dm.sendTyping();
 					} catch (error) {
 						console.error(`Failed to send typing indicator to Discord user ${discordUserId}:`, error);
 					}
 				},
 				onError: (error) => {
-					console.error(`Error in daemon-to-discord typing forwarder subscription. Retrying in ${typingRetryDelay}ms.`, error);
+					console.error(`Error in daemon-to-discord typing forwarder subscription for ${chatId}. Retrying in ${typingRetryDelay}ms.`, error);
 					typingSubscription?.unsubscribe();
 					typingSubscription = null;
-					if (signal?.aborted) return;
+					if (signal?.aborted || !activeSubscriptions.has(chatId)) return;
 					setTimeout(() => {
 						typingRetryDelay = Math.min(typingRetryDelay * 2, maxRetryDelay);
 						connectTyping();
@@ -334,15 +429,54 @@ async function startDaemonToDiscordForwarder(client, trpc, discordUserId, chatId
 				},
 				onComplete: () => {
 					typingSubscription = null;
-					if (!signal?.aborted) setTimeout(() => connectTyping(), typingRetryDelay);
+					if (!signal?.aborted && activeSubscriptions.has(chatId)) setTimeout(() => connectTyping(), typingRetryDelay);
 				}
 			});
 		};
+		activeSubscriptions.set(chatId, { unsubscribe: () => subscription?.unsubscribe() });
+		activeTypingSubscriptions.set(chatId, { unsubscribe: () => typingSubscription?.unsubscribe() });
 		connect();
 		connectTyping();
+	};
+	const syncSubscriptions = async () => {
+		if (signal?.aborted) return;
+		const state = await readDiscordState();
+		if (state.lastSyncedMessageIds) currentLastSyncedMessageIds = {
+			...currentLastSyncedMessageIds,
+			...state.lastSyncedMessageIds
+		};
+		const targetChatIds = /* @__PURE__ */ new Set();
+		targetChatIds.add(defaultChatId);
+		if (state.channelChatMap) {
+			for (const mappedEntry of Object.values(state.channelChatMap)) if (mappedEntry.chatId) targetChatIds.add(mappedEntry.chatId);
+		}
+		for (const targetChatId of targetChatIds) if (!activeSubscriptions.has(targetChatId)) startSubscriptionForChat(targetChatId);
+		for (const [activeChatId, sub] of activeSubscriptions.entries()) if (!targetChatIds.has(activeChatId)) {
+			sub.unsubscribe();
+			activeSubscriptions.delete(activeChatId);
+			activeTypingSubscriptions.get(activeChatId)?.unsubscribe();
+			activeTypingSubscriptions.delete(activeChatId);
+		}
+	};
+	return new Promise((resolve) => {
+		syncSubscriptions().catch(console.error);
+		const statePath = getDiscordStatePath();
+		const stateDir = path.dirname(statePath);
+		if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
+		let debounceTimer = null;
+		const watcher = fs.watch(stateDir, (eventType, filename) => {
+			if (filename === path.basename(statePath)) {
+				if (debounceTimer) clearTimeout(debounceTimer);
+				debounceTimer = setTimeout(() => {
+					syncSubscriptions().catch(console.error);
+				}, 200);
+			}
+		});
 		signal?.addEventListener("abort", () => {
-			subscription?.unsubscribe();
-			typingSubscription?.unsubscribe();
+			if (debounceTimer) clearTimeout(debounceTimer);
+			watcher.close();
+			for (const sub of activeSubscriptions.values()) sub.unsubscribe();
+			for (const sub of activeTypingSubscriptions.values()) sub.unsubscribe();
 			resolve();
 		});
 	});
@@ -369,23 +503,100 @@ async function main() {
 	}
 	const trpc = getTRPCClient();
 	const client = new Client({
-		intents: [GatewayIntentBits.DirectMessages, GatewayIntentBits.MessageContent],
+		intents: [
+			GatewayIntentBits.DirectMessages,
+			GatewayIntentBits.MessageContent,
+			GatewayIntentBits.Guilds,
+			GatewayIntentBits.GuildMessages
+		],
 		partials: [Partials.Channel]
 	});
+	const filteringConfig = { filters: (await readDiscordState()).filters };
 	client.once(Events.ClientReady, (readyClient) => {
 		console.log(`Ready! Logged in as ${readyClient.user.tag}`);
-		startDaemonToDiscordForwarder(readyClient, trpc, config.authorizedUserId, config.chatId).catch((error) => {
+		startDaemonToDiscordForwarder(readyClient, trpc, config.authorizedUserId, {
+			chatId: config.chatId,
+			config: filteringConfig
+		}).catch((error) => {
 			console.error("Error in daemon-to-discord forwarder:", error);
 		});
 	});
 	client.on(Events.MessageCreate, async (message) => {
 		if (message.author.id === client.user?.id) return;
-		if (message.guild) return;
-		if (!isAuthorized(message.author.id, config.authorizedUserId)) {
+		if (message.author.bot) return;
+		const externalContextId = message.channelId;
+		const currentState = await readDiscordState();
+		const mappedChatId = currentState.channelChatMap?.[externalContextId]?.chatId;
+		const isRoutingCommand = message.content.startsWith("/chat") || message.content.startsWith("/agent");
+		if (message.guild) {
+			const channelConfig = currentState.channelChatMap?.[externalContextId];
+			if (channelConfig?.requireMention !== void 0 ? channelConfig.requireMention : config.requireMention) {
+				const isMentioned = message.mentions.has(client.user.id);
+				let isReplyToBot = false;
+				if (message.reference && message.reference.messageId) try {
+					isReplyToBot = (await message.channel.messages.fetch(message.reference.messageId)).author.id === client.user.id;
+				} catch (err) {
+					console.error("Failed to fetch referenced message for mention check:", err);
+				}
+				if (!isMentioned && !isReplyToBot) return;
+			}
+		}
+		if (!isAuthorized$1(message.author.id, config.authorizedUserId)) {
 			console.log(`Unauthorized message from ${message.author.tag} (${message.author.id}) ignored.`);
 			return;
 		}
 		console.log(`Received message from ${message.author.tag}: ${message.content}`);
+		if (isRoutingCommand) {
+			const stringChatMap = Object.fromEntries(Object.entries(currentState.channelChatMap || {}).map(([k, v]) => [k, v.chatId || ""]));
+			const routingResult = await handleRoutingCommand(message.content, externalContextId, stringChatMap, "discord", trpc);
+			if (routingResult) {
+				if (routingResult.type === "mapped") await updateDiscordState((latestState) => ({ channelChatMap: {
+					...latestState.channelChatMap || {},
+					[externalContextId]: {
+						...latestState.channelChatMap?.[externalContextId] || {},
+						chatId: routingResult.newChatId
+					}
+				} }));
+				await message.reply(routingResult.text);
+				return;
+			}
+		}
+		let targetChatId = mappedChatId;
+		if (!targetChatId && !isRoutingCommand) if (!currentState.channelChatMap || Object.values(currentState.channelChatMap).every((entry) => !entry.chatId)) {
+			targetChatId = config.chatId || "default";
+			console.log(`First contact detected. Automatically mapping channel ${externalContextId} to chat ${targetChatId}.`);
+			await updateDiscordState((latestState) => ({ channelChatMap: {
+				...latestState.channelChatMap || {},
+				[externalContextId]: {
+					...latestState.channelChatMap?.[externalContextId] || {},
+					chatId: targetChatId
+				}
+			} }));
+		} else {
+			const isDirectMessage = !message.guild;
+			const isMentioned = message.mentions.has(client.user.id);
+			const isSlashCommand = message.content.startsWith("/");
+			if (isDirectMessage || isMentioned || isSlashCommand) {
+				console.log(`Unmapped channel ${externalContextId}, sending first contact warning.`);
+				await message.reply("This channel/space is not currently mapped to a daemon chat. Please use `/chat [chat-id]` or `/agent [agent-id]` to map it.");
+			} else console.log(`Unmapped channel ${externalContextId}, silently ignoring background message.`);
+			return;
+		}
+		if (!targetChatId) targetChatId = config.chatId || "default";
+		const commandResult = await handleAdapterCommand(message.content, filteringConfig, trpc, targetChatId);
+		if (commandResult) {
+			if (commandResult.type === "text") {
+				if (commandResult.newConfig) {
+					filteringConfig.filters = commandResult.newConfig.filters;
+					await updateDiscordState({ filters: filteringConfig.filters });
+				}
+				await message.reply(commandResult.text);
+			} else if (commandResult.type === "debug") {
+				const formatted = commandResult.messages.length === 0 ? "No ignored background messages found." : `**Debug Output (${commandResult.messages.length} ignored messages):**\n\n` + commandResult.messages.map((msg) => formatMessage(msg)).join("\n\n---\n\n");
+				await message.reply(formatted);
+			}
+			return;
+		}
 		const downloadedFiles = [];
 		if (message.attachments.size > 0) {
 			const tmpDir = path.join(getClawminiDir(process.cwd()), "tmp", "discord");
@@ -428,7 +639,7 @@ async function main() {
 				client: "cli",
 				data: {
 					message: finalContent,
-					chatId: config.chatId,
+					chatId: targetChatId,
 					files: downloadedFiles.length > 0 ? downloadedFiles : void 0,
 					adapter: "discord",
 					noWait: true
@@ -439,6 +650,9 @@ async function main() {
 			console.error("Failed to forward message to daemon:", error);
 		}
 	});
+	client.on(Events.InteractionCreate, async (interaction) => {
+		await handleDiscordInteraction(interaction, config, trpc);
+	});
 	try {
 		await client.login(config.botToken);
 	} catch (error) {
@@ -446,16 +660,7 @@ async function main() {
 		process.exit(1);
 	}
 }
-if ((() => {
-	try {
-		if (typeof process === "undefined" || !process.argv || process.argv.length < 2) return false;
-		const argv1 = process.argv[1];
-		if (!argv1) return false;
-		return path.resolve(argv1) === path.resolve(fileURLToPath(import.meta.url));
-	} catch {
-		return false;
-	}
-})()) main().catch((error) => {
+main().catch((error) => {
 	console.error("Unhandled error in Discord Adapter:", error);
 	process.exit(1);
 });