fluxplugin 1.0.1 → 1.0.3

package/dist/node/chunks/chunk-3FH6NAJG.js

@@ -0,0 +1,38 @@
+// src/cli/tailwind.ts
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+function resolveTailwindCli(startDirs) {
+  for (const dir of startDirs) {
+    try {
+      const pj = createRequire(path.join(dir, "package.json")).resolve("@tailwindcss/cli/package.json");
+      const pkg = JSON.parse(readFileSync(pj, "utf8"));
+      const rel = typeof pkg.bin === "string" ? pkg.bin : Object.values(pkg.bin ?? {})[0];
+      if (rel) return path.join(path.dirname(pj), rel);
+    } catch {
+    }
+  }
+  return void 0;
+}
+function compileTailwind(opts, log = console.log) {
+  const cli = resolveTailwindCli([opts.cwd, ...opts.searchFrom ?? [], process.cwd()]);
+  if (!cli || !existsSync(cli)) throw new Error('Tailwind is not installed: run "npm install -D tailwindcss @tailwindcss/cli"');
+  const args = [cli, "-i", opts.input, "-o", opts.output];
+  if (!opts.watch) {
+    const r = spawnSync(process.execPath, args, { cwd: opts.cwd, encoding: "utf8" });
+    if (r.status !== 0) throw new Error(`tailwind failed: ${(r.stderr || r.stdout || "").trim().split("\n").slice(-3).join(" ")}`);
+    log(`tailwind \u2192 ${path.relative(opts.cwd, opts.output)}`);
+    return () => {
+    };
+  }
+  const child = spawn(process.execPath, [...args, "--watch=always"], { cwd: opts.cwd, stdio: ["ignore", "ignore", "pipe"] });
+  child.stderr?.on("data", (d) => /error/i.test(String(d)) && log("tailwind: " + String(d).trim()));
+  log(`tailwind watching ${path.relative(opts.cwd, opts.input)}`);
+  return () => void child.kill();
+}
+
+export {
+  resolveTailwindCli,
+  compileTailwind
+};

package/dist/node/chunks/{chunk-BZ7NZF7I.js → chunk-C7VWZZOX.js}

@@ -9,12 +9,13 @@ import {
   core_exports,
   errorMessage,
   serializeError,
-  validateManifest
-} from "./chunk-XPLGAEBH.js";
+  validateManifest,
+  videoEmbedUrl
+} from "./chunk-EVX2O65A.js";
 
 // src/main/framework.ts
-import { watch } from "node:fs";
-import path6 from "node:path";
+import { promises as fsp, watch } from "node:fs";
+import path7 from "node:path";
 
 // src/main/discover.ts
 import { promises as fs2 } from "node:fs";
@@ -341,7 +342,7 @@ async function extractTarGz(buf, dest) {
 }
 
 // src/main/registry.ts
