zotero-plugin-scaffold 0.3.4 → 0.4.0

package/dist/shared/{zotero-plugin-scaffold.DfqO5HjX.mjs → zotero-plugin-scaffold.CLDX-OU6.mjs}

@@ -1,5 +1,5 @@
 import { loadConfig as loadConfig$1 } from 'c12';
-import { isPlainObject, kebabCase, mapValues, toMerged, escapeRegExp, delay, debounce } from 'es-toolkit';
+import { isPlainObject, kebabCase, mapValues, toMerged, escapeRegExp, debounce, delay } from 'es-toolkit';
 import { readJsonSync, outputFile, emptyDir, copy, readJSON, outputJSON, move, writeJson, pathExists, ensureDir, remove } from 'fs-extra/esm';
 import { createHooks } from 'hookable';
 import process from 'node:process';
@@ -11,7 +11,7 @@ import { createReadStream, existsSync } from 'node:fs';
 import { readFile, writeFile, stat } from 'node:fs/promises';
 import { basename, dirname, join, resolve, extname } from 'node:path';
 import AdmZip from 'adm-zip';
-import { build } from 'esbuild';
+import { build, context } from 'esbuild';
 import { glob, globSync } from 'tinyglobby';
 import { createHash } from 'node:crypto';
 import { parseSync, printSync } from '@swc/core';
@@ -23,8 +23,8 @@ import net from 'node:net';
 import { Buffer } from 'node:buffer';
 import domain from 'node:domain';
 import EventEmitter from 'node:events';
-import http from 'node:http';
 import { Xvfb } from 'xvfb-ts';
