@nuxt/devtools 3.2.4 → 4.0.0-alpha.2

package/dist/chunks/module-main.mjs

@@ -1,24 +1,22 @@
-import fs, { existsSync, promises, statSync, realpathSync, readFileSync, accessSync, constants } from 'node:fs';
-import fsp from 'node:fs/promises';
+import fs$1, { promises, statSync, realpathSync, readFileSync, existsSync, accessSync, constants } from 'node:fs';
+import fs from 'node:fs/promises';
 import os, { homedir } from 'node:os';
 import { logger, useNuxt, addVitePlugin, addPlugin, addTemplate, extendViteConfig, addImports } from '@nuxt/kit';
 import { colors } from 'consola/utils';
-import { join, dirname as dirname$1, resolve, isAbsolute } from 'pathe';
+import { join, dirname, resolve, isAbsolute } from 'pathe';
 import sirv from 'sirv';
 import { searchForWorkspaceRoot } from 'vite';
-import { d as defaultAllowedExtensions, a as defaultTabOptions, W as WS_EVENT_NAME } from '../shared/devtools.CT6XRG-F.mjs';
-import path, { dirname, join as join$1, relative, parse } from 'node:path';
-import { hash } from 'ohash';
-import { runtimeDir, clientDir, packageDir, isGlobalInstall } from '../dirs.mjs';
-import { createBirpcGroup } from 'birpc';
-import { parse as parse$1, stringify } from 'structured-clone-es';
+import { d as defaultAllowedExtensions, a as defaultTabOptions } from '../shared/devtools.DClER4Dv.mjs';
+import { runtimeDir, clientDir, packageDir } from '../dirs.mjs';
 import { startSubprocess } from '@nuxt/devtools-kit';
-import Git from 'simple-git';
+import { x } from 'tinyexec';
 import { glob } from 'tinyglobby';
+import path, { relative, parse, dirname as dirname$1 } from 'node:path';
 import { imageMeta } from 'image-meta';
 import { debounce } from 'perfect-debounce';
 import destr from 'destr';
 import { setupHooksDebug } from '../../dist/runtime/shared/hooks.js';
+import { hash } from 'ohash';
 import process$1 from 'node:process';
 import { builtinModules, createRequire } from 'node:module';
 import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
@@ -27,97 +25,12 @@ import assert from 'node:assert';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
 import { resolveModule, getPackageInfo } from 'local-pkg';
-import isInstalledGlobally from 'is-installed-globally';
 import { parseModule } from 'magicast';
 import { getDefaultExportOptions, addNuxtModule } from 'magicast/helpers';
-import { detectPackageManager } from 'nypm';
 import semver from 'semver';
 import { normalizeBaseKey, normalizeKey } from 'unstorage';
 
-const version$1 = "3.2.4";
-
-const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-function randomStr(size = 16, dict = urlAlphabet) {
-  let id = "";
-  let i = size;
-  const len = dict.length;
-  while (i--)
-    id += dict[Math.random() * len | 0];
-  return id;
-}
-
-function getHomeDir() {
-  return process.env.XDG_CONFIG_HOME || homedir();
-}
-async function readLocalOptions(defaults, options) {
-  const { filePath } = getOptionsFilepath(options);
-  if (existsSync(filePath)) {
-    try {
-      const options2 = {
-        ...defaults,
-        ...JSON.parse(await fsp.readFile(filePath, "utf-8")).settings || {}
-      };
-      return options2;
-    } catch (e) {
-      console.error(`[DevTools] failed to parse local options file: ${filePath}, fallback to defaults`);
-      console.error(e);
-      return { ...defaults };
-    }
-  } else {
-    return { ...defaults };
-  }
-}
-function getOptionsFilepath(options) {
-  let hashedKey;
-  if (options.key)
-    hashedKey = hash(`${options.root}:${options.key}`);
-  else
-    hashedKey = hash(options.root);
-  const home = getHomeDir();
-  const filePath = join(home, ".nuxt/devtools", `${hashedKey}.json`);
-  return {
-    filePath,
-    hashedKey
-  };
-}
-async function clearLocalOptions(options) {
-  const { filePath } = getOptionsFilepath(options);
-  if (existsSync(filePath))
-    await fsp.unlink(filePath);
-}
-async function writeLocalOptions(settings, options) {
-  const { filePath, hashedKey } = getOptionsFilepath(options);
-  await fsp.mkdir(dirname(filePath), { recursive: true });
-  await fsp.writeFile(
-    filePath,
-    JSON.stringify(
-      {
-        root: options.root,
-        hash: hashedKey,
-        settings
-      },
-      null,
-      2
-    ),
-    "utf-8"
-  );
-}
-
-let token;
-async function getDevAuthToken() {
-  if (token)
-    return token;
-  const home = getHomeDir();
-  const dir = join$1(home, ".nuxt/devtools");
-  const filepath = join$1(dir, "dev-auth-token.txt");
-  if (existsSync(filepath))
-    token = (await fsp.readFile(filepath, "utf-8")).trim();
-  if (!token)
-    token = randomStr(16);
-  await fsp.mkdir(dir, { recursive: true });
-  await fsp.writeFile(filepath, token, "utf-8");
-  return token;
-}
+const version$1 = "4.0.0-alpha.2";
 
 const COLON_RE = /:/g;
 function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
@@ -140,7 +53,7 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
     }, nuxt);
     refresh("getAnalyzeBuildInfo");
     initalized = void 0;
