clawmini 0.0.7 → 0.0.9

package/dist/workspace-oWmVh5mi.mjs

@@ -0,0 +1,1001 @@
+import fs from "node:fs";
+import path, { sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import crypto, { createHash, randomBytes } from "node:crypto";
+import fsPromises from "node:fs/promises";
+import { z } from "zod";
+
+//#region src/shared/policies.ts
+const BUILTIN_POLICY_SCRIPTS_DIR = ".clawmini/policy-scripts";
+const BUILTIN_POLICIES = {
+	"manage-policies": {
+		description: "Add, update, or remove clawmini policies (subcommands: add, update, remove). Reads are unrestricted via `requests show`.",
+		command: `./${BUILTIN_POLICY_SCRIPTS_DIR}/manage-policies.js`,
+		allowHelp: true,
+		autoApprove: false
+	},
+	"run-host": {
+		description: "Run an arbitrary shell command on the host via `sh -c`",
+		command: `./${BUILTIN_POLICY_SCRIPTS_DIR}/run-host.js`,
+		allowHelp: true,
+		autoApprove: false
+	}
+};
+
+//#endregion
+//#region src/shared/config.ts
+const PolicyDefinitionSchema = z.looseObject({
+	description: z.string().optional(),
+	command: z.string(),
+	args: z.array(z.string()).optional(),
+	allowHelp: z.boolean().optional(),
+	autoApprove: z.boolean().optional()
+});
+const FallbackSchema = z.looseObject({
+	commands: z.looseObject({
+		new: z.string().optional(),
+		append: z.string().optional(),
+		getSessionId: z.string().optional(),
+		getMessageContent: z.string().optional()
+	}).optional(),
+	env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+	retries: z.number().int().min(0).default(1),
+	delayMs: z.number().int().min(0).default(1e3)
+});
+const AgentSchema = z.looseObject({
+	extends: z.string().optional(),
+	commands: z.looseObject({
+		new: z.string().optional(),
+		append: z.string().optional(),
+		getSessionId: z.string().optional(),
+		getMessageContent: z.string().optional()
+	}).optional(),
+	apiTokenEnvVar: z.string().optional(),
+	apiUrlEnvVar: z.string().optional(),
+	env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+	subagentEnv: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+	modelShorthands: z.record(z.string(), z.string()).optional(),
+	directory: z.string().optional(),
+	skillsDir: z.string().nullable().optional(),
+	fallbacks: z.array(FallbackSchema).optional(),
+	files: z.string().default("./attachments").optional()
+});
+const CronJobSchema = z.lazy(() => z.looseObject({
+	id: z.string().min(1),
+	createdAt: z.string().optional(),
+	message: z.string().default(""),
+	reply: z.string().optional(),
+	agentId: z.string().optional(),
+	env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+	session: z.looseObject({ type: z.string() }).optional(),
+	schedule: z.union([
+		z.looseObject({ cron: z.string() }),
+		z.looseObject({ every: z.string() }),
+		z.looseObject({ at: z.string() })
+	]),
+	nextSessionId: z.string().optional(),
+	action: z.enum([
+		"stop",
+		"interrupt",
+		"continue"
+	]).optional(),
+	jobs: z.looseObject({
+		add: z.array(z.lazy(() => CronJobSchema)).optional(),
+		remove: z.array(z.string()).optional()
+	}).optional()
+}));
+const RouterConfigSchema = z.union([z.string(), z.looseObject({
+	use: z.string(),
+	with: z.record(z.string(), z.any()).optional()
+})]);
+const SubagentTrackerSchema = z.looseObject({
+	id: z.string(),
+	agentId: z.string().optional(),
+	sessionId: z.string().optional(),
+	createdAt: z.string(),
+	status: z.enum([
+		"active",
+		"completed",
+		"failed"
+	]),
+	parentId: z.string().optional()
+});
+const ChatSettingsSchema = z.looseObject({
+	defaultAgent: z.string().optional(),
+	sessions: z.record(z.string(), z.string()).optional(),
+	routers: z.array(RouterConfigSchema).optional(),
+	jobs: z.array(CronJobSchema).optional(),
+	subagents: z.record(z.string(), SubagentTrackerSchema).optional()
+});
+const AgentSessionSettingsSchema = z.looseObject({ env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional() });
+const EnvironmentSchema = z.looseObject({
+	extends: z.string().optional(),
+	init: z.string().optional(),
+	up: z.string().optional(),
+	down: z.string().optional(),
+	prefix: z.string().optional(),
+	envFormat: z.string().optional(),
+	exportLiteTo: z.string().optional(),
+	baseDir: z.string().optional(),
+	env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+	policies: z.record(z.string(), PolicyDefinitionSchema).optional()
+});
+const SettingsSchema = z.looseObject({
+	chats: z.looseObject({ defaultId: z.string().optional() }).optional(),
+	defaultAgent: AgentSchema.optional(),
+	environments: z.record(z.string(), z.string()).optional(),
+	routers: z.array(RouterConfigSchema).optional(),
+	files: z.string().default("./attachments").optional(),
+	api: z.union([z.boolean(), z.looseObject({
+		host: z.string().optional(),
+		port: z.number().optional(),
+		proxy_host: z.string().optional()
+	})]).optional()
+});
+
+//#endregion
+//#region src/shared/utils/fs.ts
+function pathIsInsideDir(path, dir, { allowSameDir = false } = {}) {
+	const dirWithSep = dir.endsWith(sep) ? dir : dir + sep;
+	if (allowSameDir && path === dir) return true;
+	return path.startsWith(dirWithSep) && path !== dir;
+}
+
+//#endregion
+//#region src/shared/template-manifest.ts
+const TemplateManifestSchema = z.looseObject({ files: z.record(z.string(), z.enum(["track", "seed-once"])).optional() });
+const InstalledFilesSchema = z.looseObject({ files: z.record(z.string(), z.looseObject({ sha: z.string() })).optional() });
+function sha256(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+async function fileSha(filePath) {
+	try {
+		return sha256(await fsPromises.readFile(filePath));
+	} catch {
+		return null;
+	}
+}
+async function readTemplateManifest(templateDir) {
+	const manifestPath = path.join(templateDir, "template.json");
+	try {
+		const raw = await fsPromises.readFile(manifestPath, "utf-8");
+		const parsed = TemplateManifestSchema.safeParse(JSON.parse(raw));
+		return parsed.success ? parsed.data : null;
+	} catch {
+		return null;
+	}
+}
+function getFileMode(relPath, manifest, defaultMode) {
+	if (!manifest?.files) return defaultMode;
+	const normalized = relPath.split(path.sep).join("/");
+	if (manifest.files[normalized]) return manifest.files[normalized];
+	const dirEntries = Object.entries(manifest.files).filter(([k]) => k.endsWith("/"));
+	dirEntries.sort((a, b) => b[0].length - a[0].length);
+	for (const [entry, mode] of dirEntries) if (normalized.startsWith(entry)) return mode;
+	return defaultMode;
+}
+async function walkTemplateFiles(dir, opts = {}) {
+	const skipRoot = new Set(opts.skipRoot ?? ["template.json", "settings.json"]);
+	const out = [];
+	async function walk(current, prefix) {
+		let entries;
+		try {
+			entries = await fsPromises.readdir(current, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) await walk(path.join(current, entry.name), rel);
+			else if (entry.isFile()) {
+				if (!prefix && skipRoot.has(entry.name)) continue;
+				out.push(rel);
+			}
+		}
+	}
+	await walk(dir, "");
+	return out;
+}
+async function planRefresh(templateDir, targetDir, manifest, installed, options) {
+	const templateFiles = await walkTemplateFiles(templateDir);
+	const actions = [];
+	const nextFiles = { ...installed?.files ?? {} };
+	for (const rel of templateFiles) {
+		const mode = getFileMode(rel, manifest, options.defaultMode);
+		const templatePath = path.join(templateDir, rel);
+		const targetPath = path.join(targetDir, rel);
+		const templateHash = sha256(await fsPromises.readFile(templatePath));
+		if (options.firstInstall) {
+			actions.push({
+				action: "write",
+				relPath: rel,
+				reason: "new"
+			});
+			nextFiles[rel] = { sha: templateHash };
+			continue;
+		}
+		if (mode === "seed-once") {
+			const diskHash = await fileSha(targetPath);
+			const recorded = installed?.files?.[rel]?.sha;
+			if (diskHash === null && !recorded) {
+				actions.push({
+					action: "write",
+					relPath: rel,
+					reason: "new"
+				});
+				nextFiles[rel] = { sha: templateHash };
+			} else actions.push({
+				action: "skip-seed-once",
+				relPath: rel
+			});
+			continue;
+		}
+		const recorded = installed?.files?.[rel]?.sha;
+		const diskHash = await fileSha(targetPath);
+		if (diskHash === null) {
+			actions.push({
+				action: "write",
+				relPath: rel,
+				reason: "refresh"
+			});
+			nextFiles[rel] = { sha: templateHash };
+			continue;
+		}
+		if (!recorded) {
+			if (options.accept) {
+				actions.push({
+					action: "write",
+					relPath: rel,
+					reason: "refresh"
+				});
+				nextFiles[rel] = { sha: templateHash };
+			} else actions.push({
+				action: "skip-diverged",
+				relPath: rel,
+				reason: "no-recorded-sha"
+			});
+			continue;
+		}
+		if (diskHash === templateHash) {
+			actions.push({
+				action: "skip-unchanged",
+				relPath: rel
+			});
+			nextFiles[rel] = { sha: templateHash };
+			continue;
+		}
+		if (diskHash === recorded || options.accept) {
+			actions.push({
+				action: "write",
+				relPath: rel,
+				reason: "refresh"
+			});
+			nextFiles[rel] = { sha: templateHash };
+		} else actions.push({
+			action: "skip-diverged",
+			relPath: rel,
+			reason: "edited"
+		});
+	}
+	return {
+		actions,
+		nextInstalled: { files: nextFiles }
+	};
+}
+async function applyPlan(templateDir, targetDir, plan) {
+	for (const action of plan.actions) {
+		if (action.action !== "write") continue;
+		const src = path.join(templateDir, action.relPath);
+		const dst = path.join(targetDir, action.relPath);
+		await fsPromises.mkdir(path.dirname(dst), { recursive: true });
+		await fsPromises.copyFile(src, dst);
+	}
+}
+async function readInstalledFiles(filePath) {
+	try {
+		const raw = await fsPromises.readFile(filePath, "utf-8");
+		const parsed = InstalledFilesSchema.safeParse(JSON.parse(raw));
+		return parsed.success ? parsed.data : null;
+	} catch {
+		return null;
+	}
+}
+async function writeInstalledFiles(filePath, data) {
+	await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+	const tmpPath = `${filePath}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+	await fsPromises.writeFile(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+	await fsPromises.rename(tmpPath, filePath);
+}
+function sliceInstalledUnder(installed, prefix) {
+	if (!installed?.files) return null;
+	const p = `${prefix}/`;
+	const filtered = {};
+	for (const [k, v] of Object.entries(installed.files)) if (k.startsWith(p)) filtered[k.slice(p.length)] = v;
+	return { files: filtered };
+}
+function prefixPlanKeys(plan, prefix) {
+	const p = prefix ? `${prefix}/` : "";
+	return {
+		actions: plan.actions.map((a) => ({
+			...a,
+			relPath: p + a.relPath
+		})),
+		nextInstalled: { files: Object.fromEntries(Object.entries(plan.nextInstalled.files ?? {}).map(([k, v]) => [p + k, v])) }
+	};
+}
+
+//#endregion
+//#region src/shared/workspace.ts
+function getWorkspaceRoot(startDir = process.cwd()) {
+	let curr = startDir;
+	while (curr !== path.parse(curr).root) {
+		if (fs.existsSync(path.join(curr, ".clawmini"))) return curr;
+		if (fs.existsSync(path.join(curr, "package.json")) || fs.existsSync(path.join(curr, ".git"))) return curr;
+		curr = path.dirname(curr);
+	}
+	return startDir;
+}
+function resolveAgentWorkDir(agentId, customDir, startDir = process.cwd()) {
+	const workspaceRoot = getWorkspaceRoot(startDir);
+	let dirPath = workspaceRoot;
+	if (customDir) dirPath = path.resolve(workspaceRoot, customDir);
+	else if (agentId !== "default") dirPath = path.resolve(workspaceRoot, agentId);
+	if (!pathIsInsideDir(dirPath, workspaceRoot, { allowSameDir: true })) throw new Error("Invalid agent directory: resolves outside the workspace.");
+	return dirPath;
+}
+function resolveAgentSkillsDir(agentId, agentData, startDir = process.cwd()) {
+	if (agentData.skillsDir === null) return null;
+	const workDir = resolveAgentWorkDir(agentId, agentData.directory, startDir);
+	return path.resolve(workDir, agentData.skillsDir || ".agents/skills");
+}
+async function ensureAgentWorkDir(agentId, customDir, startDir = process.cwd()) {
+	const dirPath = resolveAgentWorkDir(agentId, customDir, startDir);
+	if (!fs.existsSync(dirPath)) {
+		await fsPromises.mkdir(dirPath, { recursive: true });
+		console.log(`Created agent working directory at ${dirPath}`);
+	}
+	return dirPath;
+}
+function getClawminiDir(startDir = process.cwd()) {
+	return path.join(getWorkspaceRoot(startDir), ".clawmini");
+}
+function getSocketPath(startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "daemon.sock");
+}
+function getSettingsPath(startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "settings.json");
+}
+function getPoliciesPath(startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "policies.json");
+}
+function getChatSettingsPath(chatId, startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "chats", chatId, "settings.json");
+}
+function isValidAgentId(agentId) {
+	if (!agentId || agentId.length === 0) return false;
+	return /^[a-zA-Z0-9_]+(?:-[a-zA-Z0-9_]+)*$/.test(agentId);
+}
+function getAgentDir(agentId, startDir = process.cwd()) {
+	if (!isValidAgentId(agentId)) throw new Error(`Invalid agent ID: ${agentId}`);
+	return path.join(getClawminiDir(startDir), "agents", agentId);
+}
+function getAgentSettingsPath(agentId, startDir = process.cwd()) {
+	return path.join(getAgentDir(agentId, startDir), "settings.json");
+}
+function getInstalledFilesPath(agentId, startDir = process.cwd()) {
+	return path.join(getAgentDir(agentId, startDir), "installed-files.json");
+}
+function getAgentSessionSettingsPath(agentId, sessionId, startDir = process.cwd()) {
+	if (!isValidAgentId(agentId)) throw new Error(`Invalid agent ID: ${agentId}`);
+	return path.join(getClawminiDir(startDir), "agents", agentId, "sessions", sessionId, "settings.json");
+}
+async function readJsonFile(filePath) {
+	try {
+		const data = await fsPromises.readFile(filePath, "utf-8");
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+}
+async function writeJsonFile(filePath, data) {
+	const dir = path.dirname(filePath);
+	await fsPromises.mkdir(dir, { recursive: true });
+	const tmpPath = `${filePath}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+	await fsPromises.writeFile(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+	await fsPromises.rename(tmpPath, filePath);
+}
+async function readChatSettings(chatId, startDir = process.cwd()) {
+	const data = await readJsonFile(getChatSettingsPath(chatId, startDir));
+	if (!data) return null;
+	const parsed = ChatSettingsSchema.safeParse(data);
+	return parsed.success ? parsed.data : null;
+}
+async function writeChatSettings(chatId, data, startDir = process.cwd()) {
+	await writeJsonFile(getChatSettingsPath(chatId, startDir), data);
+}
+const chatSettingsLocks = /* @__PURE__ */ new Map();
+async function updateChatSettings(chatId, updater, startDir = process.cwd()) {
+	const prevLock = chatSettingsLocks.get(chatId) || Promise.resolve();
+	let release;
+	const nextLock = new Promise((resolve) => {
+		release = resolve;
+	});
+	const nextLockPromise = prevLock.catch(() => {}).then(() => nextLock);
+	chatSettingsLocks.set(chatId, nextLockPromise);
+	try {
+		await prevLock;
+		await writeChatSettings(chatId, await updater(await readChatSettings(chatId, startDir) || {}), startDir);
+	} finally {
+		release();
+		if (chatSettingsLocks.get(chatId) === nextLockPromise) chatSettingsLocks.delete(chatId);
+	}
+}
+async function readAgentSessionSettings(agentId, sessionId, startDir = process.cwd()) {
+	const data = await readJsonFile(getAgentSessionSettingsPath(agentId, sessionId, startDir));
+	if (!data) return null;
+	const parsed = AgentSessionSettingsSchema.safeParse(data);
+	return parsed.success ? parsed.data : null;
+}
+async function writeAgentSessionSettings(agentId, sessionId, data, startDir = process.cwd()) {
+	await writeJsonFile(getAgentSessionSettingsPath(agentId, sessionId, startDir), data);
+}
+async function getAgentOverlay(agentId, startDir = process.cwd()) {
+	const filePath = getAgentSettingsPath(agentId, startDir);
+	let dataStr;
+	try {
+		dataStr = await fsPromises.readFile(filePath, "utf-8");
+	} catch (err) {
+		if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") return null;
+		throw err;
+	}
+	let data;
+	try {
+		data = JSON.parse(dataStr);
+	} catch (parseErr) {
+		const message = parseErr instanceof Error ? parseErr.message : String(parseErr);
+		throw new Error(`Invalid JSON in ${filePath}: ${message}`, { cause: parseErr });
+	}
+	const parsed = AgentSchema.safeParse(data);
+	if (!parsed.success) throw new Error(`Invalid schema in ${filePath}: ${parsed.error.message}`);
+	return parsed.data;
+}
+async function readAgentTemplateSettings(templateName, startDir) {
+	let templatePath;
+	try {
+		templatePath = await resolveTemplatePath(templateName, startDir);
+	} catch {
+		return null;
+	}
+	const data = await readJsonFile(path.join(templatePath, "settings.json"));
+	if (!data) return null;
+	const parsed = AgentSchema.safeParse(data);
+	if (!parsed.success) return null;
+	const result = { ...parsed.data };
+	delete result.directory;
+	return result;
+}
+async function getAgent(agentId, startDir = process.cwd()) {
+	const overlay = await getAgentOverlay(agentId, startDir);
+	if (!overlay) return null;
+	if (!overlay.extends) return overlay;
+	const template = await readAgentTemplateSettings(overlay.extends, startDir);
+	if (!template) return overlay;
+	const { env: overlayEnv, subagentEnv: overlaySub, modelShorthands: overlayShorthands, ...overlayRest } = overlay;
+	const { env: templateEnv, subagentEnv: templateSub, modelShorthands: templateShorthands, ...templateRest } = template;
+	const merged = {
+		...templateRest,
+		...overlayRest
+	};
+	const mergedEnv = mergeOneLevel(templateEnv, overlayEnv);
+	if (mergedEnv) merged.env = mergedEnv;
+	const mergedSub = mergeOneLevel(templateSub, overlaySub);
+	if (mergedSub) merged.subagentEnv = mergedSub;
+	const mergedShorthands = mergeOneLevel(templateShorthands, overlayShorthands);
+	if (mergedShorthands) merged.modelShorthands = mergedShorthands;
+	return merged;
+}
+async function writeAgentSettings(agentId, data, startDir = process.cwd()) {
+	await ensureAgentWorkDir(agentId, data.directory, startDir);
+	await writeJsonFile(getAgentSettingsPath(agentId, startDir), data);
+}
+const agentSettingsLocks = /* @__PURE__ */ new Map();
+async function updateAgentOverlay(agentId, updater, startDir = process.cwd()) {
+	const prevLock = agentSettingsLocks.get(agentId) || Promise.resolve();
+	let release;
+	const nextLock = new Promise((resolve) => {
+		release = resolve;
+	});
+	const nextLockPromise = prevLock.catch(() => {}).then(() => nextLock);
+	agentSettingsLocks.set(agentId, nextLockPromise);
+	try {
+		await prevLock;
+		const overlay = await getAgentOverlay(agentId, startDir);
+		if (!overlay) throw new Error(`Agent '${agentId}' has no settings overlay.`);
+		const updated = await updater(overlay);
+		if (updated === null) return false;
+		await writeAgentSettings(agentId, updated, startDir);
+		return true;
+	} finally {
+		release();
+		if (agentSettingsLocks.get(agentId) === nextLockPromise) agentSettingsLocks.delete(agentId);
+	}
+}
+async function listAgents(startDir = process.cwd()) {
+	const agentsDir = path.join(getClawminiDir(startDir), "agents");
+	try {
+		const entries = await fsPromises.readdir(agentsDir, { withFileTypes: true });
+		const agentIds = [];
+		for (const entry of entries) if (entry.isDirectory()) {
+			const settingsPath = path.join(agentsDir, entry.name, "settings.json");
+			try {
+				await fsPromises.access(settingsPath);
+				agentIds.push(entry.name);
+			} catch {}
+		}
+		return agentIds;
+	} catch {
+		return [];
+	}
+}
+async function deleteAgent(agentId, startDir = process.cwd()) {
+	const dir = getAgentDir(agentId, startDir);
+	const agentsDir = path.join(getClawminiDir(startDir), "agents");
+	if (!pathIsInsideDir(dir, agentsDir)) throw new Error(`Security Error: Cannot delete agent directory outside of ${agentsDir}`);
+	try {
+		await fsPromises.rm(dir, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+}
+async function isDirectory(dirPath) {
+	try {
+		return (await fsPromises.stat(dirPath)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function resolveTemplatePathBase(templateName, startDir = process.cwd()) {
+	const workspaceRoot = getWorkspaceRoot(startDir);
+	const localTemplatePath = path.join(workspaceRoot, ".clawmini", "templates", templateName);
+	if (await isDirectory(localTemplatePath)) return localTemplatePath;
+	let currentDir = path.dirname(fileURLToPath(import.meta.url));
+	while (currentDir !== path.parse(currentDir).root && !fs.existsSync(path.join(currentDir, "package.json"))) currentDir = path.dirname(currentDir);
+	const searchPath = path.join(currentDir, "templates", templateName);
+	if (await isDirectory(searchPath)) return searchPath;
+	throw new Error(`Template not found: ${templateName} (searched local: ${localTemplatePath}, built-in: ${searchPath})`);
+}
+async function resolveTemplatePath(templateName, startDir = process.cwd()) {
+	if (templateName === "environments" || templateName.startsWith("environments/")) throw new Error(`Template not found: ${templateName}`);
+	return resolveTemplatePathBase(templateName, startDir);
+}
+async function resolveEnvironmentTemplatePath(templateName, startDir = process.cwd()) {
+	return resolveTemplatePathBase(path.join("environments", templateName), startDir);
+}
+async function resolveSkillsTemplatePath(startDir = process.cwd()) {
+	return resolveTemplatePathBase("skills", startDir);
+}
+async function copyTemplateBase(templatePath, targetDir, allowMissingDir = false, overwrite = false) {
+	try {
+		if ((await fsPromises.readdir(targetDir)).length > 0 && !overwrite) throw new Error(`Target directory is not empty: ${targetDir}`);
+	} catch (err) {
+		if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") if (allowMissingDir) await fsPromises.mkdir(targetDir, { recursive: true });
+		else throw new Error(`Target directory does not exist: ${targetDir}`, { cause: err });
+		else throw err;
+	}
+	const rootTemplateJson = path.resolve(templatePath, "template.json");
+	await fsPromises.cp(templatePath, targetDir, {
+		recursive: true,
+		force: true,
+		filter: (src) => path.resolve(src) !== rootTemplateJson
+	});
+}
+async function copyTemplate(templateName, targetDir, startDir = process.cwd(), opts = {}) {
+	await copyTemplateBase(await resolveTemplatePath(templateName, startDir), targetDir, false, opts.force ?? false);
+}
+async function resolveTargetAgentSkillsDir(agentId, startDir = process.cwd()) {
+	const agentDir = getAgentDir(agentId, startDir);
+	try {
+		if (!(await fsPromises.stat(agentDir)).isDirectory()) throw new Error(`Agent not found: ${agentId}`);
+	} catch (err) {
+		if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") throw new Error(`Agent not found: ${agentId}`, { cause: err });
+		throw err;
+	}
+	let agentData = null;
+	try {
+		agentData = await getAgent(agentId, startDir);
+	} catch {}
+	if (agentData) return resolveAgentSkillsDir(agentId, agentData, startDir);
+	const workDir = resolveAgentWorkDir(agentId, void 0, startDir);
+	return path.resolve(workDir, ".agents/skills");
+}
+async function copyEnvironmentTemplate(templateName, targetDir, startDir = process.cwd()) {
+	await copyTemplateBase(await resolveEnvironmentTemplatePath(templateName, startDir), targetDir, true);
+}
+async function copyAgentSkills(agentId, startDir = process.cwd(), overwrite = false) {
+	const targetDir = await resolveTargetAgentSkillsDir(agentId, startDir);
+	if (targetDir === null) throw new Error(`Agent '${agentId}' has skills disabled (skillsDir is null).`);
+	await copyTemplateBase(await resolveSkillsTemplatePath(startDir), targetDir, true, overwrite);
+}
+async function copyAgentSkill(agentId, skillName, startDir = process.cwd(), overwrite = false) {
+	const targetDir = await resolveTargetAgentSkillsDir(agentId, startDir);
+	if (targetDir === null) throw new Error(`Agent '${agentId}' has skills disabled (skillsDir is null).`);
+	const templatePath = await resolveSkillsTemplatePath(startDir);
+	const specificSkillPath = path.join(templatePath, skillName);
+	try {
+		if (!(await fsPromises.stat(specificSkillPath)).isDirectory()) throw new Error(`Skill not found: ${skillName}`);
+	} catch (err) {
+		if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") throw new Error(`Skill not found: ${skillName}`, { cause: err });
+		throw err;
+	}
+	await copyTemplateBase(specificSkillPath, path.join(targetDir, skillName), true, overwrite);
+}
+async function collectTemplateCollisions(templateDir, targetDir) {
+	const templateFiles = await walkTemplateFiles(templateDir);
+	const collisions = [];
+	for (const rel of templateFiles) try {
+		await fsPromises.access(path.join(targetDir, rel));
+		collisions.push(rel);
+	} catch {}
+	return collisions;
+}
+function formatCollisionError(collisions) {
+	return `Target directory has existing files that the template would overwrite:\n${collisions.slice(0, 5).map((p) => `  ${p}`).join("\n")}${collisions.length > 5 ? `\n  ... and ${collisions.length - 5} more` : ""}\nRe-run with --force to overwrite.`;
+}
+async function applyTemplateToAgent(agentId, templateName, overrides, startDir = process.cwd(), opts = {}) {
+	const agentWorkDir = resolveAgentWorkDir(agentId, overrides.directory, startDir);
+	if (opts.fork) {
+		await copyTemplate(templateName, agentWorkDir, startDir, { force: opts.force ?? false });
+		const settingsPath = path.join(agentWorkDir, "settings.json");
+		const manifestPath = path.join(agentWorkDir, "template.json");
+		try {
+			const rawSettings = await fsPromises.readFile(settingsPath, "utf-8");
+			const parsedSettings = JSON.parse(rawSettings);
+			const validation = AgentSchema.safeParse(parsedSettings);
+			if (validation.success) {
+				const templateData = validation.data;
+				if (templateData.directory) {
+					console.warn(`Warning: Ignoring 'directory' field from template settings.json. Using default or provided directory.`);
+					delete templateData.directory;
+				}
+				const mergedEnv = {
+					...templateData.env || {},
+					...overrides.env || {}
+				};
+				const mergedData = {
+					...templateData,
+					...overrides
+				};
+				delete mergedData.extends;
+				if (Object.keys(mergedEnv).length > 0) mergedData.env = mergedEnv;
+				await writeAgentSettings(agentId, mergedData, startDir);
+			}
+		} catch {}
+		for (const tmp of [settingsPath, manifestPath]) try {
+			await fsPromises.rm(tmp);
+		} catch {}
+		return;
+	}
+	const templateDir = await resolveTemplatePath(templateName, startDir);
+	const manifest = await readTemplateManifest(templateDir);
+	await fsPromises.mkdir(agentWorkDir, { recursive: true });
+	if (!opts.force) {
+		const collisions = await collectTemplateCollisions(templateDir, agentWorkDir);
+		if (collisions.length > 0) throw new Error(formatCollisionError(collisions));
+	}
+	const plan = await planRefresh(templateDir, agentWorkDir, manifest, null, {
+		defaultMode: "seed-once",
+		firstInstall: true
+	});
+	await applyPlan(templateDir, agentWorkDir, plan);
+	await writeInstalledFiles(getInstalledFilesPath(agentId, startDir), plan.nextInstalled);
+	await writeAgentSettings(agentId, {
+		extends: templateName,
+		...overrides
+	}, startDir);
+}
+async function refreshAgentTemplate(agentId, agent, startDir = process.cwd(), opts = {}) {
+	if (!agent.extends) return null;
+	const templateDir = await resolveTemplatePath(agent.extends, startDir);
+	const agentWorkDir = resolveAgentWorkDir(agentId, agent.directory, startDir);
+	const manifest = await readTemplateManifest(templateDir);
+	const installedPath = getInstalledFilesPath(agentId, startDir);
+	const plan = await planRefresh(templateDir, agentWorkDir, manifest, await readInstalledFiles(installedPath), {
+		defaultMode: "seed-once",
+		...opts.accept === void 0 ? {} : { accept: opts.accept }
+	});
+	if (opts.dryRun) return plan;
+	await applyPlan(templateDir, agentWorkDir, plan);
+	await writeInstalledFiles(installedPath, plan.nextInstalled);
+	return plan;
+}
+async function refreshAgentSkills(agentId, agent, startDir = process.cwd(), opts = {}) {
+	const skillsTargetDir = resolveAgentSkillsDir(agentId, agent, startDir);
+	if (skillsTargetDir === null) return null;
+	let skillsTemplateRoot;
+	try {
+		skillsTemplateRoot = await resolveSkillsTemplatePath(startDir);
+	} catch {
+		return null;
+	}
+	const agentWorkDir = resolveAgentWorkDir(agentId, agent.directory, startDir);
+	const prefixRel = path.relative(agentWorkDir, skillsTargetDir).split(path.sep).join("/");
+	let skillDirs;
+	try {
+		skillDirs = await fsPromises.readdir(skillsTemplateRoot, { withFileTypes: true });
+	} catch {
+		return null;
+	}
+	const installedPath = getInstalledFilesPath(agentId, startDir);
+	let installed = await readInstalledFiles(installedPath);
+	const allActions = [];
+	for (const entry of skillDirs) {
+		if (!entry.isDirectory()) continue;
+		const skillName = entry.name;
+		const skillTemplateDir = path.join(skillsTemplateRoot, skillName);
+		const skillTargetDir = path.join(skillsTargetDir, skillName);
+		const keyPrefix = `${prefixRel}/${skillName}`;
+		const plan = await planRefresh(skillTemplateDir, skillTargetDir, await readTemplateManifest(skillTemplateDir), sliceInstalledUnder(installed, keyPrefix), {
+			defaultMode: "track",
+			...opts.firstInstall ? { firstInstall: true } : {},
+			...opts.accept === void 0 ? {} : { accept: opts.accept }
+		});
+		const prefixed = prefixPlanKeys(plan, keyPrefix);
+		allActions.push(...prefixed.actions);
+		if (!opts.dryRun) {
+			await applyPlan(skillTemplateDir, skillTargetDir, plan);
+			installed = { files: {
+				...installed?.files ?? {},
+				...prefixed.nextInstalled.files ?? {}
+			} };
+		}
+	}
+	if (!opts.dryRun && installed) await writeInstalledFiles(installedPath, installed);
+	return {
+		actions: allActions,
+		nextInstalled: installed ?? { files: {} }
+	};
+}
+function formatPlanActions(plan, opts = {}) {
+	const prefix = opts.prefix ?? (opts.agentId ? `[${opts.agentId}] ` : "");
+	return plan.actions.map((action) => {
+		switch (action.action) {
+			case "write": return `${prefix}${action.reason === "new" ? "install" : "refresh"}  ${action.relPath}`;
+			case "skip-unchanged": return `${prefix}unchanged ${action.relPath}`;
+			case "skip-seed-once": return `${prefix}seed-once ${action.relPath}`;
+			case "skip-diverged": return `${prefix}diverged ${action.relPath} (${action.reason})`;
+			case "skip-absent-from-template": return `${prefix}absent   ${action.relPath}`;
+		}
+	});
+}
+async function readSettings(startDir = process.cwd()) {
+	const data = await readJsonFile(getSettingsPath(startDir));
+	if (!data) return null;
+	const parsed = SettingsSchema.safeParse(data);
+	return parsed.success ? parsed.data : null;
+}
+async function writeSettings(data, startDir = process.cwd()) {
+	await writeJsonFile(getSettingsPath(startDir), data);
+}
+async function readPoliciesFile(startDir = process.cwd()) {
+	const data = await readJsonFile(getPoliciesPath(startDir));
+	if (!data) return null;
+	if (data.policies && typeof data.policies === "object") return data;
+	return null;
+}
+function resolvePolicies(file, clawminiDir) {
+	if (!file) return null;
+	const workspaceRoot = path.dirname(clawminiDir);
+	const resolveCommand = (definition) => {
+		if (!definition.command.startsWith("./") && !definition.command.startsWith("../")) return definition;
+		return {
+			...definition,
+			command: path.resolve(workspaceRoot, definition.command)
+		};
+	};
+	const resolved = {};
+	for (const [name, value] of Object.entries(file.policies)) if (value !== false) resolved[name] = resolveCommand(value);
+	for (const [name, definition] of Object.entries(BUILTIN_POLICIES)) {
+		if (name in file.policies) continue;
+		const scriptPath = path.join(clawminiDir, "policy-scripts", `${name}.js`);
+		if (!fs.existsSync(scriptPath)) continue;
+		resolved[name] = resolveCommand(definition);
+	}
+	return { policies: resolved };
+}
+async function readBasePolicies(startDir = process.cwd()) {
+	return resolvePolicies(await readPoliciesFile(startDir), getClawminiDir(startDir));
+}
+async function readEnvironmentPoliciesForPath(targetPath, startDir = process.cwd()) {
+	const envInfo = await getActiveEnvironmentInfo(targetPath, startDir);
+	if (!envInfo) return {};
+	const envConfig = await readEnvironment(envInfo.name, startDir);
+	if (!envConfig?.policies) return {};
+	const searchDirs = await getEnvironmentSearchDirs(envInfo.name, startDir);
+	const resolved = {};
+	for (const [name, definition] of Object.entries(envConfig.policies)) {
+		const command = definition.command.startsWith("./") || definition.command.startsWith("../") ? resolveLayeredRelativePath(definition.command, searchDirs) : definition.command;
+		const entries = Object.entries({
+			...definition,
+			command
+		}).filter(([, value]) => value !== void 0);
+		resolved[name] = Object.fromEntries(entries);
+	}
+	return resolved;
+}
+async function readPoliciesForPath(targetPath, startDir = process.cwd()) {
+	const base = await readBasePolicies(startDir);
+	const envPolicies = await readEnvironmentPoliciesForPath(targetPath, startDir);
+	if (Object.keys(envPolicies).length === 0) return base;
+	return { policies: {
+		...base?.policies || {},
+		...envPolicies
+	} };
+}
+function getEnvironmentPath(name, startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "environments", name);
+}
+function mergeOneLevel(base, overlay) {
+	if (!base && !overlay) return void 0;
+	return {
+		...base || {},
+		...overlay || {}
+	};
+}
+async function readEnvironmentRaw(name, startDir) {
+	const local = await readJsonFile(path.join(getEnvironmentPath(name, startDir), "env.json"));
+	if (local) {
+		const parsed = EnvironmentSchema.safeParse(local);
+		if (parsed.success) return parsed.data;
+	}
+	try {
+		const builtinDir = await resolveEnvironmentTemplatePath(name, startDir);
+		const builtinData = await readJsonFile(path.join(builtinDir, "env.json"));
+		if (builtinData) {
+			const parsed = EnvironmentSchema.safeParse(builtinData);
+			if (parsed.success) return parsed.data;
+		}
+	} catch {}
+	return null;
+}
+async function readBuiltinEnvironment(name, startDir) {
+	let builtinDir;
+	try {
+		builtinDir = await resolveEnvironmentTemplatePath(name, startDir);
+	} catch {
+		return null;
+	}
+	const data = await readJsonFile(path.join(builtinDir, "env.json"));
+	if (!data) return null;
+	const parsed = EnvironmentSchema.safeParse(data);
+	return parsed.success ? parsed.data : null;
+}
+async function resolveEnvironmentWithSeen(name, startDir, seen) {
+	if (seen.has(name)) throw new Error(`Environment extends cycle detected at '${name}'`);
+	seen.add(name);
+	const local = await readEnvironmentRaw(name, startDir);
+	if (!local || !local.extends) return local;
+	const parent = local.extends === name ? await readBuiltinEnvironment(name, startDir) : await resolveEnvironmentWithSeen(local.extends, startDir, seen);
+	if (!parent) return local;
+	const { env: localEnv, policies: localPolicies, ...localRestRaw } = local;
+	delete localRestRaw.extends;
+	const { env: parentEnv, policies: parentPolicies, ...parentRest } = parent;
+	const merged = {
+		...parentRest,
+		...localRestRaw
+	};
+	const mergedEnv = mergeOneLevel(parentEnv, localEnv);
+	if (mergedEnv) merged.env = mergedEnv;
+	const mergedPolicies = mergeOneLevel(parentPolicies, localPolicies);
+	if (mergedPolicies) merged.policies = mergedPolicies;
+	return merged;
+}
+async function readEnvironment(name, startDir = process.cwd()) {
+	return resolveEnvironmentWithSeen(name, startDir, /* @__PURE__ */ new Set());
+}
+async function getEnvironmentSearchDirs(name, startDir = process.cwd()) {
+	const dirs = [];
+	const seen = /* @__PURE__ */ new Set();
+	let currentName = name;
+	while (currentName && !seen.has(currentName)) {
+		seen.add(currentName);
+		const overlayDir = getEnvironmentPath(currentName, startDir);
+		if (fs.existsSync(overlayDir) && !dirs.includes(overlayDir)) dirs.push(overlayDir);
+		let builtinDir = null;
+		try {
+			builtinDir = await resolveEnvironmentTemplatePath(currentName, startDir);
+		} catch {}
+		if (builtinDir && !dirs.includes(builtinDir)) dirs.push(builtinDir);
+		const overlayData = await readJsonFile(path.join(overlayDir, "env.json"));
+		const overlayParsed = overlayData ? EnvironmentSchema.safeParse(overlayData) : null;
+		if (overlayParsed?.success && overlayParsed.data.extends) {
+			currentName = overlayParsed.data.extends;
+			continue;
+		}
+		if (builtinDir) {
+			const builtinData = await readJsonFile(path.join(builtinDir, "env.json"));
+			const builtinParsed = builtinData ? EnvironmentSchema.safeParse(builtinData) : null;
+			if (builtinParsed?.success && builtinParsed.data.extends) {
+				currentName = builtinParsed.data.extends;
+				continue;
+			}
+		}
+		currentName = void 0;
+	}
+	return dirs;
+}
+function substituteLayeredEnvDir(input, searchDirs) {
+	if (searchDirs.length === 0) return input;
+	return input.replace(/\{ENV_DIR\}(?:\/([^\s'"}]+))?/g, (_match, sub) => {
+		if (!sub) return searchDirs[0];
+		for (const dir of searchDirs) {
+			const candidate = path.resolve(dir, sub);
+			if (fs.existsSync(candidate)) return candidate;
+		}
+		return path.resolve(searchDirs[0], sub);
+	});
+}
+function resolveLayeredRelativePath(relPath, searchDirs) {
+	if (searchDirs.length === 0) return relPath;
+	for (const dir of searchDirs) {
+		const candidate = path.resolve(dir, relPath);
+		if (fs.existsSync(candidate)) return candidate;
+	}
+	return path.resolve(searchDirs[0], relPath);
+}
+async function getActiveEnvironmentInfo(targetPath, startDir = process.cwd()) {
+	const settings = await readSettings(startDir);
+	if (!settings?.environments) return null;
+	const workspaceRoot = getWorkspaceRoot(startDir);
+	const resolvedTarget = path.resolve(workspaceRoot, targetPath);
+	let bestMatch = null;
+	let maxDepth = -1;
+	for (const [envPath, envName] of Object.entries(settings.environments)) {
+		const resolvedEnvPath = path.resolve(workspaceRoot, envPath);
+		if (pathIsInsideDir(resolvedTarget, resolvedEnvPath, { allowSameDir: true })) {
+			const depth = resolvedEnvPath.split(path.sep).length;
+			if (depth > maxDepth) {
+				maxDepth = depth;
+				bestMatch = {
+					name: envName,
+					targetPath: resolvedEnvPath
+				};
+			}
+		}
+	}
+	return bestMatch;
+}
+async function enableEnvironment(name, targetPath = "./", startDir = process.cwd(), opts = {}) {
+	const targetDir = getEnvironmentPath(name, startDir);
+	if (!fs.existsSync(targetDir)) if (opts.fork) {
+		await copyEnvironmentTemplate(name, targetDir, startDir);
+		console.log(`Forked environment template '${name}'.`);
+	} else {
+		await resolveEnvironmentTemplatePath(name, startDir);
+		await fsPromises.mkdir(targetDir, { recursive: true });
+		await fsPromises.writeFile(path.join(targetDir, "env.json"), JSON.stringify({ extends: name }, null, 2), "utf-8");
+		console.log(`Enabled environment overlay '${name}' (extends built-in).`);
+	}
+	else console.log(`Environment '${name}' already exists in workspace.`);
+	const settings = await readSettings(startDir) || { chats: { defaultId: "" } };
+	const environments = settings.environments || {};
+	environments[targetPath] = name;
+	settings.environments = environments;
+	await writeSettings(settings, startDir);
+	console.log(`Enabled environment '${name}' for path '${targetPath}'.`);
+	const envConfig = await readEnvironment(name, startDir);
+	if (envConfig?.init) {
+		const workspaceRoot = getWorkspaceRoot(startDir);
+		const affectedDir = path.resolve(workspaceRoot, targetPath);
+		console.log(`Executing init command for environment '${name}': ${envConfig.init}`);
+		execSync(envConfig.init, {
+			cwd: affectedDir,
+			stdio: "inherit"
+		});
+	}
+}
+
+//#endregion
+export { updateChatSettings as A, readSettings as C, resolveSkillsTemplatePath as D, resolveAgentWorkDir as E, pathIsInsideDir as F, CronJobSchema as I, SettingsSchema as L, writeAgentSettings as M, writeChatSettings as N, substituteLayeredEnvDir as O, writeSettings as P, BUILTIN_POLICIES as R, readPoliciesForPath as S, refreshAgentTemplate as T, isValidAgentId as _, enableEnvironment as a, readChatSettings as b, getAgent as c, getEnvironmentPath as d, getEnvironmentSearchDirs as f, getWorkspaceRoot as g, getSocketPath as h, deleteAgent as i, writeAgentSessionSettings as j, updateAgentOverlay as k, getAgentOverlay as l, getSettingsPath as m, copyAgentSkill as n, formatPlanActions as o, getPoliciesPath as p, copyAgentSkills as r, getActiveEnvironmentInfo as s, applyTemplateToAgent as t, getClawminiDir as u, listAgents as v, refreshAgentSkills as w, readEnvironment as x, readAgentSessionSettings as y };
+//# sourceMappingURL=workspace-oWmVh5mi.mjs.map