@xbrowser/cli 1.8.7 → 1.9.1

package/dist/index.js

@@ -50,14 +50,14 @@ import {
   extractAndSave,
   extractRecording,
   printExtractSummary
-} from "./chunk-MJFYLKGL.js";
+} from "./chunk-X46HDAOT.js";
 import {
   filterRecording,
   parseExcludeTypes
-} from "./chunk-GJAV3QGG.js";
+} from "./chunk-ANVL2ID2.js";
 import {
   SessionRecorder
-} from "./chunk-RMYEHTLS.js";
+} from "./chunk-YSCY52UJ.js";
 import {
   addKnownIssue,
   getKnowledgePath,
@@ -82,7 +82,7 @@ import {
   resolveLaunchOpts,
   saveSessionDiskMeta,
   setActivePage
-} from "./chunk-CJJ564VK.js";
+} from "./chunk-MSQIPXKE.js";
 import "./chunk-VJNMAWPZ.js";
 import "./chunk-TNEN6VQ2.js";
 import {
@@ -109,7 +109,7 @@ import {
 // src/executor.ts
 import {
   ok as ok25,
-  fail as fail9,
+  fail as fail11,
   isCommandResult,
   CompositeStorage as CompositeStorage2,
   TipCollector as TipCollector2,
@@ -993,7 +993,7 @@ var evaluateCommand = registerCommand({
 
 // src/commands/storage.ts
 import { z as z8 } from "zod";
-import { ok as ok8 } from "@dyyz1993/xcli-core";
+import { ok as ok8, fail as fail2 } from "@dyyz1993/xcli-core";
 var getCookiesCommand = registerCommand({
   name: "get-cookies",
   description: "Get all cookies for the current page",
@@ -1015,6 +1015,7 @@ var setCookieCommand = registerCommand({
     value: z8.coerce.string(),
     domain: z8.coerce.string().optional(),
     path: z8.coerce.string().optional(),
+    url: z8.string().optional().describe("Cookie URL (alternative to domain)"),
     expires: z8.number().optional(),
     httpOnly: z8.boolean().optional(),
     secure: z8.boolean().optional(),
@@ -1034,6 +1035,9 @@ var setCookieCommand = registerCommand({
         }
       }
     }
+    if (!cookie.domain && !cookie.url) {
+      return fail2("set-cookie requires --domain or --url, or a non-blank page URL to infer from");
+    }
     await ctx.browserContext.addCookies([cookie]);
     return ok8({ name: p.name });
   }
@@ -1060,19 +1064,23 @@ var getLocalStorageCommand = registerCommand({
     z8.object({ data: z8.record(z8.string()) })
   ]),
   handler: async (p, ctx) => {
-    if (p.key) {
-      const value = await ctx.page.evaluate((k) => localStorage.getItem(k), p.key);
-      return ok8({ key: p.key, value });
+    try {
+      if (p.key) {
+        const value = await ctx.page.evaluate((k) => localStorage.getItem(k), p.key);
+        return ok8({ key: p.key, value });
+      }
+      const data = await ctx.page.evaluate(() => {
+        const entries = {};
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (key) entries[key] = localStorage.getItem(key) ?? "";
+        }
+        return entries;
+      });
+      return ok8({ data });
+    } catch (e) {
+      return fail2(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
     }
-    const data = await ctx.page.evaluate(() => {
-      const entries = {};
-      for (let i = 0; i < localStorage.length; i++) {
-        const key = localStorage.key(i);
-        if (key) entries[key] = localStorage.getItem(key) ?? "";
-      }
-      return entries;
-    });
-    return ok8({ data });
   }
 });
 var setLocalStorageCommand = registerCommand({
@@ -1085,13 +1093,17 @@ var setLocalStorageCommand = registerCommand({
   }),
   result: z8.object({ key: z8.string() }),
   handler: async (p, ctx) => {
-    await ctx.page.evaluate(
-      (args) => {
-        localStorage.setItem(args.key, args.value);
-      },
-      { key: p.key, value: p.value }
-    );
-    return ok8({ key: p.key });
+    try {
+      await ctx.page.evaluate(
+        (args) => {
+          localStorage.setItem(args.key, args.value);
+        },
+        { key: p.key, value: p.value }
+      );
+      return ok8({ key: p.key });
+    } catch (e) {
+      return fail2(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
+    }
   }
 });
 var clearLocalStorageCommand = registerCommand({
@@ -1100,21 +1112,35 @@ var clearLocalStorageCommand = registerCommand({
   scope: "page",
   result: z8.object({ cleared: z8.boolean() }),
   handler: async (_p, ctx) => {
-    await ctx.page.evaluate(() => localStorage.clear());
-    return ok8({ cleared: true });
+    try {
+      await ctx.page.evaluate(() => localStorage.clear());
+      return ok8({ cleared: true });
+    } catch (e) {
+      return fail2(`localStorage not accessible on this page: ${e instanceof Error ? e.message : String(e)}`);
+    }
   }
 });
 
 // src/commands/screenshot.ts
 import { z as z9 } from "zod";
-import { ok as ok9 } from "@dyyz1993/xcli-core";
+import { ok as ok9, fail as fail3 } from "@dyyz1993/xcli-core";
 import { writeFileSync, mkdirSync } from "fs";
-import { join as join2 } from "path";
+import { dirname, join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 var SCREENSHOTS_DIR = join2(homedir2(), ".xbrowser", "screenshots");
 function ensureScreenshotsDir() {
   mkdirSync(SCREENSHOTS_DIR, { recursive: true });
 }
+function ensureParentDir(filePath) {
+  const dir = dirname(filePath);
+  if (dir === "." || dir === "/") return null;
+  try {
+    mkdirSync(dir, { recursive: true });
+    return null;
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+}
 function generateScreenshotPath(format) {
   const timestamp = Date.now();
   const random = Math.random().toString(36).slice(2, 8);
@@ -1158,7 +1184,15 @@ var screenshotCommand = registerCommand({
       buffer = await ctx.page.screenshot(options);
     }
     if (p.output) {
-      writeFileSync(p.output, buffer, "binary");
+      const dirErr = ensureParentDir(p.output);
+      if (dirErr) {
+        return fail3(`Cannot create directory for --output "${p.output}": ${dirErr}`);
+      }
+      try {
+        writeFileSync(p.output, buffer, "binary");
+      } catch (err) {
+        return fail3(`Failed to write screenshot to "${p.output}": ${err instanceof Error ? err.message : String(err)}`);
+      }
       return ok9({
         output: p.output,
         format,
@@ -1276,7 +1310,7 @@ var setViewportCommand = registerCommand({
 
 // src/commands/frame.ts
 import { z as z12 } from "zod";
-import { ok as ok12, fail as fail2 } from "@dyyz1993/xcli-core";
+import { ok as ok12, fail as fail4 } from "@dyyz1993/xcli-core";
 var framesCommand = registerCommand({
   name: "frames",
   description: "List all frames in the current page",
@@ -1301,10 +1335,10 @@ var framesCommand = registerCommand({
 });
 var frameCommand = registerCommand({
   name: "frame",
-  description: "Switch to a frame by index or name",
+  description: "Get frame info by index or name",
   scope: "page",
   parameters: z12.object({
-    index: z12.number().optional(),
+    index: z12.number().int().min(0).optional(),
     name: z12.string().optional()
   }),
   result: z12.object({
@@ -1321,10 +1355,10 @@ var frameCommand = registerCommand({
     } else if (p.name !== void 0) {
       targetFrame = rawFrames.find((f) => f.name() === p.name);
     } else {
-      return fail2("Must provide index or name");
+      return fail4("Must provide index or name");
     }
     if (!targetFrame) {
-      return fail2("Frame not found");
+      return fail4("Frame not found");
     }
     return ok12({
       name: targetFrame.name(),
@@ -1970,7 +2004,7 @@ var actionsCommand = registerCommand({
 
 // src/commands/scrape.ts
 import { z as z15 } from "zod";
-import { ok as ok15, fail as fail3 } from "@dyyz1993/xcli-core";
+import { ok as ok15, fail as fail5 } from "@dyyz1993/xcli-core";
 
 // src/lib/html-to-markdown.ts
 import * as cheerio from "cheerio";
@@ -2371,7 +2405,7 @@ var scrapeCommand = registerCommand({
     try {
       const targetUrl = p.url || page.url();
       if (!targetUrl || targetUrl === "about:blank") {
-        return fail3("URL is required. Provide a URL or connect to a browser (--cdp) with a non-blank page.");
+        return fail5("URL is required. Provide a URL or connect to a browser (--cdp) with a non-blank page.");
       }
       let lastError;
       for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -2525,7 +2559,7 @@ var scrapeCommand = registerCommand({
           }
         }
       }
-      return fail3(`Scrape failed after ${maxAttempts} attempt(s): ${lastError?.message ?? "unknown error"}`);
+      return fail5(`Scrape failed after ${maxAttempts} attempt(s): ${lastError?.message ?? "unknown error"}`);
     } finally {
       await closeEphemeralContext(context);
     }
@@ -2538,7 +2572,7 @@ var scrapeCommand = registerCommand({
 
 // src/commands/map.ts
 import { z as z16 } from "zod";
-import { ok as ok16, fail as fail4 } from "@dyyz1993/xcli-core";
+import { ok as ok16, fail as fail6 } from "@dyyz1993/xcli-core";
 
 // src/utils/url.ts
 var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -2787,7 +2821,7 @@ var mapCommand = registerCommand({
     try {
       const targetUrl = p.url || page.url();
       if (!targetUrl || targetUrl === "about:blank") {
-        return fail4("URL is required. Provide a URL or connect to a browser (--cdp) with a non-blank page.");
+        return fail6("URL is required. Provide a URL or connect to a browser (--cdp) with a non-blank page.");
       }
       const links = await discoverUrls(page, targetUrl, {
         sitemap: p.sitemap,
@@ -3632,7 +3666,7 @@ ${errors.map((e) => `  - ${e.engine}: ${e.error}`).join("\n")}`
 
 // src/commands/network.ts
 import { z as z19 } from "zod";
-import { ok as ok19, fail as fail5 } from "@dyyz1993/xcli-core";
+import { ok as ok19, fail as fail7 } from "@dyyz1993/xcli-core";
 function extractPath2(url) {
   try {
     const u = new URL(url);
@@ -3797,7 +3831,7 @@ var networkCommand = registerCommand({
     };
     if (p.listen) {
       const page2 = ctx.page;
-      if (!page2) return fail5("No active page. Use --cdp to connect first.");
+      if (!page2) return fail7("No active page. Use --cdp to connect first.");
       const captures = [];
       const consoleMessages = [];
       const wsCaptures = [];
@@ -4454,7 +4488,7 @@ function parseMarkdownResults(rawText) {
 
 // src/commands/snapshot.ts
 import { z as z21 } from "zod";
-import { ok as ok20, fail as fail6, normalizeTips as normalizeTips3 } from "@dyyz1993/xcli-core";
+import { ok as ok20, fail as fail8, normalizeTips as normalizeTips3 } from "@dyyz1993/xcli-core";
 
 // src/runtime/ref-store.ts
 var sessions = /* @__PURE__ */ new Map();
@@ -4696,7 +4730,7 @@ async function resolveRefParams(page, params, selectorKeys, cache, sessionId) {
 
 // src/utils/site-semantics.ts
 import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync, readFileSync } from "fs";
-import { join as join4, dirname } from "path";
+import { join as join4, dirname as dirname2 } from "path";
 import { homedir as homedir4 } from "os";
 import { stringify, parse } from "yaml";
 import { execFile } from "child_process";
@@ -4789,7 +4823,7 @@ function extractDomain2(url) {
 }
 function saveSemantics(domain, pagePath, url, elements) {
   const filePath = getSemanticsPath(domain);
-  const dir = dirname(filePath);
+  const dir = dirname2(filePath);
   let site;
   if (existsSync(filePath)) {
     try {
@@ -5425,7 +5459,7 @@ var snapshotCommand = registerCommand({
       persistSemantics(url, aria);
       return ok20({ url, title, aria, text, dom }, normalizeTips3(tips));
     }
-    return fail6(`Unknown snapshot type: ${p.type}`);
+    return fail8(`Unknown snapshot type: ${p.type}`);
   }
 });
 function persistSemantics(url, aria) {
@@ -5594,7 +5628,7 @@ var waitForCommand = registerCommand({
 
 // src/commands/tab.ts
 import { z as z23 } from "zod";
-import { ok as ok22, fail as fail7 } from "@dyyz1993/xcli-core";
+import { ok as ok22, fail as fail9 } from "@dyyz1993/xcli-core";
 var TabParams = z23.object({
   subcommand: z23.enum(["list", "new", "close", "switch"]),
   url: z23.string().optional(),
@@ -5611,7 +5645,7 @@ var tabCommand = registerCommand({
   }),
   handler: async (p, ctx) => {
     if (!ctx.browserContext) {
-      return fail7("No browser context available. Use --cdp to connect to a browser first.");
+      return fail9("No browser context available. Use --cdp to connect to a browser first.");
     }
     const pages = ctx.browserContext.pages();
     switch (p.subcommand) {
@@ -5620,50 +5654,45 @@ var tabCommand = registerCommand({
       case "new":
         return handleNew(p, pages, ctx);
       case "close":
-        return handleClose(p, pages, ctx);
+        return handleClose(p, ctx);
       case "switch":
         return handleSwitch(p, pages, ctx);
       default:
-        return fail7(`Unknown subcommand: ${p.subcommand}`);
+        return fail9(`Unknown subcommand: ${p.subcommand}`);
     }
   }
 });
-function handleList(pages, ctx) {
-  const currentIndex = pages.indexOf(ctx.page);
-  const tabs = pages.map((page, i) => {
+async function handleList(pages, ctx) {
+  const tabs = [];
+  let activeIndex = -1;
+  for (let i = 0; i < pages.length; i++) {
+    const page = pages[i];
     const url = page.url();
-    let title = "";
-    try {
-      const t = page.title();
-      if (t instanceof Promise) {
-        void t.then((v) => {
-          title = v;
-        });
-      }
-    } catch {
-      title = "";
-    }
-    return {
-      index: i,
-      url,
-      title,
-      active: i === currentIndex
-    };
-  });
-  return ok22({ tabs, total: tabs.length, activeIndex: currentIndex });
+    const title = await page.title().catch(() => "");
+    const isActive = page === ctx.page;
+    if (isActive) activeIndex = i;
+    tabs.push({ index: i, url, title, active: isActive });
+  }
+  return ok22({ tabs, total: tabs.length, activeIndex });
 }
 async function handleNew(p, _pages, ctx) {
   const newPage = await ctx.browserContext.newPage();
+  const warnings = [];
   if (p.url) {
     let url = p.url;
-    if (!/^https?:\/\//i.test(url)) {
+    if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(url)) {
       url = "https://" + url;
     }
-    await newPage.goto(url, { waitUntil: "domcontentloaded", timeout: 15e3 }).catch(() => {
-    });
+    try {
+      await newPage.goto(url, { waitUntil: "domcontentloaded", timeout: 15e3 });
+    } catch (err) {
+      warnings.push(`Navigation to "${url}" failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  try {
+    await newPage.waitForLoadState("domcontentloaded");
+  } catch {
   }
-  await newPage.waitForLoadState("domcontentloaded").catch(() => {
-  });
   const session = ctx.sessionId ? getSessionById(ctx.sessionId) : void 0;
   if (session) {
     setActivePage(session, newPage);
@@ -5676,18 +5705,20 @@ async function handleNew(p, _pages, ctx) {
     index: newIndex >= 0 ? newIndex : allPages.length - 1,
     url: newPage.url(),
     title,
-    total: allPages.length
+    total: allPages.length,
+    ...warnings.length > 0 ? { warning: warnings.join("; ") } : {}
   });
 }
-async function handleClose(p, pages, ctx) {
-  if (pages.length <= 1) {
-    return fail7("Cannot close the last remaining tab");
+async function handleClose(p, ctx) {
+  const currentPages = ctx.browserContext.pages();
+  if (currentPages.length <= 1) {
+    return fail9("Cannot close the last remaining tab");
   }
-  const closeIndex = p.index ?? pages.indexOf(ctx.page);
-  if (closeIndex < 0 || closeIndex >= pages.length) {
-    return fail7(`Invalid tab index: ${closeIndex}. Valid range: 0-${pages.length - 1}`);
+  const closeIndex = p.index ?? currentPages.findIndex((pg) => pg === ctx.page);
+  if (closeIndex < 0 || closeIndex >= currentPages.length) {
+    return fail9(`Invalid tab index: ${closeIndex}. Valid range: 0-${currentPages.length - 1}`);
   }
-  const pageToClose = pages[closeIndex];
+  const pageToClose = currentPages[closeIndex];
   const isActivePage = pageToClose === ctx.page;
   await pageToClose.close();
   const remainingPages = ctx.browserContext.pages();
@@ -5703,15 +5734,15 @@ async function handleClose(p, pages, ctx) {
   return ok22({
     closedIndex: closeIndex,
     total: remainingPages.length,
-    activeIndex: isActivePage ? closeIndex < remainingPages.length ? closeIndex : remainingPages.length - 1 : pages.indexOf(ctx.page)
+    activeIndex: isActivePage ? closeIndex < remainingPages.length ? closeIndex : remainingPages.length - 1 : remainingPages.findIndex((pg) => pg === ctx.page)
   });
 }
 async function handleSwitch(p, pages, ctx) {
   if (p.index === void 0) {
-    return fail7("Parameter --index is required for switch subcommand");
+    return fail9("Parameter --index is required for switch subcommand");
   }
   if (p.index < 0 || p.index >= pages.length) {
-    return fail7(`Invalid tab index: ${p.index}. Valid range: 0-${pages.length - 1}`);
+    return fail9(`Invalid tab index: ${p.index}. Valid range: 0-${pages.length - 1}`);
   }
   const targetPage = pages[p.index];
   await targetPage.bringToFront().catch(() => {
@@ -5963,7 +5994,7 @@ registerCommandDefinition("addinitscript", ["script"]);
 
 // src/commands/find.ts
 import { z as z25 } from "zod";
-import { ok as ok24, fail as fail8, normalizeTips as normalizeTips5 } from "@dyyz1993/xcli-core";
+import { ok as ok24, fail as fail10, normalizeTips as normalizeTips5 } from "@dyyz1993/xcli-core";
 var actionSchema2 = z25.enum(["click", "fill", "type", "select", "hover", "check"]);
 var findCommand = registerCommand({
   name: "find",
@@ -6004,7 +6035,7 @@ var findCommand = registerCommand({
     });
     const count = await locator.count();
     if (count === 0) {
-      return fail8(`No element found with ${p.strategy}="${p.value}"`);
+      return fail10(`No element found with ${p.strategy}="${p.value}"`);
     }
     const tips = [];
     const target = selectTarget(locator, p.strategy);
@@ -6016,15 +6047,15 @@ var findCommand = registerCommand({
       await target.click({ timeout: p.timeout, force: true });
       return okWithTips({ matched: count, selector, action: "click" }, tips);
     } else if (actionName === "fill") {
-      if (actionValue === void 0) return fail8("find fill requires a value");
+      if (actionValue === void 0) return fail10("find fill requires a value");
       await target.fill(actionValue, { timeout: p.timeout, force: true });
       return okWithTips({ matched: count, selector, action: `fill("${actionValue}")` }, tips);
     } else if (actionName === "type") {
-      if (actionValue === void 0) return fail8("find type requires a value");
+      if (actionValue === void 0) return fail10("find type requires a value");
       await target.type(actionValue, { delay: 10, timeout: p.timeout });
       return okWithTips({ matched: count, selector, action: `type("${actionValue}")` }, tips);
     } else if (actionName === "select") {
-      if (actionValue === void 0) return fail8("find select requires a value");
+      if (actionValue === void 0) return fail10("find select requires a value");
       await target.selectOption(actionValue);
       return okWithTips({ matched: count, selector, action: `select("${actionValue}")` }, tips);
     } else if (actionName === "hover") {
@@ -6797,12 +6828,24 @@ var XBrowserPluginLoader = class {
 // src/utils/plugin-singleton.ts
 var pluginLoader = null;
 var pluginsScanned = false;
+function silenceSchemaWarnings(fn) {
+  if (process.env.XBROWSER_DEBUG || process.env.VITEST_WORKER_ID) return fn();
+  const originalWarn = console.warn;
+  console.warn = (...args) => {
+    const msg = typeof args[0] === "string" ? args[0] : "";
+    if (msg.includes('has no "result" schema')) return;
+    originalWarn(...args);
+  };
+  return fn().finally(() => {
+    console.warn = originalWarn;
+  });
+}
 async function getPluginLoader() {
   if (!pluginLoader) {
     pluginLoader = new XBrowserPluginLoader();
   }
   if (!pluginsScanned) {
-    await pluginLoader.scanAndLoad();
+    await silenceSchemaWarnings(() => pluginLoader.scanAndLoad());
     pluginsScanned = true;
   }
   return pluginLoader;
@@ -7460,7 +7503,7 @@ async function guardCheck(commandName) {
   }
 }
 function errorResult(message) {
-  return { ...fail9(message), duration: 0 };
+  return { ...fail11(message), duration: 0 };
 }
 function tipsToMessages(tips) {
   if (!tips || tips.length === 0) return [];
@@ -7540,7 +7583,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
   }
   let targetPageOverride = null;
   if (_target && extraOpts?.cdpEndpoint) {
-    const { findTargetPage } = await import("./browser-TLIDFFEG.js");
+    const { findTargetPage } = await import("./browser-C63PFGPT.js");
     targetPageOverride = await findTargetPage(extraOpts.cdpEndpoint, _target);
     if (!targetPageOverride) {
       return errorResult(`Target "${_target}" not found. Use 'xbrowser targets --cdp ${extraOpts.cdpEndpoint}' to list available pages.`);
@@ -7764,7 +7807,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
       duration,
       timestamp: start
     });
-    return { ...fail9(errorMessage), duration };
+    return { ...fail11(errorMessage), duration };
   } finally {
   }
 }
@@ -7805,7 +7848,7 @@ async function executeChain(input, options) {
             results.push({
               command: cmdName,
               raw: cmdStr,
-              ...fail9(`Plugin "${cmdName}" requires a sub-command`),
+              ...fail11(`Plugin "${cmdName}" requires a sub-command`),
               duration: 0
             });
             if (type === "and") {
@@ -7824,7 +7867,7 @@ async function executeChain(input, options) {
             results.push({
               command: cmdName,
               raw: cmdStr,
-              ...fail9(`Unknown command "${subCommand}" for plugin "${cmdName}"`),
+              ...fail11(`Unknown command "${subCommand}" for plugin "${cmdName}"`),
               duration: 0
             });
             if (type === "and") {
@@ -7956,7 +7999,7 @@ async function executeChain(input, options) {
             results.push({
               command: `${cmdName} ${subCommand}`,
               raw: cmdStr,
-              ...fail9(errorMessage),
+              ...fail11(errorMessage),
               duration: duration2
             });
             if (type === "and") {
@@ -8288,8 +8331,14 @@ var configBuiltin = {
         "preview.quality",
         "preview.fps"
       ]);
-      if (!knownKeys.has(key) && !key.startsWith("browser.") && !key.startsWith("captcha.") && !key.startsWith("preview.")) {
-        console.warn(`\u26A0\uFE0F Unknown config key: "${key}". Known keys: browser.*, captcha.*, preview.*`);
+      const isKnownNamespace = key.startsWith("browser.") || key.startsWith("captcha.") || key.startsWith("preview.");
+      if (!knownKeys.has(key) && !isKnownNamespace) {
+        console.error(
+          `Unknown config key: "${key}".
+Known namespaces: browser.*, captcha.*, preview.*
+Run "xbrowser config list" to see current keys.`
+        );
+        process.exit(1);
       }
       setConfigValue(key, value);
       console.log(`Set ${key} = ${value}`);
@@ -8312,7 +8361,7 @@ import {
   readFileSync as readFileSync8,
   writeFileSync as writeFileSync10
 } from "fs";
-import { resolve as resolve8, basename as basename2, dirname as dirname3 } from "path";
+import { resolve as resolve8, basename as basename2, dirname as dirname4 } from "path";
 import { homedir as homedir7 } from "os";
 
 // src/plugin/install-sources/local.ts
@@ -8570,7 +8619,7 @@ import {
   rmSync as rmSync5,
   cpSync as cpSync5
 } from "fs";
-import { resolve as resolve7, join as join10, dirname as dirname2 } from "path";
+import { resolve as resolve7, join as join10, dirname as dirname3 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 import { gunzipSync } from "zlib";
 import {
@@ -8636,7 +8685,7 @@ function extractManifestToDir(manifest, targetDir) {
   mkdirSync7(targetDir, { recursive: true });
   for (const file of manifest) {
     const filePath = resolve7(targetDir, file.path);
-    mkdirSync7(dirname2(filePath), { recursive: true });
+    mkdirSync7(dirname3(filePath), { recursive: true });
     writeFileSync9(filePath, Buffer.from(file.content, "base64"));
   }
 }
@@ -8885,7 +8934,7 @@ var PluginInstaller = class {
           if (resp.ok) {
             const content2 = await resp.text();
             const dst = resolve8(sharedDir, file);
-            const dstDir = dirname3(dst);
+            const dstDir = dirname4(dst);
             if (!existsSync10(dstDir)) mkdirSync8(dstDir, { recursive: true });
             writeFileSync10(dst, content2, "utf-8");
             console.log(`\u2705 Downloaded shared/${file} from GitHub`);
@@ -8910,7 +8959,7 @@ var PluginInstaller = class {
       const dst = resolve8(sharedDir, file);
       if (existsSync10(src)) {
         try {
-          cpSync6(dirname3(src), dirname3(dst), { recursive: true });
+          cpSync6(dirname4(src), dirname4(dst), { recursive: true });
           console.log(`\u2705 Copied shared/${file} for plugin "${basename2(pluginDir)}"`);
         } catch {
           try {
@@ -9053,7 +9102,7 @@ function outputResult(result, mode = "text") {
 function outputError(message) {
   const formatted = formatter.formatError(message, { color: true, emoji: false });
   console.error(formatted);
-  process.exit(1);
+  process.exitCode = 1;
 }
 function outputEnvelope(result, meta, mode) {
   if (mode !== "json" && mode !== "yaml") {
@@ -10528,7 +10577,6 @@ async function handleBrowserCommand(command, args, options, sessionName, mode, c
         break;
       }
       case "scrape":
-        if (!args[0]) outputError("Usage: xbrowser scrape <url> [--format markdown|html|text] [--mode raw|clean|compact] [--selector <sel>] [--timeout <ms>]");
         cmdName = "scrape";
         params = {
           url: args[0],
@@ -10540,7 +10588,6 @@ async function handleBrowserCommand(command, args, options, sessionName, mode, c
         };
         break;
       case "map":
-        if (!args[0]) outputError("Usage: xbrowser map <url> [--search <query>] [--sitemap include|only] [--include-subdomains] [--limit <n>]");
         cmdName = "map";
         params = {
           url: args[0],
@@ -10675,12 +10722,20 @@ async function handleBrowserCommand(command, args, options, sessionName, mode, c
     }
   }
   const outputFile = options.output;
-  if (outputFile && result.success && result.data) {
-    const { writeFileSync: writeFileSync13 } = await import("fs");
-    const content = typeof result.data === "string" ? result.data : result.data.content || result.data.text || JSON.stringify(result.data, null, 2);
-    writeFileSync13(outputFile, content, "utf-8");
-    console.log(`
+  const dataObj = result.data;
+  const handlerAlreadyWrote = !!dataObj && typeof dataObj.output === "string";
+  if (outputFile && result.success && result.data && !handlerAlreadyWrote) {
+    const { writeFileSync: writeFileSync13, mkdirSync: mkdirSync11 } = await import("fs");
+    const { dirname: dirname7 } = await import("path");
+    const content = typeof result.data === "string" ? result.data : dataObj.content || dataObj.text || JSON.stringify(result.data, null, 2);
+    try {
+      mkdirSync11(dirname7(outputFile), { recursive: true });
+      writeFileSync13(outputFile, content, "utf-8");
+      console.log(`
   \u{1F4C4} Written to ${outputFile}`);
+    } catch (err) {
+      outputError(`Failed to write --output "${outputFile}": ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
 }
 
@@ -11146,7 +11201,11 @@ Total: ${enrichedPlugins.length} plugins`);
     case "login":
     case "whoami":
     case "logout":
-      outputError(`"${sub}" has moved to the marketplace plugin. Use: xbrowser marketplace ${sub}`);
+      outputError(
+        `"plugin ${sub}" is no longer available: the built-in marketplace publisher was removed.
+To publish a plugin, use npm directly: \`npm publish\` from the plugin directory.
+See docs/plugin-guide.md for the publishing workflow.`
+      );
       break;
     default:
       console.log(handlePluginHelp());
@@ -11507,23 +11566,51 @@ async function handleConvert(args, _mode) {
   const path5 = await import("path");
   const { default: yaml3 } = await import("yaml");
   const { generateJSScript: generateJSScript2, generatePythonScript: generatePythonScript2, generateBashScript: generateBashScript2 } = await import("./convert-R3XXYKC6.js");
-  const content = fs6.readFileSync(filePath, "utf-8");
-  const recording = yaml3.parse(content);
-  if (recording.actions && !recording.events) recording.events = recording.actions;
+  let recording;
+  try {
+    const content = fs6.readFileSync(filePath, "utf-8");
+    recording = yaml3.parse(content);
+  } catch (e) {
+    console.error(`Error: Failed to read "${filePath}": ${e instanceof Error ? e.message.split("\n")[0] : String(e)}`);
+    process.exit(1);
+  }
+  if (recording === null || typeof recording !== "object" || Array.isArray(recording)) {
+    console.error(`Error: "${filePath}" does not contain a valid recording (expected a YAML/JSON object with events or actions).`);
+    process.exit(1);
+  }
+  const rawActions = recording.actions;
+  if (Array.isArray(rawActions) && !Array.isArray(recording.events)) {
+    recording.events = rawActions.map((a) => {
+      const action = a;
+      const element = action.element ?? {};
+      return {
+        type: action.type,
+        selector: element.selector ?? action.selector,
+        data: {
+          ...action.data,
+          value: action.value ?? action.data?.value,
+          key: action.key ?? action.data?.key,
+          x: action.scrollX ?? action.data?.x,
+          y: action.scrollY ?? action.data?.y
+        }
+      };
+    });
+  }
   const ext = path5.extname(outputPath).toLowerCase();
+  const recordingTyped = recording;
   let script;
   if (ext === ".py") {
-    script = generatePythonScript2(recording);
+    script = generatePythonScript2(recordingTyped);
   } else if (ext === ".sh") {
-    script = generateBashScript2(recording);
+    script = generateBashScript2(recordingTyped);
   } else {
-    script = generateJSScript2(recording);
+    script = generateJSScript2(recordingTyped);
   }
   fs6.writeFileSync(outputPath, script);
   fs6.chmodSync(outputPath, 493);
-  const eventCount = (recording.events || recording.actions || []).length;
+  const eventCount = (recordingTyped.events || []).length;
   console.log(`Converted ${filePath} -> ${outputPath}`);
-  console.log(`  Events: ${eventCount}, Start URL: ${recording.startUrl}`);
+  console.log(`  Events: ${eventCount}, Start URL: ${recordingTyped.startUrl}`);
   console.log(`  Run: ${ext === ".py" ? "python" : ext === ".sh" ? "./" : "node"} ${outputPath}`);
 }
 async function handleExtract(args, _mode) {
@@ -11532,11 +11619,16 @@ async function handleExtract(args, _mode) {
     console.error("Usage: xbrowser extract <recording.yaml>");
     process.exit(1);
   }
-  const { extractAndSave: extractAndSave2, printExtractSummary: printExtractSummary2 } = await import("./extract-RM62AJXW.js");
-  const { summary, outputPath } = extractAndSave2(filePath);
-  printExtractSummary2(summary);
-  console.log(`
+  const { extractAndSave: extractAndSave2, printExtractSummary: printExtractSummary2 } = await import("./extract-DSU2RVMN.js");
+  try {
+    const { summary, outputPath } = extractAndSave2(filePath);
+    printExtractSummary2(summary);
+    console.log(`
 Saved LLM summary: ${outputPath}`);
+  } catch (e) {
+    console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+  }
 }
 async function handleFilter(args, _mode, options) {
   const filePath = args[0];
@@ -11545,19 +11637,24 @@ async function handleFilter(args, _mode, options) {
     console.error("Usage: xbrowser filter <input.yaml> <output.yaml> [--exclude type1,type2]");
     process.exit(1);
   }
-  const { filterRecording: filterRecording2, parseExcludeTypes: parseExcludeTypes2 } = await import("./filter-K6FGRJQU.js");
+  const { filterRecording: filterRecording2, parseExcludeTypes: parseExcludeTypes2 } = await import("./filter-3DXC6432.js");
   const excludeArgs = args.slice(2).concat(
     Object.entries(options || {}).flatMap(
       ([k, v]) => k.startsWith("exclude") ? [`--${k}${typeof v === "string" ? "=" + v : ""}`] : []
     )
   );
   const excludeTypes = parseExcludeTypes2(excludeArgs);
-  const result = filterRecording2(filePath, outputPath, excludeTypes);
-  console.log(`Filtered ${filePath} -> ${outputPath}`);
-  console.log(`  Original: ${result.originalCount}, After: ${result.filteredCount}, Removed: ${result.removed} (${result.percentage}%)`);
+  try {
+    const result = filterRecording2(filePath, outputPath, excludeTypes);
+    console.log(`Filtered ${filePath} -> ${outputPath}`);
+    console.log(`  Original: ${result.originalCount}, After: ${result.filteredCount}, Removed: ${result.removed} (${result.percentage}%)`);
+  } catch (e) {
+    console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+  }
 }
 async function handleGeneratePlugin(sessionName, pluginName, outputDir) {
-  const { SessionRecorder: SessionRecorder2 } = await import("./session-recorder-33UKWCIR.js");
+  const { SessionRecorder: SessionRecorder2 } = await import("./session-recorder-KPU4YQAE.js");
   const { readSiteKnowledge: readSiteKnowledge2, toMarkdown } = await import("./site-knowledge-SYC6VCDB.js");
   const { mkdirSync: mkdirSync11, writeFileSync: writeFileSync13 } = await import("fs");
   const { join: join14 } = await import("path");
@@ -11725,8 +11822,21 @@ export default createSite({
     url: '${data.startUrl}',
     detect: async (ctx: CommandContext) => {
       const page = ensurePage(ctx);
-      // TODO: Add login detection logic
-      return false;
+      // Best-effort login detection: check for common logged-in indicators.
+      // Customize these selectors for your site's specific login state.
+      try {
+        const loggedIn = await page.evaluate(() => {
+          const el = document.querySelector(
+            '[class*="avatar"], [class*="user-info"], [class*="logged-in"], ' +
+            '[data-testid*="user"], [data-testid*="avatar"], ' +
+            'a[href*="logout"], button[class*="logout"]'
+          );
+          return !!el;
+        });
+        return loggedIn;
+      } catch {
+        return false;
+      }
     },
   },
 
@@ -11753,7 +11863,7 @@ async function handleRun(filePath, options) {
     outputError("No commands found in file");
     return;
   }
-  const chain = commands.join(" && ");
+  const chain = commands.join(" ; ");
   const chainResult = await executeChain(chain, {
     cdpEndpoint: options?.cdpEndpoint,
     sessionName: options?.sessionName,
@@ -13088,6 +13198,7 @@ async function handleChainInput(input, argv) {
 }
 async function routeCommand(argvIn, stdinCommands) {
   let argv = argvIn;
+  process.exitCode = 0;
   try {
     if (stdinCommands && stdinCommands.length > 0) {
       await handleStdinMode(stdinCommands, argv);
@@ -13485,6 +13596,7 @@ Run "xbrowser ${command} ${subCommand} --help" to see available parameters.`
             const result = await forwardExec(`${command}.${subCommand}`, params, sessionName, cdpEndpoint, userTimeout);
             const resultData = result && typeof result === "object" && "data" in result ? result.data : void 0;
             if (result && result.success === false && resultData?.code === "LOGIN_REQUIRED") {
+              process.exitCode = 1;
               outputLoginRequired(result, mode);
               return;
             }
@@ -13519,7 +13631,7 @@ Run "xbrowser ${command} ${subCommand} --help" to see available parameters.`
               const targetPage = pages[cmdTabIndex];
               await targetPage.bringToFront().catch(() => {
               });
-              const { setActivePage: setActivePage2 } = await import("./browser-TLIDFFEG.js");
+              const { setActivePage: setActivePage2 } = await import("./browser-C63PFGPT.js");
               setActivePage2(session, targetPage);
             }
           }
@@ -13556,6 +13668,7 @@ Run "xbrowser ${command} ${subCommand} --help" to see available parameters.`
               sessionName
             });
             if (!loginGuard.ok) {
+              process.exitCode = 1;
               const result2 = {
                 success: false,
                 data: loginGuard.data ?? null,
@@ -13599,8 +13712,9 @@ Run "xbrowser ${command} ${subCommand} --help" to see available parameters.`
             }
             const outputData = isCommandResult2(result) ? result.data : result && typeof result === "object" ? result.data ?? result : result;
             const tips = isCommandResult2(result) ? result.tips : result && typeof result === "object" ? result.tips : void 0;
+            const resultSuccess = isCommandResult2(result) ? result.success !== false : true;
+            if (!resultSuccess) process.exitCode = 1;
             if (mode === "json" || mode === "yaml") {
-              const resultSuccess = isCommandResult2(result) ? result.success !== false : true;
               const resultMsg = isCommandResult2(result) ? result.message : void 0;
               const duration = Date.now() - cmdStart;
               const envelopeMeta = { command: `${command} ${subCommand}` };