clawmini 0.0.1

package/.gemini/settings.json

@@ -0,0 +1,46 @@
+{
+    "tools": {
+        "allowed": [
+            "write_file",
+            "replace",
+            "activate_skill",
+            "run_shell_command(cat)",
+            "run_shell_command(grep)",
+            "run_shell_command(find)",
+            "run_shell_command(tail)",
+            "run_shell_command(head)",
+            "run_shell_command(wc)",
+            "run_shell_command(sort)",
+            "run_shell_command(echo)",
+            "run_shell_command(ls)",
+            "run_shell_command(pwd)",
+            "run_shell_command(cd)",
+            "run_shell_command(git diff)",
+            "run_shell_command(git status)",
+            "run_shell_command(git log)",
+            "run_shell_command(git show)",
+            "run_shell_command(git add)",
+            "run_shell_command(git commit)",
+            "run_shell_command(sed)",
+            "run_shell_command(awk)",
+            "run_shell_command(cp)",
+            "run_shell_command(mv)",
+            "run_shell_command(chmod)",
+            "run_shell_command(chown)",
+            "run_shell_command(touch)",
+            "run_shell_command(rm)",
+            "run_shell_command(mkdir)",
+            "run_shell_command(rmdir)",
+            "run_shell_command(npm)",
+            "run_shell_command(>)",
+            "run_shell_command(<<)",
+            "run_shell_command(heredoc)",
+            "run_shell_command(redirection)"
+        ],
+        "exclude": [
+            "ask_user",
+            "save_memory",
+            "write_todos"
+        ]
+    }
+}

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": true,
+  "printWidth": 100,
+  "tabWidth": 2
+}

package/GEMINI.md

@@ -0,0 +1,11 @@
+When editing or creating files, ALWAYS use the write_tool/replace tools over run_shell_command with `cat` or `echo`.
+
+# Take notes in napkin.md
+
+./napkin.md contains notes for development.
+At the start of any session, read napkin.md.
+As you work, take notes in napkin.md including:
+
+- corrections the user has given you that future developers may care about
+- mistakes you made when running a command, with the corrections
+- challenges you had to resolve, with the final solution

package/README.md

