clawmini 0.0.1 → 0.0.2

package/dist/daemon/index.mjs

@@ -1,8 +1,9 @@
-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 { C as CronJobSchema, _ as readSettings, a as getAgent, c as getSettingsPath, g as readPolicies, h as readEnvironment, i as getActiveEnvironmentInfo, l as getSocketPath, m as readChatSettings, o as getClawminiDir, p as readAgentSessionSettings, s as getEnvironmentPath, u as getWorkspaceRoot, w as SettingsSchema, x as writeChatSettings, y as writeAgentSessionSettings } from "../workspace-BC1ahx4R.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 { l as listChats, o as getDefaultChatId, s as getMessages } from "../chats-CpRQrNHj.mjs";
+import { n as exportLiteToEnvironment } from "../lite-DBUuHsX0.mjs";
+import { a as daemonEvents, i as DAEMON_EVENT_TYPING, o as emitTyping, r as DAEMON_EVENT_MESSAGE_APPENDED, t as appendMessage } from "../chats-BcbxvPlj.mjs";
+import { n as executeSafe, r as interpolateArgs, t as createSnapshot } from "../policy-utils-BvfOK6Ih.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import { execSync, spawn } from "node:child_process";
@@ -12,9 +13,128 @@ 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 fs$2 from "fs/promises";
+import path$1 from "path";
+import { randomInt } from "crypto";
+import crypto$1, { randomUUID } from "node:crypto";
 import schedule from "node-schedule";
 