-async function readManifest(dir) {
+async function readPluginManifest(dir) {
   const raw = JSON.parse(await fs5.readFile(path5.join(dir, MANIFEST_FILE), "utf8"));
   const v = validateManifest(raw);
   if (!v.manifest) throw new Error(`invalid manifest: ${v.issues.map((i) => `${i.path}: ${i.message}`).join("; ")}`);
@@ -358,6 +359,34 @@ var toEntry = (m, location, source, sha256) => ({
   source,
   sha256
 });
+var RUNTIME_DIRS = /* @__PURE__ */ new Set(["dist", "assets", "images", "docs"]);
+var RUNTIME_FILES = /^(plugin\.json|readme(\.[a-z]+)?|license(\.[a-z]+)?|changelog(\.[a-z]+)?|icon\.(png|svg|jpg|webp))$/i;
+var SOURCE_FILE = /\.(tsx?|jsx|map|scss|sass|less)$/i;
+async function copyPluginRuntime(src, dest) {
+  const copied = [];
+  const manifest = JSON.parse(await fs5.readFile(path5.join(src, MANIFEST_FILE), "utf8"));
+  const referenced = new Set(
+    [manifest["main"], manifest["preload"], manifest["renderer"], manifest["icon"], manifest["banner"], manifest["readme"], ...manifest["styles"] ?? [], ...manifest["screenshots"] ?? []].filter((x) => typeof x === "string").map((x) => path5.normalize(x).replace(/^(\.\/|\.\\)/, ""))
+  );
+  const walk2 = async (rel) => {
+    for (const e of await fs5.readdir(path5.join(src, rel), { withFileTypes: true })) {
+      const r = rel ? path5.join(rel, e.name) : e.name;
+      if (e.isDirectory()) {
+        if (rel === "" ? RUNTIME_DIRS.has(e.name) : true) await walk2(r);
+      } else if (e.isFile()) {
+        const top = r.split(path5.sep)[0];
+        const ok = referenced.has(r) || (rel === "" ? RUNTIME_FILES.test(e.name) : RUNTIME_DIRS.has(top) && !SOURCE_FILE.test(e.name));
+        if (!ok || SOURCE_FILE.test(e.name) && !referenced.has(r)) continue;
+        await fs5.mkdir(path5.dirname(path5.join(dest, r)), { recursive: true });
+        await fs5.copyFile(path5.join(src, r), path5.join(dest, r));
+        copied.push(r.split(path5.sep).join("/"));
+      }
+    }
+  };
+  await fs5.mkdir(dest, { recursive: true });
+  await walk2("");
+  return copied;
+}
 async function copyDir(src, dest) {
   await fs5.mkdir(dest, { recursive: true });
   for (const e of await fs5.readdir(src, { withFileTypes: true })) {
@@ -368,6 +397,37 @@ async function copyDir(src, dest) {
     else if (e.isFile()) await fs5.copyFile(s, d);
   }
 }
+function entriesFromIndex(index, baseUrl, source, query = "") {
+  const q = query.toLowerCase();
+  return (index.plugins ?? []).filter((p) => p && typeof p.id === "string" && typeof p.version === "string" && typeof p.url === "string").filter((p) => !q || `${p.id} ${p.name ?? ""} ${p.description ?? ""}`.toLowerCase().includes(q)).map((p) => ({
+    id: p.id,
+    name: p.name ?? p.id,
+    version: p.version,
+    description: p.description,
+    author: p.author,
+    permissions: p.permissions ?? [],
+    location: new URL(p.url, baseUrl).href,
+    source,
+    sha256: p.sha256,
+    homepage: p.homepage,
+    icon: p.icon
+  }));
+}
+async function pruneNonRuntime(dir) {
+  const removed = [];
+  const walk2 = async (rel) => {
+    for (const e of await fs5.readdir(path5.join(dir, rel), { withFileTypes: true })) {
+      const r = rel ? path5.join(rel, e.name) : e.name;
+      const abs = path5.join(dir, r);
+      if (e.isDirectory()) {
+        if (e.name === "node_modules" || rel === "" && (e.name === "src" || e.name === ".git")) await fs5.rm(abs, { recursive: true, force: true }), removed.push(r + "/");
+        else await walk2(r);
+      } else if (/\.(map|tsx?|scss|sass|less)$/i.test(e.name) && !/\.d\.ts$/i.test(e.name)) await fs5.rm(abs, { force: true }), removed.push(r);
+    }
+  };
+  await walk2("");
+  return removed;
+}
 var LocalRegistry = class {
   constructor(dir, name = `local:${dir}`) {
     this.dir = dir;
@@ -387,7 +447,7 @@ var LocalRegistry = class {
     for (const n of names.sort()) {
       const root = path5.join(this.dir, n);
       try {
-        const { manifest } = await readManifest(root);
+        const { manifest } = await readPluginManifest(root);
         if (!q || `${manifest.id} ${manifest.name} ${manifest.description ?? ""}`.toLowerCase().includes(q)) out.push(toEntry(manifest, root, this.name));
       } catch {
       }
@@ -395,8 +455,8 @@ var LocalRegistry = class {
     return out;
   }
   async fetch(entry, dest) {
-    await copyDir(entry.location, dest);
-    return (await readManifest(dest)).manifest;
+    await copyPluginRuntime(entry.location, dest);
+    return (await readPluginManifest(dest)).manifest;
   }
 };
 var HttpRegistry = class {
@@ -409,21 +469,10 @@ var HttpRegistry = class {
   fetchImpl;
   name;
   async search(query = "") {
-    const res = await this.fetchImpl(new URL("index.json", this.baseUrl.endsWith("/") ? this.baseUrl : this.baseUrl + "/"));
-    if (!res.ok) throw new Error(`registry responded ${res.status}`);
-    const j = await res.json();
-    const q = query.toLowerCase();
-    return (j.plugins ?? []).filter((p) => !q || `${p["id"]} ${p["name"]} ${p["description"] ?? ""}`.toLowerCase().includes(q)).map((p) => ({
-      id: String(p["id"]),
-      name: String(p["name"] ?? p["id"]),
-      version: String(p["version"]),
-      description: p["description"],
-      author: p["author"],
-      permissions: p["permissions"] ?? [],
-      location: new URL(String(p["url"]), this.baseUrl).href,
-      source: this.name,
-      sha256: p["sha256"]
-    }));
+    const base = this.baseUrl.endsWith("/") ? this.baseUrl : this.baseUrl + "/";
+    const res = await this.fetchImpl(new URL("index.json", base));
+    if (!res.ok) throw new Error(`store responded ${res.status}`);
+    return entriesFromIndex(await res.json(), base, this.name, query);
   }
   async fetch(entry, dest) {
     const res = await this.fetchImpl(entry.location);
@@ -433,7 +482,7 @@ var HttpRegistry = class {
       throw new Error("downloaded archive does not match the registry checksum");
     }
     await extractTarGz(buf, dest);
-    return (await readManifest(dest)).manifest;
+    return (await readPluginManifest(dest)).manifest;
   }
 };
 var PluginInstaller = class {
@@ -456,7 +505,7 @@ var PluginInstaller = class {
     const out = [];
     for (const n of await fs5.readdir(this.pluginsDir).catch(() => [])) {
       try {
-        out.push((await readManifest(path5.join(this.pluginsDir, n))).manifest);
+        out.push((await readPluginManifest(path5.join(this.pluginsDir, n))).manifest);
       } catch {
       }
     }
@@ -473,11 +522,12 @@ var PluginInstaller = class {
     await fs5.mkdir(path5.dirname(stage), { recursive: true });
     try {
       const manifest = await registry.fetch(entry, stage);
+      await pruneNonRuntime(stage);
       if (manifest.id !== entry.id) throw new Error(`registry entry "${entry.id}" contains plugin "${manifest.id}"`);
       const target = this.dirOf(entry.id);
       let previousVersion;
       try {
-        previousVersion = (await readManifest(target)).manifest.version;
+        previousVersion = (await readPluginManifest(target)).manifest.version;
         const bk = path5.join(this.backupDir, entry.id, previousVersion);
         await fs5.rm(bk, { recursive: true, force: true });
         await fs5.mkdir(path5.dirname(bk), { recursive: true });
@@ -495,7 +545,7 @@ var PluginInstaller = class {
   /** Removes the plugin directory (backups are kept so the user can still roll back/reinstall). */
   async uninstall(id) {
     const dir = this.dirOf(id);
-    const { manifest } = await readManifest(dir);
+    const { manifest } = await readPluginManifest(dir);
     const bk = path5.join(this.backupDir, id, manifest.version);
     await fs5.rm(bk, { recursive: true, force: true });
     await fs5.mkdir(path5.dirname(bk), { recursive: true });
@@ -513,7 +563,7 @@ var PluginInstaller = class {
     const dir = this.dirOf(id);
     let current;
     try {
-      current = (await readManifest(dir)).manifest.version;
+      current = (await readPluginManifest(dir)).manifest.version;
       const bk = path5.join(this.backupDir, id, current);
       await fs5.rm(bk, { recursive: true, force: true });
       await fs5.rename(dir, bk);
@@ -530,19 +580,132 @@ var PluginInstaller = class {
   }
 };
 
+// src/main/stores.ts
+import path6 from "node:path";
+
+// src/main/github-registry.ts
+import crypto3 from "node:crypto";
+var DEFAULT_TOPIC = "fluxplugin-plugin";
+var MAX_PACKAGE_BYTES = 100 * 1024 * 1024;
+var isLoopback = (h) => h === "127.0.0.1" || h === "localhost" || h === "[::1]";
+function assertSafeUrl(u) {
+  const url = new URL(u);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopback(url.hostname))) throw new Error(`refusing non-https URL: ${u}`);
+  return url;
+}
+var GitHubRegistry = class {
+  constructor(o = {}) {
+    this.o = o;
+    this.name = o.name ?? (o.repo ? `github:${o.repo}` : `github:topic/${o.topic ?? DEFAULT_TOPIC}`);
+  }
+  o;
+  name;
+  cache = /* @__PURE__ */ new Map();
+  get api() {
+    return (this.o.apiBase ?? "https://api.github.com").replace(/\/$/, "");
+  }
+  get raw() {
+    return (this.o.rawBase ?? "https://raw.githubusercontent.com").replace(/\/$/, "");
+  }
+  trusted(url) {
+    const hosts = /* @__PURE__ */ new Set(["api.github.com", "github.com", "raw.githubusercontent.com", new URL(this.api).hostname, new URL(this.raw).hostname]);
+    return hosts.has(url.hostname);
+  }
+  async get(u, accept = "application/vnd.github+json") {
+    const url = assertSafeUrl(u);
+    const headers = { accept, "user-agent": "fluxplugin" };
+    if (this.o.token && this.trusted(url)) headers["authorization"] = `Bearer ${this.o.token}`;
+    const res = await (this.o.fetchImpl ?? fetch)(url, { headers, redirect: "follow", signal: AbortSignal.timeout(2e4) });
+    if (res.status === 403 || res.status === 429) {
+      if (res.headers.get("x-ratelimit-remaining") === "0" || res.status === 429) throw new Error("GitHub rate limit reached. Set GITHUB_TOKEN (any token, no scopes needed) to raise it, or retry later.");
+    }
+    if (!res.ok) throw new Error(`GitHub responded ${res.status} for ${url.pathname}`);
+    return res;
+  }
+  async json(u) {
+    return await (await this.get(u)).json();
+  }
+  async search(query = "") {
+    const hit = this.cache.get(query);
+    if (hit && Date.now() - hit.at < 6e4) return hit.entries;
+    const entries = this.o.repo ? await this.catalog(query) : await this.discover(query);
+    this.cache.set(query, { at: Date.now(), entries });
+    return entries;
+  }
+  async catalog(query) {
+    const ref = this.o.ref ?? "HEAD";
+    const base = `${this.raw}/${this.o.repo}/${ref}/`;
+    const index = await this.json(new URL(this.o.indexPath ?? "index.json", base).href);
+    return entriesFromIndex(index, base, this.name, query);
+  }
+  async discover(query) {
+    const q = `topic:${this.o.topic ?? DEFAULT_TOPIC}${query ? ` ${query} in:name,description,readme` : ""}`;
+    const found = await this.json(`${this.api}/search/repositories?q=${encodeURIComponent(q)}&per_page=30&sort=updated`);
+    const out = [];
+    const queue = [...found.items ?? []];
+    const worker = async () => {
+      for (let repo = queue.shift(); repo; repo = queue.shift()) {
+        try {
+          const rel = await this.json(`${this.api}/repos/${repo.full_name}/releases/latest`);
+          const descAsset = rel.assets?.find((a) => a.name.endsWith(".fluxplugin.json"));
+          if (!descAsset) continue;
+          const d = await (await this.get(descAsset.browser_download_url, "application/json")).json();
+          const pkg = rel.assets?.find((a) => a.name === d.file);
+          if (!d || typeof d.id !== "string" || typeof d.version !== "string" || !pkg || !/^[0-9a-f]{64}$/.test(d.sha256 ?? "")) continue;
+          out.push({ id: d.id, name: d.name ?? d.id, version: d.version, description: d.description, author: d.author, permissions: d.permissions ?? [], location: pkg.browser_download_url, source: this.name, sha256: d.sha256, homepage: repo.html_url, stars: repo.stargazers_count });
+        } catch (e) {
+          if (/rate limit/i.test(e.message)) throw e;
+        }
+      }
+    };
+    await Promise.all(Array.from({ length: 5 }, worker));
+    return out.sort((a, b) => (b.stars ?? 0) - (a.stars ?? 0) || a.id.localeCompare(b.id));
+  }
+  async fetch(entry, dest) {
+    const res = await this.get(entry.location, "application/octet-stream");
+    const len = Number(res.headers.get("content-length") ?? 0);
+    if (len > MAX_PACKAGE_BYTES) throw new Error("package is too large");
+    const buf = Buffer.from(await res.arrayBuffer());
+    if (buf.length > MAX_PACKAGE_BYTES) throw new Error("package is too large");
+    if (!entry.sha256) throw new Error("this store entry has no checksum; refusing to install an unverifiable package");
+    if (crypto3.createHash("sha256").update(buf).digest("hex") !== entry.sha256.replace(/^sha256-/, "")) throw new Error("downloaded package does not match the published checksum");
+    await extractTarGz(buf, dest);
+    return (await readPluginManifest(dest)).manifest;
+  }
+};
+
+// src/main/stores.ts
+var DEFAULT_STORE = { type: "github", topic: DEFAULT_TOPIC };
+function createRegistries(specs = [DEFAULT_STORE], opts = {}) {
+  const env = opts.env ?? process.env;
+  const token = env["GITHUB_TOKEN"] ?? env["GH_TOKEN"];
+  return specs.map((s) => {
+    switch (s.type) {
+      case "github":
+        return new GitHubRegistry({ ...s, token, fetchImpl: opts.fetchImpl });
+      case "http":
+        return new HttpRegistry(s.url, opts.fetchImpl);
+      case "local":
+        return new LocalRegistry(path6.resolve(opts.baseDir ?? process.cwd(), s.path));
+      default:
+        throw new Error(`unknown store type: ${JSON.stringify(s)}`);
+    }
+  });
+}
+
 // src/main/framework.ts
 var MainFramework = class {
   constructor(options) {
     this.options = options;
     this.logs = new LogStore(5e3);
-    this.state = new JsonStateFile(path6.join(options.dataDir, "plugins-state.json"));
+    this.state = new JsonStateFile(path7.join(options.dataDir, "plugins-state.json"));
     this.permissions = new PermissionManager({
       autoGrant: !options.requireApproval,
       onChange: (id, snap) => void this.state.update((s) => ({ approved: { ...s.approved, [id]: snap.granted } })).catch(() => void 0)
     });
     this.manager = new PluginManager({
       runtime: "main",
-      storage: new FsStorageBackend(path6.join(options.dataDir, "storage")),
+      storage: new FsStorageBackend(path7.join(options.dataDir, "storage")),
       permissions: this.permissions,
       logs: this.logs,
       frameworkVersion: options.frameworkVersion,
@@ -554,11 +717,12 @@ var MainFramework = class {
       ...options.manager
     });
     this.manager.ipc.setTransport({ broadcast: (c, p, t) => this.broadcast(c, p, t) });
-    this.installer = new PluginInstaller(options.installDir ?? options.pluginDirs[0], path6.join(options.dataDir, "backups"), options.registries ?? []);
+    this.installer = new PluginInstaller(options.installDir ?? options.pluginDirs[0], path7.join(options.dataDir, "backups"), options.registries ?? createRegistries(options.stores));
     this.manager.subscribe(() => {
       this.revision++;
       this.broadcast(MGMT.changed, { revision: this.revision });
     });
+    this.manager.notifications.onPush((n) => this.broadcast("flux.notification", n));
     this.registerManagementApi();
   }
   options;
@@ -612,13 +776,13 @@ var MainFramework = class {
       try {
         const w = watch(dir, { recursive: true }, (_evt, filename) => {
           if (!filename) return;
-          const parts = String(filename).split(path6.sep);
+          const parts = String(filename).split(path7.sep);
           if (parts.includes("node_modules") || parts.includes("src")) return;
           const folder = parts[0];
           clearTimeout(this.reloadTimers.get(folder));
           this.reloadTimers.set(
             folder,
-            setTimeout(() => void this.hotReloadFolder(path6.join(dir, folder)), 150)
+            setTimeout(() => void this.hotReloadFolder(path7.join(dir, folder)), 150)
           );
         });
         this.watchers.push(w);
@@ -728,6 +892,7 @@ var MainFramework = class {
     h(MGMT.configSchema, ({ id }) => this.manager.getConfig(id)?.describe() ?? null);
     h(MGMT.logs, ({ id }) => this.logs.query(id ? { source: id } : {}).slice(-200));
     h(MGMT.diagnostics, ({ id }) => this.manager.diagnostics(id));
+    h(MGMT.details, ({ id }) => this.details(id));
     h(MGMT.search, ({ query }) => this.installer.search(query));
     h(MGMT.updates, () => this.installer.updates());
     h(MGMT.install, async ({ entry }) => this.installAndLoad(entry));
@@ -745,6 +910,43 @@ var MainFramework = class {
       return r;
     });
   }
+  /** Store-page data for one plugin: icon, banner, screenshots, video and the README (Markdown). */
+  async details(id) {
+    const m = this.manager.manifest(id);
+    const root = this.manager.info(id).root;
+    const url = this.options.assetUrl ?? ((pid, rel) => `fluxplugin://${pid}/${rel.replace(/^\.\//, "")}`);
+    let readme;
+    if (root) {
+      const file = path7.resolve(root, m.readme ?? "README.md");
+      if (file.startsWith(path7.resolve(root) + path7.sep)) {
+        try {
+          const st = await fsp.stat(file);
+          if (st.size <= 2e5) readme = await fsp.readFile(file, "utf8");
+        } catch {
+        }
+      }
+    }
+    const author = typeof m.author === "string" ? m.author : m.author?.name;
+    const repository = typeof m.repository === "string" ? m.repository : m.repository?.url;
+    return {
+      id,
+      name: m.name,
+      version: m.version,
+      description: m.description,
+      author,
+      license: m.license,
+      homepage: m.homepage,
+      repository,
+      categories: m.categories ?? [],
+      keywords: m.keywords ?? [],
+      links: m.links ?? {},
+      iconUrl: m.icon ? url(id, m.icon) : void 0,
+      bannerUrl: m.banner ? url(id, m.banner) : void 0,
+      screenshotUrls: (m.screenshots ?? []).map((s) => url(id, s)),
+      video: m.video ? { url: m.video, embedUrl: videoEmbedUrl(m.video) } : void 0,
+      readme
+    };
+  }
   requireConfig(id) {
     const c = this.manager.getConfig(id);
     if (!c) throw new Error(`plugin "${id}" has no configuration (activate it first)`);
@@ -764,7 +966,7 @@ var MainFramework = class {
 
 // src/main/adapters.ts
 import http from "node:http";
-import path7 from "node:path";
+import path8 from "node:path";
 import { promises as fs6 } from "node:fs";
 function attachElectron(fw, electron) {
   const { ipcMain, webContents } = electron;
@@ -798,6 +1000,11 @@ var MIME = {
   ".svg": "image/svg+xml",
   ".png": "image/png",
   ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
   ".woff2": "font/woff2",
   ".map": "application/json"
 };
@@ -813,12 +1020,12 @@ async function resolvePluginAsset(fw, url) {
   const root = fw.manager.info(id).root;
   if (!root) return null;
   const rel = decodeURIComponent(u.pathname).replace(/^\/+/, "");
-  const file = path7.resolve(root, rel);
-  if (!file.startsWith(path7.resolve(root) + path7.sep)) return null;
+  const file = path8.resolve(root, rel);
+  if (!file.startsWith(path8.resolve(root) + path8.sep)) return null;
   const m = fw.manager.manifest(id);
-  const main = m.main ? path7.resolve(root, m.main) : void 0;
-  if (file === main || path7.basename(file) === "plugin.json") return null;
-  const ext = path7.extname(file).toLowerCase();
+  const main = m.main ? path8.resolve(root, m.main) : void 0;
+  if (file === main || path8.basename(file) === "plugin.json") return null;
+  const ext = path8.extname(file).toLowerCase();
   if (!(ext in MIME)) return null;
   try {
     await fs6.access(file);
@@ -934,19 +1141,19 @@ function createLoopbackBridge(fw) {
 }
 
 // src/main/serve-web.ts
-import path8 from "node:path";
+import path9 from "node:path";
 import { promises as fs7 } from "node:fs";
 var TYPES = { ".html": "text/html", ".js": "text/javascript", ".mjs": "text/javascript", ".css": "text/css", ".map": "application/json", ".svg": "image/svg+xml", ".png": "image/png" };
 function serveWeb(fw, opts) {
-  const dist = path8.resolve(opts.distDir);
+  const dist = path9.resolve(opts.distDir);
   return attachHttp(fw, {
     port: opts.port ?? 5173,
     host: opts.host,
     fallback: async (req, res) => {
       const rel = !req.url || req.url === "/" ? "index.html" : decodeURIComponent(req.url.split("?")[0]).replace(/^\/+/, "");
-      const file = path8.resolve(dist, rel);
-      const type = TYPES[path8.extname(file)];
-      if (!type || !file.startsWith(dist + path8.sep)) return false;
+      const file = path9.resolve(dist, rel);
+      const type = TYPES[path9.extname(file)];
+      if (!type || !file.startsWith(dist + path9.sep)) return false;
       try {
         res.writeHead(200, { "content-type": type, "cache-control": "no-store" });
         res.end(await fs7.readFile(file));
@@ -975,10 +1182,18 @@ export {
   createTarGz,
   readTarGz,
   extractTarGz,
+  readPluginManifest,
+  copyPluginRuntime,
   copyDir,
+  entriesFromIndex,
+  pruneNonRuntime,
   LocalRegistry,
   HttpRegistry,
   PluginInstaller,
+  DEFAULT_TOPIC,
+  GitHubRegistry,
+  DEFAULT_STORE,
+  createRegistries,
   MainFramework,
   attachElectron,
   PLUGIN_SCHEME,