@xbrowser/cli 1.2.0 → 1.2.2

package/dist/daemon-main.js

@@ -24,6 +24,9 @@ import {
 } from "./chunk-SLQR57XZ.js";
 import "./chunk-QFROODUU.js";
 import "./chunk-TNEN6VQ2.js";
+import {
+  getPluginLoader
+} from "./chunk-PHBK3TRN.js";
 import {
   getDaemonConfig,
   getDaemonProcessStatus
@@ -34,15 +37,15 @@ import {
 import "./chunk-KFQGP6VL.js";
 
 // src/daemon/daemon-main.ts
-import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync7, appendFileSync, unlinkSync } from "fs";
-import { join as join9 } from "path";
-import { homedir as homedir9 } from "os";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, appendFileSync, unlinkSync } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir8 } from "os";
 import { startHttpServer } from "@dyyz1993/xcli-core";
 
 // src/daemon/rpc-handlers.ts
-import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync6 } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir8 } from "os";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir7 } from "os";
 import {
   createSessionMeta,
   removeSession
@@ -449,15 +452,15 @@ var clickCommand = registerCommand({
     let detectedNewPage;
     let cleanup;
     if (ctx.browserContext?.on) {
-      const pagePromise = new Promise((resolve3) => {
+      const pagePromise = new Promise((resolve) => {
         const timer = setTimeout(() => {
           ctx.browserContext.off("page", handler);
-          resolve3(void 0);
+          resolve(void 0);
         }, 3e3);
         const handler = (page2) => {
           clearTimeout(timer);
           ctx.browserContext.off("page", handler);
-          resolve3(page2);
+          resolve(page2);
         };
         ctx.browserContext.on("page", handler);
       });
@@ -907,10 +910,10 @@ var setCookieCommand = registerCommand({
   description: "Set a cookie",
   scope: "page",
   parameters: z8.object({
-    name: z8.string(),
-    value: z8.string(),
-    domain: z8.string().optional(),
-    path: z8.string().optional(),
+    name: z8.coerce.string(),
+    value: z8.coerce.string(),
+    domain: z8.coerce.string().optional(),
+    path: z8.coerce.string().optional(),
     expires: z8.number().optional(),
     httpOnly: z8.boolean().optional(),
     secure: z8.boolean().optional(),
@@ -1255,7 +1258,7 @@ var consoleCheckCommand = registerCommand({
       await page.goto(p.url, { waitUntil: "domcontentloaded" });
     }
     const messages = await page.evaluate((args) => {
-      return new Promise((resolve3) => {
+      return new Promise((resolve) => {
         const collected = [];
         const originalConsole = {
           log: console.log,
@@ -1322,7 +1325,7 @@ ${a.stack || ""}`;
           console.warn = originalConsole.warn;
           console.error = originalConsole.error;
           console.info = originalConsole.info;
-          resolve3(collected);
+          resolve(collected);
         }, args.duration);
       });
     }, { duration: p.duration });
@@ -1748,7 +1751,7 @@ async function executeAction(page, action) {
       if (action.selector) {
         await page.waitForSelector(action.selector, { timeout: 3e4 });
       } else if (action.milliseconds) {
-        await new Promise((resolve3) => setTimeout(resolve3, action.milliseconds));
+        await new Promise((resolve) => setTimeout(resolve, action.milliseconds));
       } else {
         throw new Error("wait action requires either milliseconds or selector");
       }
@@ -1837,8 +1840,8 @@ var actionsCommand = registerCommand({
         results.push(result);
       }
     })();
-    const timeoutPromise = new Promise((resolve3) => {
-      setTimeout(resolve3, timeoutMs);
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(resolve, timeoutMs);
     });
     await Promise.race([executionPromise, timeoutPromise]);
     const title = await ctx.page.title();
@@ -2316,44 +2319,45 @@ var scrapeCommand = registerCommand({
           switch (p.format) {
             case "markdown": {
               const tablesMd = await page.evaluate(() => {
-                const tableSelectors = [
-                  "table",
-                  '[role="table"]',
-                  '[role="grid"]',
-                  '[class*="el-table"]',
-                  // Element UI
-                  '[class*="ant-table"]',
-                  // Ant Design
-                  '[class*="MuiTable"]',
-                  // Material UI
-                  '[class*="table"]'
-                  // Generic table-like
-                ].join(",");
-                const tables = document.querySelectorAll(tableSelectors);
-                if (tables.length === 0) return "";
+                document.querySelectorAll(
+                  '.el-table__fixed, .el-table__fixed-right, [class*="fixed-left"], [class*="fixed-right"], .ant-table-fixed-left, .ant-table-fixed-right'
+                ).forEach((el) => el.remove());
+                document.querySelectorAll("table").forEach((t) => {
+                  if (t.closest(".el-table__fixed, .el-table__fixed-right")) t.remove();
+                });
+                const tables = document.querySelectorAll("table");
+                if (tables.length === 0) {
+                  const altTables = document.querySelectorAll(
+                    '[role="table"], [role="grid"], .el-table__body, .ant-table-tbody'
+                  );
+                  if (altTables.length === 0) return "";
+                  return Array.from(altTables).map((table) => {
+                    return extractRowsFromContainer(table);
+                  }).filter((md) => md).join("\n\n");
+                }
                 return Array.from(tables).map((table) => {
-                  const rows = table.querySelectorAll('tr, [role="row"], [class*="row"]');
+                  return extractRowsFromContainer(table);
+                }).filter((md) => md).join("\n\n");
+                function extractRowsFromContainer(container) {
+                  const rows = container.querySelectorAll(':scope > tr, :scope > thead > tr, :scope > tbody > tr, :scope > tfoot > tr, [role="row"]');
                   if (rows.length === 0) return "";
                   const mdRows = Array.from(rows).map((row) => {
-                    const cells = row.querySelectorAll('th, td, [role="columnheader"], [role="cell"], [class*="cell"], [class*="col"]');
+                    const cells = row.querySelectorAll(':scope > th, :scope > td, :scope > [role="columnheader"], :scope > [role="cell"]');
+                    if (cells.length === 0) return "";
                     return "| " + Array.from(cells).map((c) => {
                       const cellText = c.innerText?.trim().replace(/\n/g, " ") || "";
                       return cellText.replace(/\|/g, "\\|") || "";
                     }).join(" | ") + " |";
-                  }).join("\n");
+                  }).filter((r) => r);
+                  if (mdRows.length === 0) return "";
                   const headerRow = rows[0];
-                  const headerCells = headerRow.querySelectorAll('th, [role="columnheader"], [class*="header"]');
-                  const hasHeader = headerCells.length > 0;
-                  if (hasHeader && mdRows) {
-                    const headerCount = headerCells.length;
-                    const sep = "| " + Array(headerCount).fill("---").join(" | ") + " |";
-                    return mdRows.split("\n").map((line, i) => {
-                      if (i === 0) return line + "\n" + sep;
-                      return line;
-                    }).join("\n");
+                  const headerCells = headerRow.querySelectorAll(':scope > th, :scope > [role="columnheader"]');
+                  if (headerCells.length > 0) {
+                    const sep = "| " + Array(headerCells.length).fill("---").join(" | ") + " |";
+                    return mdRows[0] + "\n" + sep + "\n" + mdRows.slice(1).join("\n");
                   }
-                  return mdRows;
-                }).join("\n\n");
+                  return mdRows.join("\n");
+                }
               });
               content = htmlToMarkdown(html, { onlyMainContent: p.onlyMainContent });
               if (tablesMd) {
@@ -2557,11 +2561,11 @@ async function navigateForMap(page, url, timeout = 15e3) {
 }
 async function extractPageLinks(page, baseUrl) {
   await navigateForMap(page, baseUrl);
-  await new Promise((resolve3) => setTimeout(resolve3, 2e3));
+  await new Promise((resolve) => setTimeout(resolve, 2e3));
   await page.evaluate(() => {
     window.scrollTo(0, document.body.scrollHeight);
   });
-  await new Promise((resolve3) => setTimeout(resolve3, 1e3));
+  await new Promise((resolve) => setTimeout(resolve, 1e3));
   const origin = new URL(baseUrl).origin;
   const rawLinks = await page.evaluate((evalOrigin) => {
     return Array.from(document.querySelectorAll("a[href]")).map((a) => {
@@ -4419,25 +4423,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((resolve3) => {
+  return new Promise((resolve) => {
     execFile(
       piBin,
       ["--provider", LLM_PROVIDER, "--model", LLM_MODEL, prompt],
       { timeout: LLM_TIMEOUT_MS, maxBuffer: 1024 * 1024 },
       (err, stdout, _stderr) => {
         if (err) {
-          resolve3(null);
+          resolve(null);
           return;
         }
         const output = (stdout || "").trim();
         if (!output) {
-          resolve3(null);
+          resolve(null);
           return;
         }
         try {
           const parsed = parse(output);
           if (!parsed || typeof parsed !== "object") {
-            resolve3(null);
+            resolve(null);
             return;
           }
           const elements = {};
@@ -4452,9 +4456,9 @@ async function analyzeWithLLM(ariaSnapshot) {
               };
             }
           }
-          resolve3(Object.keys(elements).length > 0 ? elements : null);
+          resolve(Object.keys(elements).length > 0 ? elements : null);
         } catch {
-          resolve3(null);
+          resolve(null);
         }
       }
     );
@@ -4809,7 +4813,7 @@ async function pollUntil(timeout, pollInterval, predicate) {
   const startedAt = Date.now();
   while (Date.now() - startedAt <= timeout) {
     if (await predicate()) return true;
-    await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
   }
   return false;
 }
@@ -5415,11 +5419,11 @@ function resolveScriptContent(params) {
 async function readStdin() {
   const { createReadStream } = await import("fs");
   const { createInterface } = await import("readline");
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve, reject) => {
     const lines = [];
     const rl = createInterface({ input: createReadStream("/dev/stdin") });
     rl.on("line", (line) => lines.push(line));
-    rl.on("close", () => resolve3(lines.join("\n")));
+    rl.on("close", () => resolve(lines.join("\n")));
     rl.on("error", reject);
   });
 }
@@ -5887,434 +5891,6 @@ function formatDetectionMessage(result) {
   Action: ${action}`;
 }
 
-// src/plugin/loader.ts
-import {
-  Core
-} from "@dyyz1993/xcli-core";
-import { resolve as resolve2 } from "path";
-import { existsSync as existsSync4, readdirSync } from "fs";
-import { homedir as homedir5 } from "os";
-
-// src/plugin/metadata-parser.ts
-import { existsSync as existsSync2 } from "fs";
-import { resolve } from "path";
-
-// src/utils/json-file.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
-function readJsonFile(filePath, defaultValue) {
-  try {
-    const content = readFileSync3(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 = resolve(pluginPath, "package.json");
-    if (!existsSync2(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 mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
-import { join as join5 } from "path";
-import { execSync } from "child_process";
-var SHARED_PLUGIN_DEPENDENCIES = {
-  "zod": "^3.24.0",
-  "@dyyz1993/xcli-core": "^0.12.1"
-};
-function ensurePluginDependencies(pluginsDir) {
-  const zodPath = join5(pluginsDir, "node_modules", "zod");
-  if (existsSync3(zodPath)) return;
-  mkdirSync4(pluginsDir, { recursive: true });
-  const pkgPath = join5(pluginsDir, "package.json");
-  let pkg = {};
-  if (existsSync3(pkgPath)) {
-    try {
-      pkg = readJsonFile(pkgPath, {});
-    } catch {
-    }
-  }
-  const existingDeps = pkg.dependencies || {};
-  let needsInstall = false;
-  for (const [dep, version] of Object.entries(SHARED_PLUGIN_DEPENDENCIES)) {
-    if (!existingDeps[dep]) {
-      existingDeps[dep] = version;
-      needsInstall = true;
-    }
-  }
-  if (!needsInstall && existsSync3(join5(pluginsDir, "node_modules"))) return;
-  pkg.dependencies = existingDeps;
-  pkg.private = true;
-  pkg.description = pkg.description || "xbrowser plugins \u2014 shared dependencies";
-  writeFileSync5(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
-  try {
-    execSync("npm install --production --no-package-lock --no-fund --no-audit", {
-      cwd: pluginsDir,
-      stdio: "pipe",
-      timeout: 6e4,
-      env: { ...process.env, NODE_ENV: "production" }
-    });
-  } catch (err) {
-    console.warn(`\u26A0\uFE0F  Failed to install shared plugin dependencies: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-
-// src/plugin/contract.ts
-import {
-  unwrapZod,
-  fieldsFromZodObjectReflected,
-  zodTypeToContractType
-} from "@dyyz1993/xcli-core";
-function buildPluginContract(site) {
-  const commands = site.getAllCommands().map((command) => buildCommandContract(site.getCommand?.(command.name) || command, {
-    siteRequiresLogin: site.config?.requiresLogin
-  }));
-  return {
-    version: 2,
-    plugin: {
-      name: site.name,
-      url: site.url,
-      description: site.config?.description,
-      requiresLogin: site.config?.requiresLogin
-    },
-    commands
-  };
-}
-function buildCommandContract(command, options = {}) {
-  const extension = command.xbrowser || {};
-  const inferredFields = fieldsFromZodObject(command.parameters);
-  const fields = mergeFields(inferredFields, extension.form?.fields || []);
-  const positional = extension.positional || fields.filter((field) => field.positional).map((field) => field.name);
-  const requiresLogin = command.requiresLogin === true || options.siteRequiresLogin === true && command.name !== "login" && command.name !== "logout";
-  const capabilities = extension.capabilities || inferCapabilities(command.scope || "project", requiresLogin);
-  const outputSchema = command.result ? summarizeZod(command.result) : void 0;
-  return {
-    name: command.name,
-    description: command.description || "",
-    scope: command.scope || "project",
-    requiresLogin,
-    category: extension.category,
-    capabilities,
-    positional,
-    form: {
-      title: extension.form?.title || command.description || command.name,
-      description: extension.form?.description,
-      submitLabel: extension.form?.submitLabel || "Run",
-      fields
-    },
-    output: extension.output || (outputSchema ? { schema: outputSchema } : void 0)
-  };
-}
-function fieldsFromZodObject(schema) {
-  const reflected = fieldsFromZodObjectReflected(schema);
-  return reflected.map((field) => {
-    const widget = widgetFor(field.type, field.enum);
-    return {
-      name: field.name,
-      label: toLabel(field.name),
-      type: field.type,
-      widget,
-      required: field.required,
-      ...field.description ? { description: field.description } : {},
-      ...field.default !== void 0 ? { default: field.default } : {},
-      ...field.enum ? { enum: field.enum } : {},
-      ...field.type === "array" ? { multiple: true } : {}
-    };
-  });
-}
-function mergeFields(inferred, overrides) {
-  if (overrides.length === 0) return inferred;
-  const byName = new Map(inferred.map((field) => [field.name, field]));
-  const seen = /* @__PURE__ */ new Set();
-  const merged = [];
-  for (const override of overrides) {
-    if (!override.name) continue;
-    const base = byName.get(override.name) || {
-      name: override.name,
-      label: toLabel(override.name),
-      type: "string",
-      widget: "text",
-      required: false
-    };
-    merged.push({ ...base, ...override, name: override.name });
-    seen.add(override.name);
-  }
-  for (const field of inferred) {
-    if (!seen.has(field.name)) merged.push(field);
-  }
-  return merged;
-}
-function inferCapabilities(scope, requiresLogin) {
-  const caps = [];
-  if (scope === "page") caps.push("browser.page");
-  if (scope === "browser") caps.push("browser.context");
-  if (requiresLogin) caps.push("auth.login");
-  return caps;
-}
-function widgetFor(type, enumValues) {
-  if (enumValues) return "select";
-  if (type === "boolean") return "checkbox";
-  if (type === "number") return "number";
-  if (type === "array") return "multi-select";
-  if (type === "object") return "json";
-  return "text";
-}
-function summarizeZod(schema) {
-  const unwrapped = unwrapZod(schema);
-  if (unwrapped.typeName === "ZodArray") {
-    const def = unwrapped.schema?._def;
-    return {
-      type: "array",
-      items: summarizeZod(def?.type || def?.innerType)
-    };
-  }
-  const shape = getObjectShape(schema);
-  if (!shape) {
-    return {
-      type: zodTypeToContractType(unwrapped.typeName),
-      required: !unwrapped.optional,
-      ...unwrapped.description ? { description: unwrapped.description } : {}
-    };
-  }
-  return Object.fromEntries(
-    Object.entries(shape).map(([name, field]) => {
-      const inner = unwrapZod(field);
-      return [name, {
-        type: zodTypeToContractType(inner.typeName),
-        required: !inner.optional,
-        ...inner.description ? { description: inner.description } : {}
-      }];
-    })
-  );
-}
-function getObjectShape(schema) {
-  const zod = schema;
-  const shapeOrFn = zod?.shape ?? zod?._def?.shape;
-  if (!shapeOrFn) return void 0;
-  return typeof shapeOrFn === "function" ? shapeOrFn() : shapeOrFn;
-}
-function toLabel(name) {
-  return name.replace(/([A-Z])/g, " $1").replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim().replace(/^./, (char) => char.toUpperCase());
-}
-
-// src/plugin/login-required-patch.ts
-import { SiteInstanceImpl } from "@dyyz1993/xcli-core";
-var patched = false;
-function patchLoginRequired() {
-  if (patched) return;
-  patched = true;
-  const target = SiteInstanceImpl.prototype;
-  const originalCommand = target.command;
-  const wrapped = function(...args) {
-    const result = originalCommand.apply(this, args);
-    const [name, cmd] = args;
-    const loginRequired = cmd.loginRequired;
-    if (loginRequired) {
-      const commands = this.commands;
-      const entry = commands?.get(name);
-      if (entry) {
-        entry.loginRequired = loginRequired;
-      }
-    }
-    return result;
-  };
-  Object.defineProperty(target, "command", {
-    value: wrapped,
-    writable: true,
-    configurable: true
-  });
-}
-
-// src/plugin/loader.ts
-var DEFAULT_PLUGIN_DIRS = [".xcli/plugins", "../.xcli/plugins"];
-var XBrowserPluginLoader = class {
-  core;
-  loader;
-  options;
-  constructor(options) {
-    patchLoginRequired();
-    this.options = options ?? {};
-    const cwd = this.options.cwd || process.cwd();
-    const coreConfig = {
-      name: "xbrowser",
-      version: "0.1.0",
-      description: "Browser automation CLI",
-      configDirName: ".xbrowser",
-      envPrefix: "XBROWSER",
-      pluginDirs: [
-        ...DEFAULT_PLUGIN_DIRS,
-        resolve2(cwd, ".xcli/plugins")
-      ]
-    };
-    this.core = new Core(coreConfig);
-    this.loader = this.core.loader;
-  }
-  getAPI() {
-    return this.loader.getAPI();
-  }
-  /**
-   * Get the core instance for external use.
-   * @returns The xcli-core Core instance.
-   */
-  getCore() {
-    return this.core;
-  }
-  getPlugin(id) {
-    return this.loader.getPlugin(id);
-  }
-  getPluginStatus(id) {
-    return this.loader.getPluginStatus(id);
-  }
-  getLoadedPlugins() {
-    return this.loader.getLoadedPlugins();
-  }
-  getPluginContract(siteName, commandName) {
-    const site = this.core.loader.getSite(siteName);
-    if (!site) return void 0;
-    const contract = buildPluginContract(site);
-    if (!commandName) return contract;
-    return contract.commands.find((command) => command.name === commandName);
-  }
-  async loadPlugin(pluginPath, id) {
-    return this.loader.loadPlugin(pluginPath, id);
-  }
-  async unloadPlugin(id) {
-    return this.loader.unloadPlugin(id);
-  }
-  async reloadPlugin(id) {
-    return this.loader.reloadPlugin(id);
-  }
-  async loadFromFunction(setup) {
-    return this.loader.loadFromFunction(setup);
-  }
-  async scanAndLoad() {
-    const cwd = this.options.cwd || process.cwd();
-    const globalDir = this.options.globalDir || resolve2(homedir5(), ".xbrowser/plugins");
-    ensurePluginDependencies(globalDir);
-    const dirs = [
-      resolve2(cwd, ".xcli/plugins"),
-      resolve2(cwd, "../.xcli/plugins"),
-      this.options.userDir || resolve2(homedir5(), ".xcli/plugins"),
-      globalDir
-    ];
-    const loaded = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const dir of dirs) {
-      if (!existsSync4(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 = resolve2(dir, entry.name);
-        let indexPath = resolve2(pluginDir, "index.js");
-        if (!existsSync4(indexPath)) {
-          indexPath = resolve2(pluginDir, "index.ts");
-        }
-        if (!existsSync4(indexPath)) continue;
-        try {
-          if (!existsSync4(resolve2(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);
-            if (!metadata) {
-              console.warn(`\u26A0\uFE0F  Plugin "${entry.name}" has package.json but no xbrowser metadata. Add { "xbrowser": { "description": "..." } } to package.json.`);
-            }
-          }
-          const instance = await this.loadPlugin(indexPath, entry.name);
-          loaded.push(instance);
-        } catch (err) {
-          if (process.env.XBROWSER_DEBUG) {
-            console.warn(`\u26A0\uFE0F  Plugin "${entry.name}" load failed: ${err instanceof Error ? err.message : String(err)}`);
-          }
-        }
-      }
-    }
-    return loaded;
-  }
-  async unload() {
-    return this.loader.unload();
-  }
-};
-
-// src/utils/plugin-singleton.ts
-var pluginLoader = null;
-var pluginsScanned = false;
-async function getPluginLoader() {
-  if (!pluginLoader) {
-    pluginLoader = new XBrowserPluginLoader();
-  }
-  if (!pluginsScanned) {
-    await pluginLoader.scanAndLoad();
-    pluginsScanned = true;
-  }
-  return pluginLoader;
-}
-
 // src/utils/viewer-url.ts
 function buildViewerUrl(sessionName = "default") {
   try {
@@ -6798,7 +6374,7 @@ var TipsManager = class {
     }
   }
   debounce() {
-    return new Promise((resolve3) => setTimeout(resolve3, DEBOUNCE_MS));
+    return new Promise((resolve) => setTimeout(resolve, DEBOUNCE_MS));
   }
   formatTips(tips) {
     return tips.map((tip) => {
@@ -6915,11 +6491,11 @@ async function loadHooks() {
 }
 
 // src/executor.ts
-import { homedir as homedir6 } from "os";
-import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
 var NAVIGATION_COMMANDS = /* @__PURE__ */ new Set(["goto", "back", "forward", "refresh"]);
 var snapshotHintShown = /* @__PURE__ */ new WeakSet();
-var CONFIG_DIR2 = join6(homedir6(), ".xbrowser");
+var CONFIG_DIR2 = join5(homedir5(), ".xbrowser");
 var storageCache = /* @__PURE__ */ new Map();
 function getPluginStorage(pluginName) {
   if (!storageCache.has(pluginName)) {
@@ -6931,7 +6507,7 @@ var archiveInitialized = false;
 function ensureArchiveInit() {
   if (!archiveInitialized) {
     try {
-      configureArchiveStore({ archiveDir: join6(homedir6(), ".xbrowser", "archives") });
+      configureArchiveStore({ archiveDir: join5(homedir5(), ".xbrowser", "archives") });
     } catch {
     }
     archiveInitialized = true;
@@ -7005,7 +6581,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
     params = result.data;
   }
   if (command.scope !== "cli" && !process.env.XBROWSER_DAEMON_WORKER) {
-    const { forwardExec } = await import("./daemon-client-R4QWHD7V.js");
+    const { forwardExec } = await import("./daemon-client-COJQESU2.js");
     const result = await forwardExec(commandName, params, sessionName, extraOpts?.cdpEndpoint);
     if (result) return result;
   }
@@ -7688,10 +7264,10 @@ async function replayEntry(entry, options = {}) {
 }
 
 // src/daemon/feedback-store.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5 } from "fs";
-import { join as join7 } from "path";
-import { homedir as homedir7 } from "os";
-var FEEDBACK_FILE = join7(homedir7(), ".xbrowser", "feedback.json");
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir6 } from "os";
+var FEEDBACK_FILE = join6(homedir6(), ".xbrowser", "feedback.json");
 var FeedbackStore = class {
   entries = [];
   constructor() {
@@ -7699,7 +7275,7 @@ var FeedbackStore = class {
   }
   load() {
     try {
-      const data = readFileSync4(FEEDBACK_FILE, "utf8");
+      const data = readFileSync3(FEEDBACK_FILE, "utf8");
       this.entries = JSON.parse(data);
     } catch {
       this.entries = [];
@@ -7707,8 +7283,8 @@ var FeedbackStore = class {
   }
   save() {
     try {
-      mkdirSync5(join7(homedir7(), ".xbrowser"), { recursive: true });
-      writeFileSync6(FEEDBACK_FILE, JSON.stringify(this.entries, null, 2));
+      mkdirSync4(join6(homedir6(), ".xbrowser"), { recursive: true });
+      writeFileSync4(FEEDBACK_FILE, JSON.stringify(this.entries, null, 2));
     } catch {
     }
   }
@@ -8006,7 +7582,7 @@ var PlaybackEngine = class _PlaybackEngine {
 // src/daemon/rpc-handlers.ts
 var activeRecorders = /* @__PURE__ */ new Map();
 var replayResumeResolvers = /* @__PURE__ */ new Map();
-var CONFIG_DIR3 = join8(homedir8(), ".xbrowser");
+var CONFIG_DIR3 = join7(homedir7(), ".xbrowser");
 var RECORDING_INJECT_JS = `
 (function(){
   if(window.__xb_rec) return;
@@ -8098,6 +7674,8 @@ function createRPCHandler() {
         // ── Utility ──
         case "ping":
           return { ok: true, pid: process.pid };
+        case "plugins:reload":
+          return handlePluginsReload();
         // ── Network analysis ──
         case "network:list":
           return handleNetworkList(params);
@@ -8284,6 +7862,13 @@ function createRPCHandler() {
     registerSessionIfNew(sessionName);
     return result;
   }
+  async function handlePluginsReload() {
+    const { resetPluginLoader } = await import("./plugin-singleton-ZBVTWEYK.js");
+    resetPluginLoader();
+    const loader = await import("./plugin-singleton-ZBVTWEYK.js").then((m) => m.getPluginLoader());
+    const sites = loader.getCore().loader.getSites();
+    return { ok: true, plugins: sites.length };
+  }
   async function handleAgentObserve(params) {
     const sessionName = params.session || "default";
     const commandParams = {
@@ -8454,10 +8039,10 @@ function createRPCHandler() {
     if (!sess) return { ok: false, error: "No session" };
     try {
       const events = await sess.page.evaluate(() => window.__xb_evts || []);
-      const recordingsDir = join8(CONFIG_DIR3, "recordings");
-      mkdirSync6(recordingsDir, { recursive: true });
-      const outPath = params.path || join8(recordingsDir, `recording-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`);
-      writeFileSync7(outPath, JSON.stringify({
+      const recordingsDir = join7(CONFIG_DIR3, "recordings");
+      mkdirSync5(recordingsDir, { recursive: true });
+      const outPath = params.path || join7(recordingsDir, `recording-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`);
+      writeFileSync5(outPath, JSON.stringify({
         startUrl: sess.page.url(),
         recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
         events
@@ -8557,13 +8142,19 @@ function createRPCHandler() {
   }
   async function handleRecordStop(params) {
     const sessionName = params.session || "default";
+    const outputPath = params.output;
     const recorder = activeRecorders.get(sessionName);
     if (!recorder) {
       const existingData = SessionRecorder.readData(sessionName);
       if (existingData) {
+        if (outputPath) {
+          const { writeFileSync: writeFileSync7 } = await import("fs");
+          writeFileSync7(outputPath, JSON.stringify(existingData, null, 2), "utf-8");
+        }
         return {
           ok: true,
           message: "Recorder process already exited. Recording data found on disk.",
+          output: outputPath,
           session: sessionName,
           actions: existingData.actions.length,
           network: existingData.network.length
@@ -8574,8 +8165,20 @@ function createRPCHandler() {
     try {
       const { data, summary } = await recorder.stop();
       activeRecorders.delete(sessionName);
+      if (outputPath) {
+        const { writeFileSync: writeFileSync7, mkdirSync: mkdirSync7 } = await import("fs");
+        const { dirname: dirname2 } = await import("path");
+        mkdirSync7(dirname2(outputPath), { recursive: true });
+        if (outputPath.endsWith(".yaml") || outputPath.endsWith(".yml")) {
+          const yaml2 = (await import("yaml")).default;
+          writeFileSync7(outputPath, yaml2.stringify(data), "utf-8");
+        } else {
+          writeFileSync7(outputPath, JSON.stringify(data, null, 2), "utf-8");
+        }
+      }
       return {
         ok: true,
+        output: outputPath,
         session: sessionName,
         actions: data.actions.length,
         network: data.network.length,
@@ -8664,8 +8267,13 @@ function createRPCHandler() {
     let rawContent;
     let parsed;
     try {
-      rawContent = readFileSync6(file, "utf8");
-      parsed = JSON.parse(rawContent);
+      rawContent = readFileSync5(file, "utf8");
+      try {
+        parsed = JSON.parse(rawContent);
+      } catch {
+        const yaml2 = (await import("yaml")).default;
+        parsed = yaml2.parse(rawContent);
+      }
     } catch (e) {
       return { ok: false, success: false, duration: 0, eventsPlayed: 0, totalEvents: 0, errors: [{ eventIndex: -1, error: "Failed to read/parse file: " + String(e) }] };
     }
@@ -8708,8 +8316,8 @@ function createRPCHandler() {
     const result = await engine.play({
       slowMo,
       onCheckpoint: async (checkpoint) => {
-        return new Promise((resolve3) => {
-          replayResumeResolvers.set(sessionName, () => resolve3(true));
+        return new Promise((resolve) => {
+          replayResumeResolvers.set(sessionName, () => resolve(true));
           console.log(`[replay] Checkpoint reached: [${checkpoint.type}] ${checkpoint.hint}`);
           console.log('[replay] Send "replay:resume" RPC to continue.');
         });
@@ -9773,13 +9381,13 @@ var FileListHandler = class {
   async handle(ctx) {
     const msg = ctx.message;
     try {
-      const { readdirSync: readdirSync2, statSync } = await import("fs");
-      const { join: join10, resolve: resolve3 } = await import("path");
-      const targetPath = resolve3(msg.path);
-      const entries = readdirSync2(targetPath);
+      const { readdirSync, statSync } = await import("fs");
+      const { join: join9, resolve } = await import("path");
+      const targetPath = resolve(msg.path);
+      const entries = readdirSync(targetPath);
       const files = entries.map((name) => {
         try {
-          const stat = statSync(join10(targetPath, name));
+          const stat = statSync(join9(targetPath, name));
           return { name, isDir: stat.isDirectory(), size: stat.size, modified: stat.mtime.toISOString() };
         } catch {
           return { name, isDir: false, size: 0, modified: "" };
@@ -9796,10 +9404,10 @@ var FileDownloadHandler = class {
   async handle(ctx) {
     const msg = ctx.message;
     try {
-      const { readFileSync: readFileSync7 } = await import("fs");
-      const { resolve: resolve3, basename } = await import("path");
-      const targetPath = resolve3(msg.path);
-      const data = readFileSync7(targetPath);
+      const { readFileSync: readFileSync6 } = await import("fs");
+      const { resolve, basename } = await import("path");
+      const targetPath = resolve(msg.path);
+      const data = readFileSync6(targetPath);
       const base64 = data.toString("base64");
       const ext = targetPath.split(".").pop()?.toLowerCase() || "";
       const mimeMap = {
@@ -10103,7 +9711,7 @@ var WSServer = class extends EventEmitter2 {
       this.isRunning = false;
       return;
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve, reject) => {
       this.wsServer.close((err) => {
         if (err) {
           reject(err);
@@ -10111,7 +9719,7 @@ var WSServer = class extends EventEmitter2 {
           this.wsServer = null;
           this.isRunning = false;
           this.emit("stopped");
-          resolve3();
+          resolve();
         }
       });
     });
@@ -11440,8 +11048,8 @@ connectWS();
 }
 
 // src/daemon/daemon-main.ts
-var CONFIG_DIR4 = join9(homedir9(), ".xbrowser");
-var LOG_FILE = join9(CONFIG_DIR4, "daemon.log");
+var CONFIG_DIR4 = join8(homedir8(), ".xbrowser");
+var LOG_FILE = join8(CONFIG_DIR4, "daemon.log");
 function log(msg) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
   const line = `[DAEMON ${ts}] ${msg}
@@ -11473,7 +11081,7 @@ async function main() {
     if (err.code === "EADDRINUSE") {
       log(`Port ${daemonPort} already in use \u2014 another daemon instance likely won the startup race. Exiting gracefully.`);
       try {
-        unlinkSync(join9(CONFIG_DIR4, "daemon.json"));
+        unlinkSync(join8(CONFIG_DIR4, "daemon.json"));
       } catch {
       }
       process.exit(0);
@@ -11507,8 +11115,8 @@ async function main() {
   rpcHandler.setPreviewWS(previewWS);
   previewWS.on("screencast-started", (sid) => log(`Preview screencast started: ${sid}`));
   previewWS.on("screencast-stopped", (sid) => log(`Preview screencast stopped: ${sid}`));
-  mkdirSync7(CONFIG_DIR4, { recursive: true });
-  writeFileSync8(join9(CONFIG_DIR4, "daemon.json"), JSON.stringify({
+  mkdirSync6(CONFIG_DIR4, { recursive: true });
+  writeFileSync6(join8(CONFIG_DIR4, "daemon.json"), JSON.stringify({
     port: daemonPort,
     pid: process.pid,
     startedAt: Date.now()