unplugin-devpilot 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2025-PRESENT Huali (https://github.com/zcf0508)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/client/index.d.mts

@@ -0,0 +1,62 @@
+//#region src/core/types.d.ts
+interface ClientInfo {
+  clientId: string;
+  url: string;
+  title: string;
+  userAgent: string;
+  connectedAt: number;
+  lastActiveAt: number;
+}
+interface BaseServerFunctions {
+  ping: () => string;
+  updateClientInfo: (info: Omit<ClientInfo, "clientId" | "connectedAt" | "lastActiveAt">) => void;
+}
+interface PluginServerFunctions {}
+type ServerFunctions = BaseServerFunctions & PluginServerFunctions;
+interface BaseClientFunctions {
+  notifyTaskUpdate: (count: number) => void;
+  notifyTaskCompleted: (taskId: string) => void;
+}
+interface PluginClientFunctions {}
+type ClientFunctions = BaseClientFunctions & PluginClientFunctions;
+//#endregion
+//#region src/client/types.d.ts
+type RpcHandlers = ClientFunctions;
+type PromisifyServerFunctions<T = ServerFunctions> = { [K in keyof T]: T[K] extends ((...args: infer Args) => infer Return) ? (...args: Args) => Promise<Awaited<Return>> : never };
+interface DevpilotClient<S extends Record<string, any> = ServerFunctions> {
+  getClientId: () => string | null;
+  rpcCall: <K extends keyof PromisifyServerFunctions<S>>(method: K, ...args: Parameters<PromisifyServerFunctions<S>[K]>) => Promise<ReturnType<PromisifyServerFunctions<S>[K]>>;
+  isConnected: () => boolean;
+  onConnected: (callback: () => void) => () => void;
+  onDisconnected: (callback: () => void) => () => void;
+}
+interface DevpilotClientOptions {
+  wsPort: number;
+  rpcHandlers?: Partial<RpcHandlers>;
+  extendRpcHandlers?: Record<string, (...args: any[]) => any>;
+}
+//#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>;
+declare function getDevpilotClient<S extends Record<string, any> = ServerFunctions>(): DevpilotClient<S> | null;
+/**
+* Define and type-check RPC handlers for the client
+* This ensures the handlers are correctly typed and will be recognized by the RPC system
+* @param handlers - RPC handlers object that extends the base RpcHandlers
+* @returns The handlers object (for convenience)
+* @example
+* ```ts
+* export const rpcHandlers = defineRpcHandlers({
+*   querySelector: async (selector: string) => {
+*     // implementation
+*   },
+*   getDOMTree: async (maxDepth: number) => {
+*     // implementation
+*   }
+* });
+* ```
+*/
+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 };

package/dist/client/index.mjs

