unplugin-devpilot 0.0.4 → 0.0.5

package/README.md

@@ -79,6 +79,7 @@ export default defineConfig({
       wsPort: 3100, // Optional: Specify WebSocket port (will be randomly allocated if not specified)
       mcpPort: 3101, // Optional: Specify MCP server port (will use random port if specified port is occupied)
       plugins: [], // Optional: Array of DevpilotPlugin instances
+      skillPaths: ['./.github/skills/devpilot', './.cursor/skills/devpilot'], // Optional: Array of paths to core skill files
     }),
   ],
 });

package/dist/client/index.d.mts

@@ -10,6 +10,12 @@ interface ClientInfo {
 interface BaseServerFunctions {
   ping: () => string;
   updateClientInfo: (info: Omit<ClientInfo, "clientId" | "connectedAt" | "lastActiveAt">) => void;
+  storageGetItem: (namespace: string, key: string) => Promise<any>;
+  storageSetItem: (namespace: string, key: string, value: any) => Promise<void>;
+  storageRemoveItem: (namespace: string, key: string) => Promise<void>;
+  storageGetKeys: (namespace: string, base?: string) => Promise<string[]>;
+  storageHasItem: (namespace: string, key: string) => Promise<boolean>;
+  storageClear: (namespace: string, base?: string) => Promise<void>;
 }
 interface PluginServerFunctions {}
 type ServerFunctions = BaseServerFunctions & PluginServerFunctions;
@@ -36,6 +42,17 @@ interface DevpilotClientOptions {
   extendRpcHandlers?: Record<string, (...args: any[]) => any>;
 }
 //#endregion
+//#region src/client/storage.d.ts
+interface ClientStorage {
+  getItem: <T = any>(key: string) => Promise<T | null>;
+  setItem: <T = any>(key: string, value: T) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+  getKeys: (base?: string) => Promise<string[]>;
+  hasItem: (key: string) => Promise<boolean>;
+  clear: (base?: string) => Promise<void>;
+}
+declare function createClientStorage(client: DevpilotClient<any>, namespace: string): ClientStorage;
+//#endregion
 //#region src/client/index.d.ts
 declare function createDevpilotClient<S extends Record<string, any> = ServerFunctions>(options: DevpilotClientOptions): DevpilotClient<S>;
 declare function initDevpilot<S extends Record<string, any> = ServerFunctions>(options: DevpilotClientOptions): DevpilotClient<S>;
@@ -59,4 +76,4 @@ declare function getDevpilotClient<S extends Record<string, any> = ServerFunctio
 */
 declare function defineRpcHandlers<T extends { [K in keyof T]: (...args: any[]) => any }>(handlers: T): T;
 //#endregion
-export { type DevpilotClient, type DevpilotClientOptions, type RpcHandlers, createDevpilotClient, defineRpcHandlers, getDevpilotClient, initDevpilot };
+export { type ClientStorage, type DevpilotClient, type DevpilotClientOptions, type RpcHandlers, createClientStorage, createDevpilotClient, defineRpcHandlers, getDevpilotClient, initDevpilot };

package/dist/client/index.mjs

@@ -1,3 +1,16 @@
+//#region src/client/storage.ts
+function createClientStorage(client, namespace) {
+	return {
+		getItem: (key) => client.rpcCall("storageGetItem", namespace, key),
+		setItem: (key, value) => client.rpcCall("storageSetItem", namespace, key, value),
+		removeItem: (key) => client.rpcCall("storageRemoveItem", namespace, key),
+		getKeys: (base) => client.rpcCall("storageGetKeys", namespace, base),
+		hasItem: (key) => client.rpcCall("storageHasItem", namespace, key),
+		clear: (base) => client.rpcCall("storageClear", namespace, base)
+	};
+}
+
+//#endregion
 //#region src/client/index.ts
 function generateId() {
 	return Math.random().toString(36).slice(2, 12);
@@ -143,4 +156,4 @@ function defineRpcHandlers(handlers) {
 }
 
 //#endregion
-export { createDevpilotClient, defineRpcHandlers, getDevpilotClient, initDevpilot };
+export { createClientStorage, createDevpilotClient, defineRpcHandlers, getDevpilotClient, initDevpilot };

package/dist/farm.d.mts

@@ -1,4 +1,4 @@
-import { t as unpluginDevpilot } from "./index-WH3owjvn.mjs";
+import { t as unpluginDevpilot } from "./index-DMYihCqJ.mjs";
 
 //#region src/farm.d.ts
 /**

package/dist/farm.mjs

@@ -1,4 +1,4 @@
-import { n as unpluginDevpilot } from "./src-AEXLBOF9.mjs";
+import { n as unpluginDevpilot } from "./src-DkQU5cZx.mjs";
 
 //#region src/farm.ts
 /**

package/dist/{index-Csy16I0Z.d.mts → index-B3RgT4Na.d.mts}

@@ -1,3 +1,124 @@
+//#region ../../node_modules/.pnpm/unstorage@1.17.4/node_modules/unstorage/dist/shared/unstorage.Ca7R4QL2.d.mts
+type StorageValue = null | string | number | boolean | object;
+type WatchEvent = "update" | "remove";
+type WatchCallback = (event: WatchEvent, key: string) => any;
+type MaybePromise<T> = T | Promise<T>;
+type MaybeDefined<T> = T extends any ? T : any;
+type Unwatch = () => MaybePromise<void>;
+interface StorageMeta {
+  atime?: Date;
+  mtime?: Date;
+  ttl?: number;
+  [key: string]: StorageValue | Date | undefined;
+}
+type TransactionOptions = Record<string, any>;
+type GetKeysOptions = TransactionOptions & {
+  maxDepth?: number;
+};
+interface DriverFlags {
+  maxDepth?: boolean;
+  ttl?: boolean;
+}
+interface Driver<OptionsT = any, InstanceT = any> {
+  name?: string;
+  flags?: DriverFlags;
+  options?: OptionsT;
+  getInstance?: () => InstanceT;
+  hasItem: (key: string, opts: TransactionOptions) => MaybePromise<boolean>;
+  getItem: (key: string, opts?: TransactionOptions) => MaybePromise<StorageValue>;
+  /** @experimental */
+  getItems?: (items: {
+    key: string;
+    options?: TransactionOptions;
+  }[], commonOptions?: TransactionOptions) => MaybePromise<{
+    key: string;
+    value: StorageValue;
+  }[]>;
+  /** @experimental */
+  getItemRaw?: (key: string, opts: TransactionOptions) => MaybePromise<unknown>;
+  setItem?: (key: string, value: string, opts: TransactionOptions) => MaybePromise<void>;
+  /** @experimental */
+  setItems?: (items: {
+    key: string;
+    value: string;
+    options?: TransactionOptions;
+  }[], commonOptions?: TransactionOptions) => MaybePromise<void>;
+  /** @experimental */
+  setItemRaw?: (key: string, value: any, opts: TransactionOptions) => MaybePromise<void>;
+  removeItem?: (key: string, opts: TransactionOptions) => MaybePromise<void>;
+  getMeta?: (key: string, opts: TransactionOptions) => MaybePromise<StorageMeta | null>;
+  getKeys: (base: string, opts: GetKeysOptions) => MaybePromise<string[]>;
+  clear?: (base: string, opts: TransactionOptions) => MaybePromise<void>;
+  dispose?: () => MaybePromise<void>;
+  watch?: (callback: WatchCallback) => MaybePromise<Unwatch>;
+}
+type StorageDefinition = {
+  items: unknown;
+  [key: string]: unknown;
+};
+type StorageItemMap<T> = T extends StorageDefinition ? T["items"] : T;
+type StorageItemType<T, K> = K extends keyof StorageItemMap<T> ? StorageItemMap<T>[K] : T extends StorageDefinition ? StorageValue : T;
+interface Storage<T extends StorageValue = StorageValue> {
+  hasItem<U extends Extract<T, StorageDefinition>, K extends keyof StorageItemMap<U>>(key: K, opts?: TransactionOptions): Promise<boolean>;
+  hasItem(key: string, opts?: TransactionOptions): Promise<boolean>;
+  getItem<U extends Extract<T, StorageDefinition>, K extends string & keyof StorageItemMap<U>>(key: K, ops?: TransactionOptions): Promise<StorageItemType<T, K> | null>;
+  getItem<R = StorageItemType<T, string>>(key: string, opts?: TransactionOptions): Promise<R | null>;
+  /** @experimental */
+  getItems: <U extends T>(items: (string | {
+    key: string;
+    options?: TransactionOptions;
+  })[], commonOptions?: TransactionOptions) => Promise<{
+    key: string;
+    value: U;
+  }[]>;
+  /** @experimental See https://github.com/unjs/unstorage/issues/142 */
+  getItemRaw: <T = any>(key: string, opts?: TransactionOptions) => Promise<MaybeDefined<T> | null>;
+  setItem<U extends Extract<T, StorageDefinition>, K extends keyof StorageItemMap<U>>(key: K, value: StorageItemType<T, K>, opts?: TransactionOptions): Promise<void>;
+  setItem<U extends T>(key: string, value: U, opts?: TransactionOptions): Promise<void>;
+  /** @experimental */
+  setItems: <U extends T>(items: {
+    key: string;
+    value: U;
+    options?: TransactionOptions;
+  }[], commonOptions?: TransactionOptions) => Promise<void>;
+  /** @experimental See https://github.com/unjs/unstorage/issues/142 */
+  setItemRaw: <T = any>(key: string, value: MaybeDefined<T>, opts?: TransactionOptions) => Promise<void>;
+  removeItem<U extends Extract<T, StorageDefinition>, K extends keyof StorageItemMap<U>>(key: K, opts?: (TransactionOptions & {
+    removeMeta?: boolean;
+  }) | boolean): Promise<void>;
+  removeItem(key: string, opts?: (TransactionOptions & {
+    removeMeta?: boolean;
+  }) | boolean): Promise<void>;
+  getMeta: (key: string, opts?: (TransactionOptions & {
+    nativeOnly?: boolean;
+  }) | boolean) => MaybePromise<StorageMeta>;
+  setMeta: (key: string, value: StorageMeta, opts?: TransactionOptions) => Promise<void>;
+  removeMeta: (key: string, opts?: TransactionOptions) => Promise<void>;
+  getKeys: (base?: string, opts?: GetKeysOptions) => Promise<string[]>;
+  clear: (base?: string, opts?: TransactionOptions) => Promise<void>;
+  dispose: () => Promise<void>;
+  watch: (callback: WatchCallback) => Promise<Unwatch>;
+  unwatch: () => Promise<void>;
+  mount: (base: string, driver: Driver) => Storage;
+  unmount: (base: string, dispose?: boolean) => Promise<void>;
+  getMount: (key?: string) => {
+    base: string;
+    driver: Driver;
+  };
+  getMounts: (base?: string, options?: {
+    parents?: boolean;
+  }) => {
+    base: string;
+    driver: Driver;
+  }[];
+  keys: Storage["getKeys"];
+  get: Storage<T>["getItem"];
+  set: Storage<T>["setItem"];
+  has: Storage<T>["hasItem"];
+  del: Storage<T>["removeItem"];
+  remove: Storage<T>["removeItem"];
+}
+//#endregion
 //#region src/core/utils.d.ts
 /**
 * Resolve the module path relative to the plugin to an absolute path
@@ -4123,6 +4244,7 @@ declare function defineMcpToolRegister<OutputArgs extends ZodRawShapeCompat | An
 //#region src/core/plugin/index.d.ts
 interface DevpilotPluginContext {
   wsPort: number;
+  storage: Storage;
 }
 /**
 * Resolve the module path relative to the plugin to an absolute path
@@ -4143,4 +4265,4 @@ interface DevpilotPluginContext {
 */
 declare function resolveClientModule(importMetaUrl: string, relativePath: string): string;
 //#endregion
-export { resolveModule as a, defineMcpToolRegister as i, resolveClientModule as n, McpToolRegister as r, DevpilotPluginContext as t };
+export { type resolveModule as a, defineMcpToolRegister as i, resolveClientModule as n, Storage as o, McpToolRegister as r, StorageValue as s, DevpilotPluginContext as t };

package/dist/{index-WH3owjvn.d.mts → index-DMYihCqJ.d.mts}

@@ -1,4 +1,4 @@
-import { r as McpToolRegister, t as DevpilotPluginContext } from "./index-Csy16I0Z.mjs";
+import { o as Storage, r as McpToolRegister, s as StorageValue, t as DevpilotPluginContext } from "./index-B3RgT4Na.mjs";
 import { UnpluginInstance } from "unplugin";
 import { WebSocket } from "ws";
 
@@ -45,20 +45,20 @@ interface Options {
   mcpPort?: number;
   plugins?: DevpilotPlugin[];
   /**
-  * The path to generate the core skill file
-  * - directory path: './src/skills/devpilot' (will generate SKILL.md in this directory)
-  * - file path: './src/skills/devpilot/SKILL.md' (will generate the specified file)
+  * The paths to generate the core skill files
+  * - directory path: './.github/skills/devpilot' (will generate SKILL.md in this directory)
+  * - file path: './.github/skills/devpilot/SKILL.md' (will generate the specified file)
   *
   * If not specified, no core skill file will be generated
   * @example
   * ```ts
   * Devpilot({
-  *   skillCorePath: './src/skills/devpilot',
+  *   skillPaths: ['./.github/skills/devpilot', './.cursor/skills/devpilot'],
   *   plugins: [],
   * })
   * ```
   */
-  skillCorePath?: string;
+  skillPaths?: string[];
 }
 //#endregion
 //#region ../../node_modules/.pnpm/birpc@4.0.0/node_modules/birpc/dist/index.d.mts
@@ -188,6 +188,12 @@ interface PendingTask {
 interface BaseServerFunctions {
   ping: () => string;
   updateClientInfo: (info: Omit<ClientInfo, "clientId" | "connectedAt" | "lastActiveAt">) => void;
+  storageGetItem: (namespace: string, key: string) => Promise<any>;
+  storageSetItem: (namespace: string, key: string, value: any) => Promise<void>;
+  storageRemoveItem: (namespace: string, key: string) => Promise<void>;
+  storageGetKeys: (namespace: string, base?: string) => Promise<string[]>;
+  storageHasItem: (namespace: string, key: string) => Promise<boolean>;
+  storageClear: (namespace: string, base?: string) => Promise<void>;
 }
 interface PluginServerFunctions {}
 type ServerFunctions = BaseServerFunctions & PluginServerFunctions;
@@ -271,7 +277,11 @@ declare const clientManager: ClientManager;
 */
 declare function resolveSkillModule(importMetaUrl: string, relativePath: string): string;
 //#endregion
+//#region src/core/storage.d.ts
+declare const storage: Storage<StorageValue>;
+declare function getPluginStorage(namespace: string): Storage<StorageValue>;
+//#endregion
 //#region src/index.d.ts
 declare const unpluginDevpilot: UnpluginInstance<Options | undefined, false>;
 //#endregion
-export { BaseServerFunctions as a, ClientInfo as c, PluginServerFunctions as d, ServerFunctions as f, Options as h, BaseClientFunctions as i, PendingTask as l, DevpilotPlugin as m, resolveSkillModule as n, ClientDiscoveryFilter as o, TaskHistory as p, clientManager as r, ClientFunctions as s, unpluginDevpilot as t, PluginClientFunctions as u };
+export { Options as _, clientManager as a, ClientDiscoveryFilter as c, PendingTask as d, PluginClientFunctions as f, DevpilotPlugin as g, TaskHistory as h, resolveSkillModule as i, ClientFunctions as l, ServerFunctions as m, getPluginStorage as n, BaseClientFunctions as o, PluginServerFunctions as p, storage as r, BaseServerFunctions as s, unpluginDevpilot as t, ClientInfo as u };

package/dist/index.d.mts

@@ -1,3 +1,3 @@
-import { a as resolveModule, i as defineMcpToolRegister, n as resolveClientModule, t as DevpilotPluginContext } from "./index-Csy16I0Z.mjs";
-import { a as BaseServerFunctions, c as ClientInfo, d as PluginServerFunctions, f as ServerFunctions, h as Options, i as BaseClientFunctions, l as PendingTask, m as DevpilotPlugin, n as resolveSkillModule, o as ClientDiscoveryFilter, p as TaskHistory, r as clientManager, s as ClientFunctions, t as unpluginDevpilot, u as PluginClientFunctions } from "./index-WH3owjvn.mjs";
-export { BaseClientFunctions, BaseServerFunctions, ClientDiscoveryFilter, ClientFunctions, ClientInfo, DevpilotPlugin, DevpilotPluginContext, Options, PendingTask, PluginClientFunctions, PluginServerFunctions, ServerFunctions, TaskHistory, clientManager, unpluginDevpilot as default, unpluginDevpilot, defineMcpToolRegister, resolveClientModule, resolveModule, resolveSkillModule };
+import { a as resolveModule, i as defineMcpToolRegister, n as resolveClientModule, t as DevpilotPluginContext } from "./index-B3RgT4Na.mjs";
+import { _ as Options, a as clientManager, c as ClientDiscoveryFilter, d as PendingTask, f as PluginClientFunctions, g as DevpilotPlugin, h as TaskHistory, i as resolveSkillModule, l as ClientFunctions, m as ServerFunctions, n as getPluginStorage, o as BaseClientFunctions, p as PluginServerFunctions, r as storage, s as BaseServerFunctions, t as unpluginDevpilot, u as ClientInfo } from "./index-DMYihCqJ.mjs";
+export { BaseClientFunctions, BaseServerFunctions, ClientDiscoveryFilter, ClientFunctions, ClientInfo, DevpilotPlugin, DevpilotPluginContext, Options, PendingTask, PluginClientFunctions, PluginServerFunctions, ServerFunctions, TaskHistory, clientManager, unpluginDevpilot as default, unpluginDevpilot, defineMcpToolRegister, getPluginStorage, resolveClientModule, resolveModule, resolveSkillModule, storage };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { i as clientManager, n as unpluginDevpilot, r as resolveSkillModule, t as src_default } from "./src-AEXLBOF9.mjs";
+import { a as storage, i as getPluginStorage, n as unpluginDevpilot, o as clientManager, r as resolveSkillModule, t as src_default } from "./src-DkQU5cZx.mjs";
 import { n as defineMcpToolRegister, r as resolveModule, t as resolveClientModule } from "./plugin-B1Afr0m3.mjs";
 
-export { clientManager, src_default as default, defineMcpToolRegister, resolveClientModule, resolveModule, resolveSkillModule, unpluginDevpilot };
+export { clientManager, src_default as default, defineMcpToolRegister, getPluginStorage, resolveClientModule, resolveModule, resolveSkillModule, storage, unpluginDevpilot };

package/dist/plugin.d.mts

@@ -1,2 +1,2 @@
-import { a as resolveModule, i as defineMcpToolRegister, n as resolveClientModule, r as McpToolRegister, t as DevpilotPluginContext } from "./index-Csy16I0Z.mjs";
+import { a as resolveModule, i as defineMcpToolRegister, n as resolveClientModule, r as McpToolRegister, t as DevpilotPluginContext } from "./index-B3RgT4Na.mjs";
 export { DevpilotPluginContext, McpToolRegister as McpServerRegister, defineMcpToolRegister, resolveClientModule, resolveModule };

package/dist/rspack.d.mts

@@ -1,4 +1,4 @@
-import { t as unpluginDevpilot } from "./index-WH3owjvn.mjs";
+import { t as unpluginDevpilot } from "./index-DMYihCqJ.mjs";
 
 //#region src/rspack.d.ts
 /**

package/dist/rspack.mjs

@@ -1,4 +1,4 @@
-import { n as unpluginDevpilot } from "./src-AEXLBOF9.mjs";
+import { n as unpluginDevpilot } from "./src-DkQU5cZx.mjs";
 
 //#region src/rspack.ts
 /**

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

@@ -19799,7 +19799,7 @@ var StreamableHTTPServerTransport = class {
 
 //#endregion
 //#region package.json
-var version = "0.0.4";
+var version = "0.0.5";
 
 //#endregion
 //#region ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/compat/util/uniqueId.mjs
@@ -19960,6 +19960,486 @@ var ClientManager = class {
 };
 const clientManager = new ClientManager();
 
+//#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 +20448,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) {
@@ -20363,7 +20846,7 @@ async function resolveOptions(options) {
 		wsPort,
 		mcpPort,
 		plugins: options.plugins || [],
-		skillCorePath: options.skillCorePath
+		skillPaths: options.skillPaths || []
 	};
 }
 async function resolveWsPort(preferred) {
@@ -20414,19 +20897,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);
@@ -20467,42 +20953,71 @@ 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 });
+		await promises.chmod(dir, 511);
+		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 {}
-		return;
+		if (existingContent !== content) {
+			await promises.writeFile(skillFilePath, content, "utf-8");
+			await promises.chmod(skillFilePath, 511);
+		}
+		await setPermissionsRecursive(dir).catch(() => {});
 	}
-	let existingContent;
+}
+async function setPermissionsRecursive(dirPath) {
 	try {
-		existingContent = await promises.readFile(skillFilePath, "utf-8");
+		await promises.chmod(dirPath, 511);
+		const entries = await promises.readdir(dirPath, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = join(dirPath, entry.name);
+			if (entry.isDirectory()) await setPermissionsRecursive(fullPath);
+			else await promises.chmod(fullPath, 511);
+		}
 	} 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`);
+}
+async function copyPluginSkillFile(sourcePath, destPath) {
+	try {
+		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");
+			await promises.chmod(destPath, 511);
+			return true;
+		}
+		return false;
+	} catch {
+		return false;
 	}
-	await promises.writeFile(skillFilePath, content, "utf-8");
 }
 
 //#endregion
@@ -24241,9 +24756,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 +24782,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 +24839,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 +24885,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 +24952,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 };

package/dist/vite.d.mts

@@ -1,4 +1,4 @@
-import { t as unpluginDevpilot } from "./index-WH3owjvn.mjs";
+import { t as unpluginDevpilot } from "./index-DMYihCqJ.mjs";
 
 //#region src/vite.d.ts
 /**

package/dist/vite.mjs

@@ -1,4 +1,4 @@
-import { n as unpluginDevpilot } from "./src-AEXLBOF9.mjs";
+import { n as unpluginDevpilot } from "./src-DkQU5cZx.mjs";
 
 //#region src/vite.ts
 /**

package/dist/webpack.d.mts

@@ -1,4 +1,4 @@
-import { t as unpluginDevpilot } from "./index-WH3owjvn.mjs";
+import { t as unpluginDevpilot } from "./index-DMYihCqJ.mjs";
 
 //#region src/webpack.d.ts
 /**

package/dist/webpack.mjs

@@ -1,4 +1,4 @@
-import { n as unpluginDevpilot } from "./src-AEXLBOF9.mjs";
+import { n as unpluginDevpilot } from "./src-DkQU5cZx.mjs";
 
 //#region src/webpack.ts
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unplugin-devpilot",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Description.",
   "author": "zcf0508 <zcf0508@live.com>",
   "license": "MIT",
@@ -87,6 +87,7 @@
     "get-port-please": "^3.2.0",
     "hookable": "^6.0.1",
     "mitt": "^3.0.1",
+    "unstorage": "^1.17.4",
     "ws": "^8.19.0",
     "zod": "^4.3.6"
   },