@xbrowser/cli 1.2.1 → 1.3.0

package/dist/chunk-2QQDTXDL.js

@@ -0,0 +1,438 @@
+// src/plugin/loader.ts
+import {
+  Core
+} from "@dyyz1993/xcli-core";
+import { resolve as resolve2 } from "path";
+import { existsSync as existsSync3, readdirSync } from "fs";
+import { homedir } from "os";
+
+// src/plugin/metadata-parser.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+
+// src/utils/json-file.ts
+import { readFileSync, writeFileSync } from "fs";
+function readJsonFile(filePath, defaultValue) {
+  try {
+    const content = readFileSync(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 (!existsSync(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 existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join } 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 = join(pluginsDir, "node_modules", "zod");
+  if (existsSync2(zodPath)) return;
+  mkdirSync(pluginsDir, { recursive: true });
+  const pkgPath = join(pluginsDir, "package.json");
+  let pkg = {};
+  if (existsSync2(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 && existsSync2(join(pluginsDir, "node_modules"))) return;
+  pkg.dependencies = existingDeps;
+  pkg.private = true;
+  pkg.description = pkg.description || "xbrowser plugins \u2014 shared dependencies";
+  writeFileSync2(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(homedir(), ".xbrowser/plugins");
+    ensurePluginDependencies(globalDir);
+    const dirs = [
+      resolve2(cwd, ".xcli/plugins"),
+      resolve2(cwd, "../.xcli/plugins"),
+      this.options.userDir || resolve2(homedir(), ".xcli/plugins"),
+      globalDir
+    ];
+    const loaded = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const dir of dirs) {
+      if (!existsSync3(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 (!existsSync3(indexPath)) {
+          indexPath = resolve2(pluginDir, "index.ts");
+        }
+        if (!existsSync3(indexPath)) continue;
+        try {
+          if (!existsSync3(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) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          console.warn(`\u26A0\uFE0F  Plugin "${entry.name}" load failed: ${errMsg}`);
+          if (errMsg.includes("Cannot find module") && errMsg.includes("shared/")) {
+            console.warn(`   \u{1F4A1} This plugin needs shared/ dependencies. Try: xbrowser plugin install shared`);
+          }
+        }
+      }
+    }
+    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;
+}
+function resetPluginLoader() {
+  pluginLoader = null;
+  pluginsScanned = false;
+}
+
+export {
+  getPluginLoader,
+  resetPluginLoader
+};

package/dist/{chunk-XYXCS7JW.js → chunk-JPSFUFPG.js}

@@ -279,8 +279,10 @@ async function forwardNetworkInspect(sessionName, id) {
 async function forwardRecordStart(session, url, cdpEndpoint) {
   return rpcCall("record:start", { session, url, cdpEndpoint }, 15e3);
 }
-async function forwardRecordStop(session) {
-  return rpcCall("record:stop", { session }, 1e4);
+async function forwardRecordStop(session, output) {
+  const params = { session };
+  if (output) params.output = output;
+  return rpcCall("record:stop", params, 1e4);
 }
 async function forwardRecordStatus(session) {
   return rpcCall("record:status", { session }, 5e3);

package/dist/cli.js

@@ -54,7 +54,7 @@ import {
   killAllDaemonProcesses,
   startDaemonProcess,
   stopDaemonProcess
-} from "./chunk-XYXCS7JW.js";
+} from "./chunk-JPSFUFPG.js";
 import {
   errMsg
 } from "./chunk-GDKLH7ZY.js";
@@ -949,10 +949,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(),
@@ -6331,8 +6331,10 @@ var XBrowserPluginLoader = class {
           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)}`);
+          const errMsg2 = err instanceof Error ? err.message : String(err);
+          console.warn(`\u26A0\uFE0F  Plugin "${entry.name}" load failed: ${errMsg2}`);
+          if (errMsg2.includes("Cannot find module") && errMsg2.includes("shared/")) {
+            console.warn(`   \u{1F4A1} This plugin needs shared/ dependencies. Try: xbrowser plugin install shared`);
           }
         }
       }
@@ -7048,7 +7050,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-ZHO6NG36.js");
+    const { forwardExec } = await import("./daemon-client-XXKMJZZ7.js");
     const result = await forwardExec(commandName, params, sessionName, extraOpts?.cdpEndpoint);
     if (result) return result;
   }
@@ -7734,9 +7736,12 @@ import {
   existsSync as existsSync10,
   readdirSync as readdirSync2,
   mkdirSync as mkdirSync8,
-  rmSync as rmSync6
+  rmSync as rmSync6,
+  copyFileSync,
+  cpSync as cpSync6,
+  readFileSync as readFileSync8
 } from "fs";
-import { resolve as resolve8, basename as basename2 } from "path";
+import { resolve as resolve8, basename as basename2, dirname as dirname3 } from "path";
 import { homedir as homedir8 } from "os";
 
 // src/plugin/install-sources/local.ts
@@ -8229,28 +8234,103 @@ var PluginInstaller = class {
     switch (type) {
       case "local":
         return await installFromLocal(source, name, targetDir).then((r) => {
+          this.fixSharedDeps(targetDir);
           ensurePluginDependencies(this.pluginsDir);
           return r;
         });
       case "npm":
         return await installFromNpm(resolvedSource, name, targetDir).then((r) => {
+          this.fixSharedDeps(targetDir);
           ensurePluginDependencies(this.pluginsDir);
           return r;
         });
       case "git":
         return await installFromGit(source, name, targetDir).then((r) => {
+          this.fixSharedDeps(targetDir);
           ensurePluginDependencies(this.pluginsDir);
           return r;
         });
       case "url":
         return await installFromUrl(source, name, targetDir).then((r) => {
+          this.fixSharedDeps(targetDir);
           ensurePluginDependencies(this.pluginsDir);
           return r;
         });
     }
   }
+  /**
+   * Fix missing `../shared/` dependencies after installation.
+   *
+   * Some marketplace/npm packages import from `../shared/` (e.g. ssr-detect.js,
+   * ai-chat-base.ts) but the `shared/` directory is not included in the package.
+   * This method scans the installed plugin's index.ts for such imports and
+   * copies the missing files from the local repository's `.xcli/plugins/shared/`
+   * directory (if available).
+   */
+  fixSharedDeps(pluginDir) {
+    const indexPath = resolve8(pluginDir, "index.ts");
+    if (!existsSync10(indexPath)) return;
+    let content;
+    try {
+      content = readFileSync8(indexPath, "utf8");
+    } catch {
+      return;
+    }
+    const sharedImportRegex = /from\s+['"]\.\.\/shared\/([^'"]+)['"]/g;
+    const missingFiles = [];
+    let match;
+    while ((match = sharedImportRegex.exec(content)) !== null) {
+      missingFiles.push(match[1]);
+    }
+    if (missingFiles.length === 0) return;
+    const sharedDir = resolve8(pluginDir, "..", "shared");
+    const toCopy = [];
+    for (const file of missingFiles) {
+      const targetPath = resolve8(sharedDir, file);
+      if (!existsSync10(targetPath)) {
+        toCopy.push(file);
+      }
+    }
+    if (toCopy.length === 0) return;
+    const repoSharedDirs = [
+      resolve8(process.cwd(), ".xcli/plugins/shared"),
+      resolve8(homedir8(), ".xbrowser/plugins/shared")
+    ];
+    let sourceSharedDir = null;
+    for (const dir of repoSharedDirs) {
+      if (existsSync10(dir)) {
+        sourceSharedDir = dir;
+        break;
+      }
+    }
+    if (!sourceSharedDir) {
+      console.warn(`\u26A0\uFE0F  Plugin "${basename2(pluginDir)}" imports shared files but they are missing: ${toCopy.join(", ")}`);
+      console.warn(`   To fix: install the "shared" plugin or copy .xcli/plugins/shared/ to ~/.xbrowser/plugins/shared/`);
+      return;
+    }
+    mkdirSync8(sharedDir, { recursive: true });
+    for (const file of toCopy) {
+      const src = resolve8(sourceSharedDir, file);
+      const dst = resolve8(sharedDir, file);
+      if (existsSync10(src)) {
+        try {
+          cpSync6(dirname3(src), dirname3(dst), { recursive: true });
+          console.log(`\u2705 Copied shared/${file} for plugin "${basename2(pluginDir)}"`);
+        } catch {
+          try {
+            copyFileSync(src, dst);
+            console.log(`\u2705 Copied shared/${file} for plugin "${basename2(pluginDir)}"`);
+          } catch {
+            console.warn(`\u26A0\uFE0F  Could not copy shared/${file}`);
+          }
+        }
+      }
+    }
+  }
   async installFromMarketplace(slug, options) {
     const result = await installFromMarketplace(this.pluginsDir, slug, options);
+    const targetDir = resolve8(this.pluginsDir, result.name);
+    this.fixSharedDeps(targetDir);
     ensurePluginDependencies(this.pluginsDir);
     return result;
   }
@@ -10272,6 +10352,18 @@ async function handlePlugin(args, options, mode) {
         await (await getPluginLoader()).reloadPlugin(result.name);
       } catch {
       }
+      try {
+        const { daemonPing } = await import("./daemon-client-XXKMJZZ7.js");
+        if (await daemonPing()) {
+          await fetch("http://localhost:9224/rpc", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ method: "plugins:reload", params: {} }),
+            signal: AbortSignal.timeout(5e3)
+          });
+        }
+      } catch {
+      }
       outputResult(
         { ok: true, name: result.name, source: result.source, path: result.path },
         mode
@@ -10427,7 +10519,8 @@ async function handleRecord(args, options, mode) {
     }
     case "stop": {
       const sessionName = options.session || "default";
-      const result = await forwardRecordStop(sessionName);
+      const output = options.output || options.o;
+      const result = await forwardRecordStop(sessionName, output);
       if (!result.ok) {
         outputError(String(result.error || "Failed to stop recording"));
         return;
@@ -10436,6 +10529,7 @@ async function handleRecord(args, options, mode) {
         ok: true,
         message: "Recording stopped.",
         sessionName,
+        output: result.output || (output || SessionRecorder.getRecordingsDir(sessionName) + "/recording.json"),
         actions: result.actions,
         network: result.network,
         durationMs: result.durationMs,
@@ -11299,7 +11393,7 @@ async function handleNetCommand(args, options, mode, sessionName) {
 
 // src/cli/test-routes.ts
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { resolve as resolve9 } from "path";
 function findPluginPath(plugin) {
   const candidates = [
@@ -11308,7 +11402,7 @@ function findPluginPath(plugin) {
   ];
   for (const p of candidates) {
     try {
-      readFileSync8(p, "utf-8");
+      readFileSync9(p, "utf-8");
       return p;
     } catch {
     }
@@ -11319,7 +11413,7 @@ function extractSchema(plugin, command) {
   const pluginPath = findPluginPath(plugin);
   let src;
   try {
-    src = readFileSync8(pluginPath, "utf-8");
+    src = readFileSync9(pluginPath, "utf-8");
   } catch {
     return null;
   }
@@ -12549,7 +12643,7 @@ Run "xbrowser ${command} ${subCommand} --help" to see available parameters.`
           }
           const needsBrowser = cmdEntry.scope === "page" || cmdEntry.scope === "browser";
           if (needsBrowser && !process.env.XBROWSER_DAEMON_WORKER) {
-            const { forwardExec } = await import("./daemon-client-ZHO6NG36.js");
+            const { forwardExec } = await import("./daemon-client-XXKMJZZ7.js");
             const userTimeout = typeof params.timeout === "number" && params.timeout > 0 ? params.timeout * 1e3 + 3e4 : void 0;
             const result = await forwardExec(`${command}.${subCommand}`, params, sessionName, cdpEndpoint, userTimeout);
             const resultData = result && typeof result === "object" && "data" in result ? result.data : void 0;

package/dist/{daemon-client-R4QWHD7V.js → daemon-client-COJQESU2.js}

@@ -162,8 +162,10 @@ async function forwardNetworkInspect(sessionName, id) {
 async function forwardRecordStart(session, url, cdpEndpoint) {
   return rpcCall("record:start", { session, url, cdpEndpoint }, 15e3);
 }
-async function forwardRecordStop(session) {
-  return rpcCall("record:stop", { session }, 1e4);
+async function forwardRecordStop(session, output) {
+  const params = { session };
+  if (output) params.output = output;
+  return rpcCall("record:stop", params, 1e4);
 }
 async function forwardRecordStatus(session) {
   return rpcCall("record:status", { session }, 5e3);