@@ -0,0 +1,146 @@
+//#region src/client/index.ts
+function generateId() {
+	return Math.random().toString(36).slice(2, 12);
+}
+function createDevpilotClient(options) {
+	const { wsPort, rpcHandlers: customHandlers } = options;
+	let ws = null;
+	let clientId = null;
+	const pendingCalls = /* @__PURE__ */ new Map();
+	const connectedCallbacks = /* @__PURE__ */ new Set();
+	const disconnectedCallbacks = /* @__PURE__ */ new Set();
+	const rpcHandlers = {
+		notifyTaskUpdate(count) {
+			window.dispatchEvent(new CustomEvent("devpilot:taskUpdate", { detail: { count } }));
+			customHandlers?.notifyTaskUpdate?.(count);
+		},
+		notifyTaskCompleted(taskId) {
+			window.dispatchEvent(new CustomEvent("devpilot:taskCompleted", { detail: { taskId } }));
+			customHandlers?.notifyTaskCompleted?.(taskId);
+		},
+		...customHandlers,
+		...options.extendRpcHandlers || {}
+	};
+	function connect() {
+		ws = new WebSocket(`ws://localhost:${wsPort}`);
+		ws.onopen = () => {
+			console.log("[devpilot] Connected to server");
+		};
+		ws.onmessage = (event) => {
+			try {
+				const data = JSON.parse(event.data);
+				if (data.type === "connected") {
+					clientId = data.clientId;
+					console.log("[devpilot] Client ID:", clientId);
+					rpcCall("updateClientInfo", {
+						url: location.href,
+						title: document.title,
+						userAgent: navigator.userAgent
+					});
+					connectedCallbacks.forEach((cb) => cb());
+					return;
+				}
+				if (data.t === "q" && data.m && data.m in rpcHandlers) {
+					const handler = rpcHandlers[data.m];
+					Promise.resolve(handler(...data.a || [])).then((result) => {
+						if (data.i) ws?.send(JSON.stringify({
+							t: "s",
+							i: data.i,
+							r: result
+						}));
+					}).catch((error) => {
+						if (data.i) ws?.send(JSON.stringify({
+							t: "s",
+							i: data.i,
+							e: error instanceof Error ? error.message : String(error)
+						}));
+					});
+					return;
+				}
+				if (data.t === "s" && data.i && pendingCalls.has(data.i)) {
+					const { resolve, reject } = pendingCalls.get(data.i);
+					pendingCalls.delete(data.i);
+					if (data.e) reject(new Error(String(data.e)));
+					else resolve(data.r);
+				}
+			} catch (e) {
+				console.error("[devpilot] Message parse error:", e);
+			}
+		};
+		ws.onclose = () => {
+			console.log("[devpilot] Disconnected, reconnecting...");
+			clientId = null;
+			disconnectedCallbacks.forEach((cb) => cb());
+			setTimeout(connect, 2e3);
+		};
+		ws.onerror = (err) => {
+			console.error("[devpilot] WebSocket error:", err);
+		};
+	}
+	function rpcCall(method, ...args) {
+		return new Promise((resolve, reject) => {
+			if (!ws || ws.readyState !== WebSocket.OPEN) {
+				reject(/* @__PURE__ */ new Error("WebSocket not connected"));
+				return;
+			}
+			const id = generateId();
+			pendingCalls.set(id, {
+				resolve,
+				reject
+			});
+			ws.send(JSON.stringify({
+				t: "q",
+				m: method,
+				a: args,
+				i: id
+			}));
+		});
+	}
+	connect();
+	return {
+		getClientId: () => clientId,
+		rpcCall,
+		isConnected: () => ws !== null && ws.readyState === WebSocket.OPEN,
+		onConnected: (callback) => {
+			connectedCallbacks.add(callback);
+			return () => connectedCallbacks.delete(callback);
+		},
+		onDisconnected: (callback) => {
+			disconnectedCallbacks.add(callback);
+			return () => disconnectedCallbacks.delete(callback);
+		}
+	};
+}
+let globalClient = null;
+function initDevpilot(options) {
+	if (globalClient) return globalClient;
+	globalClient = createDevpilotClient(options);
+	window.__devpilot = globalClient;
+	return globalClient;
+}
+function getDevpilotClient() {
+	return globalClient;
+}
+/**
+* Define and type-check RPC handlers for the client
+* This ensures the handlers are correctly typed and will be recognized by the RPC system
+* @param handlers - RPC handlers object that extends the base RpcHandlers
+* @returns The handlers object (for convenience)
+* @example
+* ```ts
+* export const rpcHandlers = defineRpcHandlers({
+*   querySelector: async (selector: string) => {
+*     // implementation
+*   },
+*   getDOMTree: async (maxDepth: number) => {
+*     // implementation
+*   }
+* });
+* ```
+*/
+function defineRpcHandlers(handlers) {
+	return handlers;
+}
+
+//#endregion
+export { createDevpilotClient, defineRpcHandlers, getDevpilotClient, initDevpilot };

package/dist/client/virtual.d.ts

@@ -0,0 +1,6 @@
+declare module 'virtual:devpilot-client' {
+  import type { DevpilotClient } from 'unplugin-devpilot/client';
+
+  export const client: DevpilotClient;
+  export const wsPort: number;
+}

package/dist/farm.d.mts

@@ -0,0 +1,19 @@
+import { t as unpluginDevpilot } from "./index-CyKvTBcJ.mjs";
+
+//#region src/farm.d.ts
+/**
+* Farm plugin
+*
+* @example
+* ```ts
+* // farm.config.js
+* import devpilot from 'unplugin-devpilot/farm'
+*
+* export default {
+*   plugins: [devpilot()],
+* }
+* ```
+*/
+declare const farm: typeof unpluginDevpilot.farm;
+//#endregion
+export { farm as default, farm as "module.exports" };

package/dist/farm.mjs

@@ -0,0 +1,26 @@
+import { n as unpluginDevpilot } from "./src-aMXlip6o.mjs";
+
+//#region src/farm.ts
+/**
+* This entry file is for Farm plugin.
+*
+* @module
+*/
+/**
+* Farm plugin
+*
+* @example
+* ```ts
+* // farm.config.js
+* import devpilot from 'unplugin-devpilot/farm'
+*
+* export default {
+*   plugins: [devpilot()],
+* }
+* ```
+*/
+const farm = unpluginDevpilot.farm;
+var farm_default = farm;
+
+//#endregion
+export { farm_default as default, farm as "module.exports" };