@nuxt/devtools 0.2.4 → 0.3.0

package/dist/chunks/module-main.mjs

@@ -1,26 +1,35 @@
-import { resolve, join, normalize } from 'path';
-import * as fs from 'fs';
-import fs__default, { readdirSync, statSync, existsSync } from 'fs';
-import { logger, getNuxtVersion, addPlugin } from '@nuxt/kit';
-import require$$0$2 from 'stream';
-import require$$0 from 'zlib';
-import require$$0$1 from 'buffer';
+import { join as join$3 } from 'node:path';
+import fs, { existsSync } from 'node:fs';
+import { useNuxt, logger, addPlugin } from '@nuxt/kit';
+import require$$0$3 from 'stream';
+import require$$0$1 from 'zlib';
+import require$$0$2 from 'buffer';
 import require$$3 from 'net';
 import require$$4 from 'tls';
 import require$$5 from 'crypto';
-import require$$0$3 from 'events';
+import require$$0$4 from 'events';
 import require$$2 from 'https';
 import require$$1 from 'http';
-import require$$0$4 from 'url';
+import require$$0$5 from 'url';
 import { searchForWorkspaceRoot } from 'vite';
+import * as require$$0 from 'fs';
+import { readdirSync, statSync } from 'fs';
+import { resolve, join as join$1, normalize as normalize$1 } from 'path';
 import * as qs from 'querystring';
-import require$$0$5 from 'tty';
-import { v as version } from '../shared/devtools.b6178134.mjs';
+import require$$0$6 from 'tty';
+import { v as version } from '../shared/devtools.30090c6e.mjs';
 import { createBirpcGroup } from 'birpc';
-import { resolvePreset } from 'unimport';
-import { join as join$1, dirname, resolve as resolve$1 } from 'pathe';
-import fsp from 'fs/promises';
+import fsp, { readFile } from 'node:fs/promises';
+import { resolve as resolve$1, join as join$2, dirname } from 'pathe';
+import { imageMeta } from 'image-meta';
+import fg from 'fast-glob';
+import { startSubprocess } from '@nuxt/devtools-kit';
+import isInstalledGlobally from 'is-installed-globally';
+import 'node:child_process';
+import { createRequire } from 'node:module';
 import 'pkg-types';
+import { getPackageInfo } from 'local-pkg';
+import { resolvePreset } from 'unimport';
 import { runtimeDir, clientDir, packageDir, isGlobalInstall } from '../dirs.mjs';
 import { R as ROUTE_ENTRY, a as ROUTE_CLIENT } from '../shared/devtools.95cf6023.mjs';
 
@@ -237,7 +246,7 @@ let Limiter$1 = class Limiter {
 
 var limiter = Limiter$1;
 
-const zlib = require$$0;
+const zlib = require$$0$1;
 
 const bufferUtil = bufferUtilExports;
 const Limiter = limiter;
@@ -758,7 +767,7 @@ var validation = {
 
 var isValidUTF8_1;
 
-const { isUtf8 } = require$$0$1;
+const { isUtf8 } = require$$0$2;
 
 //
 // Allowed token characters:
@@ -887,7 +896,7 @@ if (isUtf8) {
   }
 }
 
-const { Writable } = require$$0$2;
+const { Writable } = require$$0$3;
 
 const PerMessageDeflate$3 = permessageDeflate;
 const {
@@ -2482,13 +2491,13 @@ var extension$1 = { format: format$1, parse: parse$b };
 
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Readable$" }] */
 
-const EventEmitter$1 = require$$0$3;
+const EventEmitter$1 = require$$0$4;
 const https = require$$2;
 const http$1 = require$$1;
 const net = require$$3;
 const tls = require$$4;
 const { randomBytes, createHash: createHash$1 } = require$$5;
-const { URL } = require$$0$4;
+const { URL } = require$$0$5;
 
 const PerMessageDeflate$1 = permessageDeflate;
 const Receiver = receiver;
@@ -3468,7 +3477,11 @@ function initAsClient(websocket, address, protocols, options) {
     });
   });
 