+import http from 'node:http';
 
 const factory = (...formats) =>
   new Proxy(util.styleText.bind(util, formats), {
@@ -138,7 +138,7 @@ ${error.stack}`;
     const { space = DEFAULT_OPTIONS.SPACE, newLine = DEFAULT_OPTIONS.NEW_LINE } = options;
     const formattedContent = this.formatContent(content);
     const output = [
-      " ".repeat(space),
+      "  ".repeat(space),
       config.symbol,
       formattedContent
     ].join(" ");
@@ -329,11 +329,10 @@ const defaultConfig = {
       timeout: 1e4
     },
     abortOnFail: false,
-    exitOnFinish: false,
     headless: false,
     startupDelay: 1e3,
     waitForPlugin: "() => true",
-    watch: false,
+    watch: true,
     hooks: {}
   },
   logLevel: "INFO"
@@ -447,7 +446,7 @@ class PrefsManager {
       return value;
   }
   /**
-   * Parse Method 2 - Using swc
+   * Render Method 2 - Using swc
    */
   render() {
     const span = { start: 0, end: 0, ctxt: 0 };
@@ -516,7 +515,7 @@ class PrefsManager {
     return code;
   }
   /**
-   * Parse Method 1 - Using string
+   * Render Method 1 - Using string
    * @deprecated
    */
   renderByString() {
@@ -626,21 +625,21 @@ class Build extends Base {
     await this.ctx.hooks.callHook("build:init", this.ctx);
     await emptyDir(dist);
     await this.ctx.hooks.callHook("build:mkdir", this.ctx);
-    this.logger.tip("Preparing static assets");
+    this.logger.tip("Preparing static assets", { space: 1 });
     await this.makeAssets();
     await this.ctx.hooks.callHook("build:copyAssets", this.ctx);
-    this.logger.debug("Preparing manifest");
+    this.logger.debug("Preparing manifest", { space: 2 });
     await this.makeManifest();
     await this.ctx.hooks.callHook("build:makeManifest", this.ctx);
-    this.logger.debug("Preparing locale files");
+    this.logger.debug("Preparing locale files", { space: 2 });
     await this.prepareLocaleFiles();
     await this.ctx.hooks.callHook("build:fluent", this.ctx);
     await this.preparePrefs();
-    this.logger.tip("Bundling scripts");
+    this.logger.tip("Bundling scripts", { space: 1 });
     await this.esbuild();
     await this.ctx.hooks.callHook("build:bundle", this.ctx);
     if (process.env.NODE_ENV === "production") {
-      this.logger.tip("Packing plugin");
+      this.logger.tip("Packing plugin", { space: 1 });
       await this.pack();
       await this.ctx.hooks.callHook("build:pack", this.ctx);
       await this.makeUpdateJson();
@@ -1169,7 +1168,7 @@ class Release extends Base {
       conventionalChangelog({ releaseCount: 2, preset: "angular" }, { version }).on("data", (chunk) => {
         changelog += chunk.toString();
       }).on("end", () => {
-        changelog = changelog.split("\n").filter((line) => !line.match(/^## .*/) || !line.match(/^# .*/)).join("\n").trim();
+        changelog = changelog.split("\n").filter((line) => !line.match(/^## .*/) && !line.match(/^# .*/)).join("\n").trim();
         resolve(changelog);
       }).on("error", (err) => {
         reject(err);
@@ -1243,6 +1242,42 @@ ${changelog}
   }
 }
 
+function watch(source, event) {
+  const watcher = chokidar.watch(source, {
+    ignored: /(^|[/\\])\../,
+    // ignore dotfiles
+    persistent: true
+  });
+  const onChangeDebounced = safeDebounce(event.onChange);
+  watcher.on("ready", async () => {
+    if (event.onReady)
+      await event.onReady();
+    logger.clear();
+    logger.ready("Server Ready!");
+  }).on("change", async (path) => {
+    logger.clear();
+    logger.info(`${path} changed`);
+    await onChangeDebounced(path);
+  }).on("error", async (err) => {
+    if (event.onError)
+      await event.onError(err);
+    logger.fail("Server start failed!");
+    logger.error(err);
+  });
+}
+function safeDebounce(fn) {
+  if (!fn)
+    return () => {
+    };
+  return debounce(async (...args) => {
+    try {
+      await fn(...args);
+    } catch (error) {
+      logger.error(error);
+    }
+  }, 500);
+}
+
 function isRunning(query) {
   let cmd = "";
   switch (process.platform) {
@@ -1719,9 +1754,7 @@ class RemoteFirefox {
     const addon = await this.getInstalledAddon(addonId);
     await this.checkForAddonReloading(addon);
     await this.addonRequest(addon, "reload");
-    logger.success(
-      `\rLast extension reload: ${(/* @__PURE__ */ new Date()).toTimeString()}`
-    );
+    logger.success(`Last extension reload: ${(/* @__PURE__ */ new Date()).toTimeString()}`);
   }
 }
 function findFreeTcpPort() {
@@ -2037,37 +2070,23 @@ class Serve extends Base {
    */
   async watch() {
     const { source } = this.ctx;
-    const watcher = chokidar.watch(source, {
-      ignored: /(^|[/\\])\../,
-      // ignore dotfiles
-      persistent: true
-    });
-    const onChangeDebounced = debounce(async (path) => {
-      await this.onChange(path).catch((err) => {
-        this.logger.error(err);
-      });
-    }, 500);
-    watcher.on("ready", async () => {
-      await this.ctx.hooks.callHook("serve:ready", this.ctx);
-      this.logger.clear();
-      this.logger.ready("Server Ready!");
-    }).on("change", async (path) => {
-      this.logger.clear();
-      this.logger.info(`${path} changed`);
-      await onChangeDebounced(path);
-    }).on("error", (err) => {
-      this.logger.fail("Server start failed!");
-      this.logger.error(err);
-    });
-  }
-  async onChange(path) {
-    await this.ctx.hooks.callHook("serve:onChanged", this.ctx, path);
-    if (path.endsWith(".ts") || path.endsWith(".tsx")) {
-      await this.builder.esbuild();
-    } else {
-      await this.builder.run();
-    }
-    await this.reload();
+    watch(
+      source,
+      {
+        onReady: async () => {
+          await this.ctx.hooks.callHook("serve:ready", this.ctx);
+        },
+        onChange: async (path) => {
+          await this.ctx.hooks.callHook("serve:onChanged", this.ctx, path);
+          if (path.endsWith(".ts") || path.endsWith(".tsx")) {
+            await this.builder.esbuild();
+          } else {
+            await this.builder.run();
+          }
+          await this.reload();
+        }
+      }
+    );
   }
   async reload() {
     this.logger.tip("Reloading...");
@@ -2101,11 +2120,24 @@ class Serve extends Base {
   }
 }
 
-async function saveResource(url, path) {
-  const res = await fetch(url);
-  await outputFile(path, await res.text());
-}
+const BASE_DIR = ".scaffold";
+const CACHE_DIR = `${BASE_DIR}/cache`;
+const TESTER_BASE_PATH = `${BASE_DIR}/test`;
+const TESTER_PROFILE_DIR = `${TESTER_BASE_PATH}/profile`;
+const TESTER_DATA_DIR = `${TESTER_BASE_PATH}/data`;
+const TESTER_PLUGIN_DIR = `${TESTER_BASE_PATH}/resource`;
+const TESTER_PLUGIN_REF = "zotero-plugin-scaffold-test-runner";
+const TESTER_PLUGIN_ID = "scaffold-test@northword.cn";
 
+async function prepareHeadless() {
+  await installXvfb();
+  await installDepsForUbuntu24();
+  await installZoteroLinux();
+  const xvfb = new Xvfb({
+    timeout: 2e3
+  });
+  await xvfb.start();
+}
 function isPackageInstalled(packageName) {
   try {
     execSync(`dpkg-query -W ${packageName}`, { stdio: "ignore" });
@@ -2160,163 +2192,444 @@ async function installZoteroLinux() {
     return;
   }
   logger.debug("Installing Zotero...");
+  execSync(`cd ${CACHE_DIR}`);
   execSync("wget -O zotero.tar.bz2 'https://www.zotero.org/download/client/dl?platform=linux-x86_64&channel=beta'", { stdio: "pipe" });
   execSync("tar -xvf zotero.tar.bz2", { stdio: "pipe" });
   process.env.ZOTERO_PLUGIN_ZOTERO_BIN_PATH = `${process.cwd()}/Zotero_linux-x86_64/zotero`;
+  execSync("cd -");
 }
 
-class Test extends Base {
-  builder;
-  runner;
-  communicator = {};
-  constructor(ctx) {
-    super(ctx);
-    process.env.NODE_ENV ??= "test";
-    this.builder = new Build(ctx);
-    if (isCI) {
-      this.ctx.test.exitOnFinish = true;
-      this.ctx.test.headless = true;
-    }
+class TestHttpReporter {
+  _server;
+  _port;
+  passed = 0;
+  failed = 0;
+  constructor() {
   }
-  async run() {
-    process.on("SIGINT", this.exit);
-    await emptyDir(this.profilePath);
-    await emptyDir(this.dataDir);
-    await emptyDir(this.testPluginDir);
-    await this.ctx.hooks.callHook("test:init", this.ctx);
-    await this.builder.run();
-    await this.ctx.hooks.callHook("test:prebuild", this.ctx);
-    this.logger.clear();
-    await this.startHttpServer();
-    await this.ctx.hooks.callHook("test:listen", this.ctx);
-    await this.createTestPlugin();
-    await this.copyTestLibraries();
-    await this.ctx.hooks.callHook("test:copyAssets", this.ctx);
-    await this.bundleTests();
-    await this.ctx.hooks.callHook("test:bundleTests", this.ctx);
-    if (this.ctx.test.watch) ;
-    if (isCI || this.ctx.test.headless) {
-      await this.startZoteroHeadless();
+  async getPort() {
+    this._port = await findFreeTcpPort();
+  }
+  get port() {
+    return this._port;
+  }
+  async start() {
+    if (!this._port)
+      await this.getPort();
+    this._server = http.createServer(this.handleRequest.bind(this));
+    this._server.listen(this._port, () => {
+      logger.debug(`Server is listening on http://localhost:${this.port}`);
+    });
+    return this;
+  }
+  handleRequest(req, res) {
+    if (req.method === "GET" && req.url === "/") {
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end("Zotero Plugin Test Server is running");
+    } else if (req.method === "POST" && req.url === "/update") {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      req.on("end", async () => {
+        try {
+          const jsonData = JSON.parse(body);
+          await this.onData(jsonData);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ message: "Results received successfully" }));
+        } catch (error) {
+          logger.error(`Error parsing JSON:, ${error}`);
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid JSON" }));
+        }
+      });
     } else {
-      await this.startZotero();
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not Found" }));
     }
