@xbrowser/cli 0.14.0 → 0.14.1

package/dist/cli.js

@@ -18,20 +18,6 @@ import {
   saveSessionDiskMeta,
   setActivePage
 } from "./chunk-2ONMTDLK.js";
-import {
-  PluginMetadataParser
-} from "./chunk-HINTG75P.js";
-import {
-  NPM_REGISTRY_URL,
-  NPM_SCOPE,
-  ensureProxyFetch,
-  getConfigValue,
-  getMarketplaceUrl,
-  loadConfig,
-  readJsonFile,
-  resolveNpmPackageWithFallback,
-  setConfigValue
-} from "./chunk-FF5WHQHN.js";
 import {
   forwardCommandLog,
   forwardNetworkAnalyze,
@@ -395,15 +381,15 @@ var clickCommand = registerCommand({
     let detectedNewPage;
     let cleanup;
     if (ctx.browserContext?.on) {
-      const pagePromise = new Promise((resolve15) => {
+      const pagePromise = new Promise((resolve16) => {
         const timer = setTimeout(() => {
           ctx.browserContext.off("page", handler);
-          resolve15(void 0);
+          resolve16(void 0);
         }, 3e3);
         const handler = (page2) => {
           clearTimeout(timer);
           ctx.browserContext.off("page", handler);
-          resolve15(page2);
+          resolve16(page2);
         };
         ctx.browserContext.on("page", handler);
       });
@@ -1161,7 +1147,7 @@ var consoleCheckCommand = registerCommand({
       await page.goto(p.url, { waitUntil: "domcontentloaded" });
     }
     const messages = await page.evaluate((args) => {
-      return new Promise((resolve15) => {
+      return new Promise((resolve16) => {
         const collected = [];
         const originalConsole = {
           log: console.log,
@@ -1228,7 +1214,7 @@ ${a.stack || ""}`;
           console.warn = originalConsole.warn;
           console.error = originalConsole.error;
           console.info = originalConsole.info;
-          resolve15(collected);
+          resolve16(collected);
         }, args.duration);
       });
     }, { duration: p.duration });
@@ -1640,7 +1626,7 @@ async function executeAction(page, action) {
       if (action.selector) {
         await page.waitForSelector(action.selector, { timeout: 3e4 });
       } else if (action.milliseconds) {
-        await new Promise((resolve15) => setTimeout(resolve15, action.milliseconds));
+        await new Promise((resolve16) => setTimeout(resolve16, action.milliseconds));
       } else {
         throw new Error("wait action requires either milliseconds or selector");
       }
@@ -1723,8 +1709,8 @@ var actionsCommand = registerCommand({
         results.push(result);
       }
     })();
-    const timeoutPromise = new Promise((resolve15) => {
-      setTimeout(resolve15, timeoutMs);
+    const timeoutPromise = new Promise((resolve16) => {
+      setTimeout(resolve16, timeoutMs);
     });
     await Promise.race([executionPromise, timeoutPromise]);
     const title = await ctx.page.title();
@@ -2398,11 +2384,11 @@ async function navigateForMap(page, url, timeout = 15e3) {
 }
 async function extractPageLinks(page, baseUrl) {
   await navigateForMap(page, baseUrl);
-  await new Promise((resolve15) => setTimeout(resolve15, 2e3));
+  await new Promise((resolve16) => setTimeout(resolve16, 2e3));
   await page.evaluate(() => {
     window.scrollTo(0, document.body.scrollHeight);
   });
-  await new Promise((resolve15) => setTimeout(resolve15, 1e3));
+  await new Promise((resolve16) => setTimeout(resolve16, 1e3));
   const origin = new URL(baseUrl).origin;
   const rawLinks = await page.evaluate((evalOrigin) => {
     return Array.from(document.querySelectorAll("a[href]")).map((a) => {
@@ -4232,25 +4218,25 @@ aria snapshot\uFF1A
 async function analyzeWithLLM(ariaSnapshot) {
   const piBin = process.env.PI_CLI_PATH || "pi";
   const prompt = LLM_PROMPT.replace("{snapshot}", ariaSnapshot.slice(0, 4e3));
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     execFile(
       piBin,
       ["--provider", LLM_PROVIDER, "--model", LLM_MODEL, prompt],
       { timeout: LLM_TIMEOUT_MS, maxBuffer: 1024 * 1024 },
       (err, stdout, _stderr) => {
         if (err) {
-          resolve15(null);
+          resolve16(null);
           return;
         }
         const output = (stdout || "").trim();
         if (!output) {
-          resolve15(null);
+          resolve16(null);
           return;
         }
         try {
           const parsed = parse(output);
           if (!parsed || typeof parsed !== "object") {
-            resolve15(null);
+            resolve16(null);
             return;
           }
           const elements = {};
@@ -4265,9 +4251,9 @@ async function analyzeWithLLM(ariaSnapshot) {
               };
             }
           }
-          resolve15(Object.keys(elements).length > 0 ? elements : null);
+          resolve16(Object.keys(elements).length > 0 ? elements : null);
         } catch {
-          resolve15(null);
+          resolve16(null);
         }
       }
     );
@@ -4820,11 +4806,11 @@ function resolveScriptContent(params) {
 async function readStdin() {
   const { createReadStream } = await import("fs");
   const { createInterface: createInterface2 } = await import("readline");
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const lines = [];
     const rl = createInterface2({ input: createReadStream("/dev/stdin") });
     rl.on("line", (line) => lines.push(line));
-    rl.on("close", () => resolve15(lines.join("\n")));
+    rl.on("close", () => resolve16(lines.join("\n")));
     rl.on("error", reject);
   });
 }
@@ -5562,12 +5548,95 @@ var promoCommand = registerCommand({
 import {
   Core
 } from "@dyyz1993/xcli-core";
-import { resolve as resolve7 } from "path";
-import { existsSync as existsSync4, readdirSync } from "fs";
+import { resolve as resolve8 } from "path";
+import { existsSync as existsSync5, readdirSync } from "fs";
 import { homedir as homedir2 } from "os";
 
+// src/plugin/metadata-parser.ts
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve7 } from "path";
+
+// src/utils/json-file.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
+function readJsonFile(filePath, defaultValue) {
+  try {
+    const content = readFileSync9(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return defaultValue;
+  }
+}
+
+// src/plugin/metadata-parser.ts
+var PluginMetadataParser = class {
+  static XBROWSER_KEYWORDS = ["xbrowser", "xbrowser-plugin"];
+  static parseFromPackageJson(pluginPath) {
+    const packageJsonPath = resolve7(pluginPath, "package.json");
+    if (!existsSync3(packageJsonPath)) {
+      return null;
+    }
+    const packageJson = readJsonFile(packageJsonPath, null);
+    if (!packageJson) return null;
+    if (!packageJson.xbrowser) {
+      return null;
+    }
+    const xbrowser = packageJson.xbrowser;
+    const metadata = {
+      id: xbrowser.id || packageJson.name,
+      name: xbrowser.name || packageJson.name,
+      description: xbrowser.description || packageJson.description || "",
+      version: xbrowser.version || packageJson.version || "1.0.0",
+      author: xbrowser.author || this.extractAuthor(packageJson.author),
+      homepage: xbrowser.homepage || packageJson.homepage,
+      commands: xbrowser.commands,
+      sites: xbrowser.sites,
+      tags: xbrowser.tags,
+      screenshot: xbrowser.screenshot,
+      license: xbrowser.license || packageJson.license
+    };
+    return metadata;
+  }
+  static isXBrowserPlugin(packageJson) {
+    if (packageJson.xbrowser) {
+      return true;
+    }
+    const keywords = packageJson.keywords;
+    if (!keywords) return false;
+    return this.XBROWSER_KEYWORDS.some((kw) => keywords.includes(kw));
+  }
+  static fromNPMResult(result) {
+    const author = typeof result.author === "string" ? result.author : result.author?.name || "Unknown";
+    return {
+      id: result.name,
+      name: result.name.replace(/^xbrowser-plugin-/, "").replace(/^@[^/]+\//, ""),
+      description: result.description || "",
+      version: result.version,
+      author,
+      homepage: result.homepage || result.links?.homepage,
+      tags: result.keywords,
+      license: ""
+    };
+  }
+  static extractAuthor(author) {
+    if (typeof author === "string") return author;
+    if (typeof author === "object" && author !== null) {
+      const authorObj = author;
+      return authorObj.name || "Unknown";
+    }
+    return "Unknown";
+  }
+  static validateMetadata(metadata) {
+    const errors = [];
+    if (!metadata.id) errors.push("id is required");
+    if (!metadata.name) errors.push("name is required");
+    if (!metadata.description) errors.push("description is required");
+    if (!metadata.version) errors.push("version is required");
+    return errors;
+  }
+};
+
 // src/plugin/ensure-deps.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync4 } from "fs";
 import { join as join2 } from "path";
 import { execSync as execSync6 } from "child_process";
 var SHARED_PLUGIN_DEPENDENCIES = {
@@ -5576,11 +5645,11 @@ var SHARED_PLUGIN_DEPENDENCIES = {
 };
 function ensurePluginDependencies(pluginsDir) {
   const zodPath = join2(pluginsDir, "node_modules", "zod");
-  if (existsSync3(zodPath)) return;
+  if (existsSync4(zodPath)) return;
   mkdirSync2(pluginsDir, { recursive: true });
   const pkgPath = join2(pluginsDir, "package.json");
   let pkg2 = {};
-  if (existsSync3(pkgPath)) {
+  if (existsSync4(pkgPath)) {
     try {
       pkg2 = readJsonFile(pkgPath, {});
     } catch {
@@ -5594,11 +5663,11 @@ function ensurePluginDependencies(pluginsDir) {
       needsInstall = true;
     }
   }
-  if (!needsInstall && existsSync3(join2(pluginsDir, "node_modules"))) return;
+  if (!needsInstall && existsSync4(join2(pluginsDir, "node_modules"))) return;
   pkg2.dependencies = existingDeps;
   pkg2.private = true;
   pkg2.description = pkg2.description || "xbrowser plugins \u2014 shared dependencies";
-  writeFileSync3(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  writeFileSync4(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
   try {
     execSync6("npm install --production --no-package-lock --no-fund --no-audit", {
       cwd: pluginsDir,
@@ -5628,7 +5697,7 @@ var XBrowserPluginLoader = class {
       envPrefix: "XBROWSER",
       pluginDirs: [
         ...DEFAULT_PLUGIN_DIRS,
-        resolve7(cwd, ".xcli/plugins")
+        resolve8(cwd, ".xcli/plugins")
       ]
     };
     this.core = new Core(coreConfig);
@@ -5667,31 +5736,31 @@ var XBrowserPluginLoader = class {
   }
   async scanAndLoad() {
     const cwd = this.options.cwd || process.cwd();
-    const globalDir = this.options.globalDir || resolve7(homedir2(), ".xbrowser/plugins");
+    const globalDir = this.options.globalDir || resolve8(homedir2(), ".xbrowser/plugins");
     ensurePluginDependencies(globalDir);
     const dirs = [
-      resolve7(cwd, ".xcli/plugins"),
-      resolve7(cwd, "../.xcli/plugins"),
-      this.options.userDir || resolve7(homedir2(), ".xcli/plugins"),
+      resolve8(cwd, ".xcli/plugins"),
+      resolve8(cwd, "../.xcli/plugins"),
+      this.options.userDir || resolve8(homedir2(), ".xcli/plugins"),
       globalDir
     ];
     const loaded = [];
     const seen = /* @__PURE__ */ new Set();
     for (const dir of dirs) {
-      if (!existsSync4(dir)) continue;
+      if (!existsSync5(dir)) continue;
       const entries = readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (seen.has(entry.name)) continue;
         seen.add(entry.name);
-        const pluginDir = resolve7(dir, entry.name);
-        let indexPath = resolve7(pluginDir, "index.js");
-        if (!existsSync4(indexPath)) {
-          indexPath = resolve7(pluginDir, "index.ts");
+        const pluginDir = resolve8(dir, entry.name);
+        let indexPath = resolve8(pluginDir, "index.js");
+        if (!existsSync5(indexPath)) {
+          indexPath = resolve8(pluginDir, "index.ts");
         }
-        if (!existsSync4(indexPath)) continue;
+        if (!existsSync5(indexPath)) continue;
         try {
-          if (!existsSync4(resolve7(pluginDir, "package.json"))) {
+          if (!existsSync5(resolve8(pluginDir, "package.json"))) {
             console.warn(`\u26A0\uFE0F  Plugin "${entry.name}" has no package.json. Use "xbrowser create ${entry.name} --template static" for proper structure.`);
           } else {
             const metadata = PluginMetadataParser.parseFromPackageJson(pluginDir);
@@ -5708,22 +5777,6 @@ var XBrowserPluginLoader = class {
         }
       }
     }
-    try {
-      const { default: setupMarketplace } = await import("./marketplace-W545W4FR.js");
-      setupMarketplace(this.loader.getAPI());
-    } catch (err) {
-      if (process.env.XBROWSER_DEBUG) {
-        console.warn(`\u26A0\uFE0F  Built-in marketplace plugin load failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
-    try {
-      const { default: setupAdmin } = await import("./admin-RPJJ5CAF.js");
-      setupAdmin(this.loader.getAPI());
-    } catch (err) {
-      if (process.env.XBROWSER_DEBUG) {
-        console.warn(`\u26A0\uFE0F  Built-in admin plugin load failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
     return loaded;
   }
   async unload() {
@@ -6124,7 +6177,7 @@ var TipsManager = class {
     }
   }
   debounce() {
-    return new Promise((resolve15) => setTimeout(resolve15, DEBOUNCE_MS));
+    return new Promise((resolve16) => setTimeout(resolve16, DEBOUNCE_MS));
   }
   formatTips(tips) {
     return tips.map((tip) => {
@@ -6151,6 +6204,24 @@ function getTipsManager() {
   return globalTipsManager;
 }
 
+// src/hooks/loader.ts
+var builtinHooks = {
+  screenshot: () => import("./screenshot-MB6R7RSS.js").then((m) => m.screenshotHook)
+};
+async function loadHooks() {
+  const names = process.env.XBROWSER_HOOKS;
+  if (!names) return [];
+  const hooks = [];
+  for (const name of names.split(",")) {
+    const trimmed = name.trim();
+    const factory = builtinHooks[trimmed];
+    if (factory) {
+      hooks.push(await factory());
+    }
+  }
+  return hooks;
+}
+
 // src/executor.ts
 import { homedir as homedir3 } from "os";
 import { join as join3 } from "path";
@@ -6310,9 +6381,22 @@ async function executeCommand(commandName, params, sessionName = "default", extr
     }
   }
   try {
+    const hooks = await loadHooks();
+    if (hooks.length > 0 && session?.page) {
+      await Promise.all(hooks.map((h) => h.onBeforeCommand?.({ page: session.page, command: commandName, params })));
+    }
     const raw = await command.handler(params, ctx);
     const end = Date.now();
     const duration = end - start;
+    let hookOutputs;
+    if (hooks.length > 0 && session?.page) {
+      const outputs = [];
+      for (const h of hooks) {
+        const output = await h.onAfterCommand?.({ page: session.page, command: commandName, params, result: raw, duration });
+        if (output) outputs.push({ _hook: h.name, ...output });
+      }
+      if (outputs.length > 0) hookOutputs = outputs;
+    }
     if (session && isCommandResult(raw)) {
       const resultData = raw.data;
       const convUrl = resultData?.conversationUrl;
@@ -6360,9 +6444,9 @@ async function executeCommand(commandName, params, sessionName = "default", extr
         timestamp: start
       });
       if (isSuccess) {
-        return { ...ok25(raw.data, merged.length > 0 ? merged : raw.tips), duration };
+        return { ...ok25(raw.data, merged.length > 0 ? merged : raw.tips), duration, ...hookOutputs ? { hookOutputs } : {} };
       }
-      return { success: false, data: raw.data, message: raw.message, tips: merged.length > 0 ? merged : raw.tips || [], duration };
+      return { success: false, data: raw.data, message: raw.message, tips: merged.length > 0 ? merged : raw.tips || [], duration, ...hookOutputs ? { hookOutputs } : {} };
     }
     recordArchive(session?.id, sessionName, {
       step: 0,
@@ -6373,7 +6457,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
       duration,
       timestamp: start
     });
-    return { ...ok25(raw, smartTips), duration };
+    return { ...ok25(raw, smartTips), duration, ...hookOutputs ? { hookOutputs } : {} };
   } catch (err) {
     const end = Date.now();
     const duration = end - start;
@@ -6768,6 +6852,68 @@ var sessionKillBuiltin = {
   }
 };
 
+// src/config.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4, tmpdir } from "os";
+function getConfigFile() {
+  return join4(homedir4() || tmpdir(), ".xbrowser", "config.json");
+}
+function loadConfig() {
+  const configFile = getConfigFile();
+  if (!existsSync6(configFile)) return {};
+  return readJsonFile(configFile, {});
+}
+function saveConfig(config) {
+  const dir = join4(homedir4() || tmpdir(), ".xbrowser");
+  const configFile = getConfigFile();
+  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
+  writeFileSync5(configFile, JSON.stringify(config, null, 2), "utf-8");
+}
+function getConfigValue(key) {
+  return loadConfig()[key];
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  config[key] = value;
+  saveConfig(config);
+}
+var DEFAULT_MARKETPLACE_URL = "https://marketplace.xbrowser.dev";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org";
+var NPM_SCOPE = "@xbrowser/";
+function getMarketplaceUrl() {
+  return process.env.XBROWSER_MARKETPLACE_URL || getConfigValue("marketplaceUrl") || DEFAULT_MARKETPLACE_URL;
+}
+function resolveNpmPackageName(name) {
+  if (name.startsWith("@")) return name;
+  return `${NPM_SCOPE}${name}`;
+}
+var NPM_NAME_ALIASES = {
+  "1688": "alibaba-1688"
+};
+function generateNpmCandidates(name) {
+  if (name.startsWith("@")) return [name];
+  const resolved = NPM_NAME_ALIASES[name] ?? name;
+  return [
+    `${NPM_SCOPE}xbrowser-plugin-${resolved}`,
+    `${NPM_SCOPE}${resolved}`,
+    `xbrowser-plugin-${resolved}`
+  ];
+}
+async function resolveNpmPackageWithFallback(name) {
+  const candidates = generateNpmCandidates(name);
+  for (const candidate of candidates) {
+    try {
+      const encoded = encodeURIComponent(candidate);
+      const res = await fetch(`${NPM_REGISTRY_URL}/${encoded}`);
+      if (res.ok) return candidate;
+    } catch {
+      continue;
+    }
+  }
+  return resolveNpmPackageName(name);
+}
+
 // src/builtins/config.ts
 var configBuiltin = {
   name: "config",
@@ -6830,32 +6976,78 @@ var configBuiltin = {
 
 // src/plugin/installer.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync13,
   readdirSync as readdirSync3,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync8,
   rmSync as rmSync7
 } from "fs";
-import { resolve as resolve14, basename as basename2 } from "path";
-import { homedir as homedir4 } from "os";
+import { resolve as resolve15, basename as basename2 } from "path";
+import { homedir as homedir5 } from "os";
 
 // src/plugin/install-sources/local.ts
-import { existsSync as existsSync6, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
-import { resolve as resolve9 } from "path";
+import { existsSync as existsSync8, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
+import { resolve as resolve10 } from "path";
 
 // src/plugin/install-utils.ts
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync7,
   readdirSync as readdirSync2,
   cpSync,
   rmSync,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync9,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync10,
   createWriteStream
 } from "fs";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 import { execSync as execSync7 } from "child_process";
 import { pipeline } from "stream/promises";
 import { Readable } from "stream";
+
+// src/utils/proxy-fetch.ts
+var patched = false;
+async function ensureProxyFetch() {
+  if (patched) return;
+  patched = true;
+  if (process.env.https_proxy && !process.env.HTTPS_PROXY) {
+    process.env.HTTPS_PROXY = process.env.https_proxy;
+  }
+  if (process.env.http_proxy && !process.env.HTTP_PROXY) {
+    process.env.HTTP_PROXY = process.env.http_proxy;
+  }
+  if (process.env.all_proxy && !process.env.ALL_PROXY) {
+    process.env.ALL_PROXY = process.env.all_proxy;
+  }
+  const proxyUrl = process.env.https_proxy || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.HTTP_PROXY || process.env.all_proxy || process.env.ALL_PROXY;
+  if (!proxyUrl) return;
+  try {
+    const undici = await import("undici");
+    const EnvHttpProxyAgent = undici.EnvHttpProxyAgent;
+    const uFetch = undici.fetch;
+    const UFormData = undici.FormData;
+    if (EnvHttpProxyAgent && uFetch && UFormData) {
+      const agent = new EnvHttpProxyAgent();
+      globalThis.fetch = ((input, init) => {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        const body = init?.body;
+        if (body instanceof globalThis.FormData && !(body instanceof UFormData)) {
+          const ufd = new UFormData();
+          body.forEach((value, key) => {
+            if (value instanceof Blob) {
+              ufd.append(key, value, value.name || "file");
+            } else {
+              ufd.append(key, value);
+            }
+          });
+          return uFetch(url, { ...init, body: ufd, dispatcher: agent });
+        }
+        return uFetch(url, { ...init, dispatcher: agent });
+      });
+    }
+  } catch {
+  }
+}
+
+// src/plugin/install-utils.ts
 async function downloadToFile(url, destPath) {
   await ensureProxyFetch();
   if (url.startsWith("file://")) {
@@ -6874,7 +7066,7 @@ async function downloadToFile(url, destPath) {
   await pipeline(nodeStream, createWriteStream(destPath));
 }
 function extractTarGz(tarballPath, targetDir) {
-  mkdirSync3(targetDir, { recursive: true });
+  mkdirSync4(targetDir, { recursive: true });
   execSync7(`tar -xzf "${tarballPath}" -C "${targetDir}"`, { stdio: "pipe" });
 }
 function flattenPackageRoot(targetDir) {
@@ -6882,11 +7074,11 @@ function flattenPackageRoot(targetDir) {
   const dirs = entries.filter((e) => e.isDirectory());
   const files = entries.filter((e) => !e.isDirectory());
   if (dirs.length === 1 && files.length === 0) {
-    const pkgDir = resolve8(targetDir, dirs[0].name);
+    const pkgDir = resolve9(targetDir, dirs[0].name);
     const items = readdirSync2(pkgDir);
     for (const item of items) {
-      const src = resolve8(pkgDir, item);
-      const dst = resolve8(targetDir, item);
+      const src = resolve9(pkgDir, item);
+      const dst = resolve9(targetDir, item);
       cpSync(src, dst, { recursive: true, force: true });
     }
     rmSync(pkgDir, { recursive: true, force: true });
@@ -6894,19 +7086,19 @@ function flattenPackageRoot(targetDir) {
 }
 async function verifyPlugin(dir) {
   const warnings = [];
-  const indexPath = resolve8(dir, "index.ts");
-  if (!existsSync5(indexPath)) {
-    const indexJs = resolve8(dir, "index.js");
-    if (!existsSync5(indexJs)) {
+  const indexPath = resolve9(dir, "index.ts");
+  if (!existsSync7(indexPath)) {
+    const indexJs = resolve9(dir, "index.js");
+    if (!existsSync7(indexJs)) {
       return { valid: false, error: "No index.ts or index.js entry point found", warnings };
     }
   }
-  const pkgPath = resolve8(dir, "package.json");
-  if (!existsSync5(pkgPath)) {
+  const pkgPath = resolve9(dir, "package.json");
+  if (!existsSync7(pkgPath)) {
     warnings.push("No package.json found");
   } else {
     try {
-      const pkg2 = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+      const pkg2 = JSON.parse(readFileSync10(pkgPath, "utf-8"));
       if (!pkg2.xbrowser) {
         warnings.push("No xbrowser metadata in package.json");
       }
@@ -6925,8 +7117,8 @@ function safeCleanup(dir) {
 
 // src/plugin/install-sources/local.ts
 async function installFromLocal(source, name, targetDir) {
-  const srcPath = resolve9(source);
-  if (!existsSync6(srcPath)) {
+  const srcPath = resolve10(source);
+  if (!existsSync8(srcPath)) {
     throw new Error(`Local path does not exist: ${srcPath}`);
   }
   const tmpTarget = `${targetDir}-tmp-${Date.now()}`;
@@ -6939,7 +7131,7 @@ async function installFromLocal(source, name, targetDir) {
       safeCleanup(tmpTarget);
       throw new Error(`Invalid plugin: ${verify.error}`);
     }
-    if (existsSync6(targetDir)) {
+    if (existsSync8(targetDir)) {
       rmSync2(targetDir, { recursive: true, force: true });
     }
     cpSync2(tmpTarget, targetDir, { recursive: true, force: true });
@@ -6959,9 +7151,9 @@ async function installFromLocal(source, name, targetDir) {
 }
 
 // src/plugin/install-sources/npm.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync4, rmSync as rmSync3, cpSync as cpSync3 } from "fs";
-import { resolve as resolve10, join as join4 } from "path";
-import { tmpdir } from "os";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync6, rmSync as rmSync3, cpSync as cpSync3 } from "fs";
+import { resolve as resolve11, join as join5 } from "path";
+import { tmpdir as tmpdir2 } from "os";
 async function installFromNpm(packageName, name, targetDir) {
   await ensureProxyFetch();
   const encodedName = encodeURIComponent(packageName);
@@ -6979,13 +7171,13 @@ async function installFromNpm(packageName, name, targetDir) {
     throw new Error(`No tarball URL for ${packageName}@${latestVersion}`);
   }
   const tarballUrl = versionMeta.dist.tarball;
-  const tmpDir = join4(tmpdir(), `xbrowser-npm-${Date.now()}`);
-  mkdirSync4(tmpDir, { recursive: true });
+  const tmpDir = join5(tmpdir2(), `xbrowser-npm-${Date.now()}`);
+  mkdirSync5(tmpDir, { recursive: true });
   let warnings = [];
   try {
-    const tarballPath = join4(tmpDir, `${name}.tgz`);
+    const tarballPath = join5(tmpDir, `${name}.tgz`);
     await downloadToFile(tarballUrl, tarballPath);
-    const extractDir = join4(tmpDir, "extracted");
+    const extractDir = join5(tmpDir, "extracted");
     extractTarGz(tarballPath, extractDir);
     flattenPackageRoot(extractDir);
     const verify = await verifyPlugin(extractDir);
@@ -6993,16 +7185,16 @@ async function installFromNpm(packageName, name, targetDir) {
     if (!verify.valid) {
       throw new Error(`Invalid npm plugin: ${verify.error}`);
     }
-    if (existsSync7(targetDir)) {
+    if (existsSync9(targetDir)) {
       rmSync3(targetDir, { recursive: true, force: true });
     }
     cpSync3(extractDir, targetDir, { recursive: true, force: true });
-    const pkgPath = resolve10(targetDir, "package.json");
-    if (existsSync7(pkgPath)) {
-      const pkg2 = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+    const pkgPath = resolve11(targetDir, "package.json");
+    if (existsSync9(pkgPath)) {
+      const pkg2 = JSON.parse(readFileSync11(pkgPath, "utf-8"));
       if (!pkg2._npmSource) {
         pkg2._npmSource = { name: packageName, version: latestVersion };
-        writeFileSync4(pkgPath, JSON.stringify(pkg2, null, 2));
+        writeFileSync6(pkgPath, JSON.stringify(pkg2, null, 2));
       }
     }
   } finally {
@@ -7019,12 +7211,12 @@ async function installFromNpm(packageName, name, targetDir) {
 }
 
 // src/plugin/install-sources/git.ts
-import { existsSync as existsSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync5, rmSync as rmSync4, cpSync as cpSync4 } from "fs";
-import { resolve as resolve11, join as join5 } from "path";
-import { tmpdir as tmpdir2 } from "os";
+import { existsSync as existsSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync7, rmSync as rmSync4, cpSync as cpSync4 } from "fs";
+import { resolve as resolve12, join as join6 } from "path";
+import { tmpdir as tmpdir3 } from "os";
 import { execSync as execSync8 } from "child_process";
 async function installFromGit(gitUrl, name, targetDir) {
-  const tmpDir = join5(tmpdir2(), `xbrowser-git-${Date.now()}`);
+  const tmpDir = join6(tmpdir3(), `xbrowser-git-${Date.now()}`);
   let warnings = [];
   try {
     execSync8(`git clone --depth 1 "${gitUrl}" "${tmpDir}"`, { stdio: "pipe" });
@@ -7033,17 +7225,17 @@ async function installFromGit(gitUrl, name, targetDir) {
     if (!verify.valid) {
       throw new Error(`Invalid git plugin: ${verify.error}`);
     }
-    if (existsSync8(targetDir)) {
+    if (existsSync10(targetDir)) {
       rmSync4(targetDir, { recursive: true, force: true });
     }
     cpSync4(tmpDir, targetDir, { recursive: true, force: true });
-    rmSync4(resolve11(targetDir, ".git"), { recursive: true, force: true });
-    const pkgPath = resolve11(targetDir, "package.json");
-    if (existsSync8(pkgPath)) {
-      const pkg2 = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    rmSync4(resolve12(targetDir, ".git"), { recursive: true, force: true });
+    const pkgPath = resolve12(targetDir, "package.json");
+    if (existsSync10(pkgPath)) {
+      const pkg2 = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       if (!pkg2._gitSource) {
         pkg2._gitSource = { url: gitUrl };
-        writeFileSync5(pkgPath, JSON.stringify(pkg2, null, 2));
+        writeFileSync7(pkgPath, JSON.stringify(pkg2, null, 2));
       }
     }
   } finally {
@@ -7060,18 +7252,18 @@ async function installFromGit(gitUrl, name, targetDir) {
 }
 
 // src/plugin/install-sources/url.ts
-import { existsSync as existsSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, rmSync as rmSync5, cpSync as cpSync5 } from "fs";
-import { resolve as resolve12, join as join6, basename } from "path";
-import { tmpdir as tmpdir3 } from "os";
+import { existsSync as existsSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6, rmSync as rmSync5, cpSync as cpSync5 } from "fs";
+import { resolve as resolve13, join as join7, basename } from "path";
+import { tmpdir as tmpdir4 } from "os";
 async function installFromUrl(url, name, targetDir) {
-  const tmpDir = join6(tmpdir3(), `xbrowser-url-${Date.now()}`);
-  mkdirSync5(tmpDir, { recursive: true });
+  const tmpDir = join7(tmpdir4(), `xbrowser-url-${Date.now()}`);
+  mkdirSync6(tmpDir, { recursive: true });
   let warnings = [];
   try {
     const fileName = basename(new URL(url).pathname) || "plugin.tar.gz";
-    const tarballPath = join6(tmpDir, fileName);
+    const tarballPath = join7(tmpDir, fileName);
     await downloadToFile(url, tarballPath);
-    const extractDir = join6(tmpDir, "extracted");
+    const extractDir = join7(tmpDir, "extracted");
     extractTarGz(tarballPath, extractDir);
     flattenPackageRoot(extractDir);
     const verify = await verifyPlugin(extractDir);
@@ -7079,16 +7271,16 @@ async function installFromUrl(url, name, targetDir) {
     if (!verify.valid) {
       throw new Error(`Invalid plugin from URL: ${verify.error}`);
     }
-    if (existsSync9(targetDir)) {
+    if (existsSync11(targetDir)) {
       rmSync5(targetDir, { recursive: true, force: true });
     }
     cpSync5(extractDir, targetDir, { recursive: true, force: true });
-    const pkgPath = resolve12(targetDir, "package.json");
-    if (existsSync9(pkgPath)) {
-      const pkg2 = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+    const pkgPath = resolve13(targetDir, "package.json");
+    if (existsSync11(pkgPath)) {
+      const pkg2 = JSON.parse(readFileSync13(pkgPath, "utf-8"));
       if (!pkg2._urlSource) {
         pkg2._urlSource = { url };
-        writeFileSync6(pkgPath, JSON.stringify(pkg2, null, 2));
+        writeFileSync8(pkgPath, JSON.stringify(pkg2, null, 2));
       }
     }
   } finally {
@@ -7106,15 +7298,15 @@ async function installFromUrl(url, name, targetDir) {
 
 // src/plugin/install-sources/marketplace.ts
 import {
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync6,
-  writeFileSync as writeFileSync7,
-  readFileSync as readFileSync13,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync7,
+  writeFileSync as writeFileSync9,
+  readFileSync as readFileSync14,
   rmSync as rmSync6,
   cpSync as cpSync6
 } from "fs";
-import { resolve as resolve13, join as join7, dirname as dirname2 } from "path";
-import { tmpdir as tmpdir4 } from "os";
+import { resolve as resolve14, join as join8, dirname as dirname2 } from "path";
+import { tmpdir as tmpdir5 } from "os";
 import { gunzipSync } from "zlib";
 async function installFromMarketplace(pluginsDir, slug, options) {
   await ensureProxyFetch();
@@ -7130,13 +7322,13 @@ async function installFromMarketplace(pluginsDir, slug, options) {
   }
   const plugin = detailData.data;
   const name = options?.name || String(plugin.slug || slug);
-  const targetDir = resolve13(pluginsDir, name);
-  if (existsSync10(targetDir) && !options?.force) {
+  const targetDir = resolve14(pluginsDir, name);
+  if (existsSync12(targetDir) && !options?.force) {
     throw new Error(`Plugin "${name}" already exists. Use --force to overwrite.`);
   }
-  mkdirSync6(targetDir, { recursive: true });
-  const tmpDir = join7(tmpdir4(), `xbrowser-marketplace-${Date.now()}`);
-  mkdirSync6(tmpDir, { recursive: true });
+  mkdirSync7(targetDir, { recursive: true });
+  const tmpDir = join8(tmpdir5(), `xbrowser-marketplace-${Date.now()}`);
+  mkdirSync7(tmpDir, { recursive: true });
   const realSlug = String(plugin.slug || slug);
   try {
     await downloadAndExtractMarketplaceTarball(baseUrl, realSlug, tmpDir, targetDir);
@@ -7166,14 +7358,14 @@ function isManifestArray(data) {
   return Array.isArray(data) && data.length > 0 && typeof data[0].path === "string" && typeof data[0].content === "string";
 }
 function extractManifestToDir(manifest, targetDir) {
-  if (existsSync10(targetDir)) {
+  if (existsSync12(targetDir)) {
     rmSync6(targetDir, { recursive: true, force: true });
   }
-  mkdirSync6(targetDir, { recursive: true });
+  mkdirSync7(targetDir, { recursive: true });
   for (const file of manifest) {
-    const filePath = resolve13(targetDir, file.path);
-    mkdirSync6(dirname2(filePath), { recursive: true });
-    writeFileSync7(filePath, Buffer.from(file.content, "base64"));
+    const filePath = resolve14(targetDir, file.path);
+    mkdirSync7(dirname2(filePath), { recursive: true });
+    writeFileSync9(filePath, Buffer.from(file.content, "base64"));
   }
 }
 function tryParseAsGzippedManifest(buffer) {
@@ -7198,18 +7390,18 @@ async function downloadAndExtractMarketplaceTarball(baseUrl, slug, tmpDir, targe
   }
   if (tarballRes.status === 302 || tarballRes.headers.get("location")) {
     const redirectUrl = tarballRes.headers.get("location");
-    const tarballPath = join7(tmpDir, `${slug}.tar.gz`);
+    const tarballPath = join8(tmpDir, `${slug}.tar.gz`);
     await downloadToFile(redirectUrl, tarballPath);
-    const buffer = readFileSync13(tarballPath);
+    const buffer = readFileSync14(tarballPath);
     const manifest = tryParseAsGzippedManifest(buffer);
     if (manifest) {
       extractManifestToDir(manifest, targetDir);
       return;
     }
-    const extractDir = join7(tmpDir, "extracted");
+    const extractDir = join8(tmpDir, "extracted");
     extractTarGz(tarballPath, extractDir);
     flattenPackageRoot(extractDir);
-    if (existsSync10(targetDir)) {
+    if (existsSync12(targetDir)) {
       rmSync6(targetDir, { recursive: true, force: true });
     }
     cpSync6(extractDir, targetDir, { recursive: true, force: true });
@@ -7220,13 +7412,13 @@ async function downloadAndExtractMarketplaceTarball(baseUrl, slug, tmpDir, targe
       extractManifestToDir(manifest, targetDir);
       return;
     }
-    const tarballPath = join7(tmpDir, `${slug}.tar.gz`);
-    writeFileSync7(tarballPath, buffer);
+    const tarballPath = join8(tmpDir, `${slug}.tar.gz`);
+    writeFileSync9(tarballPath, buffer);
     try {
-      const extractDir = join7(tmpDir, "extracted");
+      const extractDir = join8(tmpDir, "extracted");
       extractTarGz(tarballPath, extractDir);
       flattenPackageRoot(extractDir);
-      if (existsSync10(targetDir)) {
+      if (existsSync12(targetDir)) {
         rmSync6(targetDir, { recursive: true, force: true });
       }
       cpSync6(extractDir, targetDir, { recursive: true, force: true });
@@ -7261,25 +7453,25 @@ function writeMarketplacePackageJson(plugin, slug, name, baseUrl, targetDir) {
       url: baseUrl
     }
   };
-  const pkgPath = resolve13(targetDir, "package.json");
-  if (!existsSync10(pkgPath)) {
-    writeFileSync7(pkgPath, JSON.stringify(packageJson, null, 2));
+  const pkgPath = resolve14(targetDir, "package.json");
+  if (!existsSync12(pkgPath)) {
+    writeFileSync9(pkgPath, JSON.stringify(packageJson, null, 2));
   } else {
     try {
-      const existing = JSON.parse(readFileSync13(pkgPath, "utf-8"));
+      const existing = JSON.parse(readFileSync14(pkgPath, "utf-8"));
       const merged = {
         ...existing,
         xbrowser: { ...existing.xbrowser, ...packageJson.xbrowser },
         _marketplace: packageJson._marketplace
       };
-      writeFileSync7(pkgPath, JSON.stringify(merged, null, 2));
+      writeFileSync9(pkgPath, JSON.stringify(merged, null, 2));
     } catch {
-      writeFileSync7(pkgPath, JSON.stringify(packageJson, null, 2));
+      writeFileSync9(pkgPath, JSON.stringify(packageJson, null, 2));
     }
   }
 }
 function ensureIndexFile(plugin, name, targetDir) {
-  if (!existsSync10(resolve13(targetDir, "index.ts")) && !existsSync10(resolve13(targetDir, "index.js"))) {
+  if (!existsSync12(resolve14(targetDir, "index.ts")) && !existsSync12(resolve14(targetDir, "index.js"))) {
     const commands = plugin.commands || [];
     const commandHandlers = commands.length > 0 ? commands.map((cmd) => {
       return [
@@ -7294,8 +7486,8 @@ function ensureIndexFile(plugin, name, targetDir) {
       `    handler: async () => ({ data: { message: 'Hello from ${name}!' }, tips: [] }),`,
       `  });`
     ].join("\n");
-    writeFileSync7(
-      resolve13(targetDir, "index.ts"),
+    writeFileSync9(
+      resolve14(targetDir, "index.ts"),
       [
         `import type { XCLIAPI } from '@dyyz1993/xcli-core';`,
         ``,
@@ -7316,7 +7508,7 @@ function ensureIndexFile(plugin, name, targetDir) {
 var PluginInstaller = class {
   pluginsDir;
   constructor(pluginsDir) {
-    this.pluginsDir = pluginsDir || resolve14(homedir4(), ".xbrowser/plugins");
+    this.pluginsDir = pluginsDir || resolve15(homedir5(), ".xbrowser/plugins");
   }
   getPluginsDir() {
     return this.pluginsDir;
@@ -7332,11 +7524,11 @@ var PluginInstaller = class {
   async install(source, options) {
     const type = this.detectSourceType(source);
     const name = options?.name || this.deriveName(source, type);
-    const targetDir = resolve14(this.pluginsDir, name);
-    if (existsSync11(targetDir) && !options?.force) {
+    const targetDir = resolve15(this.pluginsDir, name);
+    if (existsSync13(targetDir) && !options?.force) {
       throw new Error(`Plugin "${name}" already exists. Use --force to overwrite.`);
     }
-    mkdirSync7(targetDir, { recursive: true });
+    mkdirSync8(targetDir, { recursive: true });
     const resolvedSource = type === "npm" ? await resolveNpmPackageWithFallback(source) : source;
     switch (type) {
       case "local":
@@ -7393,8 +7585,8 @@ var PluginInstaller = class {
    * @throws If the plugin is not installed.
    */
   async uninstall(name) {
-    const targetDir = resolve14(this.pluginsDir, name);
-    if (!existsSync11(targetDir)) {
+    const targetDir = resolve15(this.pluginsDir, name);
+    if (!existsSync13(targetDir)) {
       throw new Error(`Plugin "${name}" not found`);
     }
     rmSync7(targetDir, { recursive: true, force: true });
@@ -7405,18 +7597,18 @@ var PluginInstaller = class {
    * @returns Array of installed plugin information.
    */
   async list(_options) {
-    if (!existsSync11(this.pluginsDir)) return [];
+    if (!existsSync13(this.pluginsDir)) return [];
     const entries = readdirSync3(this.pluginsDir, { withFileTypes: true });
     const plugins = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const pluginPath = resolve14(this.pluginsDir, entry.name);
-      const indexPath = resolve14(pluginPath, "index.ts");
-      const indexJsPath = resolve14(pluginPath, "index.js");
-      if (!existsSync11(indexPath) && !existsSync11(indexJsPath)) continue;
+      const pluginPath = resolve15(this.pluginsDir, entry.name);
+      const indexPath = resolve15(pluginPath, "index.ts");
+      const indexJsPath = resolve15(pluginPath, "index.js");
+      if (!existsSync13(indexPath) && !existsSync13(indexJsPath)) continue;
       const metadata = PluginMetadataParser.parseFromPackageJson(pluginPath);
       let source = "local";
-      const pkg2 = readJsonFile(resolve14(pluginPath, "package.json"), {});
+      const pkg2 = readJsonFile(resolve15(pluginPath, "package.json"), {});
       if (pkg2._marketplace) source = "marketplace";
       else if (pkg2._npmSource) source = "npm";
       else if (pkg2._gitSource) source = "git";
@@ -7440,10 +7632,10 @@ var PluginInstaller = class {
     }
     if (source.startsWith("file://")) {
       const filePath = decodeURIComponent(new URL(source).pathname);
-      if (existsSync11(filePath)) return "url";
+      if (existsSync13(filePath)) return "url";
     }
     if (source.endsWith(".git") || source.includes("github.com/")) return "git";
-    if (existsSync11(resolve14(source))) return "local";
+    if (existsSync13(resolve15(source))) return "local";
     return "npm";
   }
   deriveName(source, type) {
@@ -7519,10 +7711,6 @@ function handlePluginHelp() {
     "  uninstall <name>                              Uninstall a plugin",
     "  list [--json]                                 List installed plugins",
     "  reload <name>                                 Reload a plugin",
-    "  publish [--registry <url>] [--dry-run]        Publish plugin to marketplace",
-    "  login [--token <api-key>] [--registry <url>]  Login to marketplace",
-    "  whoami                                        Show current logged-in user",
-    "  logout                                        Logout from marketplace",
     "",
     "Examples:",
     "  xbrowser plugin search scraper",
@@ -7530,12 +7718,7 @@ function handlePluginHelp() {
     "  xbrowser plugin install ./my-plugin",
     "  xbrowser plugin uninstall my-plugin",
     "  xbrowser plugin list",
-    "  xbrowser plugin reload my-plugin",
-    "  xbrowser plugin publish",
-    "  xbrowser plugin publish --dry-run",
-    "  xbrowser plugin login --token my-api-key",
-    "  xbrowser plugin whoami",
-    "  xbrowser plugin logout"
+    "  xbrowser plugin reload my-plugin"
   ].join("\n");
 }
 var pluginInstallBuiltin = {
@@ -7837,76 +8020,60 @@ var NPMSearcher = class {
   }
 };
 
-// src/plugin/marketplace-search.ts
-var MarketplaceSearcher = class {
-  static getBaseUrl() {
-    return getMarketplaceUrl();
-  }
-  static async search(options = {}) {
-    await ensureProxyFetch();
-    const { query = "", tag, site, limit = 20 } = options;
-    const baseUrl = this.getBaseUrl();
-    const params = new URLSearchParams();
-    if (query) params.set("q", query);
-    if (tag) params.set("tag", tag);
-    if (site) params.set("site", site);
-    params.set("limit", String(limit));
-    const url = `${baseUrl}/api/plugins/search?${params.toString()}`;
-    try {
-      const response = await fetch(url);
-      if (!response.ok) {
-        return [];
-      }
-      const data = await response.json();
-      if (!data.success || !data.data?.items) {
-        return [];
-      }
-      return data.data.items.map((item) => this.parseMarketplacePlugin(item));
-    } catch {
-      return [];
-    }
-  }
-  static async getPluginDetail(slug) {
-    await ensureProxyFetch();
-    const baseUrl = this.getBaseUrl();
-    const url = `${baseUrl}/api/plugins/${slug}`;
-    try {
-      const response = await fetch(url);
-      if (!response.ok) return null;
-      const data = await response.json();
-      if (!data.success || !data.data) return null;
-      return this.parseMarketplacePlugin(data.data);
-    } catch {
-      return null;
-    }
-  }
-  static parseMarketplacePlugin(item) {
-    return {
+// src/builtins/plugin-search.ts
+async function searchFromMarketplacePlugin(options, loader) {
+  const sites = loader.getCore().loader.getSites();
+  const marketplaceSite = sites.find((s) => s.name === "marketplace");
+  if (!marketplaceSite) return [];
+  const searchCmd = marketplaceSite.getCommand("search");
+  if (!searchCmd) return [];
+  try {
+    const result = await searchCmd.handler(
+      {
+        query: options.query,
+        tag: options.tag,
+        site: options.site,
+        limit: options.limit
+      },
+      {}
+    );
+    const items = extractItems(result);
+    return items.map((item) => ({
       source: "marketplace",
-      slug: String(item.slug || ""),
       name: String(item.name || ""),
       version: String(item.version || "latest"),
       description: String(item.description || ""),
-      author: String(item.authorName || "Unknown"),
-      homepage: typeof item.homepageUrl === "string" ? item.homepageUrl : void 0,
-      repository: typeof item.repositoryUrl === "string" ? item.repositoryUrl : void 0,
-      keywords: Array.isArray(item.tags) ? item.tags.map(String) : [],
+      author: String(item.author || ""),
+      homepage: typeof item.homepage === "string" ? item.homepage : void 0,
       tags: Array.isArray(item.tags) ? item.tags.map(String) : [],
-      sites: Array.isArray(item.siteUrls) ? item.siteUrls.map(String) : [],
-      commands: Array.isArray(item.commands) ? item.commands.map(String) : [],
-      downloads: typeof item.downloadCount === "number" ? item.downloadCount : 0,
-      license: typeof item.license === "string" ? item.license : void 0
-    };
+      downloads: typeof item.downloads === "number" ? item.downloads : 0,
+      slug: String(item.slug || ""),
+      commands: Array.isArray(item.commands) ? item.commands.map(String) : []
+    }));
+  } catch {
+    return [];
   }
-};
-
-// src/builtins/plugin-search.ts
+}
+function extractItems(result) {
+  if (!result || typeof result !== "object") return [];
+  const r = result;
+  if ("data" in r) {
+    const data = r.data;
+    if (data && "items" in data && Array.isArray(data.items)) {
+      return data.items;
+    }
+  }
+  if ("items" in r && Array.isArray(r.items)) {
+    return r.items;
+  }
+  return [];
+}
 var pluginSearchBuiltin = {
   name: "plugin search",
   description: "Search for xbrowser plugins on npm registry and marketplace",
   help: {
     usage: "xbrowser plugin search <query> [options]",
-    description: "Search npm registry and marketplace for xbrowser-compatible plugins",
+    description: "Search npm registry and installed plugin search providers for xbrowser-compatible plugins",
     options: [
       { name: "--tag <tag>", description: "Filter by plugin tag" },
       { name: "--site <site>", description: "Filter by target site" },
@@ -7928,26 +8095,24 @@ var pluginSearchBuiltin = {
         limit: options["limit"] ? Number.parseInt(String(options["limit"])) : 20
       };
       console.log(
-        `Searching npm registry and marketplace for xbrowser plugins...${query ? ` (query: "${query}")` : ""}`
+        `Searching for xbrowser plugins...${query ? ` (query: "${query}")` : ""}`
       );
-      const [npmSettled, marketplaceSettled] = await Promise.allSettled([
+      const loader = await getPluginLoader();
+      const [npmSettled, pluginSettled] = await Promise.allSettled([
         NPMSearcher.search(searchOptions),
-        MarketplaceSearcher.search(searchOptions)
+        searchFromMarketplacePlugin(searchOptions, loader)
       ]);
       const npmResults = npmSettled.status === "fulfilled" ? npmSettled.value : [];
-      const marketplaceResults = marketplaceSettled.status === "fulfilled" ? marketplaceSettled.value : [];
+      const pluginResults = pluginSettled.status === "fulfilled" ? pluginSettled.value : [];
       if (npmSettled.status === "rejected") {
         console.warn(`Warning: npm search failed: ${npmSettled.reason}`);
       }
-      if (marketplaceSettled.status === "rejected") {
-        console.warn(`Warning: marketplace search failed: ${marketplaceSettled.reason}`);
-      }
-      const total = npmResults.length + marketplaceResults.length;
+      const total = npmResults.length + pluginResults.length;
       if (total === 0) {
         console.log("No plugins found.");
         return;
       }
-      console.log(`Found ${total} plugin(s) (npm: ${npmResults.length}, marketplace: ${marketplaceResults.length}):
+      console.log(`Found ${total} plugin(s) (npm: ${npmResults.length}, plugins: ${pluginResults.length}):
 `);
       if (npmResults.length > 0) {
         console.log("--- npm ---\n");
@@ -7971,14 +8136,14 @@ var pluginSearchBuiltin = {
           console.log("");
         });
       }
-      if (marketplaceResults.length > 0) {
+      if (pluginResults.length > 0) {
         console.log("--- marketplace ---\n");
-        marketplaceResults.forEach((result, idx) => {
+        pluginResults.forEach((result, idx) => {
           console.log(`${idx + 1}. ${result.name} [marketplace]`);
           console.log(`   ${result.description}`);
           console.log(`   Version: ${result.version}`);
-          console.log(`   Author: ${result.author}`);
-          console.log(`   Downloads: ${result.downloads}`);
+          if (result.author) console.log(`   Author: ${result.author}`);
+          if (result.downloads) console.log(`   Downloads: ${result.downloads}`);
           if (result.tags && result.tags.length > 0) {
             console.log(`   Tags: ${result.tags.join(", ")}`);
           }
@@ -7988,7 +8153,9 @@ var pluginSearchBuiltin = {
           if (result.homepage) {
             console.log(`   Homepage: ${result.homepage}`);
           }
-          console.log(`   Install: xbrowser plugin install ${result.slug} --from-marketplace`);
+          if (result.slug) {
+            console.log(`   Install: xbrowser plugin install ${result.slug} --from-marketplace`);
+          }
           console.log("");
         });
       }
@@ -8758,15 +8925,15 @@ async function handleBrowserCommand(command, args, options, sessionName, mode, c
 }
 
 // src/cli/session-routes.ts
-import { homedir as homedir5 } from "os";
-import { join as join9 } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join10 } from "path";
 import { readdirSync as readdirSync4, rmSync as rmSync8 } from "fs";
 function cleanSessionFiles() {
-  const dir = join9(homedir5(), ".xbrowser", "sessions");
+  const dir = join10(homedir6(), ".xbrowser", "sessions");
   let count = 0;
   try {
     for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-      const p = join9(dir, entry.name);
+      const p = join10(dir, entry.name);
       rmSync8(p, { recursive: true, force: true });
       count++;
     }
@@ -8869,6 +9036,67 @@ function applyRegistryOverride(options) {
     process.env.XBROWSER_MARKETPLACE_URL = registry2;
   }
 }
+function extractItems2(result) {
+  if (!result || typeof result !== "object") return [];
+  const r = result;
+  if ("data" in r) {
+    const data = r.data;
+    if (data && "items" in data && Array.isArray(data.items)) {
+      return data.items;
+    }
+  }
+  if ("items" in r && Array.isArray(r.items)) {
+    return r.items;
+  }
+  return [];
+}
+async function searchFromMarketplacePlugin2(options, loader) {
+  const sites = loader.getCore().loader.getSites();
+  const marketplaceSite = sites.find((s) => s.name === "marketplace");
+  if (!marketplaceSite) return [];
+  const searchCmd = marketplaceSite.getCommand("search");
+  if (!searchCmd) return [];
+  try {
+    const result = await searchCmd.handler(
+      {
+        query: options.query,
+        tag: options.tag,
+        site: options.site,
+        limit: options.limit
+      },
+      {}
+    );
+    const items = extractItems2(result);
+    return items.map((item) => ({ ...item, source: "marketplace" }));
+  } catch {
+    return [];
+  }
+}
+async function infoFromMarketplacePlugin(slug, loader) {
+  const sites = loader.getCore().loader.getSites();
+  const marketplaceSite = sites.find((s) => s.name === "marketplace");
+  if (!marketplaceSite) return null;
+  const infoCmd = marketplaceSite.getCommand("info");
+  if (!infoCmd) return null;
+  try {
+    const result = await infoCmd.handler({ slug }, {});
+    if (!result || typeof result !== "object") return null;
+    const r = result;
+    let plugin = null;
+    if ("data" in r) {
+      const data = r.data;
+      plugin = data?.plugin || null;
+    }
+    if (!plugin && "plugin" in r) {
+      plugin = r.plugin;
+    }
+    if (plugin && plugin.name) {
+      return { ...plugin, source: "marketplace" };
+    }
+  } catch {
+  }
+  return null;
+}
 async function handleSearch(args, options, mode) {
   const query = args[0] || "";
   applyRegistryOverride(options);
@@ -8876,11 +9104,10 @@ async function handleSearch(args, options, mode) {
   const searchLimit = options.limit ? Number(options.limit) : 20;
   const searchOpts = { query, tag: options.tag, site: options.site, limit: searchLimit };
   const results = [];
-  const marketplaceResults = await MarketplaceSearcher.search(searchOpts);
-  for (const r of marketplaceResults) {
-    results.push({ ...r, source: "marketplace" });
-  }
-  if (marketplaceResults.length === 0) {
+  const loader = await getPluginLoader();
+  const pluginResults = await searchFromMarketplacePlugin2(searchOpts, loader);
+  results.push(...pluginResults);
+  if (pluginResults.length === 0) {
     try {
       const npmResults = await NPMSearcher.search(searchOpts);
       for (const r of npmResults) {
@@ -8913,12 +9140,11 @@ async function handlePluginInfo(args, options, mode) {
   if (!slug) outputError("Usage: xbrowser plugin info <slug>");
   applyRegistryOverride(options);
   await ensureProxyFetch();
-  const marketplaceUrl = getMarketplaceUrl();
+  const loader = await getPluginLoader();
   try {
-    const resp = await fetch(`${marketplaceUrl}/api/plugins/${slug}`);
-    if (resp.ok) {
-      const raw = await resp.json();
-      const d = raw.data || raw;
+    const pluginInfo = await infoFromMarketplacePlugin(slug, loader);
+    if (pluginInfo) {
+      const d = pluginInfo;
       if (mode === "json") {
         outputResult({ source: "marketplace", ...d }, mode);
         return;
@@ -8926,12 +9152,11 @@ async function handlePluginInfo(args, options, mode) {
       console.log(`\u540D\u79F0: ${d.name || ""}`);
       console.log(`\u7248\u672C: ${d.version || ""}`);
       console.log(`\u63CF\u8FF0: ${d.description || ""}`);
-      console.log(`\u4F5C\u8005: ${d.authorName || d.author || ""}`);
-      console.log(`\u72B6\u6001: ${d.status || ""}`);
+      console.log(`\u4F5C\u8005: ${d.author || ""}`);
       console.log(`\u547D\u4EE4: ${(d.commands || []).join(", ")}`);
-      console.log(`\u4E0B\u8F7D\u91CF: ${d.downloadCount || 0}`);
+      console.log(`\u4E0B\u8F7D\u91CF: ${d.downloads || 0}`);
       console.log(`\u6807\u7B7E: ${(d.tags || []).join(", ")}`);
-      console.log(`\u7F51\u7AD9: ${(d.siteUrls || []).join(", ")}`);
+      console.log(`\u7F51\u7AD9: ${(d.sites || []).join(", ")}`);
       return;
     }
   } catch {
@@ -9434,7 +9659,7 @@ async function handleFilter(args, _mode) {
 
 // src/stdin.ts
 import { createInterface } from "readline";
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 async function readStdin2() {
   if (process.stdin.isTTY) return [];
   const lines = [];
@@ -9448,7 +9673,7 @@ async function readStdin2() {
   return lines;
 }
 function readCommandFile(filePath) {
-  const content = readFileSync14(filePath, "utf-8");
+  const content = readFileSync15(filePath, "utf-8");
   return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
 }
 
@@ -9880,24 +10105,6 @@ Commands:
   viewer [--name <n>] [--selector <sel>] Generate viewer URL
   help                              Show this help
   --version, -v                     Show version
-
-Marketplace & Admin:
-  marketplace publish [--dry-run]   Publish plugin to marketplace
-  marketplace login [--token <key>] Login to marketplace
-  marketplace register              Register developer account
-  marketplace whoami                Show current user
-  marketplace logout                Logout from marketplace
-  admin pending                     List pending plugins (admin only)
-  admin approve <slug>              Approve a plugin (admin only)
-  admin reject <slug> [--reason]    Reject a plugin (admin only)
-  admin feature <slug>              Toggle featured (admin only)
-  admin remove <slug>               Remove a plugin (admin only)
-  admin stats                       Dashboard stats (admin only)
-  admin inventory                   Plugin inventory (admin only)
-  admin list [--status <status>]    List all plugins (admin only)
-  admin bulk-approve <slugs...>     Bulk approve (admin only)
-  admin cleanup                     Reset data (admin only)
-
 Plugin Commands:
   Installed plugins provide additional commands.
   Use 'xbrowser plugin list' to see installed plugins and their commands.
@@ -10260,19 +10467,19 @@ function headersToObject(headers) {
   return result;
 }
 function readBody(req) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw) {
-        resolve15(null);
+        resolve16(null);
         return;
       }
       try {
-        resolve15(JSON.parse(raw));
+        resolve16(JSON.parse(raw));
       } catch {
-        resolve15(null);
+        resolve16(null);
       }
     });
     req.on("error", reject);
@@ -10317,7 +10524,7 @@ var HTTPServer = class {
         res.end(JSON.stringify({ error: "INTERNAL_ERROR", message, statusCode: 500 }));
       });
     });
-    return new Promise((resolve15, reject) => {
+    return new Promise((resolve16, reject) => {
       const server = this.server;
       server.on("error", (err) => {
         this.server = null;
@@ -10329,7 +10536,7 @@ var HTTPServer = class {
           this.port = addr.port;
         }
         console.log(`HTTP server listening on http://${this.host}:${this.port}`);
-        resolve15({ port: this.port, host: this.host });
+        resolve16({ port: this.port, host: this.host });
       });
     });
   }
@@ -10340,13 +10547,13 @@ var HTTPServer = class {
    */
   async stop() {
     if (!this.server) return;
-    return new Promise((resolve15, reject) => {
+    return new Promise((resolve16, reject) => {
       this.server.close((err) => {
         if (err) {
           reject(err);
         } else {
           this.server = null;
-          resolve15();
+          resolve16();
         }
       });
     });