@usecanary/browser 0.2.0 → 0.4.0

package/dist/cli.cjs

@@ -7462,15 +7462,15 @@ var require_help = __commonJS({
        * @return {string}
        *
        */
-      wrap(str, width, indent, minColumnWidth = 40) {
+      wrap(str, width, indent2, minColumnWidth = 40) {
         const indents = " \\f\\t\\v\xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF";
         const manualIndent = new RegExp(`[\\n][${indents}]+`);
         if (str.match(manualIndent)) return str;
-        const columnWidth = width - indent;
+        const columnWidth = width - indent2;
         if (columnWidth < minColumnWidth) return str;
-        const leadingStr = str.slice(0, indent);
-        const columnText = str.slice(indent).replace("\r\n", "\n");
-        const indentString = " ".repeat(indent);
+        const leadingStr = str.slice(0, indent2);
+        const columnText = str.slice(indent2).replace("\r\n", "\n");
+        const indentString = " ".repeat(indent2);
         const zeroWidthSpace = "\u200B";
         const breaks = `\\s${zeroWidthSpace}`;
         const regex = new RegExp(
@@ -9967,6 +9967,171 @@ function createLogger(opts = {}) {
 
 // ../../packages/cli-kit/src/index.ts
 var import_pino_pretty = __toESM(require_pino_pretty(), 1);
+
+// ../../packages/cli-kit/src/snippets.generated.ts
+var API_BROWSER = "- `browser.getPage(nameOrId)` \u2014 get-or-create a named page, or attach to an existing tab by the\n  `id` from `listPages()`. Named pages persist across steps in a session \u2014 call with the same\n  name to reuse the tab.\n- `browser.newPage()` \u2014 an anonymous page, auto-closed when the script ends; does not persist.\n- `browser.listPages()` \u2014 list every open tab: `[{ id, url, title, name }]` (`name` is `null`\n  for tabs you never named).\n- `browser.closePage(name)` \u2014 close and forget a named page.";
+var API_CONSOLE = "- `console.log` / `console.info` write to stdout; `console.warn` / `console.error` write to\n  stderr. Top-level `console.log` is your script's output channel.\n- `console.log` inside `page.evaluate(() => \u2026)` runs in the page and is captured into the\n  session's console artifact instead.";
+var API_FILE_HELPERS = 'All file I/O is async (await it), sandboxed to `~/.canary/tmp/` (no filesystem escape), and\nreturns the full path to the file:\n\n- `saveScreenshot(buffer, name)` \u2014 persist a screenshot buffer; buffer first:\n  `const path = await saveScreenshot(await page.screenshot(), "home.png");`\n- `writeFile(name, data)` \u2014 write a small file (e.g. JSON state):\n  `await writeFile("results.json", JSON.stringify(data));`\n- `readFile(name)` \u2014 read it back (returns the contents as a string):\n  `const data = JSON.parse(await readFile("results.json"));`';
+var API_GLOBALS = "Every script gets these globals:\n\n- `browser` \u2014 pre-connected browser handle (see the script API)\n- `console` \u2014 `log` / `info` / `warn` / `error`, captured per run\n- `setTimeout` / `clearTimeout` \u2014 basic timers\n- `saveScreenshot(buffer, name)` \u2014 save a screenshot buffer (async \u2014 await it)\n- `writeFile(name, data)` / `readFile(name)` \u2014 small-file persistence (async \u2014 await them)";
+var API_PLAYWRIGHT_METHODS = '- `page.goto(url, { waitUntil: "domcontentloaded" })` \u2014 navigate; `waitUntil` is `"load"` /\n  `"domcontentloaded"` / `"networkidle"` (prefer `"domcontentloaded"` on dev servers)\n- `page.title()` / `page.url()` \u2014 current title / URL\n- `page.snapshotForAI(options)` \u2014 AI-optimized page outline; returns `{ full, incremental? }`;\n  options `{ track?, depth?, timeout? }`\n- `page.getByRole(role, { name })` / `page.getByText(text)` \u2014 semantic locators (survive re-renders)\n- `page.textContent(sel)` / `page.innerText(sel)` / `page.innerHTML(sel)` /\n  `page.getAttribute(sel, name)` \u2014 read by selector\n- `page.inputValue(sel)` / `page.isChecked(sel)` / `page.isVisible(sel)` / `page.isHidden(sel)` \u2014\n  input and visibility state\n- `page.fill(sel, value)` / `page.click(sel)` / `page.type(sel, text)` / `page.press(sel, key)` \u2014\n  act on elements\n- `page.waitForSelector(sel, { state, timeout })` (`state`: `"attached"` / `"visible"` /\n  `"hidden"` / `"detached"`) / `page.waitForURL(pattern)` / `page.waitForLoadState(state)` /\n  `page.waitForFunction(fn)` / `page.waitForTimeout(ms)` \u2014 waiting\n- `page.screenshot({ fullPage })` \u2014 capture a screenshot Buffer; save it with `saveScreenshot(...)`\n- `page.evaluate(fn[, arg])` / `page.$eval(sel, fn)` / `page.$$eval(sel, fn)` \u2014 run plain\n  JavaScript in the page context (real DOM; args/returns must be serializable)\n- `page.locator(sel)` \u2014 a Locator for chained actions (`.click()`, `.fill(value)`,\n  `.textContent()`, `.first()`, \u2026)\n- `page.keyboard.press/type/down/up(...)` / `page.mouse.move/click/down/up(...)` \u2014 low-level input\n- `page.reload()` / `page.goBack()` / `page.goForward()` \u2014 history;\n  `page.content()` / `page.setContent(html)` \u2014 full HTML\n- `page.on("console", handler)` \u2014 observe page console events';
+var API_PLAYWRIGHT_NOTE = "Pages returned by `browser.getPage()` and `browser.newPage()` are full Playwright Page objects \u2014\nthe same API (`goto`, `click`, `fill`, `locator`, `evaluate`, `getByRole`, `waitForSelector`, \u2026):\nhttps://playwright.dev/docs/api/class-page";
+var API_SANDBOX_ENV = "Scripts execute inside a QuickJS WASM sandbox with no arbitrary access to the host system.\nThis is NOT Node.js \u2014 there is no module system and no Node API:\n\n- `require()` / `import()` \u2014 no module loading; inline any helpers in the script\n- `process`, `fs` / `path` / `os` \u2014 no process or direct filesystem access (use the file helpers)\n- `fetch` / `WebSocket` \u2014 no direct network access (the page does the networking)\n- `__dirname` / `__filename` \u2014 no path globals\n\nMemory and CPU limits are enforced, and both CPU time and wall-clock time are bounded \u2014 infinite\nloops or never-settling promises abort the script. Values crossing `evaluate` / `$eval` must be\nJSON-serializable.";
+var API_SNAPSHOT = '- `page.snapshotForAI()` returns `{ full, incremental? }` \u2014 `full` is an aria outline of the\n  page: roles, accessible names, `[ref=eN]` markers on actionable nodes. Read it to pick a\n  semantic selector \u2014 `page.getByRole("button", { name: "Continue" })`,\n  `page.getByText("Sign in")` \u2014 then act.\n- Options `{ track?, depth?, timeout? }`: re-run `page.snapshotForAI({ track: "main" })` after\n  the page changes to get just the `incremental` diff; `{ depth: N }` caps the tree on huge\n  pages; `timeout` bounds the walk.\n- `page.locator("aria-ref=e12")` works for an immediate action in the same script only \u2014 refs go\n  stale across steps and after navigations. Prefer re-deriving a semantic selector.';
+var EX_INSPECT_TABS = "const tabs = await browser.listPages();\nconsole.log(JSON.stringify(tabs, null, 2));";
+var EX_SNAPSHOT = 'const page = await browser.getPage("main");\nconst snap = await page.snapshotForAI(); // { full, incremental? }\nconsole.log(page.url(), await page.title());\nconsole.log(snap.full); // aria outline \u2014 pick a role/text selector from this\n// then act: await page.getByRole("button", { name: "Continue" }).click();\n// after changes, page.snapshotForAI({ track: "main" }) returns just the incremental diff';
+var RULE_DEV_SERVER = 'For local dev servers (Next.js, Vite, \u2026) prefer\n`await page.goto(url, { waitUntil: "domcontentloaded" })` \u2014 the default `"load"` wait can hang\non HMR, streaming, or other long-lived dev-server connections. Use `"load"` only when you\nspecifically need every subresource to finish loading.';
+var RULE_OBSERVE_FIRST = "- Unknown page? Snapshot first, then act: read `(await page.snapshotForAI()).full` to see what\n  is there, pick a semantic selector from it (`getByRole`, `getByText`), then interact. Never\n  guess selectors blind.\n- Known page or selectors? Skip the snapshot and use direct selectors \u2014 faster and more reliable.";
+
+// ../../packages/cli-kit/src/scripting-help.ts
+var indent = (text, prefix) => text.split("\n").map((line) => line.length > 0 ? prefix + line : line).join("\n");
+var SANDBOX_ENVIRONMENT = `SANDBOX ENVIRONMENT:
+${indent(API_SANDBOX_ENV, "  ")}
+
+${indent(API_GLOBALS, "  ")}`;
+var SCRIPT_API = `Script API available inside every script:
+${indent(API_BROWSER, "  ")}
+
+${indent(API_FILE_HELPERS, "  ")}
+
+${indent(API_CONSOLE, "  ")}`;
+var PLAYWRIGHT_PAGE_NOTE = API_PLAYWRIGHT_NOTE;
+var browserExample = (scriptBody, opts) => [
+  `canary-browser${opts?.connect === true ? " --connect" : ""} <<'EOF'`,
+  scriptBody,
+  "EOF"
+].join("\n");
+var INSPECT_PAGE_BODY = `const page = await browser.getPage("TARGET_ID_HERE");
+console.log(JSON.stringify({
+  url: page.url(),
+  title: await page.title(),
+}, null, 2));`;
+var SCREENSHOT_BODY = `const page = await browser.getPage("main");
+const buf = await page.screenshot();
+const path = await saveScreenshot(buf, "debug.png");
+console.log(path);`;
+var WAITING_BODY = `const page = await browser.getPage("search-results");
+await page.waitForSelector(".results");
+await page.waitForURL("**/success");
+console.log(JSON.stringify({
+  url: page.url(),
+  title: await page.title(),
+}, null, 2));`;
+var ERROR_RECOVERY_BODY = `const page = await browser.getPage("checkout");
+const path = await saveScreenshot(await page.screenshot(), "debug.png");
+console.log(JSON.stringify({
+  screenshot: path,
+  url: page.url(),
+  title: await page.title(),
+}, null, 2));`;
+var POWERSHELL_BLOCK = `  On Windows/PowerShell, use here-strings to pipe multiline scripts:
+    @"
+    const page = await browser.getPage("main");
+    console.log(await page.title());
+    "@ | canary-browser --connect`;
+var CONNECTING_SECTION = `  Connecting to a running Chrome instance:
+    Auto-discover Chrome with debugging enabled:
+      canary-browser --connect <<'EOF'
+        const page = await browser.getPage("main");
+        console.log(await page.title());
+      EOF
+
+    Connect to a specific CDP endpoint:
+      canary-browser --connect http://localhost:9222 <<'EOF'
+        const page = await browser.getPage("main");
+        console.log(await page.title());
+      EOF
+
+    To launch Chrome with debugging enabled:
+      chrome.exe --remote-debugging-port=9222
+      google-chrome --remote-debugging-port=9222
+
+    Or visit chrome://inspect/#remote-debugging to configure.`;
+function buildScriptingGuide(options) {
+  const { heading, example } = options;
+  const browserExtras = options.browserExtras === true;
+  const intro = [
+    `${heading}`,
+    "  Write small, focused scripts. Each script should do ONE thing: navigate, click, fill, or check.",
+    "  End each script by logging the state you need for the next decision.",
+    '  Use descriptive page names like "login", "checkout", or "results" instead of "page1".',
+    '  Named pages from browser.getPage("name") persist between script runs, so you usually do not need to re-navigate.',
+    "  Inside page.evaluate(...), write plain JavaScript only - no TypeScript syntax in the browser context.",
+    ...browserExtras ? [POWERSHELL_BLOCK] : []
+  ].join("\n");
+  const quickInspection = [
+    "  Quick inspection:",
+    indent(
+      example(EX_INSPECT_TABS, { step: "inspect", connect: true }),
+      "    "
+    ),
+    "",
+    indent(
+      example(INSPECT_PAGE_BODY, { step: "inspect", connect: true }),
+      "    "
+    )
+  ].join("\n");
+  const aiSnapshots = [
+    "  AI snapshots for element discovery:",
+    indent(example(EX_SNAPSHOT, { step: "discover" }), "    "),
+    "",
+    indent(API_SNAPSHOT, "    ")
+  ].join("\n");
+  const choosingApproach = [
+    "  Choosing your approach:",
+    indent(RULE_OBSERVE_FIRST, "    ")
+  ].join("\n");
+  const screenshots = [
+    "  Screenshots for visual state:",
+    indent(example(SCREENSHOT_BODY, { step: "capture" }), "    ")
+  ].join("\n");
+  const waiting = [
+    "  Waiting patterns:",
+    indent(example(WAITING_BODY, { step: "wait" }), "    ")
+  ].join("\n");
+  const devServer = [
+    "  Dev server navigation:",
+    indent(RULE_DEV_SERVER, "    ")
+  ].join("\n");
+  const errorRecovery = [
+    "  Error recovery:",
+    "    If a script fails, the page usually stays where it stopped.",
+    "    Reconnect to the same page name, take a screenshot, and log the URL/title:",
+    indent(example(ERROR_RECOVERY_BODY, { step: "recover" }), "    ")
+  ].join("\n");
+  const playwrightMethods = [
+    "  Common Playwright Page methods:",
+    indent(API_PLAYWRIGHT_METHODS, "    ")
+  ].join("\n");
+  const tips = [
+    "  Tips:",
+    "    - Use console.log(JSON.stringify(...)) for structured output.",
+    "    - Prefer page.snapshotForAI() for structure; use screenshots when visual layout or styling matters.",
+    "    - Keep page names stable across scripts so you can resume work after failures.",
+    ...browserExtras ? [
+      "    - Each --browser name maps to a separate daemon-managed browser instance.",
+      "    - Use --connect to attach to an existing browser; omit the URL to auto-discover Chrome with debugging enabled."
+    ] : [],
+    "    - Use short timeouts (--timeout 10) so scripts fail fast instead of hanging on missing elements.",
+    ...browserExtras ? [
+      "    - Add --headless for unattended automation; omit it when you want to watch the browser window."
+    ] : []
+  ].join("\n");
+  return [
+    intro,
+    quickInspection,
+    aiSnapshots,
+    choosingApproach,
+    screenshots,
+    waiting,
+    devServer,
+    errorRecovery,
+    playwrightMethods,
+    ...browserExtras ? [CONNECTING_SECTION] : [],
+    tips
+  ].join("\n\n");
+}
+
+// ../../packages/cli-kit/src/index.ts
 function requestId(prefix) {
   return `${prefix}-${Date.now()}-${process.pid}`;
 }
@@ -14820,166 +14985,8 @@ var CONNECT_AUTO_SENTINEL = "auto";
 var DEFAULT_BROWSER = "default";
 var DEFAULT_TIMEOUT_SECS = 30;
 
-// src/assets/embedded.generated.ts
-var LLM_GUIDE = `LLM USAGE GUIDE:
-  Write small, focused scripts. Each script should do ONE thing: navigate, click, fill, or check.
-  End each script by logging the state you need for the next decision.
-  Use descriptive page names like "login", "checkout", or "results" instead of "page1".
-  Named pages from browser.getPage("name") persist between script runs, so you usually do not need to re-navigate.
-  Inside page.evaluate(...), write plain JavaScript only - no TypeScript syntax in the browser context.
-  On Windows/PowerShell, use here-strings to pipe multiline scripts:
-    @"
-    const page = await browser.getPage("main");
-    console.log(await page.title());
-    "@ | canary-browser --connect
-
-  Quick inspection:
-    canary-browser --connect <<'EOF'
-    const tabs = await browser.listPages();
-    console.log(JSON.stringify(tabs, null, 2));
-    EOF
-
-    canary-browser --connect <<'EOF'
-    const page = await browser.getPage("TARGET_ID_HERE");
-    console.log(JSON.stringify({
-      url: page.url(),
-      title: await page.title(),
-    }, null, 2));
-    EOF
-
-  AI snapshots for element discovery:
-    canary-browser <<'EOF'
-    const page = await browser.getPage("main");
-    const result = await page.snapshotForAI();
-    console.log(result.full);
-    // Returns { full: string, incremental?: string }.
-    // Optional args: { track?: string, depth?: number, timeout?: number }.
-    // Read result.full to identify the right element.
-    // Then interact with it using Playwright:
-    // await page.getByRole("button", { name: "Continue" }).click();
-    // Re-run page.snapshotForAI({ track: "main" }) after the page changes.
-    EOF
-
-  Choosing your approach:
-    Unknown pages: use page.snapshotForAI() first to discover the page, then interact based on what you find.
-    Known pages/selectors: skip the snapshot and use direct Playwright selectors like page.click(), page.fill(), or page.locator() for faster, more reliable automation.
-
-  Screenshots for visual state:
-    canary-browser <<'EOF'
-    const page = await browser.getPage("main");
-    const buf = await page.screenshot();
-    const path = await saveScreenshot(buf, "debug.png");
-    console.log(path);
-    EOF
-
-  Waiting patterns:
-    canary-browser <<'EOF'
-    const page = await browser.getPage("search-results");
-    await page.waitForSelector(".results");
-    await page.waitForURL("**/success");
-    console.log(JSON.stringify({
-      url: page.url(),
-      title: await page.title(),
-    }, null, 2));
-    EOF
-
-  Dev server navigation:
-    For local dev servers (Next.js, Vite, etc.), prefer:
-      await page.goto(url, { waitUntil: "domcontentloaded" });
-    The default "load" wait can hang on HMR, streaming, or other long-lived dev-server connections.
-    Use "load" only when you specifically need every subresource to finish loading.
-
-  Error recovery:
-    If a script fails, the page usually stays where it stopped.
-    Reconnect to the same page name, take a screenshot, and log the URL/title:
-    canary-browser <<'EOF'
-    const page = await browser.getPage("checkout");
-    const path = await saveScreenshot(await page.screenshot(), "debug.png");
-    console.log(JSON.stringify({
-      screenshot: path,
-      url: page.url(),
-      title: await page.title(),
-    }, null, 2));
-    EOF
-
-  Common Playwright Page methods:
-    page.goto(url, { waitUntil: "domcontentloaded" })
-                                           Navigate to a URL; prefer this on dev servers
-    page.title()                           Get the current page title
-    page.url()                             Get the current URL
-    page.snapshotForAI(options)            Get an AI-optimized snapshot; returns { full, incremental? }
-                                           Options: { track?: string, depth?: number, timeout?: number }
-    page.getByRole(role, { name })         Target elements discovered from the snapshot
-    page.textContent(selector)             Get the text content of an element
-    page.innerHTML(selector)               Get the inner HTML of an element
-    page.fill(selector, value)             Fill an input field
-    page.click(selector)                   Click an element
-    page.type(selector, text)              Type text character by character
-    page.press(selector, key)              Press a key such as Enter or Tab
-    page.waitForSelector(selector)         Wait for an element to appear
-    page.waitForURL(url)                   Wait for navigation to a URL
-    page.screenshot()                      Capture a screenshot buffer; save it with saveScreenshot(...)
-    page.$$eval(selector, fn)              Run a function on all matching elements
-    page.$eval(selector, fn)               Run a function on the first matching element
-    page.evaluate(fn)                      Run JavaScript in the page context (plain JS only)
-    page.locator(selector)                 Create a locator for chained actions
-
-  Connecting to a running Chrome instance:
-    Auto-discover Chrome with debugging enabled:
-      canary-browser --connect <<'EOF'
-        const page = await browser.getPage("main");
-        console.log(await page.title());
-      EOF
-
-    Connect to a specific CDP endpoint:
-      canary-browser --connect http://localhost:9222 <<'EOF'
-        const page = await browser.getPage("main");
-        console.log(await page.title());
-      EOF
-
-    To launch Chrome with debugging enabled:
-      chrome.exe --remote-debugging-port=9222
-      google-chrome --remote-debugging-port=9222
-
-    Or visit chrome://inspect/#remote-debugging to configure.
-
-  Tips:
-    - Use console.log(JSON.stringify(...)) for structured output.
-    - Prefer page.snapshotForAI() for structure; use screenshots when visual layout or styling matters.
-    - Keep page names stable across scripts so you can resume work after failures.
-    - Each --browser name maps to a separate daemon-managed browser instance.
-    - Use --connect to attach to an existing browser; omit the URL to auto-discover Chrome with debugging enabled.
-    - Use short timeouts (--timeout 10) so scripts fail fast instead of hanging on missing elements.
-    - Add --headless for unattended automation; omit it when you want to watch the browser window.
-`;
-
 // src/commands/help-text.ts
-var CLI_LONG_ABOUT = `Dev Browser is a CLI for controlling local or external browsers with JavaScript scripts.
-Scripts run in a sandboxed QuickJS runtime (not Node.js). Top-level \`await\` is
-available, along with a preconnected \`browser\` global and standard \`console\` output.
-A background daemon starts automatically when needed and manages browser instances,
-named pages, and CDP connections.
-
-SANDBOX ENVIRONMENT:
-  Scripts execute inside a QuickJS WASM sandbox with no arbitrary access to the host system.
-  This is NOT Node.js \u2014 the following are NOT available:
-    - require() / import()     No module loading
-    - process                  No process access
-    - fs / path / os           No direct filesystem access
-    - fetch / WebSocket        No direct network access
-    - __dirname / __filename   No path globals
-
-  Available globals:
-    browser                    Pre-connected browser handle (see API below)
-    console                    log, warn, error, info (routed to CLI output)
-    setTimeout / clearTimeout  Basic timers
-    saveScreenshot(buf, name)  Save a screenshot buffer (async, must be awaited)
-    writeFile(name, data)      Write a file to temp dir (async, must be awaited)
-    readFile(name)             Read a file from temp dir (async, must be awaited)
-
-  Memory and CPU limits are enforced. Infinite loops will be interrupted.
-
-Primary invocation styles:
+var INVOCATION_STYLES = `Primary invocation styles:
   canary-browser <<'EOF'
     const page = await browser.getPage("main");
     await page.goto("https://example.com");
@@ -14995,40 +15002,26 @@ Primary invocation styles:
   canary-browser --connect <<'EOF'
     const page = await browser.getPage("main");
     console.log(await page.title());
-  EOF
+  EOF`;
+var CLI_LONG_ABOUT = `Dev Browser is a CLI for controlling local or external browsers with JavaScript scripts.
+Scripts run in a sandboxed QuickJS runtime (not Node.js). Top-level \`await\` is
+available, along with a preconnected \`browser\` global and standard \`console\` output.
+A background daemon starts automatically when needed and manages browser instances,
+named pages, and CDP connections.
 
-Script API available inside every script:
-  browser.getPage(nameOrId) Get a page by name (creates if new) or connect to an existing
-                            tab by its targetId from listPages().
-  browser.newPage()       Create an anonymous page. Anonymous pages are cleaned up after the script exits.
-  browser.listPages()       List all tabs: named pages and existing browser tabs.
-                            Returns [{id, url, title, name}].
-  browser.closePage(name) Close and remove a named page.
-  await saveScreenshot(buf: Buffer, name: string): Promise<string>
-                          Save a screenshot buffer to ~/.canary/tmp/<name>.
-                          Returns the full path to the saved file.
-                          Example: const path = await saveScreenshot(await page.screenshot(), "home.png");
-
-  await writeFile(name: string, data: string): Promise<string>
-                          Write data to ~/.canary/tmp/<name>.
-                          Returns the full path to the written file.
-                          Example: const path = await writeFile("results.json", JSON.stringify(data));
-
-  await readFile(name: string): Promise<string>
-                          Read a file from ~/.canary/tmp/<name>.
-                          Returns the file content as a string.
-                          Example: const data = JSON.parse(await readFile("results.json"));
-
-  console.log/info(...)   Write output to stdout.
-  console.warn/error(...) Write output to stderr.
-
-  All file I/O functions are async and must be awaited.
-  All paths are restricted to ~/.canary/tmp/ \u2014 no filesystem escape.
-
-Pages returned by \`browser.getPage()\` and \`browser.newPage()\` are full Playwright
-Page objects \u2014 you get the same API (goto, click, fill, locator, evaluate, etc.):
-  https://playwright.dev/docs/api/class-page`;
-var CLI_AFTER_LONG_HELP = LLM_GUIDE;
+${SANDBOX_ENVIRONMENT}
+
+${INVOCATION_STYLES}
+
+${SCRIPT_API}
+
+${PLAYWRIGHT_PAGE_NOTE}`;
+var CLI_AFTER_LONG_HELP = `${buildScriptingGuide({
+  browserExtras: true,
+  example: browserExample,
+  heading: "LLM USAGE GUIDE:"
+})}
+`;
 var RUN_LONG_ABOUT = "Run a script file against the browser.\n\nThe file is executed the same way as stdin input: as top-level JavaScript with `await`, `browser`, and `console` available.\n\nUse top-level flags before `run`, for example `canary-browser --browser my-project run script.js`.";
 var INSTALL_LONG_ABOUT = "Install Playwright browsers (Chromium).\n\nDownloads the Chromium build used for daemon-managed browser instances.";
 var BROWSERS_LONG_ABOUT = "List all managed browser instances.\n\nShows the browser name, whether it is daemon-launched or externally connected, its status, and any named pages currently registered.";