@xbrowser/cli 1.2.1 → 1.2.2

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/chunk-PHBK3TRN.js

@@ -0,0 +1,436 @@
+// 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) {
+          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;
+}
+function resetPluginLoader() {
+  pluginLoader = null;
+  pluginsScanned = false;
+}
+
+export {
+  getPluginLoader,
+  resetPluginLoader
+};

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(),
@@ -7048,7 +7048,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;
   }
@@ -10272,6 +10272,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 +10439,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 +10449,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,
@@ -12549,7 +12563,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);

package/dist/{daemon-client-ZHO6NG36.js → daemon-client-XXKMJZZ7.js}

@@ -29,7 +29,7 @@ import {
   forwardSessionList,
   forwardViewerCheckSelector,
   isDaemonRunning
-} from "./chunk-XYXCS7JW.js";
+} from "./chunk-JPSFUFPG.js";
 import "./chunk-GDKLH7ZY.js";
 import "./chunk-KFQGP6VL.js";
 export {