-  req.end();
+  if (opts.finishRequest) {
+    opts.finishRequest(req, websocket);
+  } else {
+    req.end();
+  }
 }
 
 /**
@@ -3848,7 +3861,7 @@ var subprotocol$1 = { parse: parse$9 };
 
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^net|tls|https$" }] */
 
-const EventEmitter = require$$0$3;
+const EventEmitter = require$$0$4;
 const http = require$$1;
 const { createHash } = require$$5;
 
@@ -4384,11 +4397,11 @@ function totalist(dir, callback, pre='') {
 	let arr = readdirSync(dir);
 	let i=0, abs, stats;
 	for (; i < arr.length; i++) {
-		abs = join(dir, arr[i]);
+		abs = join$1(dir, arr[i]);
 		stats = statSync(abs);
 		stats.isDirectory()
-			? totalist(abs, callback, join(pre, arr[i]))
-			: callback(join(pre, arr[i]), abs, stats);
+			? totalist(abs, callback, join$1(pre, arr[i]))
+			: callback(join$1(pre, arr[i]), abs, stats);
 	}
 }
 
@@ -4881,9 +4894,9 @@ function viaLocal(dir, isEtag, uri, extns) {
 	let i=0, arr=toAssume(uri, extns);
 	let abs, stats, name, headers;
 	for (; i < arr.length; i++) {
-		abs = normalize(join(dir, name=arr[i]));
-		if (abs.startsWith(dir) && fs.existsSync(abs)) {
-			stats = fs.statSync(abs);
+		abs = normalize$1(join$1(dir, name=arr[i]));
+		if (abs.startsWith(dir) && require$$0.existsSync(abs)) {
+			stats = require$$0.statSync(abs);
 			if (stats.isDirectory()) continue;
 			headers = toHeaders(name, stats, isEtag);
 			headers['Cache-Control'] = isEtag ? 'no-cache' : 'no-store';
@@ -4927,7 +4940,7 @@ function send(req, res, file, stats, headers) {
 	}
 
 	res.writeHead(code, headers);
-	fs.createReadStream(file, opts).pipe(res);
+	require$$0.createReadStream(file, opts).pipe(res);
 }
 
 const ENCODING = {
@@ -5037,7 +5050,7 @@ var picocolors = {
   set exports(v){ picocolorsExports = v; },
 };
 
-let tty = require$$0$5;
+let tty = require$$0$6;
 
 let isColorSupported =
 	!("NO_COLOR" in process.env || process.argv.includes("--no-color")) &&
@@ -5188,74 +5201,290 @@ const stringify = (value, replacer, space) => {
   }
 };
 
-function setupHooksDebug(hooks) {
-  const serverHooks = {};
-  const now = typeof globalThis.performance === "undefined" ? () => Date.now() : () => performance.now();
-  hooks.beforeEach((event) => {
-    if (!serverHooks[event.name]) {
-      serverHooks[event.name] = {
-        name: event.name,
-        start: now(),
-        // @ts-expect-error private field
-        listeners: hooks._hooks[event.name]?.length || 0,
-        executions: []
-      };
-    } else {
-      const hook = serverHooks[event.name];
-      if (hook.duration != null)
-        hook.executions.push(hook.duration);
-      hook.start = now();
-      hook.end = void 0;
-      hook.duration = void 0;
+const IGNORE_STORAGE_MOUNTS = ["root", "build", "src", "cache"];
+const shouldIgnoreStorageKey = (key) => IGNORE_STORAGE_MOUNTS.includes(key.split(":")[0]);
+function setupStorageRPC({
+  nuxt,
+  rpc
+}) {
+  const storageMounts = {};
+  let storage;
+  nuxt.hook("nitro:init", (nitro) => {
+    storage = nitro.storage;
+    nuxt.hook("ready", () => {
+      storage.watch((event, key) => {
+        if (shouldIgnoreStorageKey(key))
+          return;
+        rpc.broadcast.callHook.asEvent("storage:key:update", key, event);
+      });
+    });
+    const mounts = {
+      ...nitro.options.storage,
+      ...nitro.options.devStorage
+    };
+    for (const name of Object.keys(mounts)) {
+      if (shouldIgnoreStorageKey(name))
+        continue;
+      storageMounts[name] = mounts[name];
     }
   });
-  hooks.afterEach((event) => {
-    const hook = serverHooks[event.name];
-    if (!hook)
-      return;
-    hook.end = now();
-    hook.duration = hook.end - hook.start;
-    const listeners = hooks._hooks[event.name]?.length;
-    if (listeners != null)
-      hook.listeners = listeners;
-  });
-  return serverHooks;
+  return {
+    async getStorageMounts() {
+      return storageMounts;
+    },
+    async getStorageKeys(base) {
+      if (!storage)
+        return [];
+      try {
+        const keys = await storage.getKeys(base);
+        return keys.filter((key) => !shouldIgnoreStorageKey(key));
+      } catch (err) {
+        console.error(`Cloud not fetch storage keys for ${base}:`, err);
+        return [];
+      }
+    },
+    async getStorageItem(key) {
+      if (!storage)
+        return null;
+      return await storage.getItem(key);
+    },
+    async setStorageItem(key, value) {
+      if (!storage)
+        return;
+      return await storage.setItem(key, value);
+    },
+    async removeStorageItem(key) {
+      if (!storage)
+        return;
+      return await storage.removeItem(key);
+    }
+  };
 }
 
-const pagesIndexTemplate = `<script setup lang="ts">
-const route = useRoute()
-<\/script>
+function setupAssetsRPC({ nuxt }) {
+  const _imageMetaCache = /* @__PURE__ */ new Map();
+  return {
+    async getStaticAssets() {
+      const dir = resolve$1(nuxt.options.srcDir, nuxt.options.dir.public);
+      const baseURL = nuxt.options.app.baseURL;
+      const files = await fg(["**/*"], {
+        cwd: dir,
+        onlyFiles: true
+      });
+      function guessType(path) {
+        if (/\.(png|jpe?g|gif|svg|webp|avif|ico|bmp|tiff?)$/i.test(path))
+          return "image";
+        if (/\.(mp4|webm|ogv|mov|avi|flv|wmv|mpg|mpeg|mkv|3gp|3g2|ts|mts|m2ts|vob|ogm|ogx|rm|rmvb|asf|amv|divx|m4v|svi|viv|f4v|f4p|f4a|f4b)$/i.test(path))
+          return "video";
+        if (/\.(mp3|wav|ogg|flac|aac|wma|alac|ape|ac3|dts|tta|opus|amr|aiff|au|mid|midi|ra|rm|wv|weba|dss|spx|vox|tak|dsf|dff|dsd|cda)$/i.test(path))
+          return "audio";
+        if (/\.(woff2?|eot|ttf|otf|ttc|pfa|pfb|pfm|afm)/i.test(path))
+          return "font";
+        if (/\.(json[5c]?|te?xt|[mc]?[jt]sx?|md[cx]?|markdown)/i.test(path))
+          return "text";
+        return "other";
+      }
+      return await Promise.all(files.map(async (path) => {
+        const filePath = resolve$1(dir, path);
+        const stat = await fsp.lstat(filePath);
+        return {
+          path,
+          publicPath: join$2(baseURL, path),
+          filePath,
+          type: guessType(path),
+          size: stat.size,
+          mtime: stat.mtimeMs
+        };
+      }));
+    },
+    async getImageMeta(filepath) {
+      if (_imageMetaCache.has(filepath))
+        return _imageMetaCache.get(filepath);
+      try {
+        const meta = imageMeta(await fsp.readFile(filepath));
+        _imageMetaCache.set(filepath, meta);
+        return meta;
+      } catch (e) {
+        _imageMetaCache.set(filepath, void 0);
+        console.error(e);
+        return void 0;
+      }
+    },
+    async getTextAssetContent(filepath, limit = 300) {
+      try {
+        const content = await fsp.readFile(filepath, "utf-8");
+        return content.slice(0, limit);
+      } catch (e) {
+        console.error(e);
+        return void 0;
+      }
+    }
+  };
+}
 
-<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 pathApp = join$1(nuxt.options.srcDir, "app.vue");
-  const pathPageIndex = join$1(nuxt.options.srcDir, "pages/index.vue");
-  if (fs__default.existsSync(pathPageIndex)) {
-    logger.warn("pages/index.vue already exists, skipping");
-    return;
-  }
-  let appContent = fs__default.existsSync(pathApp) ? await fsp.readFile(pathApp, "utf-8") : void 0;
-  await fsp.mkdir(dirname(pathPageIndex), { recursive: true });
-  await fsp.writeFile(pathPageIndex, pagesIndexTemplate, "utf-8");
-  if (appContent && !appContent.includes("<NuxtPage")) {
-    appContent = appContent.replace("</template>", "  <NuxtPage />\n</template>").replace(/<NuxtWelcome\s*\/>/, "");
-    await fsp.writeFile(pathApp, appContent, "utf-8");
+function normalizeWindowsPath(input = "") {
+  if (!input || !input.includes("\\")) {
+    return input;
   }
-  logger.success("Routing creation wizard completed");
+  return input.replace(/\\/g, "/");
 }
 
-const wizard = {
-  enablePages
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...arguments_) {
+  if (arguments_.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (const argument of arguments_) {
+    if (argument && argument.length > 0) {
+      if (joined === void 0) {
+        joined = argument;
+      } else {
+        joined += `/${argument}`;
+      }
+    }
+  }
+  if (joined === void 0) {
+    return ".";
+  }
+  return normalize(joined.replace(/\/\/+/g, "/"));
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
 };
 
-const LOG_PREFIX = picocolorsExports.cyan("Nuxt DevTools:");
+const packageManagerLocks = {
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "pnpm-lock.yaml": "pnpm"
+};
+async function detectPackageManager(cwd, options = {}) {
+  const detected = await findup(cwd, async (path) => {
+    if (!options.ignorePackageJSON) {
+      const packageJSONPath = join(path, "package.json");
+      if (existsSync(packageJSONPath)) {
+        const packageJSON = JSON.parse(await readFile(packageJSONPath, "utf8"));
+        if (packageJSON?.packageManager) {
+          const [name, version] = packageJSON.packageManager.split("@");
+          return { name, version };
+        }
+      }
+    }
+    if (!options.ignoreLockFile) {
+      for (const lockFile in packageManagerLocks) {
+        if (existsSync(join(path, lockFile))) {
+          return { name: packageManagerLocks[lockFile] };
+        }
+      }
+    }
+  });
+  return {
+    name: "npm",
+    version: "latest",
+    ...detected
+  };
+}
+async function findup(cwd, match) {
+  const segments = normalize(cwd).split("/");
+  while (segments.length > 0) {
+    const path = segments.join("/");
+    const result = await match(path);
+    if (result) {
+      return result;
+    }
+    segments.pop();
+  }
+}
 
 var reExports = {};
 var re$3 = {
@@ -8164,113 +8393,98 @@ var semver = {
   rcompareIdentifiers: identifiers.rcompareIdentifiers,
 };
 
-async function checkForUpdateOf(info) {
+async function checkForUpdateOf(name, current, nuxt = useNuxt()) {
+  if (!current) {
+    const require = createRequire(nuxt.options.rootDir);
+    const info = await getPackageInfo(name, { paths: require.resolve.paths(name) || void 0 });
+    if (!info)
+      return;
+    current = info.packageJson.version;
+  }
   const packument = await import('pacote').then((r) => r.default?.packument || r.packument);
-  const manifest = await packument(info.name);
+  const manifest = await packument(name);
   const latest = manifest["dist-tags"].latest;
-  const needsUpdate = latest !== info.current && semver.lt(info.current, latest);
+  const needsUpdate = latest !== current && semver.lt(current, latest);
   return {
-    ...info,
+    name,
+    current,
     latest,
     needsUpdate
   };
 }
-function usePackageVersions() {
-  return [
-    { name: "nuxt", current: getNuxtVersion() },
-    { name: "@nuxt/devtools-edge", current: version }
-  ];
-}
-async function checkForUpdates() {
-  const versions = usePackageVersions();
-  const updates = await Promise.all(versions.map(checkForUpdateOf));
-  return updates;
+
+function setupNpmRPC({ nuxt }) {
+  let detectPromise;
+  const updatesPromise = /* @__PURE__ */ new Map();
+  function getPackageManager() {
+    detectPromise || (detectPromise = detectPackageManager(nuxt.options.rootDir).then((r) => r.name));
+    return detectPromise;
+  }
+  async function getNpmCommand(command, packageName, options = {}) {
+    const {
+      dev = true,
+      global = packageName === "@nuxt/devtools" && isInstalledGlobally
+    } = options;
+    const agent = await getPackageManager();
+    if (command === "install" || command === "update")
+      return [agent, agent === "npm" ? "install" : "add", `${packageName}@latest`, dev ? "-D" : "", global ? "-g" : "", "--ignore-scripts"].filter(Boolean);
+  }
+  async function runNpmCommand(command, packageName, options = {}) {
+    const args = await getNpmCommand(command, packageName, options);
+    if (!args)
+      return;
+    const processId = `npm:${command}:${packageName}`;
+    startSubprocess({
+      command: args[0],
+      args: args.slice(1)
+    }, {
+      id: processId,
+      name: `${command} ${packageName}`,
+      icon: "i-mdi-npm-variant-outline text-rose",
+      restartable: false
+    });
+    return {
+      processId
+    };
+  }
+  return {
+    checkForUpdateFor(name) {
+      if (!updatesPromise.has(name))
+        updatesPromise.set(name, checkForUpdateOf(name, void 0, nuxt));
+      return updatesPromise.get(name);
+    },
+    getPackageManager,
+    getNpmCommand,
+    runNpmCommand
+  };
 }
 
-function setupRPC(nuxt, _options) {
-  const components = [];
-  const imports = [];
-  const importPresets = [];
-  const serverPages = [];
+function setupCustomTabRPC({ nuxt, options, refresh }) {
   const iframeTabs = [];
   const customTabs = [];
-  const serverHooks = setupHooksDebug(nuxt.hooks);
-  let unimport;
-  let app;
-  let checkForUpdatePromise;
-  let versions = usePackageVersions();
-  const serverFunctions = {};
-  const clients = /* @__PURE__ */ new Set();
-  const birpc = createBirpcGroup(serverFunctions, []);
-  function refresh(event) {
-    birpc.broadcast.refresh.asEvent(event);
+  if (options.customTabs?.length)
+    customTabs.push(...options.customTabs);
+  async function initHooks() {
+    nuxt.hook("devtools:customTabs:refresh", initCustomTabs);
+    await initCustomTabs();
   }
-  Object.assign(serverFunctions, {
-    getServerConfig() {
-      return nuxt.options;
-    },
-    getComponents() {
-      return components;
-    },
-    async getComponentsRelationships() {
-      return [];
-    },
-    getServerPages() {
-      return serverPages;
-    },
-    getAutoImports() {
-      return {
-        imports: [
-          ...imports,
-          ...importPresets
-        ],
-        metadata: unimport?.getMetadata()
-      };
-    },
+  async function initCustomTabs() {
+    customTabs.length = 0;
+    if (options.customTabs?.length)
+      customTabs.push(...options.customTabs);
+    await nuxt.callHook("devtools:customTabs", customTabs);
+    refresh("getCustomTabs");
+  }
+  nuxt.hook("app:resolve", async () => {
+    await initHooks();
+  });
+  return {
     getCustomTabs() {
       return [
         ...iframeTabs,
         ...customTabs
       ];
     },
-    getServerLayouts() {
-      return Object.values(app?.layouts || []);
-    },
-    getServerHooks() {
-      return Object.values(serverHooks);
-    },
-    usePackageVersions() {
-      checkForUpdatePromise = checkForUpdatePromise || checkForUpdates().then((v) => {
-        versions = v;
-        refresh("usePackageVersions");
-      });
-      return versions;
-    },
-    runWizard(name, ...args) {
-      logger.info(LOG_PREFIX, `Running wizard ${picocolorsExports.green(name)}...`);
-      return wizard[name](nuxt, ...args);
-    },
-    async openInEditor(input) {
-      if (input.startsWith("./"))
-        input = resolve$1(process.cwd(), input);
-      const match = input.match(/^(.*?)([:\d]*)$/);
-      let suffix = "";
-      if (match) {
-        input = match[1];
-        suffix = match[2];
-      }
-      const file = [
-        input,
-        `${input}.js`,
-        `${input}.mjs`,
-        `${input}.ts`
-      ].find((i) => existsSync(i));
-      if (file) {
-        await import('launch-editor').then((r) => (r.default || r)(file + suffix));
-      } else {
-        console.error("File not found:", input);
-      }
-    },
     async customTabAction(name, actionIndex) {
       const tab = customTabs.find((i) => i.name === name);
       if (!tab)
@@ -8289,7 +8503,51 @@ function setupRPC(nuxt, _options) {
       nuxt.callHook("devtools:customTabs:refresh");
       return true;
     }
+  };
+}
+
+function setupHooksDebug(hooks) {
+  const serverHooks = {};
+  const now = typeof globalThis.performance === "undefined" ? () => Date.now() : () => performance.now();
+  hooks.beforeEach((event) => {
+    if (!serverHooks[event.name]) {
+      serverHooks[event.name] = {
+        name: event.name,
+        start: now(),
+        // @ts-expect-error private field
+        listeners: hooks._hooks[event.name]?.length || 0,
+        executions: []
+      };
+    } else {
+      const hook = serverHooks[event.name];
+      if (hook.duration != null)
+        hook.executions.push(hook.duration);
+      hook.start = now();
+      hook.end = void 0;
+      hook.duration = void 0;
+    }
   });
+  hooks.afterEach((event) => {
+    const hook = serverHooks[event.name];
+    if (!hook)
+      return;
+    hook.end = now();
+    hook.duration = hook.end - hook.start;
+    const listeners = hooks._hooks[event.name]?.length;
+    if (listeners != null)
+      hook.listeners = listeners;
+  });
+  return serverHooks;
+}
+
+function setupGeneralRPC({ nuxt, refresh }) {
+  const components = [];
+  const imports = [];
+  const importPresets = [];
+  const serverPages = [];
+  const serverHooks = setupHooksDebug(nuxt.hooks);
+  let unimport;
+  let app;
   nuxt.hook("components:extend", (v) => {
     components.length = 0;
     components.push(...v);
@@ -8311,7 +8569,7 @@ function setupRPC(nuxt, _options) {
       page.children?.forEach(searchChildren);
     }
     v.forEach(searchChildren);
-    serverPages.push(...Array.from(pagesSet).sort((a, b) => a.file.localeCompare(b.file)));
+    serverPages.push(...Array.from(pagesSet).sort((a, b) => a.path.localeCompare(b.path)));
     refresh("getServerPages");
   });
   nuxt.hook("imports:sources", async (v) => {
@@ -8326,43 +8584,270 @@ function setupRPC(nuxt, _options) {
   nuxt.hook("app:resolve", (v) => {
     app = v;
   });
-  const middleware = async (req, _res) => {
+  return {
+    getServerConfig() {
+      return nuxt.options;
+    },
+    getComponents() {
+      return components;
+    },
+    async getComponentsRelationships() {
+      return [];
+    },
+    getServerPages() {
+      return serverPages;
+    },
+    getAutoImports() {
+      return {
+        imports: [
+          ...imports,
+          ...importPresets
+        ],
+        metadata: unimport?.getMetadata()
+      };
+    },
+    getServerLayouts() {
+      return Object.values(app?.layouts || []);
+    },
+    getServerHooks() {
+      return Object.values(serverHooks);
+    },
+    async openInEditor(input) {
+      if (input.startsWith("./"))
+        input = resolve$1(process.cwd(), input);
+      const match = input.match(/^(.*?)([:\d]*)$/);
+      let suffix = "";
+      if (match) {
+        input = match[1];
+        suffix = match[2];
+      }
+      const path = [
+        input,
+        `${input}.js`,
+        `${input}.mjs`,
+        `${input}.ts`
+      ].find((i) => existsSync(i));
+      if (path) {
+        await import('launch-editor').then((r) => (r.default || r)(path + suffix));
+      } else {
+        console.error("File not found:", input);
+      }
+    },
+    restartNuxt(hard = true) {
+      logger.info("Restarting Nuxt...");
+      return nuxt.callHook("restart", { hard });
+    }
+  };
+}
+
+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 pathApp = join$2(nuxt.options.srcDir, "app.vue");
+  const pathPageIndex = join$2(nuxt.options.srcDir, "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(pathPageIndex), { recursive: true });
+  await fsp.writeFile(pathPageIndex, pagesIndexTemplate, "utf-8");
+  if (appContent && !appContent.includes("<NuxtPage")) {
+    appContent = appContent.replace("</template>", "  <NuxtPage />\n</template>").replace(/<NuxtWelcome\s*\/>/, "");
+    await fsp.writeFile(pathApp, appContent, "utf-8");
+  }
+  logger.success("Routing creation wizard completed");
+}
+
+const wizard = {
+  enablePages
+};
+
+const LOG_PREFIX = picocolorsExports.cyan("Nuxt DevTools:");
+
+function setupWizardRPC({ nuxt }) {
+  return {
+    runWizard(name, ...args) {
+      logger.info(LOG_PREFIX, `Running wizard ${picocolorsExports.green(name)}...`);
+      return wizard[name](nuxt, ...args);
+    }
+  };
+}
+
+function setupTerminalRPC({ nuxt, rpc, refresh }) {
+  const terminals = /* @__PURE__ */ new Map();
+  nuxt.hook("devtools:terminal:register", (terminal) => {
+    terminals.set(terminal.id, terminal);
+    refresh("getTerminals");
+    return terminal.id;
+  });
+  nuxt.hook("devtools:terminal:remove", ({ id }) => {
+    if (!terminals.has(id))
+      return false;
+    terminals.delete(id);
+    refresh("getTerminals");
+    return true;
+  });
+  nuxt.hook("devtools:terminal:write", ({ id, data }) => {
+    const terminal = terminals.get(id);
+    if (!terminal)
+      return false;
+    terminal.buffer || (terminal.buffer = "");
+    terminal.buffer += data;
+    rpc.broadcast.onTerminalData.asEvent({ id, data });
+    return true;
+  });
+  nuxt.hook("devtools:terminal:exit", ({ id, code }) => {
+    const terminal = terminals.get(id);
+    if (!terminal)
+      return false;
+    terminal.isTerminated = true;
+    rpc.broadcast.onTerminalExit.asEvent({ id, code });
+    refresh("getTerminals");
+    return true;
+  });
+  function serializeTerminal(terminal, buffer = false) {
+    if (!terminal)
+      return;
+    return {
+      id: terminal.id,
+      name: terminal.name,
+      description: terminal.description,
+      icon: terminal.icon,
+      terminatable: terminal.terminatable ?? !!terminal.onActionTerminate,
+      restartable: terminal.restartable ?? !!terminal.onActionRestart,
+      isTerminated: terminal.isTerminated,
+      buffer: buffer ? terminal.buffer : void 0
+    };
+  }
+  return {
+    getTerminals() {
+      return Array.from(terminals.values()).map((i) => serializeTerminal(i));
+    },
+    getTerminalDetail(id) {
+      return serializeTerminal(terminals.get(id), true);
+    },
+    async runTerminalAction(id, action) {
+      const terminal = terminals.get(id);
+      if (!terminal)
+        return false;
+      switch (action) {
+        case "restart":
+          if (!terminal.onActionRestart)
+            return false;
+          await terminal.onActionRestart();
+          return true;
+        case "terminate":
+          if (!terminal.onActionTerminate)
+            return false;
+          await terminal.onActionTerminate();
+          return true;
+        case "remove":
+          if (!terminal.isTerminated)
+            terminal.onActionTerminate?.();
+          terminals.delete(id);
+          refresh("getTerminals");
+          return true;
+        case "clear":
+          terminal.buffer = "";
+          refresh("getTerminals");
+          return true;
+      }
+    }
+  };
+}
+
+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(":"))
+          return;
+        const [namespace, fnName] = name.split(":");
+        return extendedRpcMap.get(namespace)?.[fnName];
+      },
+      onError(error, name) {
+        console.error(`[nuxt-devtools] RPC error on executing "${name}":`, error);
+      }
+    }
+  );
+  function refresh(event) {
+    rpc.broadcast.refresh.asEvent(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}`];
+        }
+      })
+    };
+  }
+  const ctx = {
+    nuxt,
+    options,
+    rpc,
+    refresh,
+    extendServerRpc
+  };
+  nuxt.devtools = ctx;
+  Object.assign(serverFunctions, {
+    ...setupGeneralRPC(ctx),
+    ...setupCustomTabRPC(ctx),
+    ...setupStorageRPC(ctx),
+    ...setupAssetsRPC(ctx),
+    ...setupNpmRPC(ctx),
+    ...setupWizardRPC(ctx),
+    ...setupTerminalRPC(ctx)
+  });
+  const wsClients = /* @__PURE__ */ new Set();
+  const middleware = async (req, _res, next) => {
     if (req.ws) {
       const ws = await req.ws();
-      clients.add(ws);
+      wsClients.add(ws);
       const channel = {
         post: (d) => ws.send(d),
         on: (fn) => ws.on("message", fn),
         serialize: stringify,
         deserialize: parse$7
       };
-      birpc.updateChannels((c2) => {
-        c2.push(channel);
+      rpc.updateChannels((c) => {
+        c.push(channel);
       });
       ws.on("close", () => {
-        clients.delete(ws);
-        birpc.updateChannels((c2) => {
-          const index = c2.indexOf(channel);
+        wsClients.delete(ws);
+        rpc.updateChannels((c) => {
+          const index = c.indexOf(channel);
           if (index >= 0)
-            c2.splice(index, 1);
+            c.splice(index, 1);
         });
       });
+    } else {
+      next();
     }
   };
-  async function initHooks() {
-    nuxt.hook("devtools:customTabs:refresh", initCustomTabs);
-    await initCustomTabs();
-  }
-  async function initCustomTabs() {
-    customTabs.length = 0;
-    await nuxt.callHook("devtools:customTabs", customTabs);
-    refresh("getCustomTabs");
-  }
   return {
-    serverFunctions,
     middleware,
-    initHooks,
-    birpc
+    ...ctx
   };
 }
 
@@ -8378,14 +8863,13 @@ async function enableModule(options, nuxt) {
   await nuxt.callHook("devtools:before");
   nuxt.options.imports.collectMeta = true;
   addPlugin({
-    src: join(runtimeDir, "plugins/devtools.client"),
+    src: join$3(runtimeDir, "plugins/devtools.client"),
     mode: "client"
   });
   const {
     middleware: rpcMiddleware,
-    initHooks,
-    serverFunctions
-  } = setupRPC(nuxt);
+    ...ctx
+  } = setupRPC(nuxt, options);
   const clientDirExists = existsSync(clientDir);
   nuxt.hook("vite:extendConfig", (config) => {
     var _a, _b;
@@ -8403,15 +8887,17 @@ async function enableModule(options, nuxt) {
       server.middlewares.use(ROUTE_CLIENT, sirv(clientDir, { single: true, dev: true }));
   });
   const integrations = [
-    options.viteInspect !== false ? import('./vite-inspect.mjs').then(({ setup }) => setup(nuxt, serverFunctions)) : null,
-    options.componentInspector !== false ? import('./vue-inspector.mjs').then(({ setup }) => setup(nuxt, serverFunctions)) : null,
-    options.vscode?.enabled ? import('./vscode.mjs').then(({ setup }) => setup(nuxt, serverFunctions, options.vscode || {})) : null
+    import('./plugin-metrics.mjs').then(({ setup }) => setup(ctx)),
+    options.viteInspect !== false ? import('./vite-inspect.mjs').then(({ setup }) => setup(ctx)) : null,
+    options.componentInspector !== false ? import('./vue-inspector.mjs').then(({ setup }) => setup(ctx)) : null,
+    options.vscode?.enabled ? import('./vscode.mjs').then(({ setup }) => setup(ctx)) : null
   ];
   await Promise.all(integrations);
-  nuxt.hook("app:resolve", async () => {
-    await initHooks();
+  await nuxt.callHook("devtools:initialized", {
+    version,
+    packagePath: packageDir,
+    isGlobalInstall: isGlobalInstall()
   });
-  await nuxt.callHook("devtools:initialized");
   logger.success(`Nuxt Devtools is enabled ${picocolorsExports.dim(`v${version}`)}${isGlobalInstall() ? picocolorsExports.dim("[global]") : ""} ${picocolorsExports.yellow("(experimental)")}`);
 }