-    promise = result.getProcess().then(() => {
+    promise = Promise.resolve(result.getResult()).then(() => {
       refresh("getAnalyzeBuildInfo");
       return readBuildInfo();
     }).finally(() => {
@@ -162,10 +75,10 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
         absolute: true
       });
       for (const file of files2) {
-        const slug = JSON.parse(await fsp.readFile(file, "utf-8")).slug;
-        const dir2 = dirname$1(file);
-        await fsp.mkdir(devtoolsAnalyzeDir, { recursive: true });
-        await fsp.rename(dir2, join(devtoolsAnalyzeDir, slug));
+        const slug = JSON.parse(await fs.readFile(file, "utf-8")).slug;
+        const dir2 = dirname(file);
+        await fs.mkdir(devtoolsAnalyzeDir, { recursive: true });
+        await fs.rename(dir2, join(devtoolsAnalyzeDir, slug));
       }
     }
     const files = await glob(["**/meta.json"], {
@@ -174,27 +87,30 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
       absolute: true
     });
     builds = await Promise.all(files.map(async (file) => {
-      const dir = dirname$1(file);
-      const json = JSON.parse(await fsp.readFile(file, "utf-8"));
+      const dir = dirname(file);
+      const json = JSON.parse(await fs.readFile(file, "utf-8"));
       return {
         ...json,
         features: {
-          bundleClient: fs.existsSync(join(dir, "client.html")),
-          bundleNitro: fs.existsSync(join(dir, "nitro.html")),
-          viteInspect: fs.existsSync(join(dir, ".vite-inspect"))
+          bundleClient: fs$1.existsSync(join(dir, "client.html")),
+          bundleNitro: fs$1.existsSync(join(dir, "nitro.html")),
+          viteInspect: fs$1.existsSync(join(dir, ".vite-inspect"))
         }
       };
     }));
     return builds.sort((a, b) => b.endTime - a.endTime);
   }