-    await this.ctx.hooks.callHook("test:run", this.ctx);
   }
-  async createTestPlugin() {
-    const manifest = {
-      manifest_version: 2,
-      name: this.testPluginRef,
-      version: "0.0.1",
-      description: "Test suite for the Zotero plugin. This is a runtime-generated plugin only for testing purposes.",
-      applications: {
-        zotero: {
-          id: this.testPluginID,
-          update_url: "https://invalid.com",
-          // strict_min_version: "*.*.*",
-          strict_max_version: "999.*.*"
-        }
+  async onData(body) {
+    const { type, data } = body;
+    const logger_option = { space: data.indents - 1 };
+    switch (type) {
+      case "debug":
+        logger.log(data);
+        break;
+      case "start":
+        logger.newLine();
+        break;
+      case "suite":
+        if (data.title)
+          logger.tip(data.title, logger_option);
+        break;
+      case "pass":
+        this.passed++;
+        logger.success(`${data.title} ${styleText.gray(`${data.duration}ms`)}`, logger_option);
+        break;
+      case "fail":
+        this.failed++;
+        logger.fail(styleText.red(`${data.title}, ${body.data?.error?.message}`), logger_option);
+        break;
+      case "pending":
+        logger.info(`${data.title} pending`, logger_option);
+        break;
+      case "suite end":
+        break;
+      case "end":
+        logger.newLine();
+        if (this.failed === 0)
+          logger.success(`Test run completed - ${this.passed} passed`);
+        else
+          logger.fail(`Test run completed - ${this.passed} passed, ${this.failed} failed`);
+        break;
+      default:
+        logger.log(data);
+        break;
+    }
+  }
+  stop() {
+    this._server?.close();
+  }
+}
+
+async function saveResource(url, path) {
+  const res = await fetch(url);
+  await outputFile(path, await res.text());
+}
+
+function generateBootstrap(options) {
+  return `//Code generated by the zotero-plugin-scaffold tester
+var chromeHandle;
+
+function install(data, reason) {}
+
+async function startup({ id, version, resourceURI, rootURI }, reason) {
+  await Zotero.initializationPromise;
+  const aomStartup = Components.classes[
+    "@mozilla.org/addons/addon-manager-startup;1"
+  ].getService(Components.interfaces.amIAddonManagerStartup);
+  const manifestURI = Services.io.newURI(rootURI + "manifest.json");
+  chromeHandle = aomStartup.registerChrome(manifestURI, [
+    ["content", "${TESTER_PLUGIN_REF}", rootURI + "content/"],
+  ]);
+
+  launchTests().catch((error) => {
+    Zotero.debug(error);
+    Zotero.HTTP.request(
+      "POST",
+      "http://localhost:${options.port}/update",
+      {
+        body: JSON.stringify({
+          type: "fail",
+          data: {
+            title: "Internal: Plugin awaiting timeout",
+            stack: "",
+            str: "Plugin awaiting timeout",
+          },
+        }),
       }
-    };
-    await outputJSON(`${this.testPluginDir}/manifest.json`, manifest, { spaces: 2 });
-    const bootstrap = `
-      /**
-       * Code generated by the zotero-plugin-scaffold tester
-       */
-      
-      var chromeHandle;
-      
-      function install(data, reason) {}
-      
-      async function startup({ id, version, resourceURI, rootURI }, reason) {
-        await Zotero.initializationPromise;
-        const aomStartup = Components.classes[
-          "@mozilla.org/addons/addon-manager-startup;1"
-        ].getService(Components.interfaces.amIAddonManagerStartup);
-        const manifestURI = Services.io.newURI(rootURI + "manifest.json");
-        chromeHandle = aomStartup.registerChrome(manifestURI, [
-          ["content", "${this.testPluginRef}", rootURI + "content/"],
-        ]);
-      
-        launchTests().catch((error) => {
-          Zotero.debug(error);
-          Zotero.HTTP.request(
-            "POST",
-            "http://localhost:${this.communicator.port}/update",
-            {
-              body: JSON.stringify({
-                type: "fail",
-                data: {
-                  title: "Internal: Plugin awaiting timeout",
-                  stack: "",
-                  str: "Plugin awaiting timeout",
-                },
-              }),
-            }
-          );
-        });
+    );
+  });
+}
+
+function onMainWindowLoad({ window: win }) {}
+
+function onMainWindowUnload({ window: win }) {}
+
+function shutdown({ id, version, resourceURI, rootURI }, reason) {
+  if (reason === APP_SHUTDOWN) {
+    return;
+  }
+
+  if (chromeHandle) {
+    chromeHandle.destruct();
+    chromeHandle = null;
+  }
+}
+
+function uninstall(data, reason) {}
+
+async function launchTests() {
+  // Delay to allow plugin to fully load before opening the test page
+  await Zotero.Promise.delay(${options.startupDelay || 1e3});
+
+  const waitForPlugin = "${options.waitForPlugin}";
+
+  if (waitForPlugin) {
+    // Wait for a plugin to be installed
+    await waitUtilAsync(() => {
+      try {
+        return !!eval(waitForPlugin)();
+      } catch (error) {
+        return false;
       }
-      
-      function onMainWindowLoad({ window: win }) {}
-      
-      function onMainWindowUnload({ window: win }) {}
-      
-      function shutdown({ id, version, resourceURI, rootURI }, reason) {
-        if (reason === APP_SHUTDOWN) {
-          return;
-        }
-      
-        if (chromeHandle) {
-          chromeHandle.destruct();
-          chromeHandle = null;
-        }
+    }).catch(() => {
+      throw new Error("Plugin awaiting timeout");
+    });
+  }
+
+  Services.ww.openWindow(
+    null,
+    "chrome://${TESTER_PLUGIN_REF}/content/index.xhtml",
+    "Zotero Plugin Scaffold Test Runnner",
+    "chrome,centerscreen,resizable=yes",
+    {}
+  );
+}
+
+function waitUtilAsync(condition, interval = 100, timeout = 1e4) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const intervalId = setInterval(() => {
+      if (condition()) {
+        clearInterval(intervalId);
+        resolve();
+      } else if (Date.now() - start > timeout) {
+        clearInterval(intervalId);
+        reject();
       }
-      
-      function uninstall(data, reason) {}
-      
-      async function launchTests() {
-        // Delay to allow plugin to fully load before opening the test page
-        await Zotero.Promise.delay(${this.ctx.test.startupDelay || 1e3});
-      
-        const waitForPlugin = "${this.ctx.test.waitForPlugin}";
-      
-        if (waitForPlugin) {
-          // Wait for a plugin to be installed
-          await waitUtilAsync(() => {
-            try {
-              return !!eval(waitForPlugin)();
-            } catch (error) {
-              return false;
-            }
-          }).catch(() => {
-            throw new Error("Plugin awaiting timeout");
-          });
+    }, interval);
+  });
+}
+`;
+}
+
+function generateHtml(setupCode, testFiles) {
+  const tests = testFiles.map((f) => `<script src="${f}"><\/script>`).join("\n    ");
+  return `<!-- Generated by zotero-plugin-scaffold -->
+<!DOCTYPE html>
+<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
+<head>
+    <meta charset="UTF-8"></meta>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0"></meta>
+    <title>Zotero Plugin Test</title>
+    <style>
+        html {
+            min-width: 400px;
+            min-height: 600px;
         }
