clawmini 0.0.1

package/dist/daemon/index.mjs

@@ -0,0 +1,1222 @@
+import { C as SettingsSchema, S as CronJobSchema, a as getAgent, b as writeChatSettings, c as getSettingsPath, g as readSettings, h as readEnvironment, i as getActiveEnvironmentInfo, l as getSocketPath, m as readChatSettings, o as getClawminiDir, p as readAgentSessionSettings, s as getEnvironmentPath, u as getWorkspaceRoot, v as writeAgentSessionSettings } from "../workspace-CSgfo_2J.mjs";
+import { n as pathIsInsideDir } from "../fs-B5wW0oaH.mjs";
+import { l as listChats, o as getDefaultChatId, s as getMessages } from "../chats-DKgTeU7i.mjs";
+import { n as exportLiteToEnvironment } from "../lite-Dl7WXyaH.mjs";
+import { a as daemonEvents, i as DAEMON_EVENT_TYPING, o as emitTyping, r as DAEMON_EVENT_MESSAGE_APPENDED, t as appendMessage } from "../chats-Zd_HXDHx.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { execSync, spawn } from "node:child_process";
+import fs$1 from "node:fs/promises";
+import { z } from "zod";
+import http from "node:http";
+import net from "node:net";
+import { createHTTPHandler } from "@trpc/server/adapters/standalone";
+import { TRPCError, initTRPC } from "@trpc/server";
+import crypto$1 from "node:crypto";
+import schedule from "node-schedule";
+
+//#region src/daemon/queue.ts
+var Queue = class {
+	pending = [];
+	isRunning = false;
+	currentController = null;
+	currentPayload;
+	enqueue(task, payload) {
+		return new Promise((resolve, reject) => {
+			this.pending.push({
+				task,
+				payload,
+				resolve,
+				reject
+			});
+			this.processNext().catch(() => {});
+		});
+	}
+	async processNext() {
+		if (this.isRunning || this.pending.length === 0) return;
+		this.isRunning = true;
+		const entry = this.pending.shift();
+		this.currentController = new AbortController();
+		this.currentPayload = entry.payload;
+		try {
+			await entry.task(this.currentController.signal);
+			entry.resolve();
+		} catch (error) {
+			entry.reject(error);
+		} finally {
+			this.isRunning = false;
+			this.currentController = null;
+			this.currentPayload = void 0;
+			this.processNext().catch(() => {});
+		}
+	}
+	abortCurrent() {
+		if (this.currentController) {
+			const error = /* @__PURE__ */ new Error("Task aborted");
+			error.name = "AbortError";
+			this.currentController.abort(error);
+		}
+	}
+	getCurrentPayload() {
+		return this.currentPayload;
+	}
+	clear(reason = "Task cleared") {
+		const tasksToClear = [...this.pending];
+		this.pending = [];
+		for (const { reject } of tasksToClear) {
+			const error = new Error(reason);
+			error.name = "AbortError";
+			reject(error);
+		}
+	}
+	extractPending() {
+		const extracted = this.pending.map((p) => p.payload).filter((p) => p !== void 0);
+		this.clear("Task extracted for batching");
+		return extracted;
+	}
+};
+const directoryQueues = /* @__PURE__ */ new Map();
+function getQueue(dir) {
+	if (!directoryQueues.has(dir)) directoryQueues.set(dir, new Queue());
+	return directoryQueues.get(dir);
+}
+
+//#endregion
+//#region src/daemon/routers/slash-new.ts
+function slashNew(state) {
+	if (/^\/new(\s|$)/.test(state.message)) {
+		const newMessage = state.message.replace(/^\/new(\s+|$)/, "").trim();
+		return {
+			...state,
+			message: newMessage,
+			sessionId: crypto.randomUUID(),
+			reply: "[@clawmini/slash-new] Starting a new session..."
+		};
+	}
+	return state;
+}
+
+//#endregion
+//#region src/daemon/routers/slash-command.ts
+async function slashCommand(state) {
+	const commandsDir = path.resolve(getClawminiDir(), "commands");
+	let currentMessage = state.message;
+	const matches = [...currentMessage.matchAll(/(?<=^|\s)\/([a-zA-Z0-9_\-:.]+)(?=\s|$)/g)];
+	if (matches.length === 0) return state;
+	for (const match of matches) {
+		const fullMatch = match[0];
+		const commandName = match[1];
+		if (!commandName) continue;
+		const targetPathMd = path.resolve(commandsDir, `${commandName}.md`);
+		const targetPathTxt = path.resolve(commandsDir, `${commandName}.txt`);
+		if (!pathIsInsideDir(path.resolve(commandsDir, commandName), commandsDir)) continue;
+		let content;
+		try {
+			content = await fs$1.readFile(targetPathMd, "utf8");
+		} catch {
+			try {
+				content = await fs$1.readFile(targetPathTxt, "utf8");
+			} catch {
+				continue;
+			}
+		}
+		currentMessage = currentMessage.replace(fullMatch, content.trim());
+	}
+	return {
+		...state,
+		message: currentMessage
+	};
+}
+
+//#endregion
+//#region src/daemon/routers/utils.ts
+function createSlashActionRouter(command, action, replyMessage) {
+	return function(state) {
+		if (new RegExp(`^\\/${command}(\\s|$)`).test(state.message)) {
+			const replaceRegex = new RegExp(`^\\/${command}(\\s+|$)`);
+			const newMessage = state.message.replace(replaceRegex, "").trim();
+			return {
+				...state,
+				message: newMessage,
+				action,
+				reply: replyMessage
+			};
+		}
+		return state;
+	};
+}
+
+//#endregion
+//#region src/daemon/routers/slash-stop.ts
+const slashStop = createSlashActionRouter("stop", "stop", "Stopping current task...");
+
+//#endregion
+//#region src/daemon/routers/slash-interrupt.ts
+const slashInterrupt = createSlashActionRouter("interrupt", "interrupt", "Interrupting current task...");
+
+//#endregion
+//#region src/daemon/routers.ts
+async function executeRouterPipeline(initialState, routers) {
+	let state = { ...initialState };
+	for (const router of routers) if (router === "@clawmini/slash-new") state = slashNew(state);
+	else if (router === "@clawmini/slash-command") state = await slashCommand(state);
+	else if (router === "@clawmini/slash-stop") state = slashStop(state);
+	else if (router === "@clawmini/slash-interrupt") state = slashInterrupt(state);
+	else try {
+		state = await executeCustomRouter(router, state);
+	} catch (err) {
+		console.error(`Router error [${router}]:`, err);
+	}
+	return state;
+}
+async function executeCustomRouter(command, state) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, { shell: true });
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		const timer = setTimeout(() => {
+			child.kill();
+			reject(/* @__PURE__ */ new Error("Router execution timed out"));
+		}, 1e4);
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			if (code !== 0) return reject(/* @__PURE__ */ new Error(`Process exited with code ${code}. Stderr: ${stderr}`));
+			try {
+				const result = JSON.parse(stdout);
+				const newState = { ...state };
+				if (typeof result.message === "string") newState.message = result.message;
+				if (typeof result.agent === "string") newState.agentId = result.agent;
+				if (typeof result.session === "string") newState.sessionId = result.session;
+				if (typeof result.env === "object" && result.env !== null) newState.env = {
+					...newState.env,
+					...result.env
+				};
+				if (typeof result.reply === "string") newState.reply = result.reply;
+				if (typeof result.action === "string") newState.action = result.action;
+				resolve(newState);
+			} catch (err) {
+				reject(/* @__PURE__ */ new Error(`Failed to parse router output: ${err}. Stdout: ${stdout}`));
+			}
+		});
+		child.on("error", (err) => {
+			clearTimeout(timer);
+			reject(err);
+		});
+		const inputState = {
+			message: state.message,
+			chatId: state.chatId,
+			agentId: state.agentId,
+			sessionId: state.sessionId,
+			env: state.env,
+			action: state.action
+		};
+		if (child.stdin) {
+			child.stdin.on("error", (err) => {
+				if (err.code !== "EPIPE") console.error("stdin error:", err);
+			});
+			child.stdin.write(JSON.stringify(inputState));
+			child.stdin.end();
+		}
+	});
+}
+
+//#endregion
+//#region src/daemon/auth.ts
+const DAEMON_SECRET = crypto$1.randomBytes(32);
+function generateToken(payload) {
+	const payloadStr = Buffer.from(JSON.stringify(payload)).toString("base64");
+	return `${payloadStr}.${crypto$1.createHmac("sha256", DAEMON_SECRET).update(payloadStr).digest("hex")}`;
+}
+function validateToken(token) {
+	try {
+		const parts = token.split(".");
+		if (parts.length !== 2) return null;
+		const [payloadStr, signature] = parts;
+		if (!payloadStr || !signature) return null;
+		const expectedHmac = crypto$1.createHmac("sha256", DAEMON_SECRET).update(payloadStr).digest("hex");
+		const signatureBuffer = Buffer.from(signature, "hex");
+		const expectedHmacBuffer = Buffer.from(expectedHmac, "hex");
+		if (signatureBuffer.length !== expectedHmacBuffer.length || !crypto$1.timingSafeEqual(signatureBuffer, expectedHmacBuffer)) return null;
+		const payloadJson = Buffer.from(payloadStr, "base64").toString("utf8");
+		return JSON.parse(payloadJson);
+	} catch {
+		return null;
+	}
+}
+function getApiContext(settings) {
+	if (settings?.api === void 0) return null;
+	let isApiEnabled = false;
+	let apiHost = "127.0.0.1";
+	let apiPort = 3e3;
+	let proxyHost = void 0;
+	if (typeof settings.api === "boolean") isApiEnabled = settings.api;
+	else if (typeof settings.api === "object") {
+		isApiEnabled = true;
+		apiHost = settings.api.host ?? "127.0.0.1";
+		apiPort = settings.api.port ?? 3e3;
+		proxyHost = settings.api.proxy_host;
+	}
+	if (!isApiEnabled) return null;
+	return {
+		host: apiHost,
+		port: apiPort,
+		proxy_host: proxyHost
+	};
+}
+
+//#endregion
+//#region src/shared/utils/env.ts
+function applyEnvOverrides(targetEnv, overrides) {
+	if (!overrides) return;
+	for (const [key, val] of Object.entries(overrides)) if (val === true && process.env[key] !== void 0) targetEnv[key] = process.env[key];
+	else if (typeof val === "string") targetEnv[key] = val;
+}
+function getActiveEnvKeys(...envs) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const env of envs) {
+		if (!env) continue;
+		Object.entries(env).forEach(([key, val]) => {
+			if (val === true || typeof val === "string") keys.add(key);
+		});
+	}
+	return keys;
+}
+
+//#endregion
+//#region src/daemon/message.ts
+function calculateDelay(attempt, baseDelayMs, isFallback = false) {
+	const effectiveAttempt = isFallback ? attempt + 1 : attempt;
+	if (effectiveAttempt <= 0) return 0;
+	const delay = baseDelayMs * Math.pow(2, effectiveAttempt - 1);
+	return Math.min(delay, 15e3);
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function resolveSessionState(chatId, cwd, sessionId, overrideAgentId) {
+	const chatSettings = await readChatSettings(chatId, cwd);
+	const agentId = overrideAgentId ?? (typeof chatSettings?.defaultAgent === "string" ? chatSettings.defaultAgent : "default");
+	let targetSessionId = sessionId;
+	if (!targetSessionId) targetSessionId = (chatSettings?.sessions || {})[agentId] || "default";
+	const agentSessionSettings = await readAgentSessionSettings(agentId, targetSessionId, cwd);
+	return {
+		chatSettings,
+		agentId,
+		targetSessionId,
+		agentSessionSettings,
+		isNewSession: !agentSessionSettings
+	};
+}
+function prepareCommandAndEnv(agent, message, isNewSession, agentSessionSettings, fallback) {
+	const currentAgent = {
+		...agent,
+		commands: {
+			...agent.commands,
+			...fallback?.commands || {}
+		},
+		env: {
+			...agent.env,
+			...fallback?.env || {}
+		}
+	};
+	let command = currentAgent.commands?.new ?? "";
+	const env = {
+		...process.env,
+		CLAW_CLI_MESSAGE: message
+	};
+	applyEnvOverrides(env, currentAgent.env);
+	if (!isNewSession && currentAgent.commands?.append) {
+		command = currentAgent.commands.append;
+		applyEnvOverrides(env, agentSessionSettings?.env);
+	}
+	return {
+		command,
+		env,
+		currentAgent
+	};
+}
+async function runExtractionCommand(name, command, runCommand, cwd, env, mainResult, signal) {
+	try {
+		console.log(`Executing extraction command (${name}): ${command}`);
+		const res = await runCommand({
+			command,
+			cwd,
+			env,
+			stdin: mainResult.stdout,
+			signal
+		});
+		if (res.exitCode === 0) return { result: res.stdout.trim() };
+		else return { error: `${name} failed: ${res.stderr}` };
+	} catch (e) {
+		return { error: `${name} error: ${e.message}` };
+	}
+}
+/**
+* Formats the environment prefix string by replacing placeholders with actual values.
+* Available placeholders:
+* - {WORKSPACE_DIR}: The root directory of the workspace.
+* - {AGENT_DIR}: The directory where the agent is executing.
+* - {ENV_DIR}: The directory of the active environment.
+* - {HOME_DIR}: The home directory of the current user.
+* - {ENV_ARGS}: The formatted environment arguments based on envFormat.
+*/
+function formatEnvironmentPrefix(prefix, replacements) {
+	const map = {
+		"{WORKSPACE_DIR}": replacements.targetPath,
+		"{AGENT_DIR}": replacements.executionCwd,
+		"{ENV_DIR}": replacements.envDir,
+		"{HOME_DIR}": process.env.HOME || "",
+		"{ENV_ARGS}": replacements.envArgs
+	};
+	return prefix.replace(/{(WORKSPACE_DIR|AGENT_DIR|ENV_DIR|HOME_DIR|ENV_ARGS)}/g, (match) => map[match] || match);
+}
+async function executeDirectMessage(chatId, state, settings, cwd, runCommand, noWait = true, userMessageContent) {
+	const userMsg = {
+		id: crypto.randomUUID(),
+		role: "user",
+		content: userMessageContent ?? state.message,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await appendMessage(chatId, userMsg);
+	if (state.reply) await appendMessage(chatId, {
+		id: crypto.randomUUID(),
+		messageId: userMsg.id,
+		role: "log",
+		source: "router",
+		content: state.reply,
+		stderr: "",
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		command: "router",
+		cwd,
+		exitCode: 0,
+		...state.reply.includes("NO_REPLY_NECESSARY") ? { level: "verbose" } : {}
+	});
+	if (!state.message.trim() && state.action !== "stop" && state.action !== "interrupt") return;
+	const queue = getQueue(cwd);
+	if (state.action === "stop") {
+		queue.abortCurrent();
+		queue.clear();
+		return;
+	}
+	if (state.action === "interrupt") {
+		const currentPayload = queue.getCurrentPayload();
+		queue.abortCurrent();
+		const extracted = queue.extractPending();
+		const payloads = currentPayload ? [currentPayload, ...extracted] : extracted;
+		if (payloads.length > 0) state.message = `${payloads.map((text) => `<message>\n${text}\n</message>`).join("\n\n")}\n\n<message>\n${state.message}\n</message>`.trim();
+	}
+	if (!state.message.trim()) return;
+	const routerEnv = state.env ?? {};
+	const taskPromise = queue.enqueue(async (signal) => {
+		const { agentId, agentSessionSettings, isNewSession, targetSessionId: finalSessionId } = await resolveSessionState(chatId, cwd, state.sessionId, state.agentId);
+		let mergedAgent = settings?.defaultAgent || {};
+		if (agentId !== "default") try {
+			const customAgent = await getAgent(agentId, cwd);
+			if (customAgent) mergedAgent = {
+				...mergedAgent,
+				...customAgent,
+				commands: {
+					...mergedAgent.commands,
+					...customAgent.commands
+				},
+				env: {
+					...mergedAgent.env,
+					...customAgent.env
+				}
+			};
+		} catch {}
+		const executionConfigs = [{
+			retries: 0,
+			delayMs: 1e3
+		}, ...(mergedAgent.fallbacks || []).map((f) => ({
+			fallback: f,
+			retries: f.retries,
+			delayMs: f.delayMs
+		}))];
+		const workspaceRoot = getWorkspaceRoot(cwd);
+		let executionCwd = cwd;
+		if (mergedAgent.directory) executionCwd = path.resolve(workspaceRoot, mergedAgent.directory);
+		else if (agentId !== "default") executionCwd = path.resolve(workspaceRoot, agentId);
+		let lastLogMsg;
+		let success = false;
+		for (let configIdx = 0; configIdx < executionConfigs.length; configIdx++) {
+			const config = executionConfigs[configIdx];
+			const isFallbackConfig = configIdx > 0;
+			for (let attempt = 0; attempt <= config.retries; attempt++) {
+				const delay = calculateDelay(attempt, config.delayMs, isFallbackConfig);
+				if (delay > 0) {
+					await appendMessage(chatId, {
+						id: crypto.randomUUID(),
+						messageId: userMsg.id,
+						role: "log",
+						content: `Error running agent, retrying in ${Math.round(delay / 1e3)} seconds...`,
+						stderr: "",
+						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+						command: "retry-delay",
+						cwd: executionCwd,
+						exitCode: 0
+					});
+					await sleep(delay);
+				}
+				const { env, currentAgent, command: initialCommand } = prepareCommandAndEnv(mergedAgent, state.message, isNewSession, agentSessionSettings, config.fallback);
+				let command = initialCommand;
+				if (!command) continue;
+				const agentSpecificEnv = getActiveEnvKeys(currentAgent.env, !isNewSession ? agentSessionSettings?.env : void 0);
+				agentSpecificEnv.add("CLAW_CLI_MESSAGE");
+				Object.assign(env, routerEnv);
+				Object.keys(routerEnv).forEach((k) => agentSpecificEnv.add(k));
+				const apiCtx = getApiContext(settings);
+				if (apiCtx) {
+					env["CLAW_API_URL"] = apiCtx.proxy_host ? `${apiCtx.proxy_host}:${apiCtx.port}` : `http://${apiCtx.host}:${apiCtx.port}`;
+					agentSpecificEnv.add("CLAW_API_URL");
+					env["CLAW_API_TOKEN"] = generateToken({
+						chatId,
+						agentId,
+						sessionId: finalSessionId,
+						timestamp: Date.now()
+					});
+					agentSpecificEnv.add("CLAW_API_TOKEN");
+				}
+				const activeEnvInfo = await getActiveEnvironmentInfo(executionCwd, cwd);
+				if (activeEnvInfo) {
+					const activeEnvName = activeEnvInfo.name;
+					const activeEnv = await readEnvironment(activeEnvName, cwd);
+					if (activeEnv?.env) for (const [key, value] of Object.entries(activeEnv.env)) if (value === false) {
+						delete env[key];
+						agentSpecificEnv.delete(key);
+					} else {
+						let interpolatedValue = String(value);
+						interpolatedValue = interpolatedValue.replace(/\{PATH\}/g, process.env.PATH || "");
+						interpolatedValue = interpolatedValue.replace(/\{ENV_DIR\}/g, getEnvironmentPath(activeEnvName, cwd));
+						interpolatedValue = interpolatedValue.replace(/\{WORKSPACE_DIR\}/g, activeEnvInfo.targetPath);
+						env[key] = interpolatedValue;
+						agentSpecificEnv.add(key);
+					}
+					if (activeEnv?.prefix) {
+						const envArgs = Array.from(agentSpecificEnv).map((key) => {
+							if (activeEnv.envFormat) return activeEnv.envFormat.replace("{key}", key);
+							return key;
+						}).join(" ");
+						const prefixReplaced = formatEnvironmentPrefix(activeEnv.prefix, {
+							targetPath: activeEnvInfo.targetPath,
+							executionCwd,
+							envDir: getEnvironmentPath(activeEnvName, cwd),
+							envArgs
+						});
+						if (prefixReplaced.includes("{COMMAND}")) command = prefixReplaced.replace("{COMMAND}", command);
+						else command = `${prefixReplaced} ${command}`;
+					}
+				}
+				console.log(`Executing command: ${command}`);
+				let mainResult;
+				const typingInterval = setInterval(() => {
+					emitTyping(chatId);
+				}, 5e3);
+				try {
+					mainResult = await runCommand({
+						command,
+						cwd: executionCwd,
+						env,
+						signal
+					});
+				} finally {
+					clearInterval(typingInterval);
+				}
+				const logMsg = {
+					id: crypto.randomUUID(),
+					messageId: userMsg.id,
+					role: "log",
+					content: mainResult.stdout,
+					stdout: mainResult.stdout,
+					stderr: "",
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					command,
+					cwd: executionCwd,
+					exitCode: mainResult.exitCode,
+					...mainResult.stdout.includes("NO_REPLY_NECESSARY") ? { level: "verbose" } : {}
+				};
+				const errors = [];
+				if (mainResult.stderr) errors.push(mainResult.stderr);
+				let currentSuccess = mainResult.exitCode === 0;
+				if (currentSuccess) {
+					if (currentAgent.commands?.getMessageContent) {
+						const { result, error } = await runExtractionCommand("getMessageContent", currentAgent.commands.getMessageContent, runCommand, executionCwd, env, mainResult, signal);
+						if (result !== void 0) {
+							logMsg.content = result;
+							logMsg.stdout = mainResult.stdout;
+							if (result.includes("NO_REPLY_NECESSARY")) logMsg.level = "verbose";
+							else delete logMsg.level;
+							if (result.trim() === "") currentSuccess = false;
+						}
+						if (error) errors.push(error);
+					}
+				}
+				logMsg.stderr = errors.join("\n\n");
+				lastLogMsg = logMsg;
+				if (currentSuccess) {
+					success = true;
+					if (isNewSession && currentAgent.commands?.getSessionId) {
+						const { result, error } = await runExtractionCommand("getSessionId", currentAgent.commands.getSessionId, runCommand, executionCwd, env, mainResult, signal);
+						if (result) await writeAgentSessionSettings(agentId, finalSessionId, { env: { SESSION_ID: result } }, cwd);
+						if (error) logMsg.stderr = [logMsg.stderr, error].filter(Boolean).join("\n\n");
+					}
+					break;
+				}
+			}
+			if (success) break;
+		}
+		if (lastLogMsg) await appendMessage(chatId, lastLogMsg);
+	}, state.message);
+	if (!noWait) await taskPromise;
+	else taskPromise.catch((err) => {
+		if (err.name !== "AbortError") console.error("Task execution error:", err);
+	});
+}
+async function getInitialRouterState(chatId, message, cwd = process.cwd(), overrideAgentId, overrideSessionId) {
+	const chatSettings = await readChatSettings(chatId, cwd) ?? {};
+	const agentId = overrideAgentId ?? chatSettings.defaultAgent ?? "default";
+	return {
+		message,
+		chatId,
+		agentId,
+		sessionId: overrideSessionId ?? chatSettings.sessions?.[agentId] ?? "default",
+		env: {}
+	};
+}
+async function handleUserMessage(chatId, message, settings, cwd = process.cwd(), noWait = false, runCommand, sessionId, overrideAgentId) {
+	const chatSettings = await readChatSettings(chatId, cwd) ?? {};
+	if (overrideAgentId && chatSettings.defaultAgent !== overrideAgentId) {
+		chatSettings.defaultAgent = overrideAgentId;
+		await writeChatSettings(chatId, chatSettings, cwd);
+	}
+	const initialState = await getInitialRouterState(chatId, message, cwd, overrideAgentId, sessionId);
+	const initialAgent = initialState.agentId;
+	const finalState = await executeRouterPipeline(initialState, chatSettings.routers ?? settings?.routers ?? []);
+	const finalMessage = finalState.message;
+	const finalAgentId = finalState.agentId;
+	const finalSessionId = finalState.sessionId ?? crypto.randomUUID();
+	const routerEnv = finalState.env ?? {};
+	const currentAgentId = finalAgentId ?? chatSettings.defaultAgent ?? "default";
+	let settingsChanged = false;
+	if (finalAgentId && finalAgentId !== initialAgent) {
+		chatSettings.defaultAgent = finalAgentId;
+		settingsChanged = true;
+	}
+	if (finalSessionId && chatSettings.sessions?.[currentAgentId] !== finalSessionId) {
+		chatSettings.sessions = chatSettings.sessions || {};
+		chatSettings.sessions[currentAgentId] = finalSessionId;
+		settingsChanged = true;
+	}
+	if (settingsChanged) await writeChatSettings(chatId, chatSettings, cwd);
+	const directState = {
+		message: finalMessage,
+		chatId,
+		env: routerEnv
+	};
+	if (finalAgentId !== void 0) directState.agentId = finalAgentId;
+	if (finalSessionId !== void 0) directState.sessionId = finalSessionId;
+	if (finalState.reply !== void 0) directState.reply = finalState.reply;
+	if (finalState.action !== void 0) directState.action = finalState.action;
+	await executeDirectMessage(chatId, directState, settings, cwd, runCommand, noWait, message);
+}
+
+//#endregion
+//#region src/daemon/utils/spawn.ts
+const runCommand = async ({ command, cwd, env, stdin, signal, logToTerminal }) => {
+	return new Promise((resolve, reject) => {
+		const p = spawn(command, {
+			shell: true,
+			cwd,
+			env,
+			signal
+		});
+		if (stdin && p.stdin) {
+			p.stdin.on("error", (err) => {
+				if (err.code !== "EPIPE") console.error("stdin error:", err);
+			});
+			p.stdin.write(stdin);
+			p.stdin.end();
+		}
+		let stdout = "";
+		let stderr = "";
+		if (p.stdout) p.stdout.on("data", (data) => {
+			stdout += data.toString();
+			if (logToTerminal && !stdin) process.stdout.write(data);
+		});
+		if (p.stderr) p.stderr.on("data", (data) => {
+			stderr += data.toString();
+			if (logToTerminal && !stdin) process.stderr.write(data);
+		});
+		p.on("close", (code) => {
+			resolve({
+				stdout,
+				stderr,
+				exitCode: code ?? 1
+			});
+		});
+		p.on("error", (err) => {
+			if (err.name === "AbortError") {
+				reject(err);
+				return;
+			}
+			resolve({
+				stdout: "",
+				stderr: err.toString(),
+				exitCode: 1
+			});
+		});
+	});
+};
+
+//#endregion
+//#region src/daemon/cron.ts
+var CronManager = class {
+	jobs = /* @__PURE__ */ new Map();
+	getJobKey(chatId, jobId) {
+		return `${chatId}::${jobId}`;
+	}
+	async init() {
+		const chats = await listChats();
+		for (const chatId of chats) {
+			const settings = await readChatSettings(chatId);
+			if (settings?.jobs) for (const job of settings.jobs) try {
+				this.scheduleJob(chatId, job);
+			} catch (err) {
+				console.error(`Failed to initialize job ${job.id} for chat ${chatId}:`, err instanceof Error ? err.message : err);
+			}
+		}
+	}
+	scheduleJob(chatId, job) {
+		this.unscheduleJob(chatId, job.id);
+		let rule;
+		let isOneOff = false;
+		if ("cron" in job.schedule) rule = job.schedule.cron;
+		else if ("every" in job.schedule) {
+			const everyStr = job.schedule.every;
+			const match = everyStr.match(/^(\d+)\s*(m|min|minutes?|h|hours?|d|days?)$/i);
+			if (match) {
+				const val = parseInt(match[1], 10);
+				const unit = match[2].toLowerCase();
+				if (unit.startsWith("m")) rule = `*/${val} * * * *`;
+				else if (unit.startsWith("h")) rule = `0 */${val} * * *`;
+				else if (unit.startsWith("d")) rule = `0 0 */${val} * *`;
+				else rule = everyStr;
+			} else rule = everyStr;
+		} else if ("at" in job.schedule) {
+			const atStr = job.schedule.at;
+			const match = atStr.match(/^(\d+)\s*(m|min|minutes?|h|hours?|d|days?|s|sec|seconds?)$/i);
+			if (match) {
+				const val = parseInt(match[1], 10);
+				const unit = match[2].toLowerCase();
+				let ms = 0;
+				if (unit.startsWith("s")) ms = val * 1e3;
+				else if (unit.startsWith("m")) ms = val * 60 * 1e3;
+				else if (unit.startsWith("h")) ms = val * 60 * 60 * 1e3;
+				else if (unit.startsWith("d")) ms = val * 24 * 60 * 60 * 1e3;
+				rule = new Date(Date.now() + ms);
+			} else {
+				rule = new Date(atStr);
+				if (isNaN(rule.getTime())) throw new Error(`Invalid date format for 'at' schedule: ${atStr}`);
+			}
+			isOneOff = true;
+		} else {
+			console.warn(`Unknown schedule format for job ${job.id}`);
+			return;
+		}
+		try {
+			const scheduledJob = schedule.scheduleJob(rule, async () => {
+				await this.executeJob(chatId, job, isOneOff);
+			});
+			if (scheduledJob) this.jobs.set(this.getJobKey(chatId, job.id), scheduledJob);
+		} catch (err) {
+			console.error(`Failed to schedule job ${job.id} for chat ${chatId}:`, err);
+		}
+	}
+	unscheduleJob(chatId, jobId) {
+		const key = this.getJobKey(chatId, jobId);
+		const job = this.jobs.get(key);
+		if (job) {
+			job.cancel();
+			this.jobs.delete(key);
+		}
+	}
+	async executeJob(chatId, job, isOneOff) {
+		try {
+			const settingsPath = getSettingsPath();
+			let globalSettings;
+			try {
+				const settingsStr = await fs$1.readFile(settingsPath, "utf8");
+				globalSettings = JSON.parse(settingsStr);
+			} catch {
+				globalSettings = void 0;
+			}
+			const overrideSessionId = job.session?.type === "new" ? crypto.randomUUID() : void 0;
+			const routerState = await getInitialRouterState(chatId, job.message, process.cwd(), job.agentId, overrideSessionId);
+			if (job.env !== void 0) {
+				routerState.env = routerState.env || {};
+				applyEnvOverrides(routerState.env, job.env);
+			}
+			if (job.reply !== void 0) routerState.reply = job.reply;
+			await executeDirectMessage(chatId, routerState, globalSettings, process.cwd(), runCommand, false, job.message);
+			if (isOneOff) {
+				const chatSettings = await readChatSettings(chatId);
+				if (chatSettings && chatSettings.jobs) {
+					chatSettings.jobs = chatSettings.jobs.filter((j) => j.id !== job.id);
+					await writeChatSettings(chatId, chatSettings);
+				}
+				this.unscheduleJob(chatId, job.id);
+			}
+		} catch (err) {
+			console.error(`Error executing cron job ${job.id} for chat ${chatId}:`, err);
+		}
+	}
+};
+const cronManager = new CronManager();
+
+//#endregion
+//#region src/daemon/router.ts
+const t = initTRPC.context().create();
+const router = t.router;
+const publicProcedure = t.procedure;
+const apiAuthMiddleware = t.middleware(({ ctx, next }) => {
+	if (ctx.isApiServer) {
+		if (!ctx.tokenPayload) throw new TRPCError({
+			code: "UNAUTHORIZED",
+			message: "Missing or invalid token"
+		});
+	}
+	return next({ ctx: {
+		...ctx,
+		tokenPayload: ctx.tokenPayload
+	} });
+});
+const apiProcedure = t.procedure.use(apiAuthMiddleware);
+async function getUniquePath(p) {
+	let currentPath = p;
+	let counter = 1;
+	while (true) try {
+		await fs$1.stat(currentPath);
+		const ext = path.extname(p);
+		const base = path.basename(p, ext);
+		currentPath = path.join(path.dirname(p), `${base}-${counter}${ext}`);
+		counter++;
+	} catch {
+		return currentPath;
+	}
+}
+async function resolveAgentDir(agentId, workspaceRoot) {
+	if (agentId && agentId !== "default") {
+		try {
+			const agent = await getAgent(agentId, workspaceRoot);
+			if (agent && agent.directory) return path.resolve(workspaceRoot, agent.directory);
+		} catch (err) {
+			console.warn(`Could not load custom agent '${agentId}' for resolving directory:`, err);
+		}
+		return path.resolve(workspaceRoot, agentId);
+	}
+	return workspaceRoot;
+}
+async function resolveAndCheckChatId(ctx, inputChatId) {
+	const chatId = inputChatId ?? (ctx.isApiServer && ctx.tokenPayload ? ctx.tokenPayload.chatId : await getDefaultChatId());
+	if (ctx.isApiServer && ctx.tokenPayload) {
+		if (ctx.tokenPayload.chatId !== chatId) throw new TRPCError({
+			code: "FORBIDDEN",
+			message: "Token not authorized for this chat"
+		});
+	}
+	return chatId;
+}
+async function getAgentFilesDir(agentId, chatId, settings, workspaceRoot) {
+	const chatSettings = await readChatSettings(chatId) ?? {};
+	const targetAgentId = agentId ?? chatSettings.defaultAgent ?? "default";
+	let agentFilesDir = settings?.defaultAgent?.files || "./attachments";
+	const agentDir = await resolveAgentDir(targetAgentId, workspaceRoot);
+	if (targetAgentId !== "default") try {
+		const customAgent = await getAgent(targetAgentId, workspaceRoot);
+		if (customAgent?.files) agentFilesDir = customAgent.files;
+	} catch (err) {
+		console.warn(`Could not load custom agent '${targetAgentId}' for resolving files directory:`, err);
+	}
+	return path.resolve(agentDir, agentFilesDir);
+}
+async function validateAttachments(files) {
+	const { pathIsInsideDir } = await import("../fs-B5wW0oaH.mjs").then((n) => n.t);
+	const { getClawminiDir } = await import("../workspace-CSgfo_2J.mjs").then((n) => n._);
+	const tmpDir = path.join(getClawminiDir(process.cwd()), "tmp");
+	for (const file of files) {
+		const absoluteFile = path.resolve(process.cwd(), file);
+		if (!pathIsInsideDir(absoluteFile, tmpDir)) throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "File must be inside the temporary directory."
+		});
+		try {
+			await fs$1.access(absoluteFile);
+		} catch {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: `File does not exist: ${file}`
+			});
+		}
+	}
+}
+async function validateLogFile(file, agentDir, workspaceRoot) {
+	const { pathIsInsideDir } = await import("../fs-B5wW0oaH.mjs").then((n) => n.t);
+	const resolvedPath = path.resolve(agentDir, file);
+	if (!pathIsInsideDir(resolvedPath, agentDir, { allowSameDir: true })) throw new TRPCError({
+		code: "BAD_REQUEST",
+		message: "File must be within the agent workspace."
+	});
+	try {
+		await fs$1.access(resolvedPath);
+	} catch {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: `File does not exist: ${file}`
+		});
+	}
+	return path.relative(workspaceRoot, resolvedPath);
+}
+const AppRouter = router({
+	sendMessage: apiProcedure.input(z.object({
+		type: z.literal("send-message"),
+		client: z.literal("cli"),
+		data: z.object({
+			message: z.string(),
+			chatId: z.string().optional(),
+			sessionId: z.string().optional(),
+			agentId: z.string().optional(),
+			noWait: z.boolean().optional(),
+			files: z.array(z.string()).optional(),
+			adapter: z.string().optional()
+		})
+	})).mutation(async ({ input, ctx }) => {
+		let message = input.data.message;
+		const chatId = await resolveAndCheckChatId(ctx, input.data.chatId);
+		const noWait = input.data.noWait ?? false;
+		const sessionId = input.data.sessionId;
+		const agentId = input.data.agentId;
+		const settingsPath = getSettingsPath();
+		let settings;
+		try {
+			const settingsStr = await fs$1.readFile(settingsPath, "utf8");
+			settings = JSON.parse(settingsStr);
+		} catch (err) {
+			throw new Error(`Failed to read settings from ${settingsPath}: ${err}`, { cause: err });
+		}
+		const files = input.data.files;
+		if (files && files.length > 0) {
+			const workspaceRoot = getWorkspaceRoot(process.cwd());
+			const chatSettings = await readChatSettings(chatId) ?? {};
+			const agentDir = await resolveAgentDir(agentId ?? chatSettings.defaultAgent ?? "default", workspaceRoot);
+			const absoluteFilesDir = await getAgentFilesDir(agentId, chatId, settings, workspaceRoot);
+			const adapterNamespace = input.data.adapter || "cli";
+			const targetDir = path.join(absoluteFilesDir, adapterNamespace);
+			const { pathIsInsideDir } = await import("../fs-B5wW0oaH.mjs").then((n) => n.t);
+			if (!pathIsInsideDir(targetDir, workspaceRoot, { allowSameDir: true })) throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Target directory must be within the workspace."
+			});
+			await validateAttachments(files);
+			await fs$1.mkdir(targetDir, { recursive: true });
+			const finalPaths = [];
+			for (const file of files) {
+				const fileName = path.basename(file);
+				const targetPath = await getUniquePath(path.join(targetDir, fileName));
+				try {
+					await fs$1.rename(file, targetPath);
+				} catch {
+					await fs$1.copyFile(file, targetPath);
+					await fs$1.unlink(file);
+				}
+				finalPaths.push(path.relative(agentDir, targetPath));
+			}
+			const fileList = `Attached files:\n${finalPaths.map((p) => `- ${p}`).join("\n")}`;
+			message = message ? `${message}\n\n${fileList}` : fileList;
+		}
+		await handleUserMessage(chatId, message, settings, void 0, noWait, (args) => runCommand({
+			...args,
+			logToTerminal: true
+		}), sessionId, agentId);
+		return { success: true };
+	}),
+	getMessages: apiProcedure.input(z.object({
+		chatId: z.string().optional(),
+		limit: z.number().optional()
+	})).query(async ({ input, ctx }) => {
+		return getMessages(await resolveAndCheckChatId(ctx, input.chatId), input.limit);
+	}),
+	waitForMessages: apiProcedure.input(z.object({
+		chatId: z.string().optional(),
+		lastMessageId: z.string().optional()
+	})).subscription(async function* ({ input, ctx, signal }) {
+		const chatId = await resolveAndCheckChatId(ctx, input.chatId);
+		if (input.lastMessageId) {
+			const messages = await getMessages(chatId);
+			const lastIndex = messages.findIndex((m) => m.id === input.lastMessageId);
+			if (lastIndex !== -1 && lastIndex < messages.length - 1) yield messages.slice(lastIndex + 1);
+		}
+		const { on } = await import("node:events");
+		try {
+			for await (const [event] of on(daemonEvents, DAEMON_EVENT_MESSAGE_APPENDED, { signal })) if (event.chatId === chatId) yield [event.message];
+		} catch (err) {
+			if (err instanceof Error && err.name === "AbortError") return;
+			throw err;
+		}
+	}),
+	waitForTyping: apiProcedure.input(z.object({ chatId: z.string().optional() })).subscription(async function* ({ input, ctx, signal }) {
+		const chatId = await resolveAndCheckChatId(ctx, input.chatId);
+		const { on } = await import("node:events");
+		try {
+			for await (const [event] of on(daemonEvents, DAEMON_EVENT_TYPING, { signal })) if (event.chatId === chatId) yield event;
+		} catch (err) {
+			if (err instanceof Error && err.name === "AbortError") return;
+			throw err;
+		}
+	}),
+	ping: publicProcedure.query(() => {
+		return { status: "ok" };
+	}),
+	shutdown: publicProcedure.mutation(() => {
+		setTimeout(() => {
+			console.log("Shutting down daemon...");
+			process.kill(process.pid, "SIGTERM");
+		}, 100);
+		return { success: true };
+	}),
+	logMessage: apiProcedure.input(z.object({
+		chatId: z.string().optional(),
+		message: z.string().optional(),
+		files: z.array(z.string()).optional()
+	})).mutation(async ({ input, ctx }) => {
+		const chatId = await resolveAndCheckChatId(ctx, input.chatId);
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
+		const filePaths = [];
+		if (input.files && input.files.length > 0) {
+			const workspaceRoot = getWorkspaceRoot(process.cwd());
+			const agentDir = await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot);
+			for (const file of input.files) {
+				const validPath = await validateLogFile(file, agentDir, workspaceRoot);
+				filePaths.push(validPath);
+			}
+		}
+		const filesArgStr = filePaths.map((p) => ` --file ${p}`).join("");
+		const logMsg = {
+			id,
+			messageId: id,
+			role: "log",
+			source: "router",
+			content: input.message || "",
+			stderr: "",
+			timestamp,
+			command: `clawmini-lite log${filesArgStr}`,
+			cwd: process.cwd(),
+			exitCode: 0,
+			...filePaths.length > 0 ? { files: filePaths } : {}
+		};
+		await import("../chats-Zd_HXDHx.mjs").then((n) => n.n).then((m) => m.appendMessage(chatId, logMsg));
+		return { success: true };
+	}),
+	listCronJobs: apiProcedure.input(z.object({ chatId: z.string().optional() })).query(async ({ input, ctx }) => {
+		return (await readChatSettings(await resolveAndCheckChatId(ctx, input.chatId)))?.jobs ?? [];
+	}),
+	addCronJob: apiProcedure.input(z.object({
+		chatId: z.string().optional(),
+		job: CronJobSchema
+	})).mutation(async ({ input, ctx }) => {
+		const chatId = await resolveAndCheckChatId(ctx, input.chatId);
+		const settings = await readChatSettings(chatId) || {};
+		const cronJobs = settings.jobs ?? [];
+		const existingIndex = cronJobs.findIndex((j) => j.id === input.job.id);
+		if (existingIndex >= 0) cronJobs[existingIndex] = input.job;
+		else cronJobs.push(input.job);
+		settings.jobs = cronJobs;
+		await writeChatSettings(chatId, settings);
+		cronManager.scheduleJob(chatId, input.job);
+		return { success: true };
+	}),
+	deleteCronJob: apiProcedure.input(z.object({
+		chatId: z.string().optional(),
+		id: z.string()
+	})).mutation(async ({ input, ctx }) => {
+		const chatId = await resolveAndCheckChatId(ctx, input.chatId);
+		const settings = await readChatSettings(chatId);
+		if (!settings || !settings.jobs) return {
+			success: true,
+			deleted: false
+		};
+		const initialLength = settings.jobs.length;
+		settings.jobs = settings.jobs.filter((j) => j.id !== input.id);
+		if (settings.jobs.length !== initialLength) {
+			await writeChatSettings(chatId, settings);
+			cronManager.unscheduleJob(chatId, input.id);
+			return {
+				success: true,
+				deleted: true
+			};
+		}
+		return {
+			success: true,
+			deleted: false
+		};
+	})
+});
+const appRouter = AppRouter;
+
+//#endregion
+//#region src/daemon/index.ts
+async function initDaemon() {
+	const socketPath = getSocketPath();
+	const clawminiDir = getClawminiDir();
+	if (!fs.existsSync(clawminiDir)) throw new Error(`${clawminiDir} does not exist`);
+	const settingsPath = getSettingsPath();
+	let apiCtx = null;
+	if (fs.existsSync(settingsPath)) try {
+		const settingsStr = fs.readFileSync(settingsPath, "utf8");
+		const settings = JSON.parse(settingsStr);
+		const parsed = SettingsSchema.safeParse(settings);
+		if (parsed.success) apiCtx = getApiContext(parsed.data);
+	} catch (err) {
+		console.warn(`Failed to read or parse settings from ${settingsPath}:`, err);
+	}
+	const runHooks = async (hookType) => {
+		try {
+			const currentSettings = await readSettings();
+			const workspaceRoot = getWorkspaceRoot(process.cwd());
+			if (!currentSettings?.environments) return;
+			for (const [envPath, envName] of Object.entries(currentSettings.environments)) try {
+				const envConfig = await readEnvironment(envName);
+				const envDir = getEnvironmentPath(envName);
+				const affectedDir = path.resolve(workspaceRoot, envPath);
+				if (hookType === "up" && envConfig) await exportLiteToEnvironment(envName, envConfig, affectedDir);
+				const command = envConfig?.[hookType];
+				if (command) {
+					console.log(`Executing '${hookType}' hook for environment '${envName}': ${command}`);
+					execSync(command, {
+						cwd: affectedDir,
+						stdio: "inherit",
+						env: {
+							...process.env,
+							ENV_DIR: envDir
+						},
+						timeout: hookType === "down" ? 1e4 : void 0
+					});
+				}
+			} catch (err) {
+				console.error(`Failed to execute '${hookType}' hook for environment '${envName}':`, err);
+				if (hookType === "up") throw err;
+			}
+		} catch (err) {
+			console.error(`Failed to run '${hookType}' hooks:`, err);
+			if (hookType === "up") throw err;
+		}
+	};
+	if (fs.existsSync(socketPath)) {
+		if (await new Promise((resolve) => {
+			const client = net.createConnection({ path: socketPath });
+			client.on("connect", () => {
+				client.destroy();
+				resolve(true);
+			});
+			client.on("error", () => {
+				resolve(false);
+			});
+		})) {
+			console.log("Daemon is already running (socket is active). Exiting.");
+			process.exit(0);
+		}
+		try {
+			fs.unlinkSync(socketPath);
+		} catch {}
+	}
+	let isReady = false;
+	let readyPromiseResolve;
+	const readyPromise = new Promise((resolve) => {
+		readyPromiseResolve = resolve;
+	});
+	const handler = createHTTPHandler({
+		router: appRouter,
+		createContext: ({ req, res }) => ({
+			req,
+			res,
+			isApiServer: false
+		})
+	});
+	const server = http.createServer(async (req, res) => {
+		if (!isReady) await readyPromise;
+		handler(req, res);
+	});
+	await new Promise((resolve, reject) => {
+		server.on("error", (err) => {
+			if (err.code === "EADDRINUSE") {
+				console.log("Daemon is already running (socket bind failed). Exiting.");
+				process.exit(0);
+			}
+			reject(err);
+		});
+		server.listen(socketPath, () => {
+			console.log(`Daemon initialized and listening on ${socketPath}`);
+			resolve();
+		});
+	});
+	await runHooks("up");
+	isReady = true;
+	readyPromiseResolve();
+	cronManager.init().catch((err) => {
+		console.error("Failed to initialize cron manager:", err);
+	});
+	let apiServer;
+	if (apiCtx) {
+		const apiHandler = createHTTPHandler({
+			router: appRouter,
+			createContext: ({ req, res }) => {
+				let tokenPayload = null;
+				const authHeader = req.headers.authorization;
+				if (authHeader && authHeader.startsWith("Bearer ")) tokenPayload = validateToken(authHeader.substring(7));
+				return {
+					req,
+					res,
+					isApiServer: true,
+					tokenPayload
+				};
+			}
+		});
+		apiServer = http.createServer((req, res) => {
+			apiHandler(req, res);
+		});
+		const host = apiCtx.host;
+		const port = apiCtx.port;
+		apiServer.listen(port, host, () => {
+			console.log(`Daemon HTTP API initialized and listening on http://${host}:${port}`);
+		});
+	}
+	let isShuttingDown = false;
+	const shutdown = async () => {
+		if (isShuttingDown) return;
+		isShuttingDown = true;
+		console.log("Daemon shutting down...");
+		await runHooks("down");
+		server.close();
+		if (apiServer) apiServer.close();
+		process.exit(0);
+	};
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+	process.on("exit", () => {
+		if (fs.existsSync(socketPath)) try {
+			fs.unlinkSync(socketPath);
+		} catch {}
+	});
+}
+if (process.argv[1] === new URL(import.meta.url).pathname) initDaemon().catch((err) => {
+	console.error("Daemon initialization failed:", err);
+	process.exit(1);
+});
+
+//#endregion
+export { initDaemon };
+//# sourceMappingURL=index.mjs.map