+  async function git(...args) {
+    const result = await x("git", args, { nodeOptions: { cwd: nuxt.options.rootDir }, throwOnError: true });
+    return result.stdout.trim();
+  }
   async function generateAnalyzeBuildName() {
     try {
-      const git = Git(nuxt.options.rootDir);
-      const branch = await git.branch();
-      const branchName = branch.current || "head";
-      const sha = await git.revparse(["--short", "HEAD"]);
-      const isWorkingTreeClean = (await git.status()).isClean();
-      if (isWorkingTreeClean)
+      const branchName = await git("rev-parse", "--abbrev-ref", "HEAD") || "head";
+      const sha = await git("rev-parse", "--short", "HEAD");
+      const status = await git("status", "--porcelain");
+      const isClean = status === "";
+      if (isClean)
         return `${branchName}#${sha}`;
       return `${branchName}#${sha}-dirty`;
     } catch {
@@ -214,10 +130,10 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
     async clearAnalyzeBuilds(token, names) {
       await ensureDevAuthToken(token);
       if (!names) {
-        await fsp.rm(devtoolsAnalyzeDir, { recursive: true, force: true });
+        await fs.rm(devtoolsAnalyzeDir, { recursive: true, force: true });
       } else {
         const targets = builds.filter((build) => names.includes(build.name));
-        await Promise.all(targets.map((target) => fsp.rm(join(devtoolsAnalyzeDir, target.slug), { recursive: true, force: true })));
+        await Promise.all(targets.map((target) => fs.rm(join(devtoolsAnalyzeDir, target.slug), { recursive: true, force: true })));
       }
       initalized = readBuildInfo();
       refresh("getAnalyzeBuildInfo");
@@ -264,7 +180,7 @@ function setupAssetsRPC({ nuxt, ensureDevAuthToken, refresh, options }) {
         const filePath = resolve(layerDir, path);
         if (!filePath.startsWith(layerDir))
           continue;
-        const stat = await fsp.lstat(filePath);
+        const stat = await fs.lstat(filePath);
         const fullPath = join(baseURL, path);
         if (!uniquePaths.has(fullPath)) {
           cache.push({
@@ -291,7 +207,7 @@ function setupAssetsRPC({ nuxt, ensureDevAuthToken, refresh, options }) {
       if (_imageMetaCache.has(filepath))
         return _imageMetaCache.get(filepath);
       try {
-        const meta = imageMeta(await fsp.readFile(filepath));
+        const meta = imageMeta(await fs.readFile(filepath));
         _imageMetaCache.set(filepath, meta);
         return meta;
       } catch (e) {
@@ -303,7 +219,7 @@ function setupAssetsRPC({ nuxt, ensureDevAuthToken, refresh, options }) {
     async getTextAssetContent(token, filepath, limit = 300) {
       await ensureDevAuthToken(token);
       try {
-        const content = await fsp.readFile(filepath, "utf-8");
+        const content = await fs.readFile(filepath, "utf-8");
         return content.slice(0, limit);
       } catch (e) {
         console.error(e);
@@ -326,16 +242,16 @@ You can configure it in Nuxt config at \`devtools.assets.uploadExtensions\`.`);
           }
           if (!override) {
             try {
-              await fsp.stat(finalPath);
+              await fs.stat(finalPath);
               const base = finalPath.slice(0, finalPath.length - ext.length - 1);
               let i = 1;
-              while (await fsp.access(`${base}-${i}.${ext}`).then(() => true).catch(() => false))
+              while (await fs.access(`${base}-${i}.${ext}`).then(() => true).catch(() => false))
                 i++;
               finalPath = `${base}-${i}.${ext}`;
             } catch {
             }
           }
-          await fsp.writeFile(finalPath, content, {
+          await fs.writeFile(finalPath, content, {
             encoding: encoding ?? "utf-8"
           });
           return finalPath;
@@ -344,14 +260,14 @@ You can configure it in Nuxt config at \`devtools.assets.uploadExtensions\`.`);
     },
     async deleteStaticAsset(token, path) {
       await ensureDevAuthToken(token);
-      return await fsp.unlink(path);
+      return await fs.unlink(path);
     },
     async renameStaticAsset(token, oldPath, newPath) {
       await ensureDevAuthToken(token);
       const exist = cache?.find((asset) => asset.filePath === newPath);
       if (exist)
         throw new Error(`[Nuxt DevTools] File ${newPath} already exists, failed to rename`);
-      return await fsp.rename(oldPath, newPath);
+      return await fs.rename(oldPath, newPath);
     }
   };
 }
@@ -7464,7 +7380,7 @@ function read(jsonPath, {base, specifier}) {
   let string;
 
   try {
-    string = fs.readFileSync(path.toNamespacedPath(jsonPath), 'utf8');
+    string = fs$1.readFileSync(path.toNamespacedPath(jsonPath), 'utf8');
   } catch (error) {
     const exception = /** @type {ErrnoException} */ (error);
 
@@ -9274,7 +9190,7 @@ async function extractExports(name, url, cache = true) {
     return JSON.parse(await promises.readFile(cachePath, "utf-8"));
   const scanned = await resolveModuleExportNames(name, { url });
   if (useCache) {
-    await promises.mkdir(dirname$1(cachePath), { recursive: true });
+    await promises.mkdir(dirname(cachePath), { recursive: true });
     await promises.writeFile(cachePath, JSON.stringify(scanned), "utf-8");
   }
   return scanned;
@@ -10255,6 +10171,63 @@ function safeKey(key) {
   return JSON.stringify(key);
 }
 
+function getHomeDir() {
+  return process.env.XDG_CONFIG_HOME || homedir();
+}
+async function readLocalOptions(defaults, options) {
+  const { filePath } = getOptionsFilepath(options);
+  if (existsSync(filePath)) {
+    try {
+      const options2 = {
+        ...defaults,
+        ...JSON.parse(await fs.readFile(filePath, "utf-8")).settings || {}
+      };
+      return options2;
+    } catch (e) {
+      console.error(`[DevTools] failed to parse local options file: ${filePath}, fallback to defaults`);
+      console.error(e);
+      return { ...defaults };
+    }
+  } else {
+    return { ...defaults };
+  }
+}
+function getOptionsFilepath(options) {
+  let hashedKey;
+  if (options.key)
+    hashedKey = hash(`${options.root}:${options.key}`);
+  else
+    hashedKey = hash(options.root);
+  const home = getHomeDir();
+  const filePath = join(home, ".nuxt/devtools", `${hashedKey}.json`);
+  return {
+    filePath,
+    hashedKey
+  };
+}
+async function clearLocalOptions(options) {
+  const { filePath } = getOptionsFilepath(options);
+  if (existsSync(filePath))
+    await fs.unlink(filePath);
+}
+async function writeLocalOptions(settings, options) {
+  const { filePath, hashedKey } = getOptionsFilepath(options);
+  await fs.mkdir(dirname$1(filePath), { recursive: true });
+  await fs.writeFile(
+    filePath,
+    JSON.stringify(
+      {
+        root: options.root,
+        hash: hashedKey,
+        settings
+      },
+      null,
+      2
+    ),
+    "utf-8"
+  );
+}
+
 let options;
 function getOptions() {
   return options;
@@ -10305,7 +10278,7 @@ function setupOptionsRPC({ nuxt }) {
 
 const ABSOLUTE_PATH_RE = /^[a-z]:|^\//i;
 const FILE_LINE_COL_RE = /^(.*?)(:[:\d]*)$/;
-const MULTIPLE_SLASHES_RE$1 = /\/+/g;
+const NUXT_WELCOME_RE = /<NuxtWelcome\s*\/>/;
 function setupGeneralRPC({
   nuxt,
   options,
@@ -10494,44 +10467,208 @@ function setupGeneralRPC({
         return false;
       }
     },
+    async enablePages(token) {
+      await ensureDevAuthToken(token);
+      const baseDir = nuxt.options.future.compatibilityVersion === 4 ? nuxt.options.dir.app : nuxt.options.srcDir;
+      const pathApp = join(baseDir, "app.vue");
+      const pathPageIndex = join(baseDir, "pages/index.vue");
+      if (existsSync(pathPageIndex)) {
+        logger.warn("pages/index.vue already exists, skipping");
+        return;
+      }
+      const pagesIndexTemplate = `<script setup lang="ts">
+const route = useRoute()
+<\/script>
+
+<template>
+  <div>
+    <h1>Nuxt Routing set up successfully!</h1>
+    <p>Current route: {{ route.path }}</p>
+    <a href="https://nuxt.com/docs/getting-started/routing" target="_blank">Learn more about Nuxt Routing</a>
+  </div>
+</template>
+`;
+      await fs.mkdir(dirname(pathPageIndex), { recursive: true });
+      await fs.writeFile(pathPageIndex, pagesIndexTemplate, "utf-8");
+      let appContent = existsSync(pathApp) ? await fs.readFile(pathApp, "utf-8") : void 0;
+      if (appContent && !appContent.includes("<NuxtPage")) {
+        appContent = appContent.replace("</template>", "  <NuxtPage />\n</template>").replace(NUXT_WELCOME_RE, "");
+        await fs.writeFile(pathApp, appContent, "utf-8");
+      }
+      logger.success("Routing creation completed");
+    },
     async restartNuxt(token, hard = true) {
       await ensureDevAuthToken(token);
       logger.info("Restarting Nuxt...");
       return nuxt.callHook("restart", { hard });
     },
-    async requestForAuth(info, origin) {
-      if (options.disableAuthorization)
-        return;
-      const token = await getDevAuthToken();
-      origin ||= `${nuxt.options.devServer.https ? "https" : "http"}://${nuxt.options.devServer.host === "::" ? "localhost" : nuxt.options.devServer.host || "localhost"}:${nuxt.options.devServer.port}`;
-      const ROUTE_AUTH = `${nuxt.options.app.baseURL || "/"}/__nuxt_devtools__/auth`.replace(MULTIPLE_SLASHES_RE$1, "/");
-      const message = [
-        `A browser is requesting permissions of ${colors.bold(colors.yellow("writing files and running commands"))} from the DevTools UI.`,
-        colors.bold(info || "Unknown"),
-        "",
-        "Please open the following URL in the browser:",
-        colors.bold(colors.green(`${origin}${ROUTE_AUTH}?token=${token}`)),
-        "",
-        "Or manually copy and paste the following token:",
-        colors.bold(colors.cyan(token))
-      ];
-      logger.box({
-        message: message.join("\n"),
-        title: colors.bold(colors.yellow(" Permission Request ")),
-        style: {
-          borderColor: "yellow",
-          borderStyle: "rounded"
-        }
-      });
+    /** @deprecated Auth is now handled by Vite DevTools */
+    async requestForAuth() {
+      logger.warn("[nuxt-devtools] `requestForAuth` is deprecated. Auth is now handled by Vite DevTools.");
     },
-    async verifyAuthToken(token) {
-      if (options.disableAuthorization)
-        return true;
-      return token === await getDevAuthToken();
+    /** @deprecated Auth is now handled by Vite DevTools */
+    async verifyAuthToken() {
+      logger.warn("[nuxt-devtools] `verifyAuthToken` is deprecated. Auth is now handled by Vite DevTools.");
+      return true;
     }
   };
 }
 
+const AGENTS = [
+  "npm",
+  "yarn",
+  "yarn@berry",
+  "pnpm",
+  "pnpm@6",
+  "bun",
+  "deno"
+];
+const LOCKS = {
+  "bun.lock": "bun",
+  "bun.lockb": "bun",
+  "deno.lock": "deno",
+  "pnpm-lock.yaml": "pnpm",
+  "pnpm-workspace.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+};
+const INSTALL_METADATA = {
+  "node_modules/.deno/": "deno",
+  "node_modules/.pnpm/": "pnpm",
+  "node_modules/.yarn-state.yml": "yarn",
+  // yarn v2+ (node-modules)
+  "node_modules/.yarn_integrity": "yarn",
+  // yarn v1
+  "node_modules/.package-lock.json": "npm",
+  ".pnp.cjs": "yarn",
+  // yarn v3+ (pnp)
+  ".pnp.js": "yarn",
+  // yarn v2 (pnp)
+  "bun.lock": "bun",
+  "bun.lockb": "bun"
+};
+
+async function pathExists(path2, type) {
+  try {
+    const stat = await fs.stat(path2);
+    return type === "file" ? stat.isFile() : stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function* lookup(cwd = process$1.cwd()) {
+  let directory = path.resolve(cwd);
+  const { root } = path.parse(directory);
+  while (directory && directory !== root) {
+    yield directory;
+    directory = path.dirname(directory);
+  }
+}
+async function parsePackageJson(filepath, options) {
+  if (!filepath || !await pathExists(filepath, "file"))
+    return null;
+  return await handlePackageManager(filepath, options);
+}
+async function detect(options = {}) {
+  const {
+    cwd,
+    strategies = ["lockfile", "packageManager-field", "devEngines-field"]
+  } = options;
+  let stopDir;
+  if (typeof options.stopDir === "string") {
+    const resolved = path.resolve(options.stopDir);
+    stopDir = (dir) => dir === resolved;
+  } else {
+    stopDir = options.stopDir;
+  }
+  for (const directory of lookup(cwd)) {
+    for (const strategy of strategies) {
+      switch (strategy) {
+        case "lockfile": {
+          for (const lock of Object.keys(LOCKS)) {
+            if (await pathExists(path.join(directory, lock), "file")) {
+              const name = LOCKS[lock];
+              const result = await parsePackageJson(path.join(directory, "package.json"), options);
+              if (result)
+                return result;
+              else
+                return { name, agent: name };
+            }
+          }
+          break;
+        }
+        case "packageManager-field":
+        case "devEngines-field": {
+          const result = await parsePackageJson(path.join(directory, "package.json"), options);
+          if (result)
+            return result;
+          break;
+        }
+        case "install-metadata": {
+          for (const metadata of Object.keys(INSTALL_METADATA)) {
+            const fileOrDir = metadata.endsWith("/") ? "dir" : "file";
+            if (await pathExists(path.join(directory, metadata), fileOrDir)) {
+              const name = INSTALL_METADATA[metadata];
+              const agent = name === "yarn" ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
+              return { name, agent };
+            }
+          }
+          break;
+        }
+      }
+    }
+    if (stopDir?.(directory))
+      break;
+  }
+  return null;
+}
+function getNameAndVer(pkg) {
+  const handelVer = (version) => version?.match(/\d+(\.\d+){0,2}/)?.[0] ?? version;
+  if (typeof pkg.packageManager === "string") {
+    const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+    return { name, ver: handelVer(ver) };
+  }
+  if (typeof pkg.devEngines?.packageManager?.name === "string") {
+    return {
+      name: pkg.devEngines.packageManager.name,
+      ver: handelVer(pkg.devEngines.packageManager.version)
+    };
+  }
+  return void 0;
+}
+async function handlePackageManager(filepath, options) {
+  try {
+    const content = await fs.readFile(filepath, "utf8");
+    const pkg = options.packageJsonParser ? await options.packageJsonParser(content, filepath) : JSON.parse(content);
+    let agent;
+    const nameAndVer = getNameAndVer(pkg);
+    if (nameAndVer) {
+      const name = nameAndVer.name;
+      const ver = nameAndVer.ver;
+      let version = ver;
+      if (name === "yarn" && ver && Number.parseInt(ver) > 1) {
+        agent = "yarn@berry";
+        version = "berry";
+        return { name, agent, version };
+      } else if (name === "pnpm" && ver && Number.parseInt(ver) < 7) {
+        agent = "pnpm@6";
+        return { name, agent, version };
+      } else if (AGENTS.includes(name)) {
+        agent = name;
+        return { name, agent, version };
+      } else {
+        return options.onUnknown?.(pkg.packageManager) ?? null;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function isMetadataYarnClassic(metadataPath) {
+  return metadataPath.endsWith(".yarn_integrity");
+}
+
 class FetchError extends Error {
   constructor(message, opts) {
     super(message, opts);
@@ -10944,13 +11081,12 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
   let detectPromise;
   const updatesPromise = /* @__PURE__ */ new Map();
   function getPackageManager() {
-    detectPromise ||= detectPackageManager(nuxt.options.rootDir);
+    detectPromise ||= detect({ cwd: nuxt.options.rootDir });
     return detectPromise;
   }
   async function getNpmCommand(command, packageName, options = {}) {
     const {
-      dev = true,
-      global = packageName === "@nuxt/devtools" && isInstalledGlobally
+      dev = true
     } = options;
     const agent = await getPackageManager();
     const name = agent?.name || "npm";
@@ -10960,7 +11096,6 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
         name === "npm" ? "install" : "add",
         `${packageName}@latest`,
         dev ? "-D" : "",
-        global ? "-g" : "",
         // In yarn berry, `--ignore-scripts` is removed
         name === "yarn" && !agent?.version?.startsWith("1.") ? "" : "--ignore-scripts"
       ].filter(Boolean);
@@ -10969,8 +11104,7 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
       return [
         name,
         name === "npm" ? "uninstall" : "remove",
-        packageName,
-        global ? "-g" : ""
+        packageName
       ].filter(Boolean);
     }
   }
@@ -11010,7 +11144,7 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
       const commands = await getNpmCommand("install", name, { dev: true });
       const filepath = nuxt.options._nuxtConfigFile;
       let source = latestGenerated;
-      source ??= await fsp.readFile(filepath, "utf-8");
+      source ??= await fs.readFile(filepath, "utf-8");
       const generated = await magicastGuard(async () => {
         const mod = parseModule(source, { sourceFileName: filepath });
         addNuxtModule(mod, name);
@@ -11029,8 +11163,7 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
           icon: "carbon:intent-request-create",
           restartable: false
         });
-        const execa = process.getProcess();
-        const result = await execa;
+        const result = await process.getResult();
         await Promise.resolve();
         installSet.delete(name);
         const code = result.exitCode;
@@ -11040,7 +11173,7 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
         }
         if (installSet.size === 0) {
           latestGenerated = null;
-          await fsp.writeFile(filepath, generated, "utf-8");
+          await fs.writeFile(filepath, generated, "utf-8");
         }
       }
       return {
@@ -11054,7 +11187,7 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
       await ensureDevAuthToken(token);
       const commands = await getNpmCommand("uninstall", name);
       const filepath = nuxt.options._nuxtConfigFile;
-      const source = await fsp.readFile(filepath, "utf-8");
+      const source = await fs.readFile(filepath, "utf-8");
       const generated = await magicastGuard(async () => {
         const mod = parseModule(source, { sourceFileName: filepath });
         const config = getDefaultExportOptions(mod);
@@ -11078,15 +11211,14 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
           icon: "carbon:intent-request-uninstall",
           restartable: false
         });
-        const execa = process.getProcess();
-        const result = await execa;
+        const result = await process.getResult();
         await Promise.resolve();
         const code = result.exitCode;
         if (code !== 0) {
           console.error(result.stderr);
           throw new Error(`[Nuxt DevTools] Failed to uninstall module, process exited with ${code}`);
         }
-        await fsp.writeFile(filepath, generated, "utf-8");
+        await fs.writeFile(filepath, generated, "utf-8");
       }
       return {
         configOriginal: source,
@@ -11500,7 +11632,7 @@ function setupTimelineRPC({ nuxt }) {
   return {
     async enableTimeline(dry) {
       const filepath = nuxt.options._nuxtConfigFile;
-      const source = await fsp.readFile(filepath, "utf-8");
+      const source = await fs.readFile(filepath, "utf-8");
       const generated = await magicastGuard(async () => {
         const mod = parseModule(source, { sourceFileName: filepath });
         const options = getDefaultExportOptions(mod);
@@ -11510,7 +11642,7 @@ function setupTimelineRPC({ nuxt }) {
         return mod.generate().code;
       }, "\nYou can enable timeline manually by adding `devtools: { timeline: { enabled: true } }`");
       if (!dry) {
-        await fsp.writeFile(filepath, generated, "utf-8");
+        await fs.writeFile(filepath, generated, "utf-8");
         await nuxt.callHook("restart", { hard: true });
       }
       return [source, generated];
@@ -11518,90 +11650,68 @@ function setupTimelineRPC({ nuxt }) {
   };
 }
 
-const LOG_PREFIX = colors.cyan("Nuxt DevTools:");
-
-const NUXT_WELCOME_RE = /<NuxtWelcome\s*\/>/;
-const pagesIndexTemplate = `<script setup lang="ts">
-const route = useRoute()
-<\/script>
-
-<template>
-  <div>
-    <h1>Nuxt Routing set up successfully!</h1>
-    <p>Current route: {{ route.path }}</p>
-    <a href="https://nuxt.com/docs/getting-started/routing" target="_blank">Learn more about Nuxt Routing</a>
-  </div>
-</template>
-`;
-async function enablePages(nuxt) {
-  const baseDir = nuxt.options.future.compatibilityVersion === 4 ? nuxt.options.dir.app : nuxt.options.srcDir;
-  const pathApp = join(baseDir, "app.vue");
-  const pathPageIndex = join(baseDir, "pages/index.vue");
-  if (fs.existsSync(pathPageIndex)) {
-    logger.warn("pages/index.vue already exists, skipping");
-    return;
-  }
-  let appContent = fs.existsSync(pathApp) ? await fsp.readFile(pathApp, "utf-8") : void 0;
-  await fsp.mkdir(dirname$1(pathPageIndex), { recursive: true });
-  await fsp.writeFile(pathPageIndex, pagesIndexTemplate, "utf-8");
-  if (appContent && !appContent.includes("<NuxtPage")) {
-    appContent = appContent.replace("</template>", "  <NuxtPage />\n</template>").replace(NUXT_WELCOME_RE, "");
-    await fsp.writeFile(pathApp, appContent, "utf-8");
-  }
-  logger.success("Routing creation wizard completed");
-}
-
-const wizard = {
-  enablePages
-};
-
-function setupWizardRPC({ nuxt, ensureDevAuthToken }) {
-  return {
-    async runWizard(token, name, ...args) {
-      await ensureDevAuthToken(token);
-      logger.info(LOG_PREFIX, `Running wizard ${colors.green(name)}...`);
-      return wizard[name](nuxt, ...args);
-    }
-  };
-}
-
 function setupRPC(nuxt, options) {
   const serverFunctions = {};
   const extendedRpcMap = /* @__PURE__ */ new Map();
-  const rpc = createBirpcGroup(
-    serverFunctions,
-    [],
-    {
-      resolver: (name, fn) => {
-        if (fn)
-          return fn;
-        if (!name.includes(":"))
+  let rpcHost;
+  const pendingBroadcasts = [];
+  function broadcast(method, ...args) {
+    if (!rpcHost) {
+      pendingBroadcasts.push({ method, args });
+      return;
+    }
+    rpcHost.broadcast({
+      method,
+      args,
+      event: true
+    });
+  }
+  function createBroadcastProxy(prefix = "") {
+    return new Proxy({}, {
+      get: (_, method) => {
+        if (typeof method !== "string")
           return;
-        const [namespace, fnName] = name.split(":");
-        return extendedRpcMap.get(namespace)?.[fnName];
-      },
-      onFunctionError(error, name) {
-        logger.error(
-          colors.yellow(`[nuxt-devtools] RPC error on executing "${colors.bold(name)}":
-`) + colors.red(error?.message || "")
-        );
-      },
-      timeout: 12e4
+        const fullMethod = prefix ? `${prefix}:${method}` : method;
+        const fn = (...args) => broadcast(fullMethod, ...args);
+        fn.asEvent = (...args) => broadcast(fullMethod, ...args);
+        return fn;
+      }
+    });
+  }
+  const functionsProxy = new Proxy(serverFunctions, {
+    set(target, prop, value) {
+      target[prop] = value;
+      if (rpcHost && typeof prop === "string") {
+        if (rpcHost.has(prop)) {
+          rpcHost.update({ name: prop, handler: value });
+        } else {
+          rpcHost.register({ name: prop, handler: value });
+        }
+      }
+      return true;
     }
-  );
+  });
+  const rpc = {
+    broadcast: createBroadcastProxy(),
+    functions: functionsProxy
+  };
   function refresh(event) {
-    rpc.broadcast.refresh.asEvent(event);
+    broadcast("refresh", event);
   }
   function extendServerRpc(namespace, functions) {
     extendedRpcMap.set(namespace, functions);
-    return {
-      broadcast: new Proxy({}, {
-        get: (_, key) => {
-          if (typeof key !== "string")
-            return;
-          return rpc.broadcast[`${namespace}:${key}`];
+    if (rpcHost) {
+      for (const [fnName, handler] of Object.entries(functions)) {
+        if (typeof handler === "function") {
+          rpcHost.register({ name: `${namespace}:${fnName}`, handler });
         }
-      })
+      }
+    }
+    return {
+      broadcast: createBroadcastProxy(namespace),
+      functions,
+      clients: [],
+      updateChannels: () => []
     };
   }
   const ctx = {
@@ -11611,11 +11721,9 @@ function setupRPC(nuxt, options) {
     refresh,
     extendServerRpc,
     openInEditorHooks: [],
-    async ensureDevAuthToken(token) {
-      if (options.disableAuthorization)
-        return;
-      if (token !== await getDevAuthToken())
-        throw new Error("[Nuxt DevTools] Invalid dev auth token.");
+    /** @deprecated Auth is now handled by Vite DevTools */
+    async ensureDevAuthToken(_token) {
+      logger.warn("[nuxt-devtools] `ensureDevAuthToken` is deprecated. Auth is now handled by Vite DevTools.");
     }
   };
   nuxt.devtools = ctx;
@@ -11625,7 +11733,6 @@ function setupRPC(nuxt, options) {
     ...setupStorageRPC(ctx),
     ...setupAssetsRPC(ctx),
     ...setupNpmRPC(ctx),
-    ...setupWizardRPC(ctx),
     ...setupTerminalRPC(ctx),
     ...setupServerRoutesRPC(ctx),
     ...setupServerTasksRPC(ctx),
@@ -11635,48 +11742,47 @@ function setupRPC(nuxt, options) {
     ...setupTelemetryRPC(ctx),
     ...setupServerDataRPC(ctx)
   });
-  const wsClients = /* @__PURE__ */ new Set();
-  const vitePlugin = {
-    name: "nuxt:devtools:rpc",
-    configureServer(server) {
-      server.ws.on("connection", (ws) => {
-        wsClients.add(ws);
-        const channel = {
-          post: (d) => ws.send(JSON.stringify({
-            type: "custom",
-            event: WS_EVENT_NAME,
-            data: d
-          })),
-          on: (fn) => {
-            ws.on("message", (e) => {
-              try {
-                const data = JSON.parse(String(e)) || {};
-                if (data.type === "custom" && data.event === WS_EVENT_NAME) {
-                  fn(data.data);
-                }
-              } catch {
-              }
-            });
-          },
-          serialize: stringify,
-          deserialize: parse$1
-        };
-        rpc.updateChannels((c) => {
-          c.push(channel);
-        });
-        ws.on("close", () => {
-          wsClients.delete(ws);
-          rpc.updateChannels((c) => {
-            const index = c.indexOf(channel);
-            if (index >= 0)
-              c.splice(index, 1);
+  function connectRpcHost(host) {
+    rpcHost = host;
+    for (const { method, args } of pendingBroadcasts) {
+      broadcast(method, ...args);
+    }
+    pendingBroadcasts.length = 0;
+    for (const [name, handler] of Object.entries(serverFunctions)) {
+      if (typeof handler === "function") {
+        try {
+          host.register({
+            name,
+            handler
           });
-        });
-      });
+        } catch (e) {
+          logger.warn(
+            colors.yellow(`[nuxt-devtools] Failed to register RPC function "${name}":
+`) + colors.red(e?.message || "")
+          );
+        }
+      }
     }
-  };
+    for (const [namespace, fns] of extendedRpcMap) {
+      for (const [fnName, handler] of Object.entries(fns)) {
+        if (typeof handler === "function") {
+          try {
+            host.register({
+              name: `${namespace}:${fnName}`,
+              handler
+            });
+          } catch (e) {
+            logger.warn(
+              colors.yellow(`[nuxt-devtools] Failed to register RPC function "${namespace}:${fnName}":
+`) + colors.red(e?.message || "")
+            );
+          }
+        }
+      }
+    }
+  }
   return {
-    vitePlugin,
+    connectRpcHost,
     ...ctx
   };
 }
@@ -11695,8 +11801,10 @@ async function enableModule(options, nuxt) {
       await import('./analyze-build.mjs').then(({ setup }) => setup(nuxt, options));
     return;
   }
-  const enabledExplicitly = nuxt.options.devtools === true || nuxt.options.devtools && nuxt.options.devtools.enabled || nuxt.options.modules.some((m) => m === "@nuxt/devtools" || m === "@nuxt/devtools-edge" || m === "@nuxt/devtools-nightly");
   await nuxt.callHook("devtools:before");
+  if (nuxt.options.devtools && typeof nuxt.options.devtools !== "boolean" && "disableAuthorization" in nuxt.options.devtools) {
+    logger.warn("[nuxt-devtools] `disableAuthorization` option is deprecated. Auth is now handled by Vite DevTools.");
+  }
   if (options.iframeProps) {
     nuxt.options.runtimeConfig.app.devtools ||= {};
     nuxt.options.runtimeConfig.app.devtools.iframeProps = options.iframeProps;
@@ -11710,38 +11818,34 @@ async function enableModule(options, nuxt) {
     src: join(runtimeDir, "plugins/devtools.server"),
     mode: "server"
   });
-  if (options.viteDevTools) {
-    logger.info("[nuxt-devtools] Enabling experimental Vite DevTools integration");
-    const DevTools = await import('@vitejs/devtools').then((r) => r.DevTools());
-    addVitePlugin(DevTools);
-    addVitePlugin({
-      name: "nuxt:devtools",
-      devtools: {
-        setup(ctx2) {
-          ctx2.docks.register({
-            id: "nuxt:devtools",
-            type: "iframe",
-            icon: "https://nuxt.com/assets/design-kit/icon-green.svg",
-            title: "Nuxt DevTools",
-            url: "/__nuxt_devtools__/client/"
-          });
-        }
+  const DevTools = await import('@vitejs/devtools').then((r) => r.DevTools());
+  addVitePlugin(DevTools);
+  let connectRpcHost;
+  addVitePlugin(defineViteDevToolsPlugin({
+    name: "nuxt:devtools",
+    devtools: {
+      setup(ctx2) {
+        ctx2.docks.register({
+          id: "nuxt:devtools",
+          type: "iframe",
+          icon: "https://nuxt.com/assets/design-kit/icon-green.svg",
+          title: "Nuxt DevTools",
+          url: "/__nuxt_devtools__/client/"
+        });
+        connectRpcHost?.(ctx2.rpc);
       }
-    });
-    addPlugin({
-      src: join(runtimeDir, "plugins/vite-devtools.client"),
-      mode: "client"
-    });
-  }
+    }
+  }));
+  addPlugin({
+    src: join(runtimeDir, "plugins/vite-devtools.client"),
+    mode: "client"
+  });
   addTemplate({
     filename: "devtools/settings.mjs",
     async getContents() {
       const uiOptions = await readLocalOptions(
         {
-          ...defaultTabOptions.ui,
-          // When not enabled explicitly, we hide the panel by default
-          // When Vite DevTools is enabled, we hide the panel by default
-          showPanel: options.viteDevTools ? false : enabledExplicitly ? true : null
+          ...defaultTabOptions.ui
         },
         { root: nuxt.options.rootDir }
       );
@@ -11771,10 +11875,10 @@ window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
     config.plugins.unshift(join(runtimeDir, "nitro/inline"));
   });
   const {
-    vitePlugin,
+    connectRpcHost: _connectRpcHost,
     ...ctx
   } = setupRPC(nuxt, options);
-  addVitePlugin(vitePlugin);
+  connectRpcHost = _connectRpcHost;
   const clientDirExists = existsSync(clientDir);
   extendViteConfig((config) => {
     config.server ||= {};
@@ -11796,15 +11900,13 @@ window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
   });
   const ROUTE_PATH = `${nuxt.options.app.baseURL || "/"}/__nuxt_devtools__`.replace(MULTIPLE_SLASHES_RE, "/");
   const ROUTE_CLIENT = `${ROUTE_PATH}/client`;
-  const ROUTE_AUTH = `${ROUTE_PATH}/auth`;
-  const ROUTE_AUTH_VERIFY = `${ROUTE_PATH}/auth-verify`;
   const ROUTE_ANALYZE = `${ROUTE_PATH}/analyze`;
   nuxt.hook("vite:serverCreated", (server) => {
     const devtoolsAnalyzeDir = join(nuxt.options.rootDir, "node_modules/.cache/nuxt-devtools/analyze");
     server.middlewares.use(ROUTE_ANALYZE, sirv(devtoolsAnalyzeDir, { single: false, dev: true, dotfiles: true, ignores: false }));
     if (clientDirExists) {
       const indexHtmlPath = join(clientDir, "index.html");
-      const indexContent = fsp.readFile(indexHtmlPath, "utf-8");
+      const indexContent = fs.readFile(indexHtmlPath, "utf-8");
       const handleStatic = sirv(clientDir, {
         dev: true,
         single: false
@@ -11821,27 +11923,6 @@ window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
         return handleStatic(req, res, () => handleIndex(res));
       });
     }
-    server.middlewares.use(ROUTE_AUTH, sirv(join(runtimeDir, "auth"), { single: true, dev: true }));
-    server.middlewares.use(ROUTE_AUTH_VERIFY, async (req, res) => {
-      const search = req.url?.split("?")[1];
-      if (!search) {
-        res.statusCode = 400;
-        res.end("No token provided");
-      }
-      const query = new URLSearchParams(search);
-      const token = query.get("token");
-      if (!token) {
-        res.statusCode = 400;
-        res.end("No token provided");
-      }
-      if (token === await getDevAuthToken()) {
-        res.statusCode = 200;
-        res.end("Valid token");
-      } else {
-        res.statusCode = 403;
-        res.end("Invalid token");
-      }
-    });
   });
   await import('./plugin-metrics.mjs').then(({ setup }) => setup(ctx));
   if (options.vueDevTools !== false)
@@ -11857,8 +11938,7 @@ window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
   await Promise.all(integrations);
   nuxt.hook("modules:done", () => nuxt.callHook("devtools:initialized", {
     version: version$1,
-    packagePath: packageDir,
-    isGlobalInstall: isGlobalInstall()
+    packagePath: packageDir
   }));
   const isMac = os.platform() === "darwin";
   logger.log([
@@ -11873,10 +11953,8 @@ window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
     "\n"
   ].join(""));
 }
+function defineViteDevToolsPlugin(plugin) {
+  return plugin;
+}
 
-const moduleMain = {
-  __proto__: null,
-  enableModule: enableModule
-};
-
-export { LOG_PREFIX as L, moduleMain as m };
+export { enableModule };