clawmini 0.0.1

package/dist/cli/index.mjs

@@ -0,0 +1,850 @@
+#!/usr/bin/env node
+import { a as getAgent, b as writeChatSettings, d as isValidAgentId, f as listAgents, g as readSettings, l as getSocketPath, m as readChatSettings, n as deleteAgent, o as getClawminiDir, r as enableEnvironment, t as applyTemplateToAgent, x as writeSettings, y as writeAgentSettings } from "../workspace-CSgfo_2J.mjs";
+import { n as pathIsInsideDir } from "../fs-B5wW0oaH.mjs";
+import { a as getChatsDir, c as isValidChatId, i as deleteChat, l as listChats, o as getDefaultChatId, r as createChat, s as getMessages, t as DEFAULT_CHAT_ID, u as setDefaultChatId } from "../chats-DKgTeU7i.mjs";
+import { t as createUnixSocketFetch } from "../fetch-BjZVyU3Z.mjs";
+import { i as writeLiteScript, r as getLiteScriptContent, t as exportLiteToAllEnvironments } from "../lite-Dl7WXyaH.mjs";
+import { Command } from "commander";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import * as fs$2 from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { createTRPCClient, httpLink } from "@trpc/client";
+import http from "node:http";
+
+//#region src/shared/agent-utils.ts
+async function createAgentWithChat(agentId, agentData, template, startDir = process.cwd()) {
+	await writeAgentSettings(agentId, agentData, startDir);
+	if (template) await applyTemplateToAgent(agentId, template, agentData, startDir);
+	if ((await listChats(startDir)).includes(agentId)) console.warn(`Warning: Chat ${agentId} already exists.`);
+	else {
+		await createChat(agentId, startDir);
+		await writeChatSettings(agentId, {
+			...await readChatSettings(agentId, startDir) || {},
+			defaultAgent: agentId
+		}, startDir);
+	}
+}
+
+//#endregion
+//#region src/cli/utils.ts
+function handleError$1(action, err) {
+	console.error(`Failed to ${action}:`, err instanceof Error ? err.message : String(err));
+	process.exit(1);
+}
+
+//#endregion
+//#region src/cli/commands/init.ts
+const initCmd = new Command("init").description("Initialize a new .clawmini settings folder").option("--agent <name>", "Initialize with a specific agent").option("--agent-template <name>", "Template to use for the agent").option("--environment <name>", "Enable a specific environment").action(async (options) => {
+	if (options.agentTemplate && !options.agent) handleError$1("initialize", /* @__PURE__ */ new Error("--agent-template cannot be used without --agent"));
+	if (options.agent && !isValidAgentId(options.agent)) handleError$1("initialize", /* @__PURE__ */ new Error(`Invalid agent ID: ${options.agent}`));
+	const cwd = process.cwd();
+	const dirPath = path.join(cwd, ".clawmini");
+	const settingsPath = path.join(dirPath, "settings.json");
+	if (fs.existsSync(settingsPath)) {
+		console.log(".clawmini already initialized");
+		return;
+	}
+	const defaultSettings = {
+		defaultAgent: {
+			commands: { new: "echo $CLAW_CLI_MESSAGE" },
+			env: {}
+		},
+		routers: [
+			"@clawmini/slash-new",
+			"@clawmini/slash-stop",
+			"@clawmini/slash-interrupt",
+			"@clawmini/slash-command"
+		],
+		api: true
+	};
+	if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+	fs.writeFileSync(settingsPath, JSON.stringify(defaultSettings, null, 2));
+	console.log("Initialized .clawmini/settings.json");
+	if (options.agent) try {
+		const agentId = options.agent;
+		await createAgentWithChat(agentId, {}, options.agentTemplate);
+		console.log(`Agent ${agentId} created successfully.`);
+		await setDefaultChatId(agentId);
+		console.log(`Default chat set to ${agentId}.`);
+	} catch (err) {
+		handleError$1("create agent", err);
+	}
+	if (options.environment) try {
+		await enableEnvironment(options.environment);
+	} catch (err) {
+		handleError$1("enable environment", err);
+	}
+});
+
+//#endregion
+//#region src/cli/client.ts
+async function getDaemonClient(options = {}) {
+	const { autoStart = true } = options;
+	const socketPath = getSocketPath();
+	if (!fs.existsSync(socketPath)) {
+		if (!autoStart) throw new Error("Daemon not running.");
+		console.log("Daemon not running. Starting daemon...");
+		const daemonPath = new URL("../daemon/index.mjs", import.meta.url).pathname;
+		const logFile = fs.openSync(path.join(getClawminiDir(), "daemon.log"), "a");
+		spawn(process.execPath, [daemonPath], {
+			detached: true,
+			stdio: [
+				"ignore",
+				logFile,
+				logFile
+			]
+		}).unref();
+		await new Promise((resolve) => setTimeout(resolve, 500));
+		if (!fs.existsSync(socketPath)) throw new Error("Failed to start daemon.");
+	}
+	return createTRPCClient({ links: [httpLink({
+		url: "http://localhost",
+		fetch: createUnixSocketFetch(socketPath)
+	})] });
+}
+
+//#endregion
+//#region src/cli/commands/messages.ts
+const messagesCmd = new Command("messages").description("Manage messages");
+messagesCmd.command("send <message>").description("Send a new message").option("-c, --chat <id>", "Specific chat to send the message to").option("-s, --session <id>", "Specific session to send the message to").option("-a, --agent <name>", "Specific agent to use for this message").option("--no-wait", "Return immediately after the server queues the message").option("-f, --file <path>", "File to attach", (val, prev) => prev.concat([val]), []).action(async (message, options) => {
+	try {
+		if (options.agent) {
+			if (!isValidAgentId(options.agent)) {
+				console.error(`Error: Invalid agent ID '${options.agent}'.`);
+				process.exit(1);
+			}
+			if (options.agent !== "default") {
+				if (!await getAgent(options.agent)) {
+					console.error(`Error: Agent '${options.agent}' not found.`);
+					process.exit(1);
+				}
+			}
+		}
+		let finalFiles = void 0;
+		if (options.file && options.file.length > 0) {
+			finalFiles = [];
+			const tmpDir = path.join(getClawminiDir(process.cwd()), "tmp");
+			await fs$2.mkdir(tmpDir, { recursive: true });
+			for (const f of options.file) {
+				const dest = path.join(tmpDir, `cli-${Date.now()}-${Math.random().toString(36).substring(2, 7)}-${path.basename(f)}`);
+				await fs$2.copyFile(path.resolve(process.cwd(), f), dest);
+				finalFiles.push(dest);
+			}
+		}
+		await (await getDaemonClient()).sendMessage.mutate({
+			type: "send-message",
+			client: "cli",
+			data: {
+				message,
+				chatId: options.chat,
+				sessionId: options.session,
+				agentId: options.agent,
+				noWait: !options.wait,
+				files: finalFiles
+			}
+		});
+		console.log("Message sent successfully.");
+	} catch (err) {
+		console.error("Failed to send message:", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+messagesCmd.command("tail").description("View message history").option("-n, --lines <number>", "Number of messages to show", parseInt).option("--json", "Output raw JSONL format").option("-c, --chat <id>", "Specific chat to view").action(async (options) => {
+	try {
+		const messages = await getMessages(options.chat ?? await getDefaultChatId(), options.lines);
+		if (options.json) messages.forEach((msg) => console.log(JSON.stringify(msg)));
+		else messages.forEach((msg) => {
+			if (msg.role === "user") console.log(`[USER] ${msg.content}`);
+			else if (msg.role === "log") {
+				if (msg.content) console.log(`[LOG] ${msg.content.trim()}`);
+				else if (msg.stderr) console.error(`[STDERR] ${msg.stderr.trim()}`);
+			}
+		});
+	} catch (err) {
+		console.error("Failed to retrieve messages:", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/cli/commands/chats.ts
+const chatsCmd = new Command("chats").description("Manage chat sessions");
+chatsCmd.command("list").description("Display existing chats").action(async () => {
+	try {
+		const chats = await listChats();
+		const defaultId = await getDefaultChatId();
+		if (chats.length === 0) {
+			console.log("No chats found.");
+			return;
+		}
+		for (const id of chats) {
+			const marker = id === defaultId ? " *" : "";
+			console.log(`- ${id}${marker}`);
+		}
+	} catch (err) {
+		console.error("Failed to list chats:", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+chatsCmd.command("add <id>").description("Initialize a new chat").action(async (id) => {
+	try {
+		await createChat(id);
+		console.log(`Chat ${id} created successfully.`);
+	} catch (err) {
+		console.error("Failed to create chat:", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+chatsCmd.command("delete <id>").description("Remove a chat").action(async (id) => {
+	try {
+		const defaultId = await getDefaultChatId();
+		await deleteChat(id);
+		console.log(`Chat ${id} deleted successfully.`);
+		if (id === defaultId) {
+			await setDefaultChatId(DEFAULT_CHAT_ID);
+			console.log(`Default chat reset to default.`);
+		}
+	} catch (err) {
+		console.error("Failed to delete chat:", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+chatsCmd.command("set-default <id>").description("Update the workspace default chat").action(async (id) => {
+	try {
+		await setDefaultChatId(id);
+		console.log(`Default chat set to ${id}.`);
+	} catch (err) {
+		console.error("Failed to set default chat:", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/cli/commands/agents.ts
+const agentsCmd = new Command("agents").description("Manage agents");
+function parseEnv(envArray) {
+	if (!envArray || envArray.length === 0) return void 0;
+	const env = {};
+	for (const e of envArray) {
+		const [key, ...rest] = e.split("=");
+		if (key && rest.length >= 0) env[key] = rest.join("=");
+	}
+	return env;
+}
+function assertValidAgentId(id) {
+	if (!isValidAgentId(id)) throw new Error(`Invalid agent ID: ${id}`);
+}
+agentsCmd.command("list").description("Display existing agents").action(async () => {
+	try {
+		const agents = await listAgents();
+		if (agents.length === 0) {
+			console.log("No agents found.");
+			return;
+		}
+		for (const id of agents) console.log(`- ${id}`);
+	} catch (err) {
+		handleError$1("list agents", err);
+	}
+});
+agentsCmd.command("add <id>").description("Create a new agent").option("-d, --directory <dir>", "Working directory for the agent").option("-t, --template <name>", "Template to use for the agent").option("-e, --env <env...>", "Environment variables in KEY=VALUE format (can be specified multiple times)").action(async (id, options) => {
+	try {
+		assertValidAgentId(id);
+		if (await getAgent(id)) throw new Error(`Agent ${id} already exists.`);
+		const agentData = {};
+		if (options.directory) agentData.directory = options.directory;
+		const env = parseEnv(options.env);
+		if (env) agentData.env = {
+			...agentData.env || {},
+			...env
+		};
+		await createAgentWithChat(id, agentData, options.template);
+		console.log(`Agent ${id} created successfully.`);
+	} catch (err) {
+		handleError$1("create agent", err);
+	}
+});
+agentsCmd.command("update <id>").description("Update an existing agent").option("-d, --directory <dir>", "Working directory for the agent").option("-e, --env <env...>", "Environment variables in KEY=VALUE format (can be specified multiple times)").action(async (id, options) => {
+	try {
+		assertValidAgentId(id);
+		const existing = await getAgent(id);
+		if (!existing) throw new Error(`Agent ${id} does not exist.`);
+		const agentData = { ...existing };
+		if (options.directory !== void 0) agentData.directory = options.directory;
+		const env = parseEnv(options.env);
+		if (env) agentData.env = {
+			...agentData.env || {},
+			...env
+		};
+		await writeAgentSettings(id, agentData);
+		console.log(`Agent ${id} updated successfully.`);
+	} catch (err) {
+		handleError$1("update agent", err);
+	}
+});
+agentsCmd.command("delete <id>").description("Remove an agent").action(async (id) => {
+	try {
+		assertValidAgentId(id);
+		if (!await getAgent(id)) throw new Error(`Agent ${id} does not exist.`);
+		await deleteAgent(id);
+		console.log(`Agent ${id} deleted successfully.`);
+	} catch (err) {
+		handleError$1("delete agent", err);
+	}
+});
+
+//#endregion
+//#region src/cli/commands/down.ts
+const downCmd = new Command("down").description("Stop the local clawmini daemon server").action(async () => {
+	try {
+		const client = await getDaemonClient({ autoStart: false });
+		process.stdout.write("Shutting down clawmini daemon...");
+		await client.shutdown.mutate();
+		const socketPath = getSocketPath();
+		while (fs.existsSync(socketPath)) {
+			await new Promise((resolve) => setTimeout(resolve, 200));
+			process.stdout.write(".");
+		}
+		console.log("\nSuccessfully shut down clawmini daemon.");
+	} catch (err) {
+		if (err instanceof Error && err.message === "Daemon not running.") console.log("Daemon is not running.");
+		else {
+			console.error("\nFailed to shut down daemon:", err instanceof Error ? err.message : String(err));
+			process.exit(1);
+		}
+	}
+});
+
+//#endregion
+//#region src/cli/commands/up.ts
+const upCmd = new Command("up").description("Start the local clawmini daemon server").action(async () => {
+	try {
+		const socketPath = getSocketPath();
+		const wasRunning = fs.existsSync(socketPath);
+		await (await getDaemonClient({ autoStart: true })).ping.query();
+		if (wasRunning) console.log("Daemon is already running.");
+		else console.log("Successfully started clawmini daemon.");
+	} catch (err) {
+		console.error("Failed to start daemon:", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/cli/commands/web-api/utils.ts
+async function parseJsonBody(req, schema) {
+	if (req.headers["content-type"] !== "application/json") throw new Error("Invalid Content-Type");
+	let bodyStr = "";
+	for await (const chunk of req) bodyStr += chunk;
+	const rawBody = JSON.parse(bodyStr);
+	if (schema) return schema.parse(rawBody);
+	return rawBody;
+}
+function sendJsonResponse(res, statusCode, data) {
+	res.writeHead(statusCode, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(data));
+}
+
+//#endregion
+//#region src/cli/commands/web-api/agents.ts
+async function handleApiAgents(req, res, urlPath) {
+	if (req.method === "GET" && urlPath === "/api/agents") {
+		const agentIds = await listAgents();
+		const agents = [];
+		for (const id of agentIds) try {
+			const agent = await getAgent(id);
+			if (agent) agents.push({
+				id,
+				...agent
+			});
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			console.error(`Failed to load agent ${id}: ${errorMessage}`);
+			agents.push({
+				id,
+				error: errorMessage
+			});
+		}
+		sendJsonResponse(res, 200, agents);
+		return true;
+	}
+	if (req.method === "POST" && urlPath === "/api/agents") {
+		try {
+			const body = await parseJsonBody(req, z.object({
+				id: z.string().refine(isValidAgentId, { message: "Invalid agent ID" }),
+				directory: z.string().optional(),
+				env: z.record(z.string(), z.string()).optional(),
+				commands: z.record(z.string(), z.string()).optional()
+			}));
+			if (await getAgent(body.id)) {
+				sendJsonResponse(res, 409, { error: "Agent already exists" });
+				return true;
+			}
+			const newAgent = {
+				directory: body.directory,
+				env: body.env || {},
+				commands: body.commands || {}
+			};
+			try {
+				await writeAgentSettings(body.id, newAgent);
+			} catch (err) {
+				sendJsonResponse(res, 400, { error: err instanceof Error ? err.message : "Invalid agent directory" });
+				return true;
+			}
+			sendJsonResponse(res, 201, {
+				id: body.id,
+				...newAgent
+			});
+		} catch {
+			sendJsonResponse(res, 500, { error: "Failed to create agent" });
+		}
+		return true;
+	}
+	const agentMatch = urlPath.match(/^\/api\/agents\/([^/]+)$/);
+	if (agentMatch && agentMatch[1]) {
+		const agentId = agentMatch[1];
+		if (!isValidAgentId(agentId)) {
+			sendJsonResponse(res, 400, { error: "Invalid agent ID" });
+			return true;
+		}
+		if (req.method === "GET") {
+			try {
+				const agent = await getAgent(agentId);
+				if (!agent) {
+					sendJsonResponse(res, 404, { error: "Agent not found" });
+					return true;
+				}
+				sendJsonResponse(res, 200, {
+					id: agentId,
+					...agent
+				});
+			} catch (err) {
+				sendJsonResponse(res, 500, { error: err instanceof Error ? err.message : String(err) });
+			}
+			return true;
+		}
+		if (req.method === "PUT" || req.method === "POST") {
+			try {
+				const body = await parseJsonBody(req, z.object({
+					directory: z.string().optional(),
+					env: z.record(z.string(), z.string()).optional(),
+					commands: z.record(z.string(), z.string()).optional()
+				}));
+				const agent = await getAgent(agentId) || {};
+				if (body.directory !== void 0) agent.directory = body.directory;
+				if (body.env !== void 0) agent.env = body.env;
+				if (body.commands !== void 0) agent.commands = body.commands;
+				try {
+					await writeAgentSettings(agentId, agent);
+				} catch (err) {
+					sendJsonResponse(res, 400, { error: err instanceof Error ? err.message : "Invalid agent directory" });
+					return true;
+				}
+				sendJsonResponse(res, 200, {
+					id: agentId,
+					...agent
+				});
+			} catch {
+				sendJsonResponse(res, 500, { error: "Failed to update agent" });
+			}
+			return true;
+		}
+		if (req.method === "DELETE") {
+			await deleteAgent(agentId);
+			sendJsonResponse(res, 200, { success: true });
+			return true;
+		}
+	}
+	return false;
+}
+
+//#endregion
+//#region src/cli/commands/web-api/chats.ts
+async function handleApiChats(req, res, urlPath) {
+	if (req.method === "GET" && urlPath === "/api/chats") {
+		sendJsonResponse(res, 200, await listChats());
+		return true;
+	}
+	if (req.method === "POST" && urlPath === "/api/chats") {
+		try {
+			const body = await parseJsonBody(req, z.object({
+				id: z.string().refine(isValidChatId, { message: "Invalid chat ID. Must be alphanumeric with dashes or underscores." }),
+				agent: z.string().optional()
+			}));
+			await createChat(body.id);
+			if (body.agent) await writeChatSettings(body.id, { defaultAgent: body.agent });
+			sendJsonResponse(res, 201, {
+				id: body.id,
+				agent: body.agent
+			});
+		} catch {
+			sendJsonResponse(res, 500, { error: "Failed to create chat" });
+		}
+		return true;
+	}
+	const chatMatch = urlPath.match(/^\/api\/chats\/([^/]+)$/);
+	if (req.method === "GET" && chatMatch && chatMatch[1]) {
+		const chatId = chatMatch[1];
+		try {
+			const since = new URL(req.url || "", `http://${req.headers.host}`).searchParams.get("since");
+			let messages = await getMessages(chatId);
+			if (since) {
+				const sinceIndex = messages.findIndex((m) => m.id === since);
+				if (sinceIndex !== -1) messages = messages.slice(sinceIndex + 1);
+			}
+			sendJsonResponse(res, 200, messages);
+		} catch {
+			sendJsonResponse(res, 404, { error: "Chat not found" });
+		}
+		return true;
+	}
+	const streamMatch = urlPath.match(/^\/api\/chats\/([^/]+)\/stream$/);
+	if (req.method === "GET" && streamMatch && streamMatch[1]) {
+		const chatId = streamMatch[1];
+		res.setHeader("Content-Type", "text/event-stream");
+		res.setHeader("Cache-Control", "no-cache");
+		res.setHeader("Connection", "keep-alive");
+		res.setHeader("Access-Control-Allow-Origin", "*");
+		res.flushHeaders();
+		const chatsDir = await getChatsDir();
+		const chatFile = path.join(chatsDir, chatId, "chat.jsonl");
+		if (!fs.existsSync(chatFile)) await createChat(chatId);
+		let currentSize = fs.statSync(chatFile).size;
+		const watcher = fs.watch(chatFile, (eventType) => {
+			if (eventType === "change") try {
+				const stat = fs.statSync(chatFile);
+				if (stat.size > currentSize) {
+					const stream = fs.createReadStream(chatFile, {
+						start: currentSize,
+						end: stat.size - 1
+					});
+					currentSize = stat.size;
+					let buffer = "";
+					stream.on("data", (chunk) => {
+						buffer += chunk.toString();
+						const parts = buffer.split("\n");
+						buffer = parts.pop() || "";
+						for (const line of parts) if (line.trim()) res.write(`data: ${line}\n\n`);
+					});
+					stream.on("end", () => {
+						if (buffer.trim()) res.write(`data: ${buffer}\n\n`);
+					});
+				}
+			} catch {}
+		});
+		req.on("close", () => {
+			watcher.close();
+		});
+		res.write(": connected\n\n");
+		return true;
+	}
+	const messageMatch = urlPath.match(/^\/api\/chats\/([^/]+)\/messages$/);
+	if (req.method === "POST" && messageMatch && messageMatch[1]) {
+		const chatId = messageMatch[1];
+		const schema = z.object({ message: z.string().min(1, "Missing or invalid \"message\" field") });
+		let body;
+		try {
+			body = await parseJsonBody(req, schema);
+		} catch (err) {
+			sendJsonResponse(res, 400, { error: err instanceof Error ? err.message : "Invalid request" });
+			return true;
+		}
+		try {
+			await (await getDaemonClient()).sendMessage.mutate({
+				type: "send-message",
+				client: "cli",
+				data: {
+					message: body.message,
+					chatId,
+					noWait: true
+				}
+			});
+			sendJsonResponse(res, 200, { success: true });
+		} catch (err) {
+			sendJsonResponse(res, 500, { error: (err instanceof Error ? err.message : "Unknown error") || "Internal Server Error" });
+		}
+		return true;
+	}
+	const cronMatch = urlPath.match(/^\/api\/chats\/([^/]+)\/cron(?:\/([^/]+))?$/);
+	if (cronMatch && cronMatch[1]) {
+		const chatId = cronMatch[1];
+		const jobId = cronMatch[2];
+		if (req.method === "GET") {
+			try {
+				sendJsonResponse(res, 200, await (await getDaemonClient()).listCronJobs.query({ chatId }));
+			} catch {
+				sendJsonResponse(res, 500, { error: "Failed to list cron jobs" });
+			}
+			return true;
+		}
+		if (req.method === "POST") {
+			try {
+				const client = await getDaemonClient();
+				const body = await parseJsonBody(req);
+				await client.addCronJob.mutate({
+					chatId,
+					job: body
+				});
+				sendJsonResponse(res, 201, { success: true });
+			} catch (err) {
+				sendJsonResponse(res, 500, { error: (err instanceof Error ? err.message : "Unknown error") || "Failed to add cron job" });
+			}
+			return true;
+		}
+		if (req.method === "DELETE" && jobId) {
+			try {
+				await (await getDaemonClient()).deleteCronJob.mutate({
+					chatId,
+					id: jobId
+				});
+				sendJsonResponse(res, 200, { success: true });
+			} catch {
+				sendJsonResponse(res, 500, { error: "Failed to delete cron job" });
+			}
+			return true;
+		}
+	}
+	return false;
+}
+
+//#endregion
+//#region src/cli/commands/web.ts
+const mimeTypes = {
+	".html": "text/html",
+	".js": "text/javascript",
+	".mjs": "text/javascript",
+	".css": "text/css",
+	".json": "application/json",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".gif": "image/gif",
+	".svg": "image/svg+xml",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2"
+};
+const webCmd = new Command("web").description("Start the local clawmini web interface").option("-p, --port <number>", "Port to bind the server to", "8080").option("-H, --host <string>", "Host to bind the server to", "127.0.0.1").action((options) => {
+	const port = parseInt(options.port, 10);
+	if (isNaN(port)) {
+		console.error("Invalid port number.");
+		process.exit(1);
+	}
+	const __filename = fileURLToPath(import.meta.url);
+	const __dirname = path.dirname(__filename);
+	const webDir = path.resolve(__dirname, "../web");
+	http.createServer(async (req, res) => {
+		try {
+			const urlPath = req.url === "/" ? "/index.html" : req.url?.split("?")[0] || "/";
+			if (urlPath.startsWith("/api/")) {
+				res.setHeader("Content-Type", "application/json");
+				res.setHeader("Access-Control-Allow-Origin", "*");
+				res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+				res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+				if (req.method === "OPTIONS") {
+					res.writeHead(204);
+					res.end();
+					return;
+				}
+				if (urlPath.startsWith("/api/agents") && await handleApiAgents(req, res, urlPath)) return;
+				if (urlPath.startsWith("/api/chats") && await handleApiChats(req, res, urlPath)) return;
+				sendJsonResponse(res, 404, { error: "Not Found" });
+				return;
+			}
+			let filePath = path.join(webDir, urlPath);
+			if (!pathIsInsideDir(filePath, webDir)) {
+				res.writeHead(403);
+				res.end("Forbidden");
+				return;
+			}
+			if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+				filePath = path.join(webDir, "index.html");
+				if (!fs.existsSync(filePath)) {
+					res.writeHead(404);
+					res.end("Not Found");
+					return;
+				}
+			}
+			const contentType = mimeTypes[path.extname(filePath).toLowerCase()] || "application/octet-stream";
+			res.writeHead(200, { "Content-Type": contentType });
+			fs.createReadStream(filePath).pipe(res);
+		} catch (err) {
+			console.error("Error serving request:", err);
+			res.writeHead(500);
+			res.end("Internal Server Error");
+		}
+	}).listen(port, options.host, () => {
+		console.log(`Clawmini web interface running at http://${options.host}:${port}/`);
+	});
+});
+
+//#endregion
+//#region src/cli/commands/jobs.ts
+const jobsCmd = new Command("jobs").description("Manage background jobs");
+function parseKeyValueArray(arr) {
+	if (!arr || arr.length === 0) return void 0;
+	const result = {};
+	for (const item of arr) {
+		const [key, ...rest] = item.split("=");
+		if (key && rest.length >= 0) result[key] = rest.join("=");
+	}
+	return result;
+}
+function handleError(action, err) {
+	console.error(`Failed to ${action}:`, err instanceof Error ? err.message : String(err));
+	process.exit(1);
+}
+jobsCmd.command("list").description("Display existing jobs").option("-c, --chat <id>", "Specific chat to list jobs from").option("--json", "Output full JSON for each job").action(async (options) => {
+	try {
+		let jobs = await (await getDaemonClient()).listCronJobs.query({ chatId: options.chat });
+		jobs = jobs.sort((a, b) => {
+			return (a.createdAt ? new Date(a.createdAt).getTime() : 0) - (b.createdAt ? new Date(b.createdAt).getTime() : 0);
+		});
+		if (options.json) {
+			console.log(JSON.stringify(jobs, null, 2));
+			return;
+		}
+		if (jobs.length === 0) {
+			console.log("No jobs found.");
+			return;
+		}
+		for (const job of jobs) {
+			let schedule = "";
+			if ("cron" in job.schedule) schedule = `cron: ${job.schedule.cron}`;
+			else if ("every" in job.schedule) schedule = `every: ${job.schedule.every}`;
+			else if ("at" in job.schedule) schedule = `at: ${job.schedule.at}`;
+			console.log(`- ${job.id} (${schedule})`);
+		}
+	} catch (err) {
+		handleError("list jobs", err);
+	}
+});
+jobsCmd.command("add <name>").description("Create a new job").option("-m, --message <text>", "The message to send", "").option("-r, --reply <text>", "An immediate reply to append").option("--at <time-or-interval>", "Execute once at this UTC time or after an interval (e.g., 2m, 4h)").option("--every <duration>", "Execute repeatedly at this interval (e.g., 20m, 4h)").option("--cron <expression>", "Execute according to the crontab expression").option("-a, --agent <agentid>", "Agent to use").option("-e, --env <env...>", "Environment variables in KEY=VALUE format (can be specified multiple times)").option("-s, --session <type>", "Session type (e.g. new)").option("-c, --chat <chatid>", "Specify the chat").action(async (name, options) => {
+	try {
+		const schedules = [
+			options.at,
+			options.every,
+			options.cron
+		].filter(Boolean);
+		if (schedules.length > 1) throw new Error("More than one schedule flag was set. Please use only one of --at, --every, or --cron.");
+		if (schedules.length === 0) throw new Error("A schedule must be specified (--at, --every, or --cron).");
+		let schedule;
+		if (options.at) schedule = { at: options.at };
+		else if (options.every) schedule = { every: options.every };
+		else schedule = { cron: options.cron };
+		const job = {
+			id: name,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			message: options.message,
+			schedule
+		};
+		if (options.reply) job.reply = options.reply;
+		if (options.agent) job.agentId = options.agent;
+		const env = parseKeyValueArray(options.env);
+		if (env) job.env = env;
+		if (options.session) {
+			if (options.session !== "new") throw new Error("Only the \"new\" session type is supported.");
+			job.session = { type: options.session };
+		}
+		await (await getDaemonClient()).addCronJob.mutate({
+			chatId: options.chat,
+			job
+		});
+		console.log(`Job '${name}' created successfully.`);
+	} catch (err) {
+		handleError("create job", err);
+	}
+});
+jobsCmd.command("delete <name>").description("Remove a job").option("-c, --chat <chatid>", "Specify the chat").action(async (name, options) => {
+	try {
+		if ((await (await getDaemonClient()).deleteCronJob.mutate({
+			chatId: options.chat,
+			id: name
+		})).deleted) console.log(`Job '${name}' deleted successfully.`);
+		else console.log(`Job '${name}' not found.`);
+	} catch (err) {
+		handleError("delete job", err);
+	}
+});
+
+//#endregion
+//#region src/cli/commands/export-lite.ts
+const exportLiteCmd = new Command("export-lite").description("Export the standalone clawmini-lite client script").option("-o, --out <path>", "Output path or directory for the script (defaults to current directory)").option("--stdout", "Output the script to stdout instead of a file").action(async (options) => {
+	let liteScriptContent = "";
+	try {
+		liteScriptContent = await getLiteScriptContent();
+	} catch (err) {
+		console.error(`Failed to read compiled clawmini-lite script. Ensure you have built the project (npm run build). Error: ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+	if (options.stdout) {
+		process.stdout.write(liteScriptContent);
+		return;
+	}
+	let finalPath = path.resolve(process.cwd(), "clawmini-lite.js");
+	if (options.out) {
+		finalPath = path.resolve(process.cwd(), options.out);
+		try {
+			const writtenPath = await writeLiteScript(finalPath);
+			console.log(`Successfully exported clawmini-lite to ${writtenPath}`);
+		} catch (err) {
+			console.error(`Failed to export script: ${err instanceof Error ? err.message : String(err)}`);
+			process.exit(1);
+		}
+		return;
+	}
+	if (!await exportLiteToAllEnvironments(process.cwd())) try {
+		const writtenPath = await writeLiteScript(finalPath);
+		console.log(`Successfully exported clawmini-lite to ${writtenPath}`);
+	} catch (err) {
+		console.error(`Failed to export script: ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/cli/commands/environments.ts
+const environmentsCmd = new Command("environments").description("Manage environments");
+environmentsCmd.command("enable <name>").description("Enable an environment for a path in the workspace").option("-p, --path <subpath>", "Path to apply the environment to", "./").action(async (name, options) => {
+	try {
+		await enableEnvironment(name, options.path);
+	} catch (err) {
+		handleError$1("enable environment", err);
+	}
+});
+environmentsCmd.command("disable").description("Disable an environment mapping").option("-p, --path <subpath>", "Path to remove the environment from", "./").action(async (options) => {
+	try {
+		const settings = await readSettings();
+		if (!settings?.environments || !settings.environments[options.path]) {
+			console.log(`No environment mapping found for path '${options.path}'.`);
+			return;
+		}
+		const name = settings.environments[options.path];
+		delete settings.environments[options.path];
+		await writeSettings(settings);
+		console.log(`Disabled environment '${name}' for path '${options.path}'.`);
+	} catch (err) {
+		handleError$1("disable environment", err);
+	}
+});
+
+//#endregion
+//#region src/cli/index.ts
+const program = new Command();
+program.name("clawmini").description("Clawmini CLI").version("0.0.1");
+program.addCommand(initCmd);
+program.addCommand(messagesCmd);
+program.addCommand(chatsCmd);
+program.addCommand(agentsCmd);
+program.addCommand(environmentsCmd);
+program.addCommand(downCmd);
+program.addCommand(upCmd);
+program.addCommand(webCmd);
+program.addCommand(jobsCmd);
+program.addCommand(exportLiteCmd);
+program.parse();
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.mjs.map