unplugin-devpilot 0.0.4 → 0.0.6

package/dist/{src-AEXLBOF9.mjs → src-BHdaOKo9.mjs}

@@ -1,4 +1,4 @@
-import { r as resolveModule } from "./plugin-B1Afr0m3.mjs";
+import { n as resolveModule, r as defineMcpToolRegister } from "./plugin-4eB8Zx4B.mjs";
 import { createRequire } from "node:module";
 import process$1 from "node:process";
 import { createUnplugin } from "unplugin";
@@ -19799,7 +19799,7 @@ var StreamableHTTPServerTransport = class {
 
 //#endregion
 //#region package.json
-var version = "0.0.4";
+var version = "0.0.6";
 
 //#endregion
 //#region ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/compat/util/uniqueId.mjs
@@ -19960,6 +19960,590 @@ var ClientManager = class {
 };
 const clientManager = new ClientManager();
 
+//#endregion
+//#region src/core/builtin-tools.ts
+const builtinToolRegisters = [
+	defineMcpToolRegister("list_clients", {
+		title: "List Clients",
+		description: "List all connected browser instances with optional filtering by URL, title, or clientId",
+		inputSchema: {
+			activeOnly: boolean().optional().default(true).describe("Only list active clients"),
+			urlPattern: string().optional().describe("Filter clients by URL pattern (substring match, case-insensitive)"),
+			titlePattern: string().optional().describe("Filter clients by page title pattern (substring match, case-insensitive)"),
+			clientId: string().optional().describe("Filter by specific client ID"),
+			groupByUrl: boolean().optional().default(false).describe("Group results by URL for easier identification")
+		}
+	}, async (params) => {
+		const filter = {
+			activeOnly: params.activeOnly,
+			urlPattern: params.urlPattern,
+			titlePattern: params.titlePattern,
+			clientId: params.clientId
+		};
+		let clients;
+		let grouped;
+		if (params.groupByUrl) {
+			grouped = clientManager.getClientsByUrl();
+			clients = Object.values(grouped).flat();
+		} else clients = clientManager.findClients(filter);
+		const result = {
+			clients,
+			total: clients.length
+		};
+		if (params.groupByUrl) result.grouped = grouped;
+		if (clients.length === 0) {
+			result.suggestions = [
+				"No clients found. Make sure the browser has the devpilot extension loaded.",
+				"Try refreshing the browser page to reconnect.",
+				"Use activeOnly=false to see recently disconnected clients."
+			];
+			if (params.urlPattern) result.suggestions.push(`No clients match URL pattern: "${params.urlPattern}"`);
+		}
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	}),
+	defineMcpToolRegister("get_pending_tasks", {
+		title: "Get Pending Tasks",
+		description: "Get pending tasks submitted from browser",
+		inputSchema: { clearAfterFetch: boolean().optional().default(true).describe("Clear tasks after fetching") }
+	}, async (params) => {
+		const tasks = clientManager.getPendingTasks(params.clearAfterFetch);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				hasTasks: tasks.length > 0,
+				tasks,
+				message: tasks.length > 0 ? `Found ${tasks.length} pending task(s)` : "No pending tasks"
+			}, null, 2)
+		}] };
+	}),
+	defineMcpToolRegister("get_task_history", {
+		title: "Get Task History",
+		description: "Get history of tasks (including completed and failed tasks). Useful for task recovery after page refresh.",
+		inputSchema: {
+			clientId: string().optional().describe("Filter tasks by client ID"),
+			status: _enum([
+				"pending",
+				"in_progress",
+				"completed",
+				"failed"
+			]).optional().describe("Filter by task status"),
+			limit: number().optional().default(50).describe("Maximum number of tasks to return")
+		}
+	}, async (params) => {
+		const history = clientManager.getTaskHistory({
+			clientId: params.clientId,
+			status: params.status,
+			limit: params.limit
+		});
+		const result = {
+			history,
+			total: history.length,
+			query: params
+		};
+		if (history.length === 0) {
+			result.message = "No task history found.";
+			if (params.clientId) result.suggestions = [`No tasks found for client "${params.clientId}".`, "Try without clientId filter to see all tasks."];
+		}
+		result.groupedByStatus = history.reduce((acc, task) => {
+			acc[task.status] = (acc[task.status] || 0) + 1;
+			return acc;
+		}, {});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	})
+];
+function getBuiltinTools() {
+	return builtinToolRegisters.map((r) => r());
+}
+function getBuiltinToolNames() {
+	return builtinToolRegisters.map((r) => r().name);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/destr@2.0.5/node_modules/destr/dist/index.mjs
+const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
+const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+function jsonParseTransform(key, value) {
+	if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
+		warnKeyDropped(key);
+		return;
+	}
+	return value;
+}
+function warnKeyDropped(key) {
+	console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
+}
+function destr(value, options = {}) {
+	if (typeof value !== "string") return value;
+	if (value[0] === "\"" && value[value.length - 1] === "\"" && value.indexOf("\\") === -1) return value.slice(1, -1);
+	const _value = value.trim();
+	if (_value.length <= 9) switch (_value.toLowerCase()) {
+		case "true": return true;
+		case "false": return false;
+		case "undefined": return;
+		case "null": return null;
+		case "nan": return NaN;
+		case "infinity": return Number.POSITIVE_INFINITY;
+		case "-infinity": return Number.NEGATIVE_INFINITY;
+	}
+	if (!JsonSigRx.test(value)) {
+		if (options.strict) throw new SyntaxError("[destr] Invalid JSON");
+		return value;
+	}
+	try {
+		if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
+			if (options.strict) throw new Error("[destr] Possible prototype pollution");
+			return JSON.parse(value, jsonParseTransform);
+		}
+		return JSON.parse(value);
+	} catch (error) {
+		if (options.strict) throw error;
+		return value;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/unstorage@1.17.4/node_modules/unstorage/dist/shared/unstorage.zVDD2mZo.mjs
+function wrapToPromise(value) {
+	if (!value || typeof value.then !== "function") return Promise.resolve(value);
+	return value;
+}
+function asyncCall(function_, ...arguments_) {
+	try {
+		return wrapToPromise(function_(...arguments_));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+function isPrimitive(value) {
+	const type = typeof value;
+	return value === null || type !== "object" && type !== "function";
+}
+function isPureObject(value) {
+	const proto = Object.getPrototypeOf(value);
+	return !proto || proto.isPrototypeOf(Object);
+}
+function stringify(value) {
+	if (isPrimitive(value)) return String(value);
+	if (isPureObject(value) || Array.isArray(value)) return JSON.stringify(value);
+	if (typeof value.toJSON === "function") return stringify(value.toJSON());
+	throw new Error("[unstorage] Cannot stringify value!");
+}
+const BASE64_PREFIX = "base64:";
+function serializeRaw(value) {
+	if (typeof value === "string") return value;
+	return BASE64_PREFIX + base64Encode(value);
+}
+function deserializeRaw(value) {
+	if (typeof value !== "string") return value;
+	if (!value.startsWith(BASE64_PREFIX)) return value;
+	return base64Decode(value.slice(7));
+}
+function base64Decode(input) {
+	if (globalThis.Buffer) return Buffer.from(input, "base64");
+	return Uint8Array.from(globalThis.atob(input), (c) => c.codePointAt(0));
+}
+function base64Encode(input) {
+	if (globalThis.Buffer) return Buffer.from(input).toString("base64");
+	return globalThis.btoa(String.fromCodePoint(...input));
+}
+const storageKeyProperties = [
+	"has",
+	"hasItem",
+	"get",
+	"getItem",
+	"getItemRaw",
+	"set",
+	"setItem",
+	"setItemRaw",
+	"del",
+	"remove",
+	"removeItem",
+	"getMeta",
+	"setMeta",
+	"removeMeta",
+	"getKeys",
+	"clear",
+	"mount",
+	"unmount"
+];
+function prefixStorage(storage, base) {
+	base = normalizeBaseKey(base);
+	if (!base) return storage;
+	const nsStorage = { ...storage };
+	for (const property of storageKeyProperties) nsStorage[property] = (key = "", ...args) => storage[property](base + key, ...args);
+	nsStorage.getKeys = (key = "", ...arguments_) => storage.getKeys(base + key, ...arguments_).then((keys) => keys.map((key2) => key2.slice(base.length)));
+	nsStorage.keys = nsStorage.getKeys;
+	nsStorage.getItems = async (items, commonOptions) => {
+		const prefixedItems = items.map((item) => typeof item === "string" ? base + item : {
+			...item,
+			key: base + item.key
+		});
+		return (await storage.getItems(prefixedItems, commonOptions)).map((entry) => ({
+			key: entry.key.slice(base.length),
+			value: entry.value
+		}));
+	};
+	nsStorage.setItems = async (items, commonOptions) => {
+		const prefixedItems = items.map((item) => ({
+			key: base + item.key,
+			value: item.value,
+			options: item.options
+		}));
+		return storage.setItems(prefixedItems, commonOptions);
+	};
+	return nsStorage;
+}
+function normalizeKey(key) {
+	if (!key) return "";
+	return key.split("?")[0]?.replace(/[/\\]/g, ":").replace(/:+/g, ":").replace(/^:|:$/g, "") || "";
+}
+function joinKeys(...keys) {
+	return normalizeKey(keys.join(":"));
+}
+function normalizeBaseKey(base) {
+	base = normalizeKey(base);
+	return base ? base + ":" : "";
+}
+function filterKeyByDepth(key, depth) {
+	if (depth === void 0) return true;
+	let substrCount = 0;
+	let index = key.indexOf(":");
+	while (index > -1) {
+		substrCount++;
+		index = key.indexOf(":", index + 1);
+	}
+	return substrCount <= depth;
+}
+function filterKeyByBase(key, base) {
+	if (base) return key.startsWith(base) && key[key.length - 1] !== "$";
+	return key[key.length - 1] !== "$";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/unstorage@1.17.4/node_modules/unstorage/dist/index.mjs
+function defineDriver(factory) {
+	return factory;
+}
+const DRIVER_NAME = "memory";
+const memory = defineDriver(() => {
+	const data = /* @__PURE__ */ new Map();
+	return {
+		name: DRIVER_NAME,
+		getInstance: () => data,
+		hasItem(key) {
+			return data.has(key);
+		},
+		getItem(key) {
+			return data.get(key) ?? null;
+		},
+		getItemRaw(key) {
+			return data.get(key) ?? null;
+		},
+		setItem(key, value) {
+			data.set(key, value);
+		},
+		setItemRaw(key, value) {
+			data.set(key, value);
+		},
+		removeItem(key) {
+			data.delete(key);
+		},
+		getKeys() {
+			return [...data.keys()];
+		},
+		clear() {
+			data.clear();
+		},
+		dispose() {
+			data.clear();
+		}
+	};
+});
+function createStorage(options = {}) {
+	const context = {
+		mounts: { "": options.driver || memory() },
+		mountpoints: [""],
+		watching: false,
+		watchListeners: [],
+		unwatch: {}
+	};
+	const getMount = (key) => {
+		for (const base of context.mountpoints) if (key.startsWith(base)) return {
+			base,
+			relativeKey: key.slice(base.length),
+			driver: context.mounts[base]
+		};
+		return {
+			base: "",
+			relativeKey: key,
+			driver: context.mounts[""]
+		};
+	};
+	const getMounts = (base, includeParent) => {
+		return context.mountpoints.filter((mountpoint) => mountpoint.startsWith(base) || includeParent && base.startsWith(mountpoint)).map((mountpoint) => ({
+			relativeBase: base.length > mountpoint.length ? base.slice(mountpoint.length) : void 0,
+			mountpoint,
+			driver: context.mounts[mountpoint]
+		}));
+	};
+	const onChange = (event, key) => {
+		if (!context.watching) return;
+		key = normalizeKey(key);
+		for (const listener of context.watchListeners) listener(event, key);
+	};
+	const startWatch = async () => {
+		if (context.watching) return;
+		context.watching = true;
+		for (const mountpoint in context.mounts) context.unwatch[mountpoint] = await watch(context.mounts[mountpoint], onChange, mountpoint);
+	};
+	const stopWatch = async () => {
+		if (!context.watching) return;
+		for (const mountpoint in context.unwatch) await context.unwatch[mountpoint]();
+		context.unwatch = {};
+		context.watching = false;
+	};
+	const runBatch = (items, commonOptions, cb) => {
+		const batches = /* @__PURE__ */ new Map();
+		const getBatch = (mount) => {
+			let batch = batches.get(mount.base);
+			if (!batch) {
+				batch = {
+					driver: mount.driver,
+					base: mount.base,
+					items: []
+				};
+				batches.set(mount.base, batch);
+			}
+			return batch;
+		};
+		for (const item of items) {
+			const isStringItem = typeof item === "string";
+			const key = normalizeKey(isStringItem ? item : item.key);
+			const value = isStringItem ? void 0 : item.value;
+			const options2 = isStringItem || !item.options ? commonOptions : {
+				...commonOptions,
+				...item.options
+			};
+			const mount = getMount(key);
+			getBatch(mount).items.push({
+				key,
+				value,
+				relativeKey: mount.relativeKey,
+				options: options2
+			});
+		}
+		return Promise.all([...batches.values()].map((batch) => cb(batch))).then((r) => r.flat());
+	};
+	const storage = {
+		hasItem(key, opts = {}) {
+			key = normalizeKey(key);
+			const { relativeKey, driver } = getMount(key);
+			return asyncCall(driver.hasItem, relativeKey, opts);
+		},
+		getItem(key, opts = {}) {
+			key = normalizeKey(key);
+			const { relativeKey, driver } = getMount(key);
+			return asyncCall(driver.getItem, relativeKey, opts).then((value) => destr(value));
+		},
+		getItems(items, commonOptions = {}) {
+			return runBatch(items, commonOptions, (batch) => {
+				if (batch.driver.getItems) return asyncCall(batch.driver.getItems, batch.items.map((item) => ({
+					key: item.relativeKey,
+					options: item.options
+				})), commonOptions).then((r) => r.map((item) => ({
+					key: joinKeys(batch.base, item.key),
+					value: destr(item.value)
+				})));
+				return Promise.all(batch.items.map((item) => {
+					return asyncCall(batch.driver.getItem, item.relativeKey, item.options).then((value) => ({
+						key: item.key,
+						value: destr(value)
+					}));
+				}));
+			});
+		},
+		getItemRaw(key, opts = {}) {
+			key = normalizeKey(key);
+			const { relativeKey, driver } = getMount(key);
+			if (driver.getItemRaw) return asyncCall(driver.getItemRaw, relativeKey, opts);
+			return asyncCall(driver.getItem, relativeKey, opts).then((value) => deserializeRaw(value));
+		},
+		async setItem(key, value, opts = {}) {
+			if (value === void 0) return storage.removeItem(key);
+			key = normalizeKey(key);
+			const { relativeKey, driver } = getMount(key);
+			if (!driver.setItem) return;
+			await asyncCall(driver.setItem, relativeKey, stringify(value), opts);
+			if (!driver.watch) onChange("update", key);
+		},
+		async setItems(items, commonOptions) {
+			await runBatch(items, commonOptions, async (batch) => {
+				if (batch.driver.setItems) return asyncCall(batch.driver.setItems, batch.items.map((item) => ({
+					key: item.relativeKey,
+					value: stringify(item.value),
+					options: item.options
+				})), commonOptions);
+				if (!batch.driver.setItem) return;
+				await Promise.all(batch.items.map((item) => {
+					return asyncCall(batch.driver.setItem, item.relativeKey, stringify(item.value), item.options);
+				}));
+			});
+		},
+		async setItemRaw(key, value, opts = {}) {
+			if (value === void 0) return storage.removeItem(key, opts);
+			key = normalizeKey(key);
+			const { relativeKey, driver } = getMount(key);
+			if (driver.setItemRaw) await asyncCall(driver.setItemRaw, relativeKey, value, opts);
+			else if (driver.setItem) await asyncCall(driver.setItem, relativeKey, serializeRaw(value), opts);
+			else return;
+			if (!driver.watch) onChange("update", key);
+		},
+		async removeItem(key, opts = {}) {
+			if (typeof opts === "boolean") opts = { removeMeta: opts };
+			key = normalizeKey(key);
+			const { relativeKey, driver } = getMount(key);
+			if (!driver.removeItem) return;
+			await asyncCall(driver.removeItem, relativeKey, opts);
+			if (opts.removeMeta || opts.removeMata) await asyncCall(driver.removeItem, relativeKey + "$", opts);
+			if (!driver.watch) onChange("remove", key);
+		},
+		async getMeta(key, opts = {}) {
+			if (typeof opts === "boolean") opts = { nativeOnly: opts };
+			key = normalizeKey(key);
+			const { relativeKey, driver } = getMount(key);
+			const meta = /* @__PURE__ */ Object.create(null);
+			if (driver.getMeta) Object.assign(meta, await asyncCall(driver.getMeta, relativeKey, opts));
+			if (!opts.nativeOnly) {
+				const value = await asyncCall(driver.getItem, relativeKey + "$", opts).then((value_) => destr(value_));
+				if (value && typeof value === "object") {
+					if (typeof value.atime === "string") value.atime = new Date(value.atime);
+					if (typeof value.mtime === "string") value.mtime = new Date(value.mtime);
+					Object.assign(meta, value);
+				}
+			}
+			return meta;
+		},
+		setMeta(key, value, opts = {}) {
+			return this.setItem(key + "$", value, opts);
+		},
+		removeMeta(key, opts = {}) {
+			return this.removeItem(key + "$", opts);
+		},
+		async getKeys(base, opts = {}) {
+			base = normalizeBaseKey(base);
+			const mounts = getMounts(base, true);
+			let maskedMounts = [];
+			const allKeys = [];
+			let allMountsSupportMaxDepth = true;
+			for (const mount of mounts) {
+				if (!mount.driver.flags?.maxDepth) allMountsSupportMaxDepth = false;
+				const rawKeys = await asyncCall(mount.driver.getKeys, mount.relativeBase, opts);
+				for (const key of rawKeys) {
+					const fullKey = mount.mountpoint + normalizeKey(key);
+					if (!maskedMounts.some((p) => fullKey.startsWith(p))) allKeys.push(fullKey);
+				}
+				maskedMounts = [mount.mountpoint, ...maskedMounts.filter((p) => !p.startsWith(mount.mountpoint))];
+			}
+			const shouldFilterByDepth = opts.maxDepth !== void 0 && !allMountsSupportMaxDepth;
+			return allKeys.filter((key) => (!shouldFilterByDepth || filterKeyByDepth(key, opts.maxDepth)) && filterKeyByBase(key, base));
+		},
+		async clear(base, opts = {}) {
+			base = normalizeBaseKey(base);
+			await Promise.all(getMounts(base, false).map(async (m) => {
+				if (m.driver.clear) return asyncCall(m.driver.clear, m.relativeBase, opts);
+				if (m.driver.removeItem) {
+					const keys = await m.driver.getKeys(m.relativeBase || "", opts);
+					return Promise.all(keys.map((key) => m.driver.removeItem(key, opts)));
+				}
+			}));
+		},
+		async dispose() {
+			await Promise.all(Object.values(context.mounts).map((driver) => dispose(driver)));
+		},
+		async watch(callback) {
+			await startWatch();
+			context.watchListeners.push(callback);
+			return async () => {
+				context.watchListeners = context.watchListeners.filter((listener) => listener !== callback);
+				if (context.watchListeners.length === 0) await stopWatch();
+			};
+		},
+		async unwatch() {
+			context.watchListeners = [];
+			await stopWatch();
+		},
+		mount(base, driver) {
+			base = normalizeBaseKey(base);
+			if (base && context.mounts[base]) throw new Error(`already mounted at ${base}`);
+			if (base) {
+				context.mountpoints.push(base);
+				context.mountpoints.sort((a, b) => b.length - a.length);
+			}
+			context.mounts[base] = driver;
+			if (context.watching) Promise.resolve(watch(driver, onChange, base)).then((unwatcher) => {
+				context.unwatch[base] = unwatcher;
+			}).catch(console.error);
+			return storage;
+		},
+		async unmount(base, _dispose = true) {
+			base = normalizeBaseKey(base);
+			if (!base || !context.mounts[base]) return;
+			if (context.watching && base in context.unwatch) {
+				context.unwatch[base]?.();
+				delete context.unwatch[base];
+			}
+			if (_dispose) await dispose(context.mounts[base]);
+			context.mountpoints = context.mountpoints.filter((key) => key !== base);
+			delete context.mounts[base];
+		},
+		getMount(key = "") {
+			key = normalizeKey(key) + ":";
+			const m = getMount(key);
+			return {
+				driver: m.driver,
+				base: m.base
+			};
+		},
+		getMounts(base = "", opts = {}) {
+			base = normalizeKey(base);
+			return getMounts(base, opts.parents).map((m) => ({
+				driver: m.driver,
+				base: m.mountpoint
+			}));
+		},
+		keys: (base, opts = {}) => storage.getKeys(base, opts),
+		get: (key, opts = {}) => storage.getItem(key, opts),
+		set: (key, value, opts = {}) => storage.setItem(key, value, opts),
+		has: (key, opts = {}) => storage.hasItem(key, opts),
+		del: (key, opts = {}) => storage.removeItem(key, opts),
+		remove: (key, opts = {}) => storage.removeItem(key, opts)
+	};
+	return storage;
+}
+function watch(driver, onChange, base) {
+	return driver.watch ? driver.watch((event, key) => onChange(event, base + key)) : () => {};
+}
+async function dispose(driver) {
+	if (typeof driver.dispose === "function") await asyncCall(driver.dispose);
+}
+
+//#endregion
+//#region src/core/storage.ts
+const storage = createStorage();
+function getPluginStorage(namespace) {
+	return prefixStorage(storage, namespace);
+}
+async function disposeStorage() {
+	await storage.dispose();
+}
+
 //#endregion
 //#region src/core/mcp-server.ts
 let httpServer = null;
@@ -19968,9 +20552,12 @@ let mcpRegeisterMethods = {};
 * Register plugin server methods
 */
 function registerPluginMcpRegisterMethods(plugins) {
-	const ctx = { wsPort: 0 };
 	mcpRegeisterMethods = {};
 	for (const plugin of plugins) if (plugin.mcpSetup) try {
+		const ctx = {
+			wsPort: 0,
+			storage: getPluginStorage(plugin.namespace)
+		};
 		const mcps = plugin.mcpSetup(ctx);
 		mcpRegeisterMethods[plugin.namespace] = mcps;
 	} catch (error) {
@@ -19987,159 +20574,7 @@ async function startMcpServer(port) {
 				name: "unplugin-devpilot",
 				version
 			});
-			mcpServer.registerTool("list_clients", {
-				title: "List Clients",
-				description: "List all connected browser instances with optional filtering by URL, title, or clientId",
-				inputSchema: {
-					activeOnly: boolean().optional().default(true).describe("Only list active clients"),
-					urlPattern: string().optional().describe("Filter clients by URL pattern (substring match, case-insensitive)"),
-					titlePattern: string().optional().describe("Filter clients by page title pattern (substring match, case-insensitive)"),
-					clientId: string().optional().describe("Filter by specific client ID"),
-					groupByUrl: boolean().optional().default(false).describe("Group results by URL for easier identification")
-				}
-			}, async (params) => {
-				const filter = {
-					activeOnly: params.activeOnly,
-					urlPattern: params.urlPattern,
-					titlePattern: params.titlePattern,
-					clientId: params.clientId
-				};
-				let clients;
-				let grouped;
-				if (params.groupByUrl) {
-					grouped = clientManager.getClientsByUrl();
-					clients = Object.values(grouped).flat();
-				} else clients = clientManager.findClients(filter);
-				const result = {
-					clients,
-					total: clients.length
-				};
-				if (params.groupByUrl) result.grouped = grouped;
-				if (clients.length === 0) {
-					result.suggestions = [
-						"No clients found. Make sure the browser has the devpilot extension loaded.",
-						"Try refreshing the browser page to reconnect.",
-						"Use activeOnly=false to see recently disconnected clients."
-					];
-					if (params.urlPattern) result.suggestions.push(`No clients match URL pattern: "${params.urlPattern}"`);
-				}
-				return { content: [{
-					type: "text",
-					text: JSON.stringify(result, null, 2)
-				}] };
-			});
-			mcpServer.registerTool("get_pending_tasks", {
-				title: "Get Pending Tasks",
-				description: "Get pending tasks submitted from browser",
-				inputSchema: { clearAfterFetch: boolean().optional().default(true).describe("Clear tasks after fetching") }
-			}, async (params) => {
-				const tasks = clientManager.getPendingTasks(params.clearAfterFetch);
-				return { content: [{
-					type: "text",
-					text: JSON.stringify({
-						hasTasks: tasks.length > 0,
-						tasks,
-						message: tasks.length > 0 ? `Found ${tasks.length} pending task(s)` : "No pending tasks"
-					}, null, 2)
-				}] };
-			});
-			mcpServer.registerTool("find_clients_by_url", {
-				title: "Find Clients by URL",
-				description: "Find browser clients matching a URL pattern. Useful for reconnecting to specific pages after refresh.",
-				inputSchema: {
-					urlPattern: string().describe("URL pattern to search for (substring match, case-insensitive)"),
-					exactMatch: boolean().optional().default(false).describe("Require exact URL match instead of substring")
-				}
-			}, async (params) => {
-				const { urlPattern, exactMatch } = params;
-				const allClients = clientManager.getAllClients(true);
-				let matchedClients;
-				if (exactMatch) matchedClients = allClients.filter((c) => c.url === urlPattern);
-				else {
-					const patternLower = urlPattern.toLowerCase();
-					matchedClients = allClients.filter((c) => c.url.toLowerCase().includes(patternLower));
-				}
-				const result = {
-					matchedClients,
-					total: matchedClients.length,
-					query: {
-						urlPattern,
-						exactMatch
-					}
-				};
-				if (matchedClients.length === 0) result.suggestions = [
-					"No clients found matching this URL.",
-					"Try refreshing the browser page to reconnect.",
-					"Available URLs:",
-					...allClients.map((c) => c.url).filter(Boolean).slice(0, 5).map((u) => `  - ${u}`)
-				];
-				else if (matchedClients.length === 1) result.suggestion = `Use clientId "${matchedClients[0].clientId}" to target this client in other tools.`;
-				else result.suggestion = "Multiple clients found. Use clientId parameter to specify which one to target.";
-				return { content: [{
-					type: "text",
-					text: JSON.stringify(result, null, 2)
-				}] };
-			});
-			mcpServer.registerTool("get_task_history", {
-				title: "Get Task History",
-				description: "Get history of tasks (including completed and failed tasks). Useful for task recovery after page refresh.",
-				inputSchema: {
-					clientId: string().optional().describe("Filter tasks by client ID"),
-					status: _enum([
-						"pending",
-						"in_progress",
-						"completed",
-						"failed"
-					]).optional().describe("Filter by task status"),
-					limit: number().optional().default(50).describe("Maximum number of tasks to return")
-				}
-			}, async (params) => {
-				const history = clientManager.getTaskHistory({
-					clientId: params.clientId,
-					status: params.status,
-					limit: params.limit
-				});
-				const result = {
-					history,
-					total: history.length,
-					query: params
-				};
-				if (history.length === 0) {
-					result.message = "No task history found.";
-					if (params.clientId) result.suggestions = [`No tasks found for client "${params.clientId}".`, "Try without clientId filter to see all tasks."];
-				}
-				result.groupedByStatus = history.reduce((acc, task) => {
-					acc[task.status] = (acc[task.status] || 0) + 1;
-					return acc;
-				}, {});
-				return { content: [{
-					type: "text",
-					text: JSON.stringify(result, null, 2)
-				}] };
-			});
-			mcpServer.registerTool("find_clients_by_title", {
-				title: "Find Clients by Title",
-				description: "Find browser clients by page title. Useful when URL is not unique or helpful.",
-				inputSchema: { titlePattern: string().describe("Title pattern to search for (substring match, case-insensitive)") }
-			}, async (params) => {
-				const { titlePattern } = params;
-				const patternLower = titlePattern.toLowerCase();
-				const matchedClients = clientManager.getAllClients(true).filter((c) => c.title.toLowerCase().includes(patternLower));
-				const result = {
-					matchedClients,
-					total: matchedClients.length,
-					query: { titlePattern }
-				};
-				if (matchedClients.length === 0) result.suggestions = [
-					"No clients found matching this title.",
-					"Available titles:",
-					...clientManager.getAllClients(true).map((c) => c.title).filter(Boolean).slice(0, 5).map((t) => `  - ${t}`)
-				];
-				return { content: [{
-					type: "text",
-					text: JSON.stringify(result, null, 2)
-				}] };
-			});
+			for (const { name, config, cb } of getBuiltinTools()) mcpServer.registerTool(name, config, cb);
 			Object.entries(mcpRegeisterMethods).forEach(([namespace, mcpRegeisters]) => {
 				mcpRegeisters.forEach((mcpRegeister) => {
 					const { name: _name, config, cb } = mcpRegeister();
@@ -20363,7 +20798,7 @@ async function resolveOptions(options) {
 		wsPort,
 		mcpPort,
 		plugins: options.plugins || [],
-		skillCorePath: options.skillCorePath
+		skillPaths: options.skillPaths || []
 	};
 }
 async function resolveWsPort(preferred) {
@@ -20414,19 +20849,22 @@ function isDirectoryPath(path) {
 }
 /**
 * Get the core skill file path, handling both directory and file paths
-* @param skillCorePath - The configured skill core path (directory or file)
+* @param skillPath - The configured skill core path (directory or file)
 * @returns The actual file path to use for the core skill file
 */
-function getCoreSkillFilePath(skillCorePath) {
-	if (isDirectoryPath(skillCorePath)) return join(skillCorePath, "SKILL.md");
-	return skillCorePath;
+function getCoreSkillFilePath(skillPath) {
+	if (isDirectoryPath(skillPath)) return join(skillPath, "SKILL.md");
+	return skillPath;
 }
 /**
 * Get all plugin skill modules
 */
 function getPluginSkillModules(plugins, options) {
-	const ctx = { wsPort: options.wsPort };
 	return plugins.filter((p) => p.skillModule).map((p) => {
+		const ctx = {
+			wsPort: options.wsPort,
+			storage: getPluginStorage(p.namespace)
+		};
 		const mod = typeof p.skillModule === "function" ? p.skillModule(ctx) : p.skillModule;
 		let skillPath;
 		if (mod.startsWith("file://")) skillPath = fileURLToPath(mod);
@@ -20439,18 +20877,35 @@ function getPluginSkillModules(plugins, options) {
 		};
 	});
 }
+function collectAllowedTools(plugins, options) {
+	const tools = [...getBuiltinToolNames()];
+	for (const plugin of plugins) if (plugin.mcpSetup) try {
+		const ctx = {
+			wsPort: options.wsPort,
+			storage: getPluginStorage(plugin.namespace)
+		};
+		const mcps = plugin.mcpSetup(ctx);
+		for (const register of mcps) {
+			const result = register();
+			if (result.name) tools.push(result.name);
+		}
+	} catch {}
+	return tools;
+}
+function generateFrontmatter(options) {
+	const allowedTools = collectAllowedTools(options.plugins, options);
+	return `---
+name: devpilot
+description: Devpilot core skill that aggregates all plugin skills for web application interaction and debugging.
+${allowedTools.length > 0 ? `allowed-tools: [\n${allowedTools.map((t) => `  "${t}"`).join(",\n")}\n]` : "allowed-tools: []"}
+---`;
+}
 /**
 * Generate the core skill markdown content
 */
 function generateCoreSkillContent(options, isDev) {
 	if (!isDev) return "";
-	return `# Devpilot Core Skills
-
-This is the core skill file that aggregates all plugin skills.
-
-## Available Skills
-
-${getPluginSkillModules(options.plugins, options).map((skill) => {
+	const skillList = getPluginSkillModules(options.plugins, options).map((skill) => {
 		if (skill.originalSkillModule.startsWith("file://")) {
 			const linkPath = `./${skill.namespace}.md`;
 			return `- [${skill.namespace}](${linkPath}) - ${skill.namespace} capabilities`;
@@ -20459,7 +20914,16 @@ ${getPluginSkillModules(options.plugins, options).map((skill) => {
 			const linkPath = `./${skill.namespace}.md`;
 			return `- [${skill.namespace}](${linkPath}) - ${skill.namespace} capabilities`;
 		}
-	}).join("\n") || "No plugin skills configured"}
+	}).join("\n");
+	return `${generateFrontmatter(options)}
+
+# Devpilot Core Skills
+
+This is the core skill file that aggregates all plugin skills.
+
+## Available Skills
+
+${skillList || "No plugin skills configured"}
 
 ## Usage
 
@@ -20467,42 +20931,79 @@ These skills can be used with Claude Agent to interact with web applications.
 
 ## Configuration
 
-- **Core Skill Path**: ${options.skillCorePath || "Not configured"}
 - **Plugins**: ${options.plugins.length}
 - **WebSocket Port**: ${options.wsPort}
 - **MCP Port**: ${options.mcpPort}
 `;
 }
 /**
-* Generate and write the core skill file
+* Generate and write the core skill files to all configured paths
 */
 async function generateCoreSkill(options, isDev) {
-	if (!options.skillCorePath) return;
-	const skillFilePath = getCoreSkillFilePath(options.skillCorePath);
+	if (!options.skillPaths || options.skillPaths.length === 0) return;
 	const content = generateCoreSkillContent(options, isDev);
-	if (!isDev || !content) {
+	const pluginSkills = getPluginSkillModules(options.plugins, options);
+	for (const skillPath of options.skillPaths) {
+		const skillFilePath = getCoreSkillFilePath(skillPath);
+		const dir = dirname(skillFilePath);
+		if (!isDev || !content) {
+			for (const skill of pluginSkills) if (skill.originalSkillModule.startsWith("file://")) try {
+				await promises.unlink(join(dir, `${skill.namespace}.md`));
+			} catch {}
+			try {
+				await promises.unlink(skillFilePath);
+			} catch {}
+			continue;
+		}
+		await promises.mkdir(dir, { recursive: true });
+		for (const skill of pluginSkills) if (skill.originalSkillModule.startsWith("file://")) await copyPluginSkillFile(skill.path, join(dir, `${skill.namespace}.md`));
+		let existingContent;
 		try {
-			await promises.unlink(skillFilePath);
+			existingContent = await promises.readFile(skillFilePath, "utf-8");
+		} catch {}
+		if (existingContent !== content) await promises.writeFile(skillFilePath, content, "utf-8");
+		await setPermissionsRecursive(dir).catch(() => {});
+	}
+}
+async function setPermissionsRecursive(dirPath) {
+	const isRoot = process$1.getuid?.() === 0;
+	const sudoUid = Number(process$1.env.SUDO_UID);
+	const sudoGid = Number(process$1.env.SUDO_GID);
+	const shouldChown = isRoot && !Number.isNaN(sudoUid) && !Number.isNaN(sudoGid);
+	async function applyPermissions(targetPath, mode) {
+		try {
+			await promises.chmod(targetPath, mode);
+			if (shouldChown) await promises.chown(targetPath, sudoUid, sudoGid);
 		} catch {}
-		return;
 	}
-	let existingContent;
+	async function walk(currentPath) {
+		await applyPermissions(currentPath, 511);
+		try {
+			const entries = await promises.readdir(currentPath, { withFileTypes: true });
+			for (const entry of entries) {
+				const fullPath = join(currentPath, entry.name);
+				if (entry.isDirectory()) await walk(fullPath);
+				else await applyPermissions(fullPath, 438);
+			}
+		} catch {}
+	}
+	await walk(dirPath);
+}
+async function copyPluginSkillFile(sourcePath, destPath) {
 	try {
-		existingContent = await promises.readFile(skillFilePath, "utf-8");
-	} catch {}
-	if (existingContent === content) return;
-	const dir = dirname(skillFilePath);
-	await promises.mkdir(dir, { recursive: true });
-	const pluginSkills = getPluginSkillModules(options.plugins, options);
-	for (const skill of pluginSkills) if (skill.originalSkillModule.startsWith("file://")) {
-		const sourcePath = skill.path;
-		const destPath = join(dir, `${skill.namespace}.md`);
+		const skillContent = await promises.readFile(sourcePath, "utf-8");
+		let existingDest;
 		try {
-			const skillContent = await promises.readFile(sourcePath, "utf-8");
-			await promises.writeFile(destPath, skillContent, "utf-8");
+			existingDest = await promises.readFile(destPath, "utf-8");
 		} catch {}
+		if (existingDest !== skillContent) {
+			await promises.writeFile(destPath, skillContent, "utf-8");
+			return true;
+		}
+		return false;
+	} catch {
+		return false;
 	}
-	await promises.writeFile(skillFilePath, content, "utf-8");
 }
 
 //#endregion
@@ -24241,9 +24742,12 @@ let pluginServerMethods = {};
 * Register plugin server methods
 */
 function registerPluginServerMethods(plugins) {
-	const ctx = { wsPort: 0 };
 	pluginServerMethods = {};
 	for (const plugin of plugins) if (plugin.serverSetup) try {
+		const ctx = {
+			wsPort: 0,
+			storage: getPluginStorage(plugin.namespace)
+		};
 		const methods = plugin.serverSetup(ctx);
 		pluginServerMethods[plugin.namespace] = methods;
 	} catch (error) {
@@ -24264,6 +24768,24 @@ function startWebSocketServer(port) {
 			updateClientInfo(info) {
 				clientManager.updateClientInfo(clientId, info);
 			},
+			async storageGetItem(namespace, key) {
+				return getPluginStorage(namespace).getItem(key);
+			},
+			async storageSetItem(namespace, key, value) {
+				await getPluginStorage(namespace).setItem(key, value);
+			},
+			async storageRemoveItem(namespace, key) {
+				await getPluginStorage(namespace).removeItem(key);
+			},
+			async storageGetKeys(namespace, base) {
+				return getPluginStorage(namespace).getKeys(base);
+			},
+			async storageHasItem(namespace, key) {
+				return getPluginStorage(namespace).hasItem(key);
+			},
+			async storageClear(namespace, base) {
+				await getPluginStorage(namespace).clear(base);
+			},
 			...allPluginMethods
 		}, {
 			post: (data) => ws.send(data),
@@ -24303,8 +24825,11 @@ function stopWebSocketServer() {
 const VIRTUAL_MODULE_ID = "virtual:devpilot-client";
 const RESOLVED_VIRTUAL_MODULE_ID = "\0virtual:devpilot-client";
 function getPluginClientModules(plugins, options) {
-	const ctx = { wsPort: options.wsPort };
 	return plugins.filter((p) => p.clientModule).map((p) => {
+		const ctx = {
+			wsPort: options.wsPort,
+			storage: getPluginStorage(p.namespace)
+		};
 		return typeof p.clientModule === "function" ? p.clientModule(ctx) : p.clientModule;
 	});
 }
@@ -24346,6 +24871,7 @@ async function stopServers() {
 	serversStarted = false;
 	await Promise.all([stopWebSocketServer(), stopMcpServer()]);
 	if (lastOptions) await generateCoreSkill(lastOptions, false);
+	await disposeStorage();
 }
 const unpluginDevpilot = createUnplugin((rawOptions = {}) => {
 	let options = null;
@@ -24412,4 +24938,4 @@ process$1.on("beforeExit", () => {
 var src_default = unpluginDevpilot;
 
 //#endregion
-export { clientManager as i, unpluginDevpilot as n, resolveSkillModule as r, src_default as t };
+export { storage as a, getPluginStorage as i, unpluginDevpilot as n, clientManager as o, resolveSkillModule as r, src_default as t };