@pubinfo/vite 2.0.12 → 2.0.14

package/dist/index.d.ts

@@ -1,9 +1,26 @@
 import { UserConfig, UserConfigFnObject } from "rolldown-vite";
+import * as vite_plugin_vue_devtools0 from "vite-plugin-vue-devtools";
+import { VitePluginVueDevToolsOptions } from "vite-plugin-vue-devtools";
 import * as _pubinfo_unplugin_openapi0 from "@pubinfo/unplugin-openapi";
 import { Options } from "@pubinfo/unplugin-openapi";
 export * from "rolldown-vite";
 export * from "vite-plugin-fake-server/client";
 
+//#region src/plugins/built-in/chrome-devtools.d.ts
+/**
+ * Chrome DevTools 插件配置选项
+ */
+interface ChromeDevtoolsOptions {
+  /** 是否启用插件 */
+  enabled?: boolean;
+  /** 自定义端口，如果不指定则自动分配 */
+  port?: number;
+  /** 是否自动注入调试脚本到页面 */
+  autoInject?: boolean;
+  /** DevTools 面板访问路径 */
+  panelPath?: string;
+}
+//#endregion
 //#region src/plugins/built-in/inject-auto.d.ts
 interface InjectAutoOptions {
   id: string;
@@ -54,6 +71,12 @@ interface PubinfoConfig {
   openapi?: Options;
   /** `resolver` */
   resolver?: ResolverPluginOptions;
+  /** devtools */
+  devtools?: Omit<VitePluginVueDevToolsOptions, 'enabled'> & {
+    enabled?: boolean;
+  };
+  /** chrome devtools */
+  chromeDevtools?: ChromeDevtoolsOptions;
   /** `commitlint` */
   commitlint?: boolean | CommitlintOptions;
 }
@@ -72,6 +95,10 @@ declare function definePubinfoConfig(config: PubinfoConfig): {
   vite: UserConfigFnObject;
   openapi?: _pubinfo_unplugin_openapi0.Options;
   resolver?: ResolverPluginOptions;
+  devtools?: Omit<vite_plugin_vue_devtools0.VitePluginVueDevToolsOptions, "enabled"> & {
+    enabled?: boolean;
+  };
+  chromeDevtools?: ChromeDevtoolsOptions;
   commitlint?: boolean | CommitlintOptions;
 };
 /**
@@ -82,7 +109,11 @@ declare function defineModuleConfig(config: ModuleConfig): {
   moduleId: InjectAutoOptions["id"];
   openapi?: _pubinfo_unplugin_openapi0.Options;
   resolver?: ResolverPluginOptions;
+  devtools?: Omit<vite_plugin_vue_devtools0.VitePluginVueDevToolsOptions, "enabled"> & {
+    enabled?: boolean;
+  };
+  chromeDevtools?: ChromeDevtoolsOptions;
   commitlint?: boolean | CommitlintOptions;
 };
 //#endregion
-export { CommitlintOptions, ModuleConfig, PubinfoConfig, ResolverPluginOptions, defineModuleConfig, definePubinfoConfig };
+export { ChromeDevtoolsOptions, CommitlintOptions, ModuleConfig, PubinfoConfig, ResolverPluginOptions, defineModuleConfig, definePubinfoConfig };

package/dist/index.js

@@ -1,16 +1,19 @@
 import { createRequire } from "node:module";
 import { defineConfig, loadEnv, mergeConfig, normalizePath } from "rolldown-vite";
-import { cwd } from "node:process";
+import process, { cwd } from "node:process";
 import chalk from "chalk";
 import consola from "consola";
-import { dirname, join, posix, relative, resolve } from "node:path";
+import path, { dirname, join, posix, relative, resolve } from "node:path";
 import vue from "@vitejs/plugin-vue";
 import vueJsx from "@vitejs/plugin-vue-jsx";
+import fs from "fs-extra";
 import boxen from "boxen";
 import MagicString from "magic-string";
 import fg from "fast-glob";
 import { merge } from "lodash-es";
 import picomatch from "picomatch";
+import "micromatch";
+import { execSync } from "node:child_process";
 import dayjs from "dayjs";
 import { readPackageJSON } from "pkg-types";
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
@@ -40,7 +43,7 @@ export * from "vite-plugin-fake-server/client"
 //#region src/helper/alias.ts
 function alias(root) {
 	const resolvePath = (name) => join(root, name);
-	const resolveDeps = (name, path) => join(createRequire(import.meta.url).resolve(name), path);
+	const resolveDeps = (name, path$1) => join(createRequire(import.meta.url).resolve(name), path$1);
 	return {
 		"@": resolvePath("src"),
 		"#": resolvePath("types"),
@@ -66,13 +69,379 @@ function getServerProxy(env, isProxy) {
 		else serverProxy[pk] = {
 			target: url,
 			changeOrigin: true,
-			rewrite: (path) => path.replace(pk, ""),
+			rewrite: (path$1) => path$1.replace(pk, ""),
 			secure: false
 		};
 	}
 	return serverProxy;
 }
 
+//#endregion
+//#region src/plugins/built-in/chrome-devtools.ts
+const GLOBAL_STATE_KEY = "__pubinfoChromeDevtoolsState__";
+const DEFAULT_VITE_PORT = 5173;
+const DEFAULT_HOST = "localhost";
+const RANDOM_PORT_RANGE = {
+	min: 56e3,
+	max: 64e3
+};
+function getGlobalState() {
+	const globalRef = globalThis;
+	if (!globalRef[GLOBAL_STATE_KEY]) globalRef[GLOBAL_STATE_KEY] = {};
+	return globalRef[GLOBAL_STATE_KEY];
+}
+/**
+* 管理 chii (Chrome DevTools 后端) 的生命周期与日志。
+*/
+var ChiiServiceManager = class {
+	port;
+	isStarted = false;
+	loggingPatched = false;
+	globalState;
+	constructor() {
+		this.globalState = getGlobalState();
+	}
+	/**
+	* 启动 chii 服务，自动处理端口复用、冲突检测与启动失败兜底。
+	*/
+	async start(customPort, vitePort, viteHost, panelPath) {
+		if (this.isStarted && this.port) return this.port;
+		const reusedPort = await this.tryReuseExistingService(customPort, vitePort);
+		if (reusedPort) {
+			this.registerPort(reusedPort);
+			return reusedPort;
+		}
+		try {
+			const { start } = await this.importChii();
+			const portCandidate = customPort || this.generatePort(vitePort);
+			const port = await this.findAvailablePort(portCandidate, customPort === void 0);
+			if (port == null) {
+				console.warn("[pubinfo][chrome-devtools] 未找到可用的 DevTools 端口，跳过启动");
+				return;
+			}
+			start({ port });
+			this.registerPort(port);
+			return port;
+		} catch (error) {
+			console.warn("[pubinfo][chrome-devtools] 启动 Chii 失败:", error);
+			return;
+		}
+	}
+	getPort() {
+		return this.port;
+	}
+	isServiceStarted() {
+		return this.isStarted && !!this.port;
+	}
+	registerPort(port) {
+		this.port = port;
+		this.isStarted = true;
+		this.globalState.port = port;
+	}
+	async tryReuseExistingService(customPort, vitePort) {
+		if (this.globalState.port != null) {
+			if (await this.isChiiRunning(this.globalState.port)) return this.globalState.port;
+			this.globalState.port = void 0;
+		}
+		if (customPort != null) {
+			if (await this.isChiiRunning(customPort)) return customPort;
+			return;
+		}
+		if (vitePort) {
+			const generatedPort = this.generatePort(vitePort);
+			if (await this.isChiiRunning(generatedPort)) return generatedPort;
+		}
+	}
+	generatePort(vitePort) {
+		if (vitePort) {
+			const prefixedCandidate = Number(`6${vitePort}`);
+			if (Number.isFinite(prefixedCandidate) && prefixedCandidate <= 65535) return prefixedCandidate;
+			const highRangeCandidate = 6e4 + vitePort % 1e3;
+			if (highRangeCandidate <= 65535) return highRangeCandidate;
+		}
+		const { min, max } = RANDOM_PORT_RANGE;
+		return min + Math.floor(Math.random() * (max - min + 1));
+	}
+	async findAvailablePort(startPort, allowIncrement) {
+		let port = startPort;
+		for (let attempt = 0; attempt < 20; attempt += 1) {
+			if (await this.isPortAvailable(port)) return port;
+			if (!allowIncrement) return;
+			port += 1;
+		}
+	}
+	async isPortAvailable(port) {
+		const net = await this.importNet();
+		return await new Promise((resolve$1) => {
+			const tester = net.createServer();
+			tester.once("error", () => {
+				try {
+					tester.close();
+				} catch {}
+				resolve$1(false);
+			});
+			tester.once("listening", () => {
+				tester.close(() => resolve$1(true));
+			});
+			tester.listen(port);
+		});
+	}
+	async isChiiRunning(port) {
+		try {
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(), 300);
+			try {
+				const response = await fetch(`http://127.0.0.1:${port}/targets`, { signal: controller.signal });
+				if (!response.ok) return false;
+				const data = await response.json();
+				return Array.isArray(data?.targets);
+			} finally {
+				clearTimeout(timeout);
+			}
+		} catch {
+			return false;
+		}
+	}
+	async importChii() {
+		await this.patchChiiLogger();
+		return await import(
+			/* @vite-ignore */
+			"chii"
+);
+	}
+	async importNet() {
+		return await import("node:net");
+	}
+	async patchChiiLogger() {
+		if (this.loggingPatched) return;
+		try {
+			const utilModule = createRequire(import.meta.url)("chii/server/lib/util.js");
+			const utilTarget = typeof utilModule.log === "function" ? utilModule : utilModule.default;
+			if (!utilTarget || typeof utilTarget.log !== "function") {
+				console.warn("[pubinfo][chrome-devtools] 未检测到 chii util.log，跳过日志定制");
+				this.loggingPatched = true;
+				return;
+			}
+			const descriptor = Object.getOwnPropertyDescriptor(utilTarget, "log");
+			if (descriptor && descriptor.writable === false) Object.defineProperty(utilTarget, "log", {
+				...descriptor,
+				writable: true,
+				configurable: true
+			});
+			const patchedLog = () => {};
+			const targetExports = utilTarget;
+			const moduleExports = utilModule;
+			const defaultExports = utilModule.default;
+			targetExports.log = patchedLog;
+			if (moduleExports !== targetExports) moduleExports.log = patchedLog;
+			if (defaultExports && defaultExports !== targetExports) defaultExports.log = patchedLog;
+			this.loggingPatched = true;
+		} catch (error) {
+			console.warn("[pubinfo][chrome-devtools] 自定义 DevTools 日志失败:", error);
+		}
+	}
+};
+/**
+* 处理 /__chrome_devtools 面板访问跳转：实时查询 chii targets，生成前端面板地址。
+*/
+var DevToolsPanelHandler = class {
+	panelPath;
+	serviceManager;
+	constructor(panelPath, serviceManager) {
+		this.panelPath = panelPath;
+		this.serviceManager = serviceManager;
+	}
+	createMiddleware(server) {
+		server.middlewares.use(async (req, res, next) => {
+			if (!this.isTargetPath(req.url)) return next();
+			const port = this.serviceManager.getPort();
+			if (!port) {
+				this.sendErrorResponse(res, "DevTools 后端服务未启动");
+				return;
+			}
+			try {
+				const devtoolsUrl = await this.getDevToolsUrl(port);
+				this.sendRedirectResponse(res, devtoolsUrl);
+			} catch (error) {
+				console.warn("[pubinfo][chrome-devtools] 获取 DevTools URL 失败:", error);
+				this.sendRedirectResponse(res, `http://127.0.0.1:${port}/`);
+			}
+		});
+	}
+	isTargetPath(url) {
+		if (!url) return false;
+		return url === this.panelPath || url === `${this.panelPath}/`;
+	}
+	async getDevToolsUrl(port) {
+		const firstTarget = (await (await fetch(`http://127.0.0.1:${port}/targets`)).json())?.targets?.[0];
+		if (firstTarget) {
+			const wsId = Math.random().toString(36).slice(2, 10);
+			return `http://127.0.0.1:${port}/front_end/chii_app.html?ws=${encodeURIComponent(`127.0.0.1:${port}/client/${wsId}?target=${firstTarget.id}`)}&rtc=false`;
+		}
+		return `http://127.0.0.1:${port}/`;
+	}
+	sendErrorResponse(res, message) {
+		res.statusCode = 503;
+		res.end(message);
+	}
+	sendRedirectResponse(res, location) {
+		res.statusCode = 302;
+		res.setHeader("Location", location);
+		res.end();
+	}
+};
+/**
+* 负责把 target.js 注入到 HTML 中，使页面成为可调试目标。
+*/
+var HtmlInjector = class {
+	serviceManager;
+	constructor(serviceManager) {
+		this.serviceManager = serviceManager;
+	}
+	injectScript(html) {
+		const port = this.serviceManager.getPort();
+		if (!port) return html;
+		const injectedMarker = `//__chrome_devtools_target_${port}`;
+		if (html.includes(injectedMarker)) return html;
+		const scriptTag = this.createScriptTag(port, injectedMarker);
+		return this.insertScriptTag(html, scriptTag);
+	}
+	createScriptTag(port, marker) {
+		return `<script>${marker}<\/script>\n<script src="http://127.0.0.1:${port}/target.js" data-pubinfo-devtools="chrome"><\/script>`;
+	}
+	insertScriptTag(html, scriptTag) {
+		if (/<head[\s\S]*?>/i.test(html)) return html.replace(/<head([\s\S]*?)>/i, (match) => `${match}\n${scriptTag}`);
+		return html.replace(/<body(.*?)>/i, (match) => `${match}\n${scriptTag}`);
+	}
+};
+/**
+* 管理 Vite Dev Server 与 chii 服务之间的协作：监听端口、控制打印、确保服务可用。
+*/
+var DevServerOrchestrator = class {
+	server;
+	lastResolvedServerInfo;
+	constructor(serviceManager, panelHandler, panelPath, customPort) {
+		this.serviceManager = serviceManager;
+		this.panelHandler = panelHandler;
+		this.panelPath = panelPath;
+		this.customPort = customPort;
+	}
+	attach(server) {
+		this.server = server;
+		this.lastResolvedServerInfo = this.resolveServerInfo();
+		this.panelHandler.createMiddleware(server);
+		this.bindStartupHooks(server);
+	}
+	async ensureReady() {
+		const info = this.resolveServerInfo();
+		await this.serviceManager.start(this.customPort, info.port, info.host, this.panelPath);
+	}
+	async ensureReadyIfNeeded() {
+		if (!this.serviceManager.isServiceStarted()) await this.ensureReady();
+	}
+	bindStartupHooks(server) {
+		const scheduleStart = () => {
+			(async () => {
+				await this.ensureReady();
+			})();
+		};
+		if (server.httpServer?.listening) scheduleStart();
+		else server.httpServer?.once("listening", () => {
+			this.lastResolvedServerInfo = void 0;
+			scheduleStart();
+		});
+		const originalPrintUrls = server.printUrls;
+		server.printUrls = () => {
+			originalPrintUrls();
+			(async () => {
+				await this.ensureReady();
+			})();
+		};
+	}
+	resolveServerInfo() {
+		const info = this.computeServerInfo();
+		this.lastResolvedServerInfo = info;
+		return info;
+	}
+	computeServerInfo() {
+		const server = this.server;
+		if (!server) return {
+			host: DEFAULT_HOST,
+			port: DEFAULT_VITE_PORT
+		};
+		const localUrl = server.resolvedUrls?.local?.[0];
+		if (localUrl) try {
+			const url = new URL(localUrl);
+			if (url.hostname && url.port) return {
+				host: this.normalizeHost(url.hostname),
+				port: Number(url.port) || DEFAULT_VITE_PORT
+			};
+		} catch {}
+		const configuredHost = typeof server.config.server.host === "string" ? server.config.server.host : DEFAULT_HOST;
+		const address = server.httpServer?.address();
+		if (address && typeof address === "object" && "port" in address && typeof address.port === "number") return {
+			host: this.normalizeHost(configuredHost),
+			port: address.port
+		};
+		return {
+			host: this.normalizeHost(configuredHost),
+			port: server.config.server.port || DEFAULT_VITE_PORT
+		};
+	}
+	normalizeHost(host) {
+		if (!host || host === "0.0.0.0" || host === "::") return DEFAULT_HOST;
+		return host;
+	}
+};
+function createChromeDevtools(options = {}) {
+	const { enabled = true, port, autoInject = true, panelPath = "/__chrome_devtools" } = options;
+	if (!enabled) return null;
+	const serviceManager = new ChiiServiceManager();
+	const panelHandler = new DevToolsPanelHandler(panelPath, serviceManager);
+	const htmlInjector = new HtmlInjector(serviceManager);
+	const orchestrator = new DevServerOrchestrator(serviceManager, panelHandler, panelPath, port);
+	return {
+		name: "pubinfo:chrome-devtools",
+		apply: "serve",
+		enforce: "post",
+		async configureServer(server) {
+			orchestrator.attach(server);
+		},
+		async transformIndexHtml(html) {
+			if (!autoInject) return html;
+			await orchestrator.ensureReadyIfNeeded();
+			return htmlInjector.injectScript(html);
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/built-in/clean-build.ts
+function createCleanBuild() {
+	let config;
+	return {
+		name: "vite-plugin-clean-build",
+		apply: "build",
+		enforce: "post",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		buildStart() {
+			const outDir = config.build.outDir;
+			const root = config.root;
+			const outputPath = path.resolve(root, outDir);
+			if (fs.existsSync(outputPath)) try {
+				fs.rmSync(outputPath, {
+					recursive: true,
+					force: true
+				});
+			} catch (error) {
+				consola.error(`[vite-plugin-clean-build] Failed to clean build directory: ${error}`);
+			}
+		}
+	};
+}
+
 //#endregion
 //#region src/plugins/built-in/info.ts
 var Ctx$1 = class {
@@ -166,8 +535,8 @@ function getPatternBase(pattern) {
 	}
 	return baseParts.join("/");
 }
-function normalizePath$1(path) {
-	return posix.normalize(path.replace(/\\/g, "/"));
+function normalizePath$1(path$1) {
+	return posix.normalize(path$1.replace(/\\/g, "/"));
 }
 function libResolverPlugin(options) {
 	const virtualModuleId = "virtual:pubinfo-resolver";
@@ -265,6 +634,34 @@ function createLibResolver(options) {
 
 //#endregion
 //#region src/plugins/built-in/system-info.ts
+function getGitInfo() {
+	try {
+		const commit = execSync("git rev-parse HEAD", { encoding: "utf-8" }).trim();
+		const commitShort = execSync("git rev-parse --short HEAD", { encoding: "utf-8" }).trim();
+		let branch = process.env.GITHUB_REF_NAME || process.env.CI_COMMIT_REF_NAME || process.env.GIT_BRANCH || process.env.BRANCH_NAME;
+		if (!branch) {
+			branch = execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf-8" }).trim();
+			if (branch === "HEAD") try {
+				const branches = execSync(`git show-ref --heads | grep ${commit}`, { encoding: "utf-8" }).trim();
+				if (branches) {
+					const match = branches.split("\n")[0].match(/refs\/heads\/(.+)$/);
+					if (match) branch = match[1];
+				}
+			} catch {}
+		}
+		return {
+			commit,
+			commitShort,
+			branch
+		};
+	} catch {
+		return {
+			commit: "",
+			commitShort: "",
+			branch: ""
+		};
+	}
+}
 function createSystemInfo(options = {}) {
 	const defineKey = options.defineKey || "__SYSTEM_INFO__";
 	return {
@@ -273,7 +670,8 @@ function createSystemInfo(options = {}) {
 			const pkg = await readPackageJSON();
 			const systemInfo = {
 				buildTime: dayjs().format("YYYY-MM-DD HH:mm:ss"),
-				pkg
+				pkg,
+				git: getGitInfo()
 			};
 			return { define: { [defineKey]: JSON.stringify(systemInfo) } };
 		}
@@ -483,9 +881,8 @@ function createInjectCSS() {
 
 //#endregion
 //#region src/plugins/intergrations/inspector.ts
-function createInspector(env) {
-	const { VITE_APP_INSPECTOR } = env;
-	if (VITE_APP_INSPECTOR && VITE_APP_INSPECTOR === "true") return VueDevTools();
+function createInspector(devtoolsConfig) {
+	if (devtoolsConfig?.enabled) return VueDevTools({ ...devtoolsConfig });
 	else return null;
 }
 
@@ -536,7 +933,8 @@ function createVitePlugins(viteEnv, isBuild = false, config, type) {
 		createUnocss(),
 		createIcons(),
 		createMock(viteEnv, isBuild),
-		createInspector(viteEnv),
+		createInspector(config.devtools),
+		createChromeDevtools(config.chromeDevtools),
 		createOpenAPI(config.openapi),
 		createLibResolver(config.resolver),
 		createAppInfo(),
@@ -546,7 +944,7 @@ function createVitePlugins(viteEnv, isBuild = false, config, type) {
 			createDTS(),
 			createInjectCSS(),
 			createInjectAuto({ id: config.moduleId })
-		] : null,
+		] : [createCleanBuild()],
 		isBuild ? createCompression(viteEnv) : null
 	].filter(Boolean);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pubinfo/vite",
   "type": "module",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -21,13 +21,14 @@
     "vue": "^3.5.17"
   },
   "dependencies": {
-    "@pubinfo/unplugin-openapi": "^0.9.0",
+    "@pubinfo/unplugin-openapi": "^0.9.1",
     "@vitejs/plugin-legacy": "^7.2.1",
     "@vitejs/plugin-vue": "^6.0.0",
     "@vitejs/plugin-vue-jsx": "^5.0.1",
     "abort-controller": "^3.0.0",
     "boxen": "^8.0.1",
     "chalk": "^5.4.1",
+    "chii": "^1.15.5",
     "consola": "^3.4.2",
     "dayjs": "^1.11.13",
     "fast-glob": "^3.3.3",
@@ -35,6 +36,7 @@
     "jszip": "^3.10.1",
     "lodash-es": "^4.17.21",
     "magic-string": "^0.30.19",
+    "micromatch": "^4.0.8",
     "picomatch": "^4.0.3",
     "pkg-types": "^2.3.0",
     "rolldown-vite": "^7.1.2",
@@ -53,9 +55,11 @@
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/lodash-es": "^4.17.12",
+    "@types/micromatch": "^4.0.9",
     "@types/node": "^24.0.10",
     "@types/picomatch": "^4.0.2",
-    "vue": "^3.5.17"
+    "vue": "^3.5.17",
+    "@pubinfo/shared": "2.0.14"
   },
   "scripts": {
     "dev": "tsdown --watch",