@vitejs/devtools 0.0.0-alpha.17 → 0.0.0-alpha.19

package/dist/{plugins-B_YgEdT2.js → plugins-l6D28NJB.js}

@@ -1,13 +1,14 @@
 import { n as dirDist, t as dirClientStandalone } from "./dirs-DcSK9l9L.js";
 import Debug from "debug";
-import { toDataURL } from "mlly";
 import { debounce } from "perfect-debounce";
+import { toDataURL } from "mlly";
+import { createEventEmitter } from "@vitejs/devtools-kit/utils/events";
 import { RpcFunctionsCollectorBase } from "birpc-x";
+import process$1 from "node:process";
 import { existsSync } from "node:fs";
 import sirv from "sirv";
 import { defineRpcFunction } from "@vitejs/devtools-kit";
 import { join } from "node:path";
-import process$1 from "node:process";
 import { normalizePath } from "vite";
 import { createRpcServer } from "@vitejs/devtools-rpc";
 import { createWsRpcPreset } from "@vitejs/devtools-rpc/presets/ws/server";
@@ -53,12 +54,9 @@ const ContextUtils = { createSimpleClientScript(fn) {
 //#region src/node/host-docks.ts
 var DevToolsDockHost = class {
 	views = /* @__PURE__ */ new Map();
-	_sendOnChange;
+	events = createEventEmitter();
 	constructor(context) {
 		this.context = context;
-		this._sendOnChange = debounce(() => {
-			context.rpc.boardcast?.$callOptional("vite:core:list-dock-entries:updated");
-		}, 10);
 	}
 	values() {
 		return Array.from(this.views.values());
@@ -66,12 +64,16 @@ var DevToolsDockHost = class {
 	register(view, force) {
 		if (this.views.has(view.id) && !force) throw new Error(`Dock with id "${view.id}" is already registered`);
 		this.views.set(view.id, view);
-		this._sendOnChange();
+		this.events.emit("dock:entry:updated", view);
+		return { update: (patch) => {
+			if (patch.id && patch.id !== view.id) throw new Error(`Cannot change the id of a dock. Use register() to add new docks.`);
+			this.update(Object.assign(this.views.get(view.id), patch));
+		} };
 	}
 	update(view) {
 		if (!this.views.has(view.id)) throw new Error(`Dock with id "${view.id}" is not registered. Use register() to add new docks.`);
 		this.views.set(view.id, view);
-		this._sendOnChange();
+		this.events.emit("dock:entry:updated", view);
 	}
 };
 
@@ -84,6 +86,104 @@ var RpcFunctionsHost = class extends RpcFunctionsCollectorBase {
 	}
 };
 
+//#endregion
+//#region src/node/host-terminals.ts
+var DevToolsTerminalHost = class {
+	sessions = /* @__PURE__ */ new Map();
+	events = createEventEmitter();
+	_boundStreams = /* @__PURE__ */ new Map();
+	constructor(context) {
+		this.context = context;
+	}
+	register(session) {
+		if (this.sessions.has(session.id)) throw new Error(`Terminal session with id "${session.id}" already registered`);
+		this.sessions.set(session.id, session);
+		this.bindStream(session);
+		this.events.emit("terminal:session:updated", session);
+		return session;
+	}
+	update(patch) {
+		if (!this.sessions.has(patch.id)) throw new Error(`Terminal session with id "${patch.id}" not registered`);
+		const session = this.sessions.get(patch.id);
+		Object.assign(session, patch);
+		this.sessions.set(patch.id, session);
+		this.bindStream(session);
+		this.events.emit("terminal:session:updated", session);
+	}
+	remove(session) {
+		this.sessions.delete(session.id);
+		this.events.emit("terminal:session:updated", session);
+		this._boundStreams.delete(session.id);
+	}
+	bindStream(session) {
+		if (this._boundStreams.has(session.id) && this._boundStreams.get(session.id)?.stream === session.stream) return;
+		this._boundStreams.get(session.id)?.dispose();
+		this._boundStreams.delete(session.id);
+		if (!session.stream) return;
+		session.buffer ||= [];
+		const events = this.events;
+		const writer = new WritableStream({ write(chunk) {
+			session.buffer.push(chunk);
+			events.emit("terminal:session:stream-chunk", {
+				id: session.id,
+				chunks: [chunk],
+				ts: Date.now()
+			});
+		} });
+		session.stream.pipeTo(writer);
+		this._boundStreams.set(session.id, {
+			dispose: () => {
+				writer.close();
+			},
+			stream: session.stream
+		});
+	}
+	async startChildProcess(executeOptions, terminal) {
+		if (this.sessions.has(terminal.id)) throw new Error(`Terminal session with id "${terminal.id}" already registered`);
+		const { exec } = await import("tinyexec");
+		let controller;
+		const stream = new ReadableStream({ start(_controller) {
+			controller = _controller;
+		} });
+		function createChildProcess() {
+			const cp$1 = exec(executeOptions.command, executeOptions.args || [], { nodeOptions: {
+				env: {
+					COLORS: "true",
+					FORCE_COLOR: "true",
+					...executeOptions.env || {}
+				},
+				cwd: executeOptions.cwd ?? process$1.cwd(),
+				stdio: "pipe"
+			} });
+			(async () => {
+				for await (const chunk of cp$1) controller?.enqueue(chunk);
+			})();
+			return cp$1;
+		}
+		let cp = createChildProcess();
+		const restart = async () => {
+			cp?.kill();
+			cp = createChildProcess();
+		};
+		const terminate = async () => {
+			cp?.kill();
+			cp = void 0;
+		};
+		const session = {
+			...terminal,
+			status: "running",
+			stream,
+			type: "child-process",
+			executeOptions,
+			getChildProcess: () => cp?.process,
+			terminate,
+			restart
+		};
+		this.register(session);
+		return Promise.resolve(session);
+	}
+};
+
 //#endregion
 //#region src/node/host-views.ts
 var DevToolsViewHost = class {
@@ -111,20 +211,76 @@ var DevToolsViewHost = class {
 };
 
 //#endregion
-//#region src/node/rpc/list-dock-entries.ts
-const listDockEntries = defineRpcFunction({
-	name: "vite:core:list-dock-entries",
-	type: "query",
+//#region src/node/rpc/internal/docks-list.ts
+const docksList = defineRpcFunction({
+	name: "vite:internal:docks:list",
+	type: "static",
 	setup: (context) => {
-		return { handler: () => Array.from(context.docks.values()) };
+		const builtinDocksEntries = [{
+			type: "~builtin",
+			id: "~terminals",
+			title: "Terminals",
+			icon: "ph:terminal-duotone",
+			get isHidden() {
+				return context.terminals.sessions.size === 0;
+			}
+		}];
+		return { handler: () => [...Array.from(context.docks.values()), ...builtinDocksEntries] };
 	}
 });
 
 //#endregion
-//#region src/node/rpc/list-rpc-functions.ts
-const listRpcFunctions = defineRpcFunction({
-	name: "vite:core:list-rpc-functions",
+//#region src/node/rpc/internal/docks-on-launch.ts
+const docksOnLaunch = defineRpcFunction({
+	name: "vite:internal:docks:on-launch",
 	type: "action",
+	setup: (context) => {
+		const launchMap = /* @__PURE__ */ new Map();
+		return { handler: async (entryId) => {
+			if (launchMap.has(entryId)) return launchMap.get(entryId);
+			const entry = context.docks.values().find((entry$1) => entry$1.id === entryId);
+			if (!entry) throw new Error(`Dock entry with id "${entryId}" not found`);
+			if (entry.type !== "launcher") throw new Error(`Dock entry with id "${entryId}" is not a launcher`);
+			try {
+				context.docks.update({
+					...entry,
+					launcher: {
+						...entry.launcher,
+						status: "loading"
+					}
+				});
+				const promise = entry.launcher.onLaunch();
+				launchMap.set(entryId, promise);
+				const result = await promise;
+				const newEntry = context.docks.values().find((entry$1) => entry$1.id === entryId) || entry;
+				if (newEntry.type === "launcher") context.docks.update({
+					...newEntry,
+					launcher: {
+						...newEntry.launcher,
+						status: "success"
+					}
+				});
+				return result;
+			} catch (error) {
+				console.error(`[VITE DEVTOOLS] Error launching dock entry "${entryId}"`, error);
+				context.docks.update({
+					...entry,
+					launcher: {
+						...entry.launcher,
+						status: "error",
+						error: error instanceof Error ? error.message : String(error)
+					}
+				});
+			}
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/internal/rpc-server-list.ts
+const rpcServerList = defineRpcFunction({
+	name: "vite:internal:rpc:server:list",
+	type: "static",
 	setup: (context) => {
 		return { async handler() {
 			return Object.fromEntries(Array.from(context.rpc.definitions.entries()).map(([name, fn]) => [name, { type: fn.type }]));
@@ -133,7 +289,43 @@ const listRpcFunctions = defineRpcFunction({
 });
 
 //#endregion
-//#region src/node/rpc/open-in-editor.ts
+//#region src/node/rpc/internal/terminals-list.ts
+const terminalsList = defineRpcFunction({
+	name: "vite:internal:terminals:list",
+	type: "static",
+	setup: (context) => {
+		return { async handler() {
+			return Array.from(context.terminals.sessions.values()).map((i$1) => {
+				return {
+					id: i$1.id,
+					title: i$1.title,
+					description: i$1.description,
+					status: i$1.status
+				};
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/internal/terminals-read.ts
+const terminalsRead = defineRpcFunction({
+	name: "vite:internal:terminals:read",
+	type: "query",
+	setup: (context) => {
+		return { async handler(id) {
+			const seesion = context.terminals.sessions.get(id);
+			if (!seesion) throw new Error(`Terminal session with id "${id}" not found`);
+			return {
+				buffer: seesion.buffer ?? [],
+				ts: Date.now()
+			};
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/public/open-in-editor.ts
 const openInEditor = defineRpcFunction({
 	name: "vite:core:open-in-editor",
 	type: "action",
@@ -145,7 +337,7 @@ const openInEditor = defineRpcFunction({
 });
 
 //#endregion
-//#region src/node/rpc/open-in-finder.ts
+//#region src/node/rpc/public/open-in-finder.ts
 const openInFinder = defineRpcFunction({
 	name: "vite:core:open-in-finder",
 	type: "action",
@@ -158,12 +350,15 @@ const openInFinder = defineRpcFunction({
 
 //#endregion
 //#region src/node/rpc/index.ts
-const builtinRpcFunctions = [
-	listRpcFunctions,
-	listDockEntries,
-	openInEditor,
-	openInFinder
+const builtinPublicRpcDecalrations = [openInEditor, openInFinder];
+const builtinInternalRpcDecalrations = [
+	docksList,
+	docksOnLaunch,
+	rpcServerList,
+	terminalsList,
+	terminalsRead
 ];
+const builtinRpcDecalrations = [...builtinPublicRpcDecalrations, ...builtinInternalRpcDecalrations];
 
 //#endregion
 //#region src/node/context.ts
@@ -177,15 +372,28 @@ async function createDevToolsContext(viteConfig, viteServer) {
 		rpc: void 0,
 		docks: void 0,
 		views: void 0,
-		utils: ContextUtils
+		utils: ContextUtils,
+		terminals: void 0
 	};
 	const rpcHost = new RpcFunctionsHost(context);
 	const docksHost = new DevToolsDockHost(context);
 	const viewsHost = new DevToolsViewHost(context);
+	const terminalsHost = new DevToolsTerminalHost(context);
 	context.rpc = rpcHost;
 	context.docks = docksHost;
 	context.views = viewsHost;
-	for (const fn of builtinRpcFunctions) rpcHost.register(fn);
+	context.terminals = terminalsHost;
+	for (const fn of builtinRpcDecalrations) rpcHost.register(fn);
+	docksHost.events.on("dock:entry:updated", debounce(() => {
+		rpcHost.boardcast.$callOptional("vite:internal:docks:updated");
+	}, 10));
+	terminalsHost.events.on("terminal:session:updated", debounce(() => {
+		rpcHost.boardcast.$callOptional("vite:internal:terminals:updated");
+		rpcHost.boardcast.$callOptional("vite:internal:docks:updated");
+	}, 10));
+	terminalsHost.events.on("terminal:session:stream-chunk", (data) => {
+		rpcHost.boardcast.$callOptional("vite:internal:terminals:stream-chunk", data);
+	});
 	const plugins = viteConfig.plugins.filter((plugin) => "devtools" in plugin);
 	for (const plugin of plugins) {
 		if (!plugin.devtools?.setup) continue;
@@ -1275,20 +1483,21 @@ async function createWsServer(options) {
 //#endregion
 //#region src/node/server.ts
 async function createDevToolsMiddleware(options) {
-	const app = createApp();
-	const { rpc, getConnectionMeta: getMetadata } = await createWsServer(options);
-	app.use("/.vdt-connection.json", eventHandler(async (event) => {
+	const h3 = createApp();
+	const { rpc, getConnectionMeta } = await createWsServer(options);
+	h3.use("/.vdt-connection.json", eventHandler(async (event) => {
 		event.node.res.setHeader("Content-Type", "application/json");
-		return event.node.res.end(JSON.stringify(await getMetadata()));
+		return event.node.res.end(JSON.stringify(await getConnectionMeta()));
 	}));
-	app.use(fromNodeMiddleware(sirv(dirClientStandalone, {
+	h3.use(fromNodeMiddleware(sirv(dirClientStandalone, {
 		dev: true,
 		single: true
 	})));
 	return {
-		h3: app,
-		middleware: toNodeListener(app),
-		rpc
+		h3,
+		rpc,
+		middleware: toNodeListener(h3),
+		getConnectionMeta
 	};
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitejs/devtools",
   "type": "module",
-  "version": "0.0.0-alpha.17",
+  "version": "0.0.0-alpha.19",
   "description": "Vite DevTools",
   "author": "VoidZero Inc.",
   "license": "MIT",
@@ -47,26 +47,28 @@
     "debug": "^4.4.3",
     "launch-editor": "^2.12.0",
     "mlly": "^1.8.0",
-    "nanoevents": "^9.1.0",
-    "open": "^10.2.0",
+    "open": "^11.0.0",
     "pathe": "^2.0.3",
     "perfect-debounce": "^2.0.0",
     "sirv": "^3.0.2",
+    "tinyexec": "^1.0.2",
     "ws": "^8.18.3",
-    "@vitejs/devtools-rpc": "0.0.0-alpha.17",
-    "@vitejs/devtools-kit": "0.0.0-alpha.17",
-    "@vitejs/devtools-vite": "0.0.0-alpha.17"
+    "@vitejs/devtools-rpc": "0.0.0-alpha.19",
+    "@vitejs/devtools-kit": "0.0.0-alpha.19",
+    "@vitejs/devtools-vite": "0.0.0-alpha.19"
   },
   "devDependencies": {
-    "@vitejs/plugin-vue": "^6.0.1",
+    "@vitejs/plugin-vue": "^6.0.2",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/xterm": "^5.5.0",
     "tsdown": "^0.16.1",
     "typescript": "^5.9.3",
-    "unplugin-vue": "^7.0.4",
+    "unplugin-vue": "^7.0.8",
     "vite": "npm:rolldown-vite@^7.2.2",
-    "vue": "^3.5.24",
-    "vue-tsc": "^3.1.3",
-    "@vitejs/devtools-vite": "0.0.0-alpha.17",
-    "@vitejs/devtools": "0.0.0-alpha.17"
+    "vue": "^3.5.25",
+    "vue-tsc": "^3.1.5",
+    "@vitejs/devtools-vite": "0.0.0-alpha.19",
+    "@vitejs/devtools": "0.0.0-alpha.19"
   },
   "scripts": {
     "build": "pnpm build:js && pnpm build:standalone",
@@ -75,7 +77,7 @@
     "watch": "tsdown --watch --config-loader=tsx",
     "dev:standalone": "cd src/client/standalone && vite dev",
     "play": "DEBUG='vite:devtools:*' pnpm -C playground run dev",
-    "play:standlone": "DEBUG='vite:devtools:*' pnpm -C playground run dev:standalone",
+    "play:standalone": "DEBUG='vite:devtools:*' pnpm -C playground run dev:standalone",
     "cli": "DEBUG='vite:devtools:*' tsx src/node/cli.ts",
     "play:build": "pnpm -C playground run build"
   }