clawmini 0.0.8 → 0.0.9

package/dist/supervisor-actions-CiW56eLi.mjs

@@ -0,0 +1,843 @@
+import { C as readSettings, F as pathIsInsideDir, g as getWorkspaceRoot, m as getSettingsPath, u as getClawminiDir, x as readEnvironment } from "./workspace-oWmVh5mi.mjs";
+import fs, { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFileSync, spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import fsPromises from "node:fs/promises";
+import net from "node:net";
+import { EventEmitter } from "node:events";
+
+//#region src/shared/chats.ts
+const DEFAULT_CHAT_ID = "default";
+async function getChatsDir(startDir = process.cwd()) {
+	const dir = path.join(getClawminiDir(startDir), "chats");
+	if (!existsSync(dir)) await fsPromises.mkdir(dir, { recursive: true });
+	return dir;
+}
+function isValidChatId(chatId) {
+	if (!chatId || chatId.length === 0) return false;
+	return /^[a-zA-Z0-9_-]+$/.test(chatId);
+}
+function assertValidChatId(id) {
+	if (!isValidChatId(id)) throw new Error(`Invalid chat ID: ${id}`);
+}
+async function createChat(id, startDir = process.cwd()) {
+	assertValidChatId(id);
+	const chatsDir = await getChatsDir(startDir);
+	const chatDir = path.join(chatsDir, id);
+	if (!existsSync(chatDir)) await fsPromises.mkdir(chatDir, { recursive: true });
+	const chatFile = path.join(chatDir, "chat.jsonl");
+	if (!existsSync(chatFile)) await fsPromises.writeFile(chatFile, "");
+}
+async function listChats(startDir = process.cwd()) {
+	const chatsDir = await getChatsDir(startDir);
+	try {
+		return (await fsPromises.readdir(chatsDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+	} catch {
+		return [];
+	}
+}
+async function deleteChat(id, startDir = process.cwd()) {
+	assertValidChatId(id);
+	const chatsDir = await getChatsDir(startDir);
+	const chatDir = path.join(chatsDir, id);
+	if (!pathIsInsideDir(chatDir, chatsDir)) throw new Error(`Security Error: Cannot delete chat directory outside of ${chatsDir}`);
+	if (existsSync(chatDir)) await fsPromises.rm(chatDir, {
+		recursive: true,
+		force: true
+	});
+}
+async function appendMessage$1(id, message, startDir = process.cwd()) {
+	assertValidChatId(id);
+	const chatsDir = await getChatsDir(startDir);
+	const chatDir = path.join(chatsDir, id);
+	if (!existsSync(chatDir)) await createChat(id, startDir);
+	const chatFile = path.join(chatDir, "chat.jsonl");
+	await fsPromises.appendFile(chatFile, JSON.stringify(message) + "\n");
+}
+async function* readLinesBackwards(filePath) {
+	const fd = await fsPromises.open(filePath, "r");
+	try {
+		const stats = await fd.stat();
+		if (stats.size === 0) return;
+		const chunkSize = 64 * 1024;
+		let position = stats.size;
+		const buffer = Buffer.alloc(chunkSize);
+		let leftoverBuffer = Buffer.alloc(0);
+		while (position > 0) {
+			const readSize = Math.min(chunkSize, position);
+			position -= readSize;
+			const { bytesRead } = await fd.read(buffer, 0, readSize, position);
+			const currentChunk = buffer.subarray(0, bytesRead);
+			let combinedBuffer = Buffer.concat([currentChunk, leftoverBuffer]);
+			let lastNewlineIdx = combinedBuffer.lastIndexOf(10);
+			while (lastNewlineIdx !== -1) {
+				const line = combinedBuffer.subarray(lastNewlineIdx + 1).toString("utf8").trim();
+				if (line) yield line;
+				combinedBuffer = combinedBuffer.subarray(0, lastNewlineIdx);
+				lastNewlineIdx = combinedBuffer.lastIndexOf(10);
+			}
+			leftoverBuffer = combinedBuffer;
+		}
+		if (leftoverBuffer.length > 0) {
+			const line = leftoverBuffer.toString("utf8").trim();
+			if (line) yield line;
+		}
+	} finally {
+		await fd.close();
+	}
+}
+function parseChatMessage(line) {
+	try {
+		const msg = JSON.parse(line);
+		if (msg && msg.role === "log") msg.role = "legacy_log";
+		return msg;
+	} catch {
+		return null;
+	}
+}
+async function getMessages(id, limit, startDir = process.cwd(), predicate, before) {
+	assertValidChatId(id);
+	const chatsDir = await getChatsDir(startDir);
+	const chatFile = path.join(chatsDir, id, "chat.jsonl");
+	if (!existsSync(chatFile)) throw new Error(`Chat directory or file for '${id}' not found.`);
+	limit = limit ?? 100;
+	if (limit <= 0) {
+		let messages = (await fsPromises.readFile(chatFile, "utf8")).split("\n").filter((line) => line.trim() !== "").map((line) => parseChatMessage(line)).filter((msg) => msg !== null);
+		if (before) {
+			const beforeIndex = messages.findIndex((m) => m.id === before);
+			if (beforeIndex !== -1) messages = messages.slice(0, beforeIndex);
+			else messages = [];
+		}
+		if (predicate) messages = messages.filter(predicate);
+		return messages;
+	}
+	const messages = [];
+	let skipping = before !== void 0;
+	for await (const line of readLinesBackwards(chatFile)) try {
+		const msg = parseChatMessage(line);
+		if (!msg) continue;
+		if (skipping) {
+			if (msg.id === before) skipping = false;
+			continue;
+		}
+		if (!predicate || predicate(msg)) {
+			messages.push(msg);
+			if (messages.length >= limit) break;
+		}
+	} catch {}
+	return messages.reverse();
+}
+async function getDefaultChatId(startDir = process.cwd()) {
+	const settingsPath = getSettingsPath(startDir);
+	if (!existsSync(settingsPath)) return DEFAULT_CHAT_ID;
+	try {
+		const content = await fsPromises.readFile(settingsPath, "utf8");
+		return JSON.parse(content).chats?.defaultId || DEFAULT_CHAT_ID;
+	} catch {
+		return DEFAULT_CHAT_ID;
+	}
+}
+async function setDefaultChatId(id, startDir = process.cwd()) {
+	assertValidChatId(id);
+	const settingsPath = getSettingsPath(startDir);
+	let settings = {};
+	if (existsSync(settingsPath)) try {
+		const content = await fsPromises.readFile(settingsPath, "utf8");
+		settings = JSON.parse(content);
+	} catch {}
+	if (!settings.chats) settings.chats = {};
+	settings.chats.defaultId = id;
+	const clawminiDir = getClawminiDir(startDir);
+	if (!existsSync(clawminiDir)) await fsPromises.mkdir(clawminiDir, { recursive: true });
+	await fsPromises.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+}
+async function findLastMessage(id, predicate, startDir = process.cwd()) {
+	assertValidChatId(id);
+	const chatsDir = await getChatsDir(startDir);
+	const chatFile = path.join(chatsDir, id, "chat.jsonl");
+	if (!existsSync(chatFile)) return null;
+	for await (const line of readLinesBackwards(chatFile)) try {
+		const msg = parseChatMessage(line);
+		if (!msg) continue;
+		if (predicate(msg)) return msg;
+	} catch {}
+	return null;
+}
+
+//#endregion
+//#region src/shared/lite.ts
+const LITE_MARKER = "clawmini-lite";
+function sha256(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+function looksLikeLiteScript(content) {
+	return content.startsWith("#!") && content.includes(LITE_MARKER);
+}
+async function resolveCompiledScript(scriptName, metaUrl) {
+	const __dirname = path.dirname(fileURLToPath(metaUrl));
+	const filename = scriptName.endsWith(".mjs") ? scriptName : `${scriptName}.mjs`;
+	const searchPaths = [
+		path.resolve(__dirname, `cli/${filename}`),
+		path.resolve(__dirname, filename),
+		path.resolve(__dirname, `../cli/${filename}`),
+		path.resolve(__dirname, `../../dist/cli/${filename}`),
+		path.resolve(__dirname, `../${filename}`),
+		path.resolve(__dirname, `../../${filename}`)
+	];
+	for (const scriptPath of searchPaths) try {
+		await fsPromises.access(scriptPath);
+		return scriptPath;
+	} catch {}
+	throw new Error(`Could not find compiled script: ${filename}`);
+}
+async function getLiteScriptContent() {
+	let liteScriptContent;
+	const liteScriptPath = await resolveCompiledScript("lite", import.meta.url);
+	liteScriptContent = await fsPromises.readFile(liteScriptPath, "utf8");
+	if (!liteScriptContent.startsWith("#!")) liteScriptContent = "#!/usr/bin/env node\n" + liteScriptContent;
+	return liteScriptContent;
+}
+async function writeLiteScript(outPath) {
+	const content = await getLiteScriptContent();
+	let finalPath = outPath;
+	const isDir = finalPath.endsWith(path.sep) || !(path.extname(finalPath) === ".js" || path.extname(finalPath) === ".mjs" || path.basename(finalPath) === "clawmini-lite");
+	try {
+		if ((await fsPromises.stat(finalPath)).isDirectory()) finalPath = path.join(finalPath, "clawmini-lite.js");
+	} catch {
+		if (isDir && !path.extname(finalPath) && !finalPath.endsWith("clawmini-lite") && !finalPath.endsWith("clawmini-lite.js")) {
+			await fsPromises.mkdir(finalPath, { recursive: true });
+			finalPath = path.join(finalPath, "clawmini-lite.js");
+		}
+	}
+	const dir = path.dirname(finalPath);
+	await fsPromises.mkdir(dir, { recursive: true });
+	await fsPromises.writeFile(finalPath, content, { mode: 493 });
+	return finalPath;
+}
+async function resolveLiteTargetPath(outPath) {
+	const isProbablyFile = path.extname(outPath) === ".js" || path.extname(outPath) === ".mjs" || path.basename(outPath) === "clawmini-lite";
+	try {
+		if ((await fsPromises.stat(outPath)).isDirectory()) return path.join(outPath, "clawmini-lite.js");
+		return outPath;
+	} catch {
+		if (isProbablyFile) return outPath;
+		return path.join(outPath, "clawmini-lite.js");
+	}
+}
+async function refreshLiteAt(outPath, opts = {}) {
+	const content = await getLiteScriptContent();
+	const finalPath = await resolveLiteTargetPath(outPath);
+	let existing = null;
+	try {
+		existing = await fsPromises.readFile(finalPath, "utf8");
+	} catch {}
+	if (existing !== null) {
+		if (sha256(existing) === sha256(content)) return {
+			status: "unchanged",
+			path: finalPath
+		};
+		if (!looksLikeLiteScript(existing)) {
+			const label = opts.label ? ` (${opts.label})` : "";
+			console.warn(`Refusing to overwrite ${finalPath}${label}: existing file is not a clawmini-lite script`);
+			return {
+				status: "refused",
+				path: finalPath
+			};
+		}
+	}
+	const dir = path.dirname(finalPath);
+	await fsPromises.mkdir(dir, { recursive: true });
+	await fsPromises.writeFile(finalPath, content, { mode: 493 });
+	return {
+		status: "written",
+		path: finalPath
+	};
+}
+async function exportLiteToEnvironment(envName, envConfig, affectedDir) {
+	if (!envConfig?.exportLiteTo) return false;
+	const finalExportPath = path.resolve(affectedDir, envConfig.exportLiteTo);
+	if (!finalExportPath.startsWith(affectedDir + path.sep) && finalExportPath !== affectedDir && !finalExportPath.startsWith(affectedDir + "/")) {
+		console.warn(`Skipping export for environment '${envName}': exportLiteTo path '${envConfig.exportLiteTo}' escapes the environment target directory '${affectedDir}'`);
+		return false;
+	}
+	try {
+		const result = await refreshLiteAt(finalExportPath, { label: `Environment: ${envName}` });
+		if (result.status === "written") console.log(`Successfully exported clawmini-lite to ${result.path} (Environment: ${envName})`);
+		else if (result.status === "refused") return false;
+		return true;
+	} catch (err) {
+		console.error(`Failed to export clawmini-lite to ${finalExportPath} (Environment: ${envName}): ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+}
+async function exportLiteToAllEnvironments(startDir = process.cwd()) {
+	let exportedToEnvironments = false;
+	try {
+		const workspaceRoot = getWorkspaceRoot(startDir);
+		const settings = await readSettings(workspaceRoot);
+		if (settings?.environments) for (const [envPath, envName] of Object.entries(settings.environments)) {
+			const envConfig = await readEnvironment(envName, workspaceRoot);
+			if (envConfig) {
+				if (await exportLiteToEnvironment(envName, envConfig, path.resolve(workspaceRoot, envPath))) exportedToEnvironments = true;
+			}
+		}
+	} catch {}
+	return exportedToEnvironments;
+}
+
+//#endregion
+//#region src/cli/supervisor-pid.ts
+function getSupervisorPidPath(startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "supervisor.pid");
+}
+function getProcessStartTime(pid) {
+	try {
+		const trimmed = execFileSync("ps", [
+			"-p",
+			String(pid),
+			"-o",
+			"lstart="
+		], {
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		return trimmed.length > 0 ? trimmed : null;
+	} catch {
+		return null;
+	}
+}
+function readSupervisorPid(startDir = process.cwd()) {
+	const p = getSupervisorPidPath(startDir);
+	if (!fs.existsSync(p)) return null;
+	const content = fs.readFileSync(p, "utf-8").trim();
+	const sep = content.indexOf(":");
+	if (sep <= 0) return null;
+	const pid = parseInt(content.slice(0, sep), 10);
+	const storedStart = content.slice(sep + 1).trim();
+	if (!Number.isFinite(pid) || pid <= 0 || storedStart.length === 0) return null;
+	try {
+		process.kill(pid, 0);
+	} catch {
+		return null;
+	}
+	const currentStart = getProcessStartTime(pid);
+	if (currentStart === null || currentStart !== storedStart) return null;
+	return pid;
+}
+function writeSupervisorPid(pid, startDir = process.cwd()) {
+	const startTime = getProcessStartTime(pid);
+	if (!startTime) throw new Error(`Cannot read start time for pid ${pid}; refusing to write supervisor.pid`);
+	fs.writeFileSync(getSupervisorPidPath(startDir), `${pid}:${startTime}`);
+}
+function removeSupervisorPid(startDir = process.cwd()) {
+	const p = getSupervisorPidPath(startDir);
+	if (fs.existsSync(p)) try {
+		fs.unlinkSync(p);
+	} catch {}
+}
+
+//#endregion
+//#region src/cli/install-detection.ts
+function realpathOrNull(p) {
+	try {
+		return fs.realpathSync(p);
+	} catch {
+		return null;
+	}
+}
+function getNpmRootGlobal() {
+	try {
+		return execFileSync("npm", ["root", "-g"], {
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim() || null;
+	} catch {
+		return null;
+	}
+}
+function detectInstall(entryPath = process.argv[1] ?? "") {
+	const entryRealPath = realpathOrNull(entryPath) ?? entryPath;
+	const npmRoot = getNpmRootGlobal();
+	const npmRootRealPath = npmRoot ? realpathOrNull(npmRoot) ?? npmRoot : null;
+	let isNpmGlobal = false;
+	if (npmRootRealPath) {
+		const rootWithSep = npmRootRealPath.endsWith(path.sep) ? npmRootRealPath : npmRootRealPath + path.sep;
+		isNpmGlobal = entryRealPath === npmRootRealPath || entryRealPath.startsWith(rootWithSep);
+	}
+	return {
+		isNpmGlobal,
+		entryRealPath,
+		npmRootRealPath
+	};
+}
+
+//#endregion
+//#region src/cli/supervisor-control.ts
+function getControlSocketPath(startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "super.sock");
+}
+function startControlServer(handlers, socketPath = getControlSocketPath()) {
+	if (fs.existsSync(socketPath)) try {
+		fs.unlinkSync(socketPath);
+	} catch {}
+	const server = net.createServer((socket) => {
+		let buf = "";
+		let handled = false;
+		const respond = (res) => {
+			if (handled) return;
+			handled = true;
+			socket.end(JSON.stringify(res) + "\n");
+		};
+		socket.on("data", (chunk) => {
+			if (handled) return;
+			buf += chunk.toString();
+			const idx = buf.indexOf("\n");
+			if (idx === -1) return;
+			const line = buf.slice(0, idx);
+			let req;
+			try {
+				req = JSON.parse(line);
+			} catch {
+				respond({
+					ok: false,
+					error: "invalid request"
+				});
+				return;
+			}
+			const handler = handlers[req.action];
+			if (!handler) {
+				respond({
+					ok: false,
+					error: `unknown action: ${req.action}`
+				});
+				return;
+			}
+			Promise.resolve().then(() => handler(req)).then((res) => respond(res), (err) => respond({
+				ok: false,
+				error: err instanceof Error ? err.message : String(err)
+			}));
+		});
+		socket.on("error", () => {});
+	});
+	server.listen(socketPath, () => {
+		try {
+			fs.chmodSync(socketPath, 384);
+		} catch {}
+	});
+	return server;
+}
+function sendControlRequest(req, socketPath = getControlSocketPath(), timeoutMs = 5e3) {
+	return new Promise((resolve, reject) => {
+		const socket = net.createConnection({ path: socketPath });
+		let buf = "";
+		let settled = false;
+		const finish = (fn) => {
+			if (settled) return;
+			settled = true;
+			try {
+				socket.destroy();
+			} catch {}
+			fn();
+		};
+		const timer = setTimeout(() => {
+			finish(() => reject(/* @__PURE__ */ new Error(`Control request timed out after ${timeoutMs}ms`)));
+		}, timeoutMs);
+		socket.on("connect", () => {
+			socket.write(JSON.stringify(req) + "\n");
+		});
+		socket.on("data", (chunk) => {
+			buf += chunk.toString();
+			const idx = buf.indexOf("\n");
+			if (idx !== -1) {
+				const line = buf.slice(0, idx);
+				clearTimeout(timer);
+				try {
+					const res = JSON.parse(line);
+					finish(() => resolve(res));
+				} catch (err) {
+					finish(() => reject(err instanceof Error ? err : new Error(String(err))));
+				}
+			}
+		});
+		socket.on("error", (err) => {
+			clearTimeout(timer);
+			finish(() => reject(err));
+		});
+		socket.on("end", () => {
+			if (!settled) {
+				clearTimeout(timer);
+				finish(() => reject(/* @__PURE__ */ new Error("Control server closed connection without responding")));
+			}
+		});
+	});
+}
+
+//#endregion
+//#region src/daemon/events.ts
+const daemonEvents = new EventEmitter();
+const DAEMON_EVENT_MESSAGE_APPENDED = "message-appended";
+const DAEMON_EVENT_TYPING = "typing";
+const DAEMON_EVENT_TURN_STARTED = "turn-started";
+const DAEMON_EVENT_TURN_ENDED = "turn-ended";
+/**
+* Unified event carrying both `ChatMessage` appends and turn lifecycle
+* events so a single `waitForMessages` subscription can interleave them
+* in emission order (no merge logic or messageQueue on the consumer side).
+*/
+const DAEMON_EVENT_CHAT_STREAM = "chat-stream";
+function emitMessageAppended(chatId, message) {
+	daemonEvents.emit(DAEMON_EVENT_MESSAGE_APPENDED, {
+		chatId,
+		message
+	});
+	const envelope = {
+		chatId,
+		item: {
+			kind: "message",
+			message
+		}
+	};
+	daemonEvents.emit(DAEMON_EVENT_CHAT_STREAM, envelope);
+}
+function emitTyping(chatId) {
+	daemonEvents.emit(DAEMON_EVENT_TYPING, { chatId });
+}
+function emitTurnStarted(event) {
+	daemonEvents.emit(DAEMON_EVENT_TURN_STARTED, event);
+	const lifecycle = {
+		type: "started",
+		turnId: event.turnId,
+		rootMessageId: event.rootMessageId,
+		...event.externalRef ? { externalRef: event.externalRef } : {}
+	};
+	const envelope = {
+		chatId: event.chatId,
+		item: {
+			kind: "turn",
+			event: lifecycle
+		}
+	};
+	daemonEvents.emit(DAEMON_EVENT_CHAT_STREAM, envelope);
+}
+function emitTurnEnded(event) {
+	daemonEvents.emit(DAEMON_EVENT_TURN_ENDED, event);
+	const lifecycle = {
+		type: "ended",
+		turnId: event.turnId,
+		outcome: event.outcome
+	};
+	const envelope = {
+		chatId: event.chatId,
+		item: {
+			kind: "turn",
+			event: lifecycle
+		}
+	};
+	daemonEvents.emit(DAEMON_EVENT_CHAT_STREAM, envelope);
+}
+
+//#endregion
+//#region src/daemon/chats.ts
+async function appendMessage(id, message, startDir = process.cwd()) {
+	await appendMessage$1(id, message, startDir);
+	emitMessageAppended(id, message);
+}
+
+//#endregion
+//#region src/daemon/pending-replies.ts
+function getPendingRepliesPath(startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "pending-replies.json");
+}
+function readFileSafe(filePath) {
+	if (!fs.existsSync(filePath)) return null;
+	try {
+		const raw = fs.readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.entries)) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+function writeAtomic(filePath, data) {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	const tmpPath = `${filePath}.${process.pid}.tmp`;
+	fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+	fs.renameSync(tmpPath, filePath);
+}
+function tryUnlink(filePath) {
+	if (!fs.existsSync(filePath)) return;
+	try {
+		fs.unlinkSync(filePath);
+	} catch {}
+}
+function enqueuePendingReply(entry, startDir = process.cwd()) {
+	const filePath = getPendingRepliesPath(startDir);
+	const entries = readFileSafe(filePath)?.entries ?? [];
+	entries.push(entry);
+	writeAtomic(filePath, {
+		version: 1,
+		entries
+	});
+}
+/**
+* Remove the first entry that matches the predicate. Used to roll back an
+* enqueued entry when the supervisor reports the action could not be started.
+*/
+function dequeuePendingReply(predicate, startDir = process.cwd()) {
+	const filePath = getPendingRepliesPath(startDir);
+	const existing = readFileSafe(filePath);
+	if (!existing) return false;
+	const idx = existing.entries.findIndex(predicate);
+	if (idx === -1) return false;
+	existing.entries.splice(idx, 1);
+	if (existing.entries.length === 0) tryUnlink(filePath);
+	else writeAtomic(filePath, existing);
+	return true;
+}
+function renderMessage(entry, runtimeVersion) {
+	switch (entry.kind) {
+		case "restart-complete": return `Clawmini restarted (v${runtimeVersion}).`;
+		case "upgrade-complete": return `Clawmini upgraded to v${runtimeVersion}.`;
+		case "upgrade-failed": return `Clawmini upgrade${entry.requestedVersion ? ` to v${entry.requestedVersion}` : ""} failed${entry.reason ? `: ${entry.reason}` : "."}`;
+	}
+}
+/**
+* Append a SystemMessage for each pending reply. Called from the daemon
+* startup path so adapters (which reconnect via tRPC subscription with
+* lastMessageId) replay the message after the daemon comes back online.
+*
+* Crash-safe: each entry is consumed only after its SystemMessage is
+* appended. A crash mid-loop leaves the un-delivered entries on disk for the
+* next daemon start to drain.
+*/
+async function drainPendingReplies(runtimeVersion, startDir = process.cwd()) {
+	const filePath = getPendingRepliesPath(startDir);
+	const data = readFileSafe(filePath);
+	if (!data) {
+		tryUnlink(filePath);
+		return;
+	}
+	const remaining = [...data.entries];
+	while (remaining.length > 0) {
+		const entry = remaining[0];
+		const sysMsg = {
+			id: randomUUID(),
+			role: "system",
+			content: renderMessage(entry, runtimeVersion),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			sessionId: void 0,
+			event: "router",
+			displayRole: "agent",
+			...entry.messageId ? { messageId: entry.messageId } : {}
+		};
+		try {
+			await appendMessage(entry.chatId, sysMsg, startDir);
+		} catch (err) {
+			console.error(`Failed to deliver pending reply to chat ${entry.chatId}:`, err instanceof Error ? err.message : err);
+		}
+		remaining.shift();
+		if (remaining.length === 0) tryUnlink(filePath);
+		else writeAtomic(filePath, {
+			version: 1,
+			entries: remaining
+		});
+	}
+}
+
+//#endregion
+//#region src/cli/supervisor-actions.ts
+const ACTION_GRACE_MS = 1e3;
+/**
+* Wire up the supervisor control socket so the daemon can request
+* /restart, /shutdown, and /upgrade out-of-band.
+*/
+function startSupervisorControl(supervisor) {
+	startControlServer({
+		restart: async (req) => {
+			if (req.chatId) enqueuePendingReply({
+				chatId: req.chatId,
+				kind: "restart-complete",
+				...req.messageId ? { messageId: req.messageId } : {}
+			});
+			setTimeout(() => {
+				supervisor.restartAll().catch((err) => {
+					process.stderr.write(`[supervisor] /restart failed: ${err instanceof Error ? err.message : String(err)}\n`);
+					if (req.chatId && req.messageId) dequeuePendingReply((e) => e.kind === "restart-complete" && e.messageId === req.messageId);
+				});
+			}, ACTION_GRACE_MS);
+			return { ok: true };
+		},
+		shutdown: async () => {
+			setTimeout(() => void supervisor.shutdown(0), ACTION_GRACE_MS);
+			return { ok: true };
+		},
+		upgrade: async (req) => {
+			const info = detectInstall();
+			if (!info.isNpmGlobal) return {
+				ok: false,
+				error: `not installed via npm install -g (running from ${info.entryRealPath})`
+			};
+			const version = req.version?.trim();
+			if (!version) return {
+				ok: false,
+				error: "missing target version"
+			};
+			if (!isAcceptableVersion(version)) return {
+				ok: false,
+				error: `invalid version: ${version}`
+			};
+			setTimeout(() => {
+				runUpgrade(supervisor, version, req.chatId, req.messageId).catch((err) => {
+					process.stderr.write(`[supervisor] /upgrade encountered an unexpected error: ${err instanceof Error ? err.message : String(err)}\n`);
+				});
+			}, ACTION_GRACE_MS);
+			return { ok: true };
+		}
+	});
+}
+function isAcceptableVersion(version) {
+	return /^[a-zA-Z0-9][a-zA-Z0-9._+-]{0,63}$/.test(version);
+}
+/**
+* In-place upgrade. Order:
+*   1. `npm install -g clawmini@<version>` (services kept running so the
+*      user isn't left in the dark if the install fails).
+*   2. Resolve the freshly-installed binary by absolute path. Bail out with
+*      an upgrade-failed reply if it's missing.
+*   3. Enqueue the upgrade-complete reply.
+*   4. Stop all children, spawn the replacement supervisor, exit.
+*
+* Any failure path enqueues an upgrade-failed reply (so the user gets visible
+* feedback) and restarts the daemon to drain it, rather than silently exiting.
+*/
+async function runUpgrade(supervisor, version, chatId, messageId) {
+	const info = detectInstall();
+	if (!info.isNpmGlobal || !info.npmRootRealPath) {
+		process.stderr.write(`[supervisor] /upgrade aborted: clawmini is not installed via npm install -g (running from ${info.entryRealPath}).\n`);
+		return;
+	}
+	const installErr = await runNpmInstall(version);
+	if (installErr) {
+		process.stderr.write(`[supervisor] /upgrade failed: ${installErr}\n`);
+		if (chatId) {
+			enqueuePendingReply({
+				chatId,
+				kind: "upgrade-failed",
+				...messageId ? { messageId } : {},
+				requestedVersion: version,
+				reason: installErr
+			});
+			await supervisor.restartAll().catch((err) => {
+				process.stderr.write(`[supervisor] additionally failed to restart services to surface the failure: ${err instanceof Error ? err.message : String(err)}\n`);
+			});
+		}
+		return;
+	}
+	const newCli = path.join(info.npmRootRealPath, "clawmini", "dist", "cli", "index.mjs");
+	if (!fs.existsSync(newCli)) {
+		const reason = `npm install reported success but ${newCli} is missing`;
+		process.stderr.write(`[supervisor] /upgrade aborted: ${reason}\n`);
+		if (chatId) {
+			enqueuePendingReply({
+				chatId,
+				kind: "upgrade-failed",
+				...messageId ? { messageId } : {},
+				requestedVersion: version,
+				reason
+			});
+			await supervisor.restartAll().catch(() => {});
+		}
+		return;
+	}
+	if (chatId) enqueuePendingReply({
+		chatId,
+		kind: "upgrade-complete",
+		...messageId ? { messageId } : {},
+		requestedVersion: version
+	});
+	process.stderr.write("[supervisor] /upgrade: stopping all services...\n");
+	await supervisor.stopAllChildren();
+	process.stderr.write(`[supervisor] /upgrade: relaunching ${newCli} serve --detach...\n`);
+	removeSupervisorPid();
+	const replacement = spawn(process.execPath, [
+		newCli,
+		"serve",
+		"--detach"
+	], {
+		detached: true,
+		stdio: "ignore",
+		cwd: process.cwd(),
+		env: process.env
+	});
+	if (!await waitForSpawn(replacement)) {
+		process.stderr.write(`[supervisor] /upgrade: replacement supervisor failed to spawn — restarting in place\n`);
+		if (chatId) {
+			dequeuePendingReply((e) => e.kind === "upgrade-complete" && e.messageId === messageId && e.requestedVersion === version);
+			enqueuePendingReply({
+				chatId,
+				kind: "upgrade-failed",
+				...messageId ? { messageId } : {},
+				requestedVersion: version,
+				reason: "replacement supervisor failed to spawn"
+			});
+		}
+		try {
+			await supervisor.restartAll();
+		} catch (err) {
+			process.stderr.write(`[supervisor] additionally failed to restart services after spawn failure: ${err instanceof Error ? err.message : String(err)}\n`);
+		}
+		return;
+	}
+	replacement.unref();
+	process.exit(0);
+}
+function runNpmInstall(version) {
+	return new Promise((resolve) => {
+		const child = spawn("npm", [
+			"install",
+			"-g",
+			`clawmini@${version}`
+		], {
+			stdio: "inherit",
+			env: process.env
+		});
+		child.on("exit", (code) => {
+			if (code === 0) resolve(null);
+			else resolve(`npm install -g exited with code ${code}`);
+		});
+		child.on("error", (err) => {
+			resolve(err instanceof Error ? err.message : String(err));
+		});
+	});
+}
+function waitForSpawn(child, timeoutMs = 5e3) {
+	return new Promise((resolve) => {
+		let settled = false;
+		const settle = (ok) => {
+			if (settled) return;
+			settled = true;
+			resolve(ok);
+		};
+		child.once("spawn", () => settle(true));
+		child.once("error", (err) => {
+			process.stderr.write(`[supervisor] replacement spawn error: ${err.message}\n`);
+			settle(false);
+		});
+		setTimeout(() => settle(true), timeoutMs);
+	});
+}
+
+//#endregion
+export { getMessages as A, writeLiteScript as C, findLastMessage as D, deleteChat as E, listChats as M, setDefaultChatId as N, getChatsDir as O, resolveCompiledScript as S, createChat as T, removeSupervisorPid as _, DAEMON_EVENT_CHAT_STREAM as a, exportLiteToEnvironment as b, daemonEvents as c, emitTyping as d, getControlSocketPath as f, readSupervisorPid as g, getSupervisorPidPath as h, appendMessage as i, isValidChatId as j, getDefaultChatId as k, emitTurnEnded as l, detectInstall as m, startSupervisorControl as n, DAEMON_EVENT_MESSAGE_APPENDED as o, sendControlRequest as p, drainPendingReplies as r, DAEMON_EVENT_TYPING as s, isAcceptableVersion as t, emitTurnStarted as u, writeSupervisorPid as v, DEFAULT_CHAT_ID as w, getLiteScriptContent as x, exportLiteToAllEnvironments as y };
+//# sourceMappingURL=supervisor-actions-CiW56eLi.mjs.map