-      
-        Services.ww.openWindow(
-          null,
-          "chrome://${this.testPluginRef}/content/index.xhtml",
-          "${this.ctx.namespace}-test",
-          "chrome,centerscreen,resizable=yes",
-          {}
-        );
-      }
-      
-      function waitUtilAsync(condition, interval = 100, timeout = 1e4) {
-        return new Promise((resolve, reject) => {
-          const start = Date.now();
-          const intervalId = setInterval(() => {
-            if (condition()) {
-              clearInterval(intervalId);
-              resolve();
-            } else if (Date.now() - start > timeout) {
-              clearInterval(intervalId);
-              reject();
-            }
-          }, interval);
-        });
+        body {
+            font-family: Arial, sans-serif;
+        }
+    </style>
+</head>
+<body>
+    <div id="mocha"></div>
+
+    <!-- Include Zotero Vars -->
+    <script src="chrome://zotero/content/include.js"><\/script>
+
+    <!-- Mocha and Chai Libraries -->
+    <script src="mocha.js"><\/script>
+    <script src="chai.js"><\/script>
+
+    <!-- Setup Mocha -->
+    <script>
+      ${setupCode}
+    <\/script>
+
+    <!-- Unit tests -->
+    ${tests}
+
+    <!-- Run Mocha -->
+    <script class="mocha-exec">
+      mocha.run();
+    <\/script>
+</body>
+</html>
+`;
+}
+
+function generateManifest() {
+  return {
+    manifest_version: 2,
+    name: "Zotero Plugin Scaffold Test Runner",
+    version: "0.0.1",
+    description: "Test suite for the Zotero plugin. This is a runtime-generated plugin only for testing purposes.",
+    applications: {
+      zotero: {
+        id: TESTER_PLUGIN_ID,
+        update_url: "https://example.com",
+        // strict_min_version: "*.*.*",
+        strict_max_version: "999.*.*"
       }
-      `.replaceAll(/^ {6}/g, "");
-    await outputFile(`${this.testPluginDir}/bootstrap.js`, bootstrap);
+    }
+  };
+}
+
+function generateMochaSetup(options) {
+  return `// Generated by zotero-plugin-scaffold
+mocha.setup({ 
+  ui: "bdd",
+  reporter: Reporter,
+  timeout: ${options.timeout} || 10000,
+  bail: ${options.abortOnFail}
+});
+
+window.expect = chai.expect;
+window.assert = chai.assert;
+
+async function send(data) {
+  const req = await Zotero.HTTP.request(
+    "POST",
+    "http://localhost:${options.port}/update",
+    {
+      body: JSON.stringify(data),
+    }
+  );
+
+  if (req.status !== 200) {
+    dump("Error sending data to server" + req.responseText);
+    return null;
+  } else {
+    const result = JSON.parse(req.responseText);
+    return result;
+  }
+}
+
+window.debug = function (data) {
+  send({ type: "debug", data });
+};
+
+let indents = 0,
+  passed = 0,
+  failed = 0,
+  aborted = false;
+
+// Inherit the default test settings from Zotero
+function Reporter(runner) {
+  function indent() {
+    return "  ".repeat(indents);
+  }
+
+  function dump(str) {
+    // console.log(str)
+    // const p = document.createElement("p")
+    // p.textContent = str
+    // document.querySelector("#mocha").append(p)
+    document.querySelector("#mocha").innerText += str;
+  }
+
+  runner.on("start", async function () {
+    console.log("start")
+    await send({ type: "start", data: { indents } });
+  });
+
+  runner.on("suite", async function (suite) {
+    console.log("suite", suite)
+    indents++;
+    const str = indent() + suite.title + "\\n";
+    dump(str);
+    await send({ type: "suite", data: { title: suite.title, root: suite.root, indents } });
+  });
+
+  runner.on("suite end", async function (suite) {
+    console.log("suite end", suite)
+    indents--;
+    const str = indents === 1 ? "\\n" : "";
+    dump(str);
+    await send({ type: "suite end", data: { title: suite.title, root: suite.root, indents } });
+  });
+
+  runner.on("pending", async function (test) {
+    console.log("pending", test)
+    const str = indent() + "pending  -" + test.title + "\\n";
+    dump(str);
+    await send({ type: "pending", data: { title: test.title, fulltest: test.fullTitle(), duration: test.duration, indents: indents + 1 } });
+  });
+
+  runner.on("pass", async function (test) {
+    console.log("pass", test)
+    passed++;
+    let str = indent() + Mocha.reporters.Base.symbols.ok + " " + test.title;
+    if ("fast" != test.speed) {
+      str += " (" + Math.round(test.duration) + " ms)";
+    }
+    str += "\\n";
+    dump(str);
+    await send({ type: "pass", data: { title: test.title, fulltest: test.fullTitle(), duration: test.duration, indents: indents + 1 } });
+
+  });
+
+  runner.on("fail", async function (test, error) {
+    console.log("fail", test, error)
+
+    // Make sure there's a blank line after all stack traces
+    // err.stack = err.stack.replace(/\\s*$/, "\\n\\n");
+
+    failed++;
+    let indentStr = indent();
+    const str =
+      indentStr +
+      // Dark red X for errors
+      Mocha.reporters.Base.symbols.err +
+      // Trigger bell if interactive
+      (Zotero.automatedTest ? "" : "\\x07") +
+      " " +
+      test.title +
+      "\\n" +
+      indentStr +
+      "  " +
+      error.message +
+      // " at\\n" +
+      // err.stack.replace(/^/gm, indentStr + "    ").trim() +
+      "\\n\\n";
+    dump(str);
+
+    await send({ type: "fail", data: { title: test.title, fulltest: test.fullTitle(), duration: test.duration, error, indents: indents + 1 } });
+
+  });
+
+  runner.on("end", async function () {
+    console.log("end")
+    const str =
+      passed +
+      "/" +
+      (passed + failed) +
+      " tests passed" +
+      (aborted ? " -- aborting" : "") +
+      "\\n";
+    dump(str);
+
+    await send({
+      type: "end",
+      data: { passed: passed, failed: failed, aborted: aborted, str, indents },
+    });
+
+    // Must exit on Zotero side, otherwise the exit code will not be 0 and CI will fail
+    if (${options.exitOnFinish ? "true" : "false"}) {
+      Zotero.Utilities.Internal.quit(0);
+    }
+  });
+}
+`;
+}
+
+class TestBundler {
+  constructor(ctx, port) {
+    this.ctx = ctx;
+    this.port = port;
+  }
+  esbuildContext;
+  async generate() {
+    await this.generateTestResources();
+    await this.createTestHtml();
+  }
+  async regenerate(changedFile) {
+    const esbuildResult = await this.esbuildContext?.rebuild();
+    const tests = findImpactedTests(changedFile, esbuildResult?.metafile);
+    await this.createTestHtml(tests);
+  }
+  async generateTestResources() {
+    const manifest = generateManifest();
+    await outputJSON(`${TESTER_PLUGIN_DIR}/manifest.json`, manifest, { spaces: 2 });
+    const bootstrap = generateBootstrap({
+      port: this.port,
+      startupDelay: this.ctx.test.startupDelay,
+      waitForPlugin: this.ctx.test.waitForPlugin
+    });
+    await outputFile(`${TESTER_PLUGIN_DIR}/bootstrap.js`, bootstrap);
+    await this.copyTestLibraries();
+    await this.bundleTests();
   }
   async copyTestLibraries() {
     const pkgs = [
@@ -2334,315 +2647,137 @@ class Test extends Base {
       }
     ];
     await Promise.all(pkgs.map(async (pkg) => {
-      const targetPath = `${this.testPluginDir}/content/${pkg.name}`;
+      const targetPath = `${TESTER_PLUGIN_DIR}/content/${pkg.name}`;
       if (pkg.local && await pathExists(pkg.local)) {
-        this.logger.debug(`Local ${pkg.name} package found`);
+        logger.debug(`Local ${pkg.name} package found`);
         await copy(pkg.local, targetPath);
         return;
       }
-      const cachePath = `${this.cacheDir}/${pkg.name}`;
+      const cachePath = `${CACHE_DIR}/${pkg.name}`;
       if (await pathExists(`${cachePath}`)) {
-        this.logger.debug(`Cache ${pkg.name} package found`);
+        logger.debug(`Cache ${pkg.name} package found`);
         await copy(cachePath, targetPath);
         return;
       }
-      this.logger.info(`No local ${pkg.name} found, we recommend you install ${pkg.name} package locally.`);
-      await saveResource(pkg.remote, `${this.cacheDir}/${pkg.name}`);
+      logger.info(`No local ${pkg.name} found, we recommend you install ${pkg.name} package locally.`);
+      await saveResource(pkg.remote, `${CACHE_DIR}/${pkg.name}`);
       await copy(cachePath, targetPath);
     }));
   }
   async bundleTests() {
     const testDirs = toArray(this.ctx.test.entries);
-    for (const dir of testDirs) {
-      let tsconfigPath = resolve(`${dir}/tsconfig.json`);
-      if (!await pathExists(tsconfigPath)) {
-        tsconfigPath = void 0;
-      }
-      await build({
-        entryPoints: await glob(`${dir}/**/*.spec.{js,ts}`),
-        outdir: `${this.testPluginDir}/content/units`,
-        bundle: true,
-        target: "firefox115",
-        tsconfig: tsconfigPath || void 0
-      });
-    }
-    const testFiles = (await glob(`**/*.spec.js`, { cwd: `${this.testPluginDir}/content` })).sort();
-    const setupCode = `
-      mocha.setup({ ui: "bdd", reporter: Reporter, timeout: ${this.ctx.test.mocha.timeout} || 10000, });
-
-      window.expect = chai.expect;
-      window.assert = chai.assert;
-
-      async function send(data) {
-        console.log("Sending data to server", data);
-        const req = await Zotero.HTTP.request(
-          "POST",
-          "http://localhost:${this.communicator.port}/update",
-          {
-            body: JSON.stringify(data),
-          }
-        );
-
-        if (req.status !== 200) {
-          dump("Error sending data to server" + req.responseText);
-          return null;
-        } else {
-          const result = JSON.parse(req.responseText);
-          return result;
-        }
-      }
-
-      window.debug = function (...data) {
-        const str = data.join("\\n");
-        Zotero.debug(str);
-        send({ type: "debug", data: { str } });
-      };
-
-      // Inherit the default test settings from Zotero
-      function Reporter(runner) {
-        var indents = 0,
-          passed = 0,
-          failed = 0,
-          aborted = false;
-
-        function indent() {
-          return Array(indents).join("  ");
-        }
-
-        function dump(str) {
-          console.log(str);
-          document.querySelector("#mocha").innerText += str;
-        }
-
-        runner.on("start", async function () {
-          await send({ type: "start" });
-        });
-
-        runner.on("suite", async function (suite) {
-          ++indents;
-          const str = indent() + suite.title + "\\n";
-          dump(str);
-          await send({ type: "suite", data: { title: suite.title, str } });
-        });
-
-        runner.on("suite end", async function (suite) {
-          --indents;
-          const str = indents === 1 ? "\\n" : "";
-          dump(str);
-          await send({ type: "suite end", data: { title: suite.title, str } });
-        });
-
-        runner.on("pending", async function (test) {
-          const str = indent() + "pending  -" + test.title + "\\n";
-          dump(str);
-          await send({ type: "pending", data: { title: test.title, str } });
-        });
-
-        runner.on("pass", async function (test) {
-          passed++;
-          let str = indent() + Mocha.reporters.Base.symbols.ok + " " + test.title;
-          if ("fast" != test.speed) {
-            str += " (" + Math.round(test.duration) + " ms)";
-          }
-          str += "\\n";
-          dump(str);
-          await send({
-            type: "pass",
-            data: { title: test.title, duration: test.duration, str },
-          });
-        });
-
-        runner.on("fail", async function (test, err) {
-          // Make sure there's a blank line after all stack traces
-          err.stack = err.stack.replace(/\\s*$/, "\\n\\n");
-
-          failed++;
-          let indentStr = indent();
-          const str =
-            indentStr +
-            // Dark red X for errors
-            "\\x1B[31;40m" +
-            Mocha.reporters.Base.symbols.err +
-            " [FAIL]\\x1B[0m" +
-            // Trigger bell if interactive
-            (Zotero.automatedTest ? "" : "\\x07") +
-            " " +
-            test.title +
-            "\\n" +
-            indentStr +
-            "  " +
-            err.message +
-            " at\\n" +
-            err.stack.replace(/^/gm, indentStr + "    ").trim() +
-            "\\n\\n";
-          dump(str);
-
-          if (${this.ctx.test.abortOnFail ? "true" : "false"}) {
-            aborted = true;
-            runner.abort();
-          }
-
-          await send({
-            type: "fail",
-            data: { title: test.title, stack: err.stack, str },
-          });
-        });
-
-        runner.on("end", async function () {
-          const str =
-            passed +
-            "/" +
-            (passed + failed) +
-            " tests passed" +
-            (aborted ? " -- aborting" : "") +
-            "\\n";
-          dump(str);
-
-          await send({
-            type: "end",
-            data: { passed: passed, failed: failed, aborted: aborted, str },
-          });
-
-          // Must exit on Zotero side, otherwise the exit code will not be 0 and CI will fail
-          if (${this.ctx.test.exitOnFinish ? "true" : "false"}) {
-            Zotero.Utilities.Internal.quit(0);
-          }
-        });
-      }
-      `.replaceAll("  ", "    ");
-    const html = `
-      <!DOCTYPE html>
-      <html lang="en" xmlns="http://www.w3.org/1999/xhtml">
-      <head>
-          <meta charset="UTF-8"></meta>
-          <meta name="viewport" content="width=device-width, initial-scale=1.0"></meta>
-          <title>Zotero Plugin Test</title>
-          <style>
-              html {
-                  min-width: 400px;
-                  min-height: 600px;
-              }
-              body {
-                  font-family: Arial, sans-serif;
-              }
-          </style>
-      </head>
-      <body>
-          <div id="mocha"></div>
-      
-          <!-- Include Zotero Vars -->
-          <script src="chrome://zotero/content/include.js"><\/script>
-
-          <!-- Mocha and Chai Libraries -->
-          <script src="mocha.js"><\/script>
-          <script src="chai.js"><\/script>
-
-          <!-- Setup Mocha -->
-          <script>
-            ${setupCode}
-          <\/script>
-
-          <!-- Unit tests -->
-          ${testFiles.map((f) => `<script src="${f}"><\/script>
-    `)}
-
-          <!-- Run Mocha -->
-          <script class="mocha-exec">
-            mocha.run();
-          <\/script>
-      </body>
-      </html>
-      `.replaceAll(/^ {6}/gm, "");
-    await outputFile(`${this.testPluginDir}/content/index.xhtml`, html);
-    this.logger.tip(`Injected ${testFiles.length} test files`);
-  }
-  async startHttpServer() {
-    this.communicator.server = http.createServer((req, res) => {
-      if (req.method === "GET" && req.url === "/") {
-        res.writeHead(200, { "Content-Type": "text/plain" });
-        res.end("Zotero Plugin Test Server is running");
-      } else if (req.method === "POST" && req.url === "/update") {
-        let body = "";
-        req.on("data", (chunk) => {
-          body += chunk;
-        });
-        req.on("end", async () => {
-          try {
-            const jsonData = JSON.parse(body);
-            await this.onHttpDataUpdated(jsonData);
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ message: "Results received successfully" }));
-          } catch (error) {
-            this.logger.error(`Error parsing JSON:, ${error}`);
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Invalid JSON" }));
-          }
-        });
-      } else {
-        res.writeHead(404, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Not Found" }));
-      }
+    const entryPoints = (await Promise.all(testDirs.map((dir) => glob(`${dir}/**/*.spec.{js,ts}`)))).flat();
+    this.esbuildContext = await context({
+      entryPoints,
+      outdir: `${TESTER_PLUGIN_DIR}/content/units`,
+      bundle: true,
+      target: "firefox115",
+      metafile: true
     });
-    const PORT = this.communicator.port = await findFreeTcpPort();
-    this.communicator.server.listen(PORT, () => {
-      this.logger.tip(`Server is listening on http://localhost:${PORT}`);
+    await this.esbuildContext.rebuild();
+  }
+  async createTestHtml(tests = []) {
+    const setupCode = generateMochaSetup({
+      timeout: this.ctx.test.mocha.timeout,
+      port: this.port,
+      abortOnFail: this.ctx.test.abortOnFail,
+      exitOnFinish: !this.ctx.test.watch
     });
-  }
-  async onHttpDataUpdated(body) {
-    if (body.type === "debug" && body.data?.str) {
-      for (const line of body.data?.str.split("\n")) {
-        this.logger.log(line);
-        this.logger.newLine();
-      }
-    }
-    const str = body.data?.str.replaceAll("\n", "");
-    if (body.type === "start") {
-      this.logger.newLine();
-    } else if (body.type === "suite" && !!str) {
-      this.logger.tip(str);
-    }
-    if (body.type === "pass" && !!str) {
-      this.logger.log(str);
-    } else if (body.type === "fail") {
-      this.logger.error(str);
-      if (this.ctx.test.abortOnFail) {
-        this.logger.error("Aborting test run due to failure");
-        if (this.ctx.test.exitOnFinish)
-          this.exit(1);
-      }
-    } else if (body.type === "suite end") {
-      this.logger.newLine();
-    } else if (body.type === "end") {
-      this.logger.success("Test run completed");
-      this.communicator.server?.close();
-      if (this.ctx.test.exitOnFinish)
-        this.exit();
+    let testFiles = tests;
+    if (testFiles.length === 0) {
+      testFiles = (await glob(`**/*.spec.js`, { cwd: `${TESTER_PLUGIN_DIR}/content` })).sort();
     }
+    const html = generateHtml(setupCode, testFiles);
+    await outputFile(`${TESTER_PLUGIN_DIR}/content/index.xhtml`, html);
   }
-  async watch() {
+}
+function findImpactedTests(changedFilePath, buildMetadata) {
+  if (!buildMetadata)
+    return [];
+  const resolvedChangedFile = resolve(changedFilePath);
+  const impactedTestFiles = /* @__PURE__ */ new Set();
+  for (const [outputFilePath, outputInfo] of Object.entries(buildMetadata.outputs)) {
+    const testFilePath = outputFilePath.replace(`${TESTER_PLUGIN_DIR}/content/`, "");
+    if (Object.keys(outputInfo.inputs).some((inputPath) => resolve(inputPath) === resolvedChangedFile)) {
+      impactedTestFiles.add(testFilePath);
+    }
   }
-  async onCodeChanged(_path) {
+  return Array.from(impactedTestFiles);
+}
+
+class Test extends Base {
+  builder;
+  zotero;
+  reporter = new TestHttpReporter();
+  testBundler;
+  constructor(ctx) {
+    super(ctx);
+    process.env.NODE_ENV ??= "test";
+    this.builder = new Build(ctx);
+    if (isCI) {
+      this.ctx.test.headless = true;
+      this.ctx.test.watch = false;
+    }
   }
-  async startZoteroHeadless() {
-    await installXvfb();
-    await installDepsForUbuntu24();
-    await installZoteroLinux();
-    const xvfb = new Xvfb({
-      timeout: 2e3
-    });
-    await xvfb.start();
+  async run() {
+    process.on("SIGINT", this.exit);
+    await emptyDir(TESTER_PROFILE_DIR);
+    await emptyDir(TESTER_DATA_DIR);
+    await emptyDir(TESTER_PLUGIN_DIR);
+    await this.ctx.hooks.callHook("test:init", this.ctx);
+    await this.builder.run();
+    await this.ctx.hooks.callHook("test:prebuild", this.ctx);
+    await this.reporter.start();
+    this.testBundler = new TestBundler(
+      this.ctx,
+      this.reporter.port
+    );
+    await this.testBundler.generate();
+    await this.ctx.hooks.callHook("test:bundleTests", this.ctx);
     await this.startZotero();
+    await this.ctx.hooks.callHook("test:run", this.ctx);
+    if (this.ctx.test.watch) {
+      this.watch();
+    }
+  }
+  async watch() {
+    const source = toArray(this.ctx.source).map((p) => resolve(p));
+    const tests = toArray(this.ctx.test.entries).map((p) => resolve(p));
+    function isSource(_path) {
+      const path = resolve(_path);
+      const isSource2 = source.find((s) => path.match(s)) || false;
+      tests.find((t) => path.match(t)) || false;
+      return isSource2;
+    }
+    watch(
+      [this.ctx.source, this.ctx.test.entries].flat(),
+      {
+        onChange: async (path) => {
+          if (isSource(path)) {
+            await this.builder.run();
+            await this.testBundler?.regenerate(path);
+            await this.zotero?.reloadAllPlugins();
+          } else {
+            await this.testBundler?.regenerate(path);
+            await this.zotero?.reloadTemporaryPluginBySourceDir(TESTER_PLUGIN_DIR);
+          }
+        }
+      }
+    );
   }
   async startZotero() {
-    this.runner = new ZoteroRunner({
+    if (this.ctx.test.headless) {
+      await prepareHeadless();
+    }
+    this.zotero = new ZoteroRunner({
       binary: {
         path: this.zoteroBinPath,
         devtools: this.ctx.server.devtools,
         args: this.ctx.server.startArgs
       },
       profile: {
-        path: this.profilePath,
-        dataDir: this.dataDir,
+        path: TESTER_PROFILE_DIR,
+        dataDir: TESTER_DATA_DIR,
         customPrefs: this.prefs
       },
       plugins: {
@@ -2650,51 +2785,36 @@ class Test extends Base {
           id: this.ctx.id,
           sourceDir: join(this.ctx.dist, "addon")
         }, {
-          id: this.testPluginID,
-          sourceDir: this.testPluginDir
+          id: TESTER_PLUGIN_ID,
+          sourceDir: TESTER_PLUGIN_DIR
         }]
       }
     });
-    await this.runner.run();
+    await this.zotero.run();
+    this.zotero.zotero?.on("close", () => this.onZoteroExit());
   }
-  exit = (code) => {
-    this.communicator.server?.close();
-    this.runner?.exit();
+  onZoteroExit = () => {
+    this.reporter.stop();
     this.ctx.hooks.callHook("test:exit", this.ctx);
-    if (code === 1) {
-      this.logger.error("Test run failed");
+    if (this.reporter.failed)
       process.exit(1);
-    } else if (code === "SIGINT") {
+    else
+      process.exit(0);
+  };
+  exit = (code) => {
+    if (code === "SIGINT") {
       this.logger.info("Tester shutdown by user request");
-      process.exit();
-    } else {
-      this.logger.success("Test run completed successfully");
-      process.exit();
     }
+    this.reporter.stop();
+    this.zotero?.exit();
+    this.ctx.hooks.callHook("test:exit", this.ctx);
+    process.exit();
   };
   get zoteroBinPath() {
     if (!process.env.ZOTERO_PLUGIN_ZOTERO_BIN_PATH)
       throw new Error("No Zotero Found.");
     return process.env.ZOTERO_PLUGIN_ZOTERO_BIN_PATH;
   }
-  get profilePath() {
-    return `.scaffold/test/profile`;
-  }
-  get dataDir() {
-    return `.scaffold/test/data`;
-  }
-  get testPluginDir() {
-    return `.scaffold/test/resource`;
-  }
-  get cacheDir() {
-    return `.scaffold/cache`;
-  }
-  get testPluginRef() {
-    return `${this.ctx.namespace}-test`;
-  }
-  get testPluginID() {
-    return `${this.testPluginRef}@only-for-testing.com`;
-  }
   get prefs() {
     const defaultPref = {
       "extensions.experiments.enabled": true,