+//#region src/daemon/request-store.ts
+const PolicyRequestSchema = z.object({
+	id: z.string(),
+	commandName: z.string(),
+	args: z.array(z.string()),
+	fileMappings: z.record(z.string(), z.string()),
+	state: z.enum([
+		"Pending",
+		"Approved",
+		"Rejected"
+	]),
+	createdAt: z.number(),
+	rejectionReason: z.string().optional(),
+	chatId: z.string(),
+	agentId: z.string()
+});
+function isENOENT(err) {
+	return Boolean(err && typeof err === "object" && "code" in err && err.code === "ENOENT");
+}
+var RequestStore = class {
+	baseDir;
+	constructor(startDir = process.cwd()) {
+		this.baseDir = path$1.join(getClawminiDir(startDir), "tmp", "requests");
+	}
+	async init() {
+		await fs$2.mkdir(this.baseDir, { recursive: true });
+	}
+	getFilePath(id) {
+		return path$1.join(this.baseDir, `${id}.json`);
+	}
+	async save(request) {
+		await this.init();
+		const filePath = this.getFilePath(request.id);
+		await fs$2.writeFile(filePath, JSON.stringify(request, null, 2), "utf8");
+	}
+	async load(id) {
+		const normalizedId = normalizePolicyId(id);
+		const filePath = this.getFilePath(normalizedId);
+		try {
+			const data = await fs$2.readFile(filePath, "utf8");
+			return PolicyRequestSchema.parse(JSON.parse(data));
+		} catch (err) {
+			if (isENOENT(err)) return null;
+			const msg = err instanceof Error ? err.message : String(err);
+			console.warn(`Failed to parse request file ${filePath}:`, msg);
+			return null;
+		}
+	}
+	async list() {
+		await this.init();
+		const requests = [];
+		try {
+			const files = await fs$2.readdir(this.baseDir);
+			for (const file of files) {
+				if (!file.endsWith(".json")) continue;
+				const id = path$1.basename(file, ".json");
+				const req = await this.load(id);
+				if (req) requests.push(req);
+			}
+		} catch (err) {
+			if (!isENOENT(err)) throw err;
+		}
+		return requests.sort((a, b) => b.createdAt - a.createdAt);
+	}
+};
+function generateRandomAlphaNumericString(length) {
+	const characters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	let result = "";
+	for (let i = 0; i < length; i++) result += characters[Math.floor(randomInt(36))];
+	return result;
+}
+function normalizePolicyId(id) {
+	return id.toLocaleUpperCase().trim();
+}
+
+//#endregion
+//#region src/daemon/policy-request-service.ts
+var PolicyRequestService = class {
+	store;
+	maxPending;
+	agentDir;
+	snapshotDir;
+	constructor(store, agentDir, snapshotDir, maxPending = 100) {
+		this.store = store;
+		this.agentDir = agentDir;
+		this.snapshotDir = snapshotDir;
+		this.maxPending = maxPending;
+	}
+	async createRequest(commandName, args, fileMappings, chatId, agentId) {
+		const allRequests = await this.store.list();
+		if (allRequests.filter((r) => r.state === "Pending").length >= this.maxPending) throw new Error(`Maximum number of pending requests (${this.maxPending}) reached.`);
+		const snapshotMappings = {};
+		for (const [key, requestedPath] of Object.entries(fileMappings)) snapshotMappings[key] = await createSnapshot(requestedPath, this.agentDir, this.snapshotDir);
+		let id = "";
+		do
+			id = generateRandomAlphaNumericString(3);
+		while (allRequests.some((r) => r.id === id));
+		const request = {
+			id,
+			commandName,
+			args,
+			fileMappings: snapshotMappings,
+			state: "Pending",
+			createdAt: Date.now(),
+			chatId,
+			agentId
+		};
+		await this.store.save(request);
+		return request;
+	}
+	getInterpolatedArgs(request) {
+		return interpolateArgs(request.args, request.fileMappings);
+	}
+};
+
+//#endregion
 //#region src/daemon/queue.ts
 var Queue = class {
 	pending = [];
@@ -154,18 +274,135 @@ const slashStop = createSlashActionRouter("stop", "stop", "Stopping current task
 //#region src/daemon/routers/slash-interrupt.ts
 const slashInterrupt = createSlashActionRouter("interrupt", "interrupt", "Interrupting current task...");
 
+//#endregion
+//#region src/daemon/routers/slash-policies.ts
+async function loadAndValidateRequest(id, state) {
+	const store = new RequestStore(getWorkspaceRoot());
+	const req = await store.load(id);
+	if (!req) return { error: {
+		...state,
+		message: "",
+		reply: `Request not found: ${id}`
+	} };
+	if (req.chatId && req.chatId !== state.chatId) return { error: {
+		...state,
+		message: "",
+		reply: `Request belongs to a different chat: ${req.chatId}`
+	} };
+	if (req.state !== "Pending") return { error: {
+		...state,
+		message: "",
+		reply: `Request is not pending: ${id}`
+	} };
+	return {
+		req,
+		store
+	};
+}
+async function slashPolicies(state) {
+	const message = state.message.trim();
+	if (message === "/pending") {
+		const pending = (await new RequestStore(getWorkspaceRoot()).list()).filter((r) => r.state === "Pending");
+		let reply = `Pending Requests (${pending.length}):\n`;
+		for (const req of pending) reply += `- ID: ${req.id} | Command: ${req.commandName} ${req.args.join(" ")}\n`;
+		return {
+			...state,
+			reply,
+			action: "stop"
+		};
+	}
+	const approveMatch = message.match(/^\/approve\s+([^\s]+)/);
+	if (approveMatch) {
+		const id = approveMatch[1];
+		if (!id) return state;
+		const { req, store, error } = await loadAndValidateRequest(id, state);
+		if (error) return error;
+		if (!req || !store) return state;
+		const policy = (await readPolicies())?.policies?.[req.commandName];
+		if (!policy) return {
+			...state,
+			message: "",
+			reply: `Policy not found: ${req.commandName}`
+		};
+		req.state = "Approved";
+		await store.save(req);
+		const interpolatedArgs = interpolateArgs([...policy.args || [], ...req.args], req.fileMappings);
+		const { stdout, stderr, exitCode } = await executeSafe(policy.command, interpolatedArgs, { cwd: getWorkspaceRoot() });
+		const commandStr = `${policy.command} ${interpolatedArgs.join(" ")}`;
+		const logMsg = {
+			id: randomUUID(),
+			messageId: state.messageId,
+			role: "log",
+			source: "router",
+			content: `Request ${id} approved and executed.`,
+			stderr,
+			stdout,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			command: commandStr,
+			cwd: getWorkspaceRoot(),
+			exitCode
+		};
+		await appendMessage(state.chatId, logMsg);
+		const agentMessage = `Request ${id} approved.\n\n${wrapInHtml("stdout", stdout)}\n\n${wrapInHtml("stderr", stderr)}\n\nExit Code: ${exitCode}`;
+		return {
+			...state,
+			message: agentMessage,
+			reply: `Approved request, running ${req.commandName}`
+		};
+	}
+	const rejectMatch = message.match(/^\/reject\s+([^\s]+)(?:\s+(.*))?/);
+	if (rejectMatch) {
+		const id = rejectMatch[1];
+		if (!id) return state;
+		const reason = rejectMatch[2] || "No reason provided";
+		const { req, store, error } = await loadAndValidateRequest(id, state);
+		if (error) return error;
+		if (!req || !store) return state;
+		req.state = "Rejected";
+		req.rejectionReason = reason;
+		await store.save(req);
+		const logMsg = {
+			id: randomUUID(),
+			messageId: state.messageId,
+			role: "log",
+			source: "router",
+			content: `Request ${id} rejected. Reason: ${reason}`,
+			stderr: "",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			command: `policy-request-reject ${id}`,
+			cwd: getWorkspaceRoot(),
+			exitCode: 1
+		};
+		await appendMessage(state.chatId, logMsg);
+		const agentMessage = `Request ${id} rejected. Reason: ${reason}`;
+		return {
+			...state,
+			message: agentMessage
+		};
+	}
+	return state;
+}
+function wrapInHtml(tag, text) {
+	if (text.trim().length === 0) return `<${tag}></${tag}>`;
+	return `<${tag}>\n${text.trim()}\n</${tag}>`;
+}
+
 //#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);
+	for (const router of routers) {
+		if (state.action === "stop") break;
+		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 if (router === "@clawmini/slash-policies") state = await slashPolicies(state);
+		else try {
+			state = await executeCustomRouter(router, state);
+		} catch (err) {
+			console.error(`Router error [${router}]:`, err);
+		}
 	}
 	return state;
 }
@@ -374,9 +611,9 @@ function formatEnvironmentPrefix(prefix, replacements) {
 	};
 	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) {
+async function executeDirectMessage(chatId, state, settings, cwd, runCommand, noWait = false, userMessageContent) {
 	const userMsg = {
-		id: crypto.randomUUID(),
+		id: state.messageId ?? crypto.randomUUID(),
 		role: "user",
 		content: userMessageContent ?? state.message,
 		timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -576,14 +813,16 @@ async function executeDirectMessage(chatId, state, settings, cwd, runCommand, no
 		if (err.name !== "AbortError") console.error("Task execution error:", err);
 	});
 }
-async function getInitialRouterState(chatId, message, cwd = process.cwd(), overrideAgentId, overrideSessionId) {
+async function getInitialRouterState(chatId, message, cwd = process.cwd(), overrideAgentId, overrideSessionId, overrideMessageId) {
 	const chatSettings = await readChatSettings(chatId, cwd) ?? {};
 	const agentId = overrideAgentId ?? chatSettings.defaultAgent ?? "default";
+	const sessionId = overrideSessionId ?? chatSettings.sessions?.[agentId] ?? "default";
 	return {
+		messageId: overrideMessageId ?? crypto.randomUUID(),
 		message,
 		chatId,
 		agentId,
-		sessionId: overrideSessionId ?? chatSettings.sessions?.[agentId] ?? "default",
+		sessionId,
 		env: {}
 	};
 }
@@ -613,6 +852,7 @@ async function handleUserMessage(chatId, message, settings, cwd = process.cwd(),
 	}
 	if (settingsChanged) await writeChatSettings(chatId, chatSettings, cwd);
 	const directState = {
+		messageId: finalState.messageId,
 		message: finalMessage,
 		chatId,
 		env: routerEnv
@@ -845,7 +1085,7 @@ async function getAgentFilesDir(agentId, chatId, settings, workspaceRoot) {
 }
 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 { getClawminiDir } = await import("../workspace-BC1ahx4R.mjs").then((n) => n.v);
 	const tmpDir = path.join(getClawminiDir(process.cwd()), "tmp");
 	for (const file of files) {
 		const absoluteFile = path.resolve(process.cwd(), file);
@@ -1018,7 +1258,7 @@ const AppRouter = router({
 			exitCode: 0,
 			...filePaths.length > 0 ? { files: filePaths } : {}
 		};
-		await import("../chats-Zd_HXDHx.mjs").then((n) => n.n).then((m) => m.appendMessage(chatId, logMsg));
+		await import("../chats-BcbxvPlj.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 }) => {
@@ -1063,6 +1303,58 @@ const AppRouter = router({
 			success: true,
 			deleted: false
 		};
+	}),
+	listPolicies: apiProcedure.query(async () => {
+		return await readPolicies();
+	}),
+	executePolicyHelp: apiProcedure.input(z.object({ commandName: z.string() })).query(async ({ input }) => {
+		const policy = (await readPolicies())?.policies?.[input.commandName];
+		if (!policy) throw new TRPCError({
+			code: "NOT_FOUND",
+			message: `Policy not found: ${input.commandName}`
+		});
+		if (!policy.allowHelp) return {
+			stdout: "",
+			stderr: "This command does not support --help\n",
+			exitCode: 1
+		};
+		const { executeSafe } = await import("../policy-utils-BvfOK6Ih.mjs").then((n) => n.i);
+		const fullArgs = [...policy.args || [], "--help"];
+		const { stdout, stderr, exitCode } = await executeSafe(policy.command, fullArgs, { cwd: getWorkspaceRoot() });
+		return {
+			stdout,
+			stderr,
+			exitCode
+		};
+	}),
+	createPolicyRequest: apiProcedure.input(z.object({
+		commandName: z.string(),
+		args: z.array(z.string()),
+		fileMappings: z.record(z.string(), z.string()),
+		chatId: z.string().optional()
+	})).mutation(async ({ input, ctx }) => {
+		const workspaceRoot = getWorkspaceRoot(process.cwd());
+		const snapshotDir = path.join(getClawminiDir(process.cwd()), "tmp", "snapshots");
+		const service = new PolicyRequestService(new RequestStore(process.cwd()), await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot), snapshotDir);
+		const chatId = await resolveAndCheckChatId(ctx, input.chatId);
+		const agentId = ctx.tokenPayload?.agentId ?? "unknown";
+		const request = await service.createRequest(input.commandName, input.args, input.fileMappings, chatId, agentId);
+		const { generateRequestPreview } = await import("../policy-utils-BvfOK6Ih.mjs").then((n) => n.i);
+		const previewContent = await generateRequestPreview(request);
+		const logMsg = {
+			id: (await import("node:crypto")).randomUUID(),
+			messageId: (await import("node:crypto")).randomUUID(),
+			role: "log",
+			source: "router",
+			content: previewContent,
+			stderr: "",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			command: "policy-request",
+			cwd: process.cwd(),
+			exitCode: 0
+		};
+		await import("../chats-BcbxvPlj.mjs").then((n) => n.n).then((m) => m.appendMessage(chatId, logMsg));
+		return request;
 	})
 });
 const appRouter = AppRouter;