@@ -0,0 +1,137 @@
+# Clawmini
+
+Clawmini is an orchestration layer for command-line AI agents, providing a unified chat experience that can span multiple conversations and multiple agents. Ultimately, it aims to deliver a personal assistant experience built entirely on top of your local tools and agents.
+
+## Features
+
+- **Persistent, Multi-Agent Chat Sessions:** Maintain separate chats for different tasks, allowing you to converse with multiple agents across multiple conversations.
+- **Safe Concurrency:** Automatically manages state and handles race conditions, queuing background commands safely to prevent file lock issues.
+- **Built-in & Bring-Your-Own UI:** Includes a fast, beautifully designed SvelteKit Web UI to visually manage agents, chats, and monitor real-time execution. Alternatively, easily build and connect your own interfaces to its local API.
+- **Agent Templates:** Quickly scaffold new agents using built-in or custom templates (e.g. `gemini`), automatically merging configuration settings.
+- **Routers & Middleware Pipeline:** Process user messages through an extensible pipeline to dynamically alter content, target specific agents or sessions, and expand slash commands before they reach an agent.
+- **Local File System Storage:** Everything is stored completely locally in `.clawmini/` within your workspace as transparent JSON/JSONL files. No cloud syncing required.
+- **Sandboxed Agent API:** The daemon can optionally expose a secure HTTP server configured via the `api` setting in `.clawmini/settings.json`, allowing remote or containerized access. Give agents a minimal zero-dependency standalone client exported via `clawmini export-lite`. It securely authenticates with the Agent API using dynamically generated HMAC tokens (`CLAW_API_TOKEN`) to allow sandboxed agents to log messages and manage cron jobs without needing direct access to the host's Unix socket.
+- **Proactivity:** Incoming messages or events from various external sources can be proactively routed back to the user or directly to the agent for autonomous handling.
+
+### Coming Soon
+
+- **Human Approval Requests:** When an agent needs permission to execute a sensitive action or requires input, it will pause and ask the user for approval via a dedicated UI or dashboard.
+
+## Quick Start
+
+Assuming you have built and linked the package globally:
+
+```bash
+# Initialize a new .clawmini settings folder, create an agent named 'coder' with the 'gemini-cladding' template, and set it as the default chat
+clawmini init --agent coder --agent-template gemini-cladding
+
+# Start the local web interface on http://localhost:8080
+clawmini web
+```
+
+## Command Reference
+
+### Initialization & Daemon
+
+- `clawmini init`: Initialize a new `.clawmini` configuration folder.
+- `clawmini up`: Start the local daemon server in the background.
+- `clawmini down`: Stop the local daemon server.
+- `clawmini export-lite [--out <path>] [--stdout]`: Export the standalone `clawmini-lite` client script for use in sandboxed environments.
+
+### Chat Management
+
+- `clawmini chats list`: Display all existing chats in the workspace.
+- `clawmini chats add <id>`: Create a new chat with the specified identifier.
+- `clawmini chats delete <id>`: Remove a chat and its associated history.
+- `clawmini chats set-default <id>`: Update the globally configured default chat for the workspace.
+
+### Messaging
+
+- `clawmini messages send <message> [--chat <id>] [--agent <name>]`: Send a message to a specific chat (defaults to the workspace default chat). Use `--agent` to assign a specific agent to handle the message.
+- `clawmini messages tail [-n NUM] [--json] [--chat <id>]`: Display the most recent messages and command logs in a chat.
+
+### Agents
+
+- `clawmini agents list`: Display all existing agents.
+- `clawmini agents add <id> [-d, --directory <dir>] [-t, --template <name>] [-e, --env <KEY=VALUE>...]`: Create a new agent, optionally setting its working directory, applying a template, and environment variables.
+- `clawmini agents update <id> [-d, --directory <dir>] [-e, --env <KEY=VALUE>...]`: Update an existing agent's configuration.
+- `clawmini agents delete <id>`: Remove an agent.
+
+### Cron Jobs
+
+- `clawmini cron list [--chat <id>]`: Display all cron jobs configured for a chat.
+- `clawmini cron add <name> [--cron <expr> | --every <duration> | --at <iso-time>] [-m, --message <text>]`: Create a new scheduled job. Supports standard cron expressions, recurring intervals (e.g., `10m`), or one-off executions at a specific time.
+- `clawmini cron delete <name> [--chat <id>]`: Remove an existing scheduled job.
+
+### Web Interface
+
+- `clawmini web [-p, --port <number>]`: Start the local web interface (default port: 8080).
+
+## Configuration
+
+## Global settings
+
+**TODO**
+
+## Routers
+
+Clawmini provides an extensible pipeline for processing user messages before they reach an agent using **Routers**. By defining a sequence of routers in your `.clawmini/settings.json` (global) or per-chat settings, you can dynamically alter message content, target specific agents or sessions, inject environment variables, and add automated replies.
+
+Built-in routers include:
+
+- `@clawmini/slash-new`: Creates a new session ID when a message starts with `/new`, effectively clearing the context window for the agent.
+- `@clawmini/slash-command`: Expands slash commands (e.g., `/foo`) with the contents of matching files in your `.clawmini/commands/` directory.
+
+You can also write custom shell script routers that accept the current state via `stdin` and output JSON to dynamically control the routing logic. See the [`RouterState` interface](src/daemon/routers/types.ts) for the exact input and output schema.
+
+## Agent Templates
+
+Clawmini provides built-in templates to help you quickly scaffold new agents with pre-configured settings and files. When you run `clawmini agents add <id> --template <name>`, it copies the template's files into the agent's working directory and merges any provided environment variables or directory options with the template's `settings.json`.
+
+The currently available built-in templates are:
+
+- `gemini`: A basic template configured to use the `gemini` CLI as the agent's backend.
+- `gemini-cladding`: A template configured to run the `gemini` CLI wrapped inside `cladding` for enhanced security.
+- `gemini-claw-cladding`: A comprehensive template that sets up an autonomous personal assistant workspace (OpenClaw). It includes the `gemini-cladding` setup plus a full suite of scaffolding files like `GEMINI.md`, `SOUL.md`, `MEMORY.md`, and `HEARTBEAT.md` to establish the agent's identity, memory, and proactive capabilities.
+
+## Development Setup
+
+Clawmini is a monorepo consisting of a Node.js TypeScript CLI/Daemon and an embedded SvelteKit frontend (in the `web/` workspace).
+
+### Prerequisites
+
+- Node.js (v18+)
+- npm
+
+### Setup
+
+```bash
+# Install dependencies for both the root CLI and the web workspace
+npm install
+
+# Build the CLI, Daemon, and statically compile the Web UI
+npm run build
+```
+
+### Development Scripts
+
+During development, you can run the following commands from the root:
+
+```bash
+# Watch mode for the CLI
+npm run dev:cli
+
+# Watch mode for the Daemon
+npm run dev:daemon
+
+# Run formatting, linting, type-checking, and tests
+npm run format
+npm run lint
+npm run check
+npm run test
+```
+
+## Architecture Notes
+
+- **Separation of Concerns:** The daemon (`src/daemon`) acts as the stateful orchestrator and queue manager, while the CLI (`src/cli`) is simply a thin TRPC client connecting via a UNIX socket.
+- **Web UI:** The `web/` directory is a SvelteKit application built with `@sveltejs/adapter-static`. Running `npm run build` bundles the web UI into `dist/web`, which is then served statically by the `clawmini web` Node.js server. Real-time updates to the web UI are powered by Server-Sent Events (SSE) tailing the local `.clawmini/chats/:id/chat.jsonl` files.

