@vitejs/devtools 0.1.5 → 0.1.8

package/dist/plugins-DfC1vp4w.js

@@ -0,0 +1,31 @@
+import { t as DevToolsServer } from "./server-DhChc9gv.js";
+import { dirDist } from "./dirs.js";
+import { join, normalize } from "pathe";
+import process from "node:process";
+//#region src/node/plugins/injection.ts
+function DevToolsInjection() {
+	return {
+		name: "vite:devtools:injection",
+		enforce: "post",
+		transformIndexHtml() {
+			return [{
+				tag: "script",
+				attrs: {
+					src: `/@fs/${process.env.VITE_DEVTOOLS_LOCAL_DEV ? normalize(join(dirDist, "..", "src/client/inject/index.ts")) : normalize(join(dirDist, "client/inject.js"))}`,
+					type: "module"
+				},
+				injectTo: "body"
+			}];
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/index.ts
+async function DevTools(options = {}) {
+	const { builtinDevTools = true } = options;
+	const plugins = [DevToolsInjection(), DevToolsServer()];
+	if (builtinDevTools) plugins.push(await import("@vitejs/devtools-rolldown").then((m) => m.DevToolsRolldownUI()));
+	return plugins;
+}
+//#endregion
+export { DevTools as t };

package/dist/{popup-BUPO6e0I.js → popup-CAT8YohS.js}

@@ -1,5 +1,5 @@
-import { G as shallowRef, M as watch, V as reactive, z as markRaw } from "./vue.runtime.esm-bundler-CS1wMbap.js";
 import { createEventEmitter } from "@vitejs/devtools-kit/utils/events";
+import { markRaw, reactive, shallowRef, watch } from "vue";
 //#region src/client/webcomponents/constants.ts
 const BUILTIN_ENTRY_CLIENT_AUTH_NOTICE = Object.freeze({
 	type: "~builtin",
@@ -170,7 +170,7 @@ let detachColorModeSync;
 let popupDockElement;
 let popupContext;
 let loadDockStandalone = async () => {
-	return await import("./DockStandalone-DxFEMDp2.js").then((n) => n.n).then((m) => m.DockStandalone);
+	return await import("./DockStandalone-BuMVHLt_.js").then((n) => n.n).then((m) => m.DockStandalone);
 };
 popupEvents.on("popup:open-requested", (context) => {
 	openDockPopup(context);

package/dist/server-BuWZ1h8p.js

@@ -0,0 +1,241 @@
+import { i as __exportAll, n as ansis_default, t as MARK_INFO } from "./constants-DfEeYo9W.js";
+import { t as getInternalContext } from "./context-internal-DZpoJjMz.js";
+import { dirClientStandalone } from "./dirs.js";
+import { n as getPort } from "./dist-DpLy3ojW.js";
+import { createDebug } from "obug";
+import { DEVTOOLS_CONNECTION_META_FILENAME } from "@vitejs/devtools-kit/constants";
+import process from "node:process";
+import sirv from "sirv";
+import { humanId } from "@vitejs/devtools-kit/utils/human-id";
+import { createApp, eventHandler, fromNodeMiddleware, getQuery, toNodeListener } from "h3";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createWsRpcPreset } from "@vitejs/devtools-rpc/presets/ws/server";
+import { createRpcServer } from "@vitejs/devtools-rpc/server";
+//#region src/node/auth-state.ts
+let pendingAuth = null;
+let tempAuthToken = generateTempId();
+function generateTempId() {
+	return humanId({
+		separator: "-",
+		capitalize: false
+	});
+}
+function getTempAuthToken() {
+	return tempAuthToken;
+}
+function refreshTempAuthToken() {
+	tempAuthToken = generateTempId();
+	return tempAuthToken;
+}
+function setPendingAuth(request) {
+	pendingAuth = request;
+}
+/**
+* Abort and clean up any existing pending auth request.
+*/
+function abortPendingAuth() {
+	if (pendingAuth) {
+		pendingAuth.abortController.abort();
+		clearTimeout(pendingAuth.timeout);
+		pendingAuth = null;
+	}
+}
+/**
+* Consume the temp auth ID: verify it matches, trust the pending client, and clean up.
+* Returns the client's authToken if successful, null otherwise.
+*/
+function consumeTempAuthToken(id, storage) {
+	if (id !== tempAuthToken || !pendingAuth) return null;
+	const { clientAuthToken, session, ua, origin, resolve } = pendingAuth;
+	storage.mutate((state) => {
+		state.trusted[clientAuthToken] = {
+			authToken: clientAuthToken,
+			ua,
+			origin,
+			timestamp: Date.now()
+		};
+	});
+	session.meta.clientAuthToken = clientAuthToken;
+	session.meta.isTrusted = true;
+	resolve({ isTrusted: true });
+	abortPendingAuth();
+	refreshTempAuthToken();
+	return clientAuthToken;
+}
+//#endregion
+//#region src/node/ws.ts
+const debugInvoked = createDebug("vite:devtools:rpc:invoked");
+const ANONYMOUS_SCOPE = "vite:anonymous:";
+async function createWsServer(options) {
+	const rpcHost = options.context.rpc;
+	const host = options.hostWebSocket ?? "localhost";
+	const https = options.context.viteConfig.server.https;
+	const port = options.portWebSocket ?? await getPort({
+		port: 7812,
+		host,
+		random: true
+	});
+	const wsClients = /* @__PURE__ */ new Set();
+	const context = options.context;
+	const contextInternal = getInternalContext(context);
+	const isClientAuthDisabled = context.mode === "build" || context.viteConfig.devtools?.config?.clientAuth === false || process.env.VITE_DEVTOOLS_DISABLE_CLIENT_AUTH === "true";
+	if (isClientAuthDisabled) console.warn("[Vite DevTools] Client authentication is disabled. Any browser can connect to the devtools and access to your server and filesystem.");
+	const preset = createWsRpcPreset({
+		port,
+		host,
+		https,
+		onConnected: (ws, req, meta) => {
+			const authToken = new URL(req.url ?? "", "http://localhost").searchParams.get("vite_devtools_auth_token") ?? void 0;
+			if (isClientAuthDisabled) meta.isTrusted = true;
+			else if (authToken && contextInternal.storage.auth.value().trusted[authToken]) {
+				meta.isTrusted = true;
+				meta.clientAuthToken = authToken;
+			} else if (authToken && ((context.viteConfig.devtools?.config)?.clientAuthTokens ?? []).includes(authToken)) {
+				meta.isTrusted = true;
+				meta.clientAuthToken = authToken;
+			}
+			wsClients.add(ws);
+			const color = meta.isTrusted ? ansis_default.green : ansis_default.yellow;
+			const trustedKeys = Object.keys(contextInternal.storage.auth.value().trusted);
+			console.log(color`${MARK_INFO} Websocket client connected. [${meta.id}] [${meta.clientAuthToken}] (${meta.isTrusted ? "trusted" : "untrusted"}) authToken=${authToken} trustedKeys=${JSON.stringify(trustedKeys)} isClientAuthDisabled=${isClientAuthDisabled}`);
+		},
+		onDisconnected: (ws, meta) => {
+			wsClients.delete(ws);
+			console.log(ansis_default.red`${MARK_INFO} Websocket client disconnected. [${meta.id}]`);
+		}
+	});
+	const asyncStorage = new AsyncLocalStorage();
+	const rpcGroup = createRpcServer(rpcHost.functions, {
+		preset,
+		rpcOptions: {
+			onFunctionError(error, name) {
+				console.error(ansis_default.red`⬢ RPC error on executing "${ansis_default.bold(name)}":`);
+				console.error(error);
+			},
+			onGeneralError(error) {
+				console.error(ansis_default.red`⬢ RPC error on executing rpc`);
+				console.error(error);
+			},
+			resolver(name, fn) {
+				const rpc = this;
+				if (!name.startsWith(ANONYMOUS_SCOPE) && !rpc.$meta.isTrusted) return () => {
+					throw new Error(`Unauthorized access to method ${JSON.stringify(name)} from client [${rpc.$meta.id}]`);
+				};
+				if (!fn) return void 0;
+				return async function(...args) {
+					debugInvoked(`${JSON.stringify(name)} from #${rpc.$meta.id}`);
+					return await asyncStorage.run({
+						rpc,
+						meta: rpc.$meta
+					}, async () => {
+						return (await fn).apply(this, args);
+					});
+				};
+			}
+		}
+	});
+	rpcHost._rpcGroup = rpcGroup;
+	rpcHost._asyncStorage = asyncStorage;
+	const getConnectionMeta = async () => {
+		return {
+			backend: "websocket",
+			websocket: port
+		};
+	};
+	return {
+		port,
+		rpc: rpcGroup,
+		rpcHost,
+		getConnectionMeta
+	};
+}
+//#endregion
+//#region src/node/server.ts
+var server_exports = /* @__PURE__ */ __exportAll({ createDevToolsMiddleware: () => createDevToolsMiddleware });
+function generateAuthPageHtml() {
+	return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Vite DevTools Authorization</title>
+  <style>
+    html { font-family: system-ui, sans-serif; padding: 2rem; }
+    body { height: 80vh; display: flex; flex-direction: column; justify-content: center; align-items: center; gap: 1rem; }
+    #message { font-size: 1.2rem; }
+    @media (prefers-color-scheme: dark) { html { background: #1a1a1a; color: #e0e0e0; } }
+  </style>
+</head>
+<body>
+  <div id="message">Verifying...</div>
+  <script>
+    const query = new URLSearchParams(location.search)
+    const id = query.get('id')
+    const el = document.getElementById('message')
+
+    if (!id) {
+      el.textContent = '\\u26a0\\ufe0f No auth token found. Please check your URL.'
+      el.style.color = '#df513f'
+    } else {
+      fetch(location.pathname.replace(/\\/$/, '') + '-verify?id=' + encodeURIComponent(id))
+        .then(async (r) => {
+          if (r.status !== 200) throw new Error(await r.text())
+          const data = await r.json()
+          const authToken = data.authToken
+
+          localStorage.setItem('__VITE_DEVTOOLS_CONNECTION_AUTH_TOKEN__', authToken)
+
+          try {
+            const bc = new BroadcastChannel('vite-devtools-auth')
+            bc.postMessage({ type: 'auth-update', authToken: authToken })
+          } catch {}
+
+          el.textContent = '\\u2705 Authorized! You can close this window now.'
+          window.close()
+        })
+        .catch((err) => {
+          el.textContent = '\\u26a0\\ufe0f Failed to authorize: ' + err.message
+          el.style.color = '#df513f'
+        })
+    }
+  <\/script>
+</body>
+</html>`;
+}
+async function createDevToolsMiddleware(options) {
+	const h3 = createApp();
+	const contextInternal = getInternalContext(options.context);
+	const { rpc, getConnectionMeta } = await createWsServer(options);
+	h3.use(`/${DEVTOOLS_CONNECTION_META_FILENAME}`, eventHandler(async (event) => {
+		event.node.res.setHeader("Content-Type", "application/json");
+		return event.node.res.end(JSON.stringify(await getConnectionMeta()));
+	}));
+	h3.use("/auth-verify", eventHandler((event) => {
+		const { id } = getQuery(event);
+		if (!id) {
+			event.node.res.statusCode = 400;
+			return event.node.res.end("Missing id parameter");
+		}
+		const clientAuthToken = consumeTempAuthToken(id, contextInternal.storage.auth);
+		if (!clientAuthToken) {
+			event.node.res.statusCode = 403;
+			return event.node.res.end("Invalid or expired auth token");
+		}
+		event.node.res.setHeader("Content-Type", "application/json");
+		return event.node.res.end(JSON.stringify({ authToken: clientAuthToken }));
+	}));
+	h3.use("/auth", eventHandler((event) => {
+		event.node.res.setHeader("Content-Type", "text/html");
+		return event.node.res.end(generateAuthPageHtml());
+	}));
+	h3.use(fromNodeMiddleware(sirv(dirClientStandalone, {
+		dev: true,
+		single: true
+	})));
+	return {
+		h3,
+		rpc,
+		middleware: toNodeListener(h3),
+		getConnectionMeta
+	};
+}
+//#endregion
+export { refreshTempAuthToken as a, getTempAuthToken as i, server_exports as n, setPendingAuth as o, abortPendingAuth as r, createDevToolsMiddleware as t };

package/dist/server-Ca6LOTxO.js

@@ -0,0 +1,3 @@
+import { n as renderDockImportsMap } from "./server-DhChc9gv.js";
+import "./dist-DpLy3ojW.js";
+export { renderDockImportsMap };