package/dist/adapter-discord/index.d.mts

@@ -0,0 +1,5 @@
+//#region src/adapter-discord/index.d.ts
+declare function main(): Promise<void>;
+//#endregion
+export { main };
+//# sourceMappingURL=index.d.mts.map

package/dist/adapter-discord/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/adapter-discord/index.ts"],"mappings":";iBASsB,IAAA,CAAA,GAAI,OAAA"}

package/dist/adapter-discord/index.mjs

@@ -0,0 +1,456 @@
+#!/usr/bin/env node
+import { l as getSocketPath, o as getClawminiDir, u as getWorkspaceRoot } from "../workspace-CSgfo_2J.mjs";
+import { t as createUnixSocketFetch } from "../fetch-BjZVyU3Z.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+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";
+
+//#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()
+});
+function getDiscordConfigPath(startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "adapters", "discord", "config.json");
+}
+async function readDiscordConfig(startDir = process.cwd()) {
+	const configPath = getDiscordConfigPath(startDir);
+	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;
+	}
+}
+async function initDiscordConfig(startDir = process.cwd()) {
+	const configPath = getDiscordConfigPath(startDir);
+	const configDir = path.dirname(configPath);
+	await fs$1.mkdir(configDir, { recursive: true });
+	if (fs.existsSync(configPath)) {
+		console.log(`Config file already exists at ${configPath}`);
+		return;
+	}
+	await fs$1.writeFile(configPath, JSON.stringify({
+		botToken: "YOUR_DISCORD_BOT_TOKEN",
+		authorizedUserId: "YOUR_DISCORD_USER_ID",
+		chatId: "default"
+	}, null, 2), "utf-8");
+	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) {
+	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" });
+				});
+			});
+			this.req.on("error", (err) => {
+				this.readyState = this.CLOSED;
+				this.dispatchEvent({
+					type: "error",
+					error: err
+				});
+			});
+			this.req.end();
+		}
+		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
+			});
+		}
+		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
+//#region src/adapter-discord/client.ts
+/**
+* Creates a TRPC client that connects to the Clawmini daemon via a Unix socket.
+*
+* @param options - Configuration options for the client.
+* @returns A TRPC client instance for the AppRouter.
+*/
+function getTRPCClient(options = {}) {
+	const socketPath = options.socketPath ?? getSocketPath();
+	if (!fs.existsSync(socketPath)) throw new Error(`Daemon not running. Socket not found at ${socketPath}`);
+	const customFetch = createUnixSocketFetch(socketPath);
+	return createTRPCClient({ links: [splitLink({
+		condition(op) {
+			return op.type === "subscription";
+		},
+		true: httpSubscriptionLink({
+			url: "http://localhost",
+			EventSource: createUnixSocketEventSource(socketPath)
+		}),
+		false: httpLink({
+			url: "http://localhost",
+			fetch: customFetch
+		})
+	})] });
+}
+
+//#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 };
+	}
+}
+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);
+	}
+}
+
+//#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 });
+			}
+		}
+	} 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) => {
+		let subscription = null;
+		let messageQueue = Promise.resolve();
+		const connect = () => {
+			if (signal?.aborted) {
+				resolve();
+				return;
+			}
+			subscription = trpc.waitForMessages.subscribe({
+				chatId,
+				lastMessageId
+			}, {
+				onData: (messages) => {
+					retryDelay = 1e3;
+					if (!Array.isArray(messages) || messages.length === 0) return;
+					messageQueue = messageQueue.then(async () => {
+						for (const rawMessage of messages) {
+							if (signal?.aborted) break;
+							const message = rawMessage;
+							if (message.role === "log") {
+								const logMessage = message;
+								if (logMessage.level === "verbose") {
+									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;
+								let absoluteFiles = [];
+								if (hasFiles) {
+									const workspaceRoot = getWorkspaceRoot(process.cwd());
+									absoluteFiles = logMessage.files.map((f) => path.resolve(workspaceRoot, f));
+								}
+								if (!hasContent && !hasFiles) {
+									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);
+										for (let i = 0; i < chunks.length; i++) {
+											if (signal?.aborted) 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);
+									}
+								} catch (error) {
+									console.error(`Failed to send message to Discord user ${discordUserId}:`, error);
+									break;
+								}
+							}
+							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);
+					subscription?.unsubscribe();
+					subscription = null;
+					if (signal?.aborted) {
+						resolve();
+						return;
+					}
+					setTimeout(() => {
+						retryDelay = Math.min(retryDelay * 2, maxRetryDelay);
+						connect();
+					}, retryDelay);
+				},
+				onComplete: () => {
+					subscription = null;
+					if (!signal?.aborted) setTimeout(() => connect(), retryDelay);
+					else resolve();
+				}
+			});
+		};
+		let typingSubscription = null;
+		let typingRetryDelay = 1e3;
+		const connectTyping = () => {
+			if (signal?.aborted) return;
+			typingSubscription = trpc.waitForTyping.subscribe({ chatId }, {
+				onData: async (event) => {
+					typingRetryDelay = 1e3;
+					if (!event) return;
+					try {
+						await (await (await client.users.fetch(discordUserId)).createDM()).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);
+					typingSubscription?.unsubscribe();
+					typingSubscription = null;
+					if (signal?.aborted) return;
+					setTimeout(() => {
+						typingRetryDelay = Math.min(typingRetryDelay * 2, maxRetryDelay);
+						connectTyping();
+					}, typingRetryDelay);
+				},
+				onComplete: () => {
+					typingSubscription = null;
+					if (!signal?.aborted) setTimeout(() => connectTyping(), typingRetryDelay);
+				}
+			});
+		};
+		connect();
+		connectTyping();
+		signal?.addEventListener("abort", () => {
+			subscription?.unsubscribe();
+			typingSubscription?.unsubscribe();
+			resolve();
+		});
+	});
+}
+function chunkString(str, size) {
+	const chunks = [];
+	const chars = Array.from(str);
+	for (let i = 0; i < chars.length; i += size) chunks.push(chars.slice(i, i + size).join(""));
+	return chunks;
+}
+
+//#endregion
+//#region src/adapter-discord/index.ts
+async function main() {
+	if (process.argv.slice(2)[0] === "init") {
+		await initDiscordConfig();
+		return;
+	}
+	console.log("Discord Adapter starting...");
+	const config = await readDiscordConfig();
+	if (!config) {
+		console.error("Failed to load Discord configuration. Please ensure .clawmini/adapters/discord/config.json exists and is valid.");
+		process.exit(1);
+	}
+	const trpc = getTRPCClient();
+	const client = new Client({
+		intents: [GatewayIntentBits.DirectMessages, GatewayIntentBits.MessageContent],
+		partials: [Partials.Channel]
+	});
+	client.once(Events.ClientReady, (readyClient) => {
+		console.log(`Ready! Logged in as ${readyClient.user.tag}`);
+		startDaemonToDiscordForwarder(readyClient, trpc, config.authorizedUserId, config.chatId).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)) {
+			console.log(`Unauthorized message from ${message.author.tag} (${message.author.id}) ignored.`);
+			return;
+		}
+		console.log(`Received message from ${message.author.tag}: ${message.content}`);
+		const downloadedFiles = [];
+		if (message.attachments.size > 0) {
+			const { getClawminiDir } = await import("../workspace-CSgfo_2J.mjs").then((n) => n._);
+			const tmpDir = path.join(getClawminiDir(process.cwd()), "tmp", "discord");
+			await fs$1.mkdir(tmpDir, { recursive: true });
+			const maxSizeMB = config.maxAttachmentSizeMB ?? 25;
+			const maxSizeBytes = maxSizeMB * 1024 * 1024;
+			for (const attachment of message.attachments.values()) {
+				if (attachment.size > maxSizeBytes) {
+					console.warn(`Attachment ${attachment.name} exceeds size limit (${maxSizeMB}MB). Ignoring.`);
+					await message.reply(`Warning: Attachment ${attachment.name} exceeds the size limit of ${maxSizeMB}MB and was ignored.`);
+					continue;
+				}
+				try {
+					const res = await fetch(attachment.url);
+					if (!res.ok) {
+						console.error(`Failed to download attachment ${attachment.name}`);
+						continue;
+					}
+					const uniqueName = `${Date.now()}-${attachment.name}`;
+					const filePath = path.join(tmpDir, uniqueName);
+					const arrayBuffer = await res.arrayBuffer();
+					await fs$1.writeFile(filePath, Buffer.from(arrayBuffer));
+					downloadedFiles.push(filePath);
+				} catch (err) {
+					console.error(`Error downloading attachment ${attachment.name}:`, err);
+				}
+			}
+		}
+		let finalContent = message.content;
+		if (message.reference && message.reference.messageId) try {
+			const referencedMessage = await message.fetchReference();
+			if (referencedMessage && referencedMessage.content) finalContent = `${referencedMessage.content.split("\n").map((line) => `> ${line}`).join("\n")}\n${finalContent}`;
+		} catch (err) {
+			console.error("Failed to fetch referenced message:", err);
+		}
+		console.log(`Forwarding message to daemon: ${finalContent}`);
+		try {
+			await trpc.sendMessage.mutate({
+				type: "send-message",
+				client: "cli",
+				data: {
+					message: finalContent,
+					chatId: config.chatId,
+					files: downloadedFiles.length > 0 ? downloadedFiles : void 0,
+					adapter: "discord",
+					noWait: true
+				}
+			});
+			console.log("Message forwarded to daemon successfully.");
+		} catch (error) {
+			console.error("Failed to forward message to daemon:", error);
+		}
+	});
+	try {
+		await client.login(config.botToken);
+	} catch (error) {
+		console.error("Failed to login to Discord:", error);
+		process.exit(1);
+	}
+}
+main().catch((error) => {
+	console.error("Unhandled error in Discord Adapter:", error);
+	process.exit(1);
+});
+
+//#endregion
+export { main };
+//# sourceMappingURL=index.mjs.map