libretto 0.2.6 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Libretto contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libretto",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "description": "AI-powered browser automation library and CLI built on Playwright",
   "license": "MIT",
   "repository": {
@@ -88,16 +88,6 @@
       "require": "./dist/shared/run/api.cjs"
     }
   },
-  "scripts": {
-    "postinstall": "node ./scripts/postinstall.mjs; npx playwright install chromium",
-    "build": "pnpm run build:runtime && pnpm run build:cli",
-    "build:runtime": "tsup --config tsup.config.ts",
-    "build:cli": "tsup --config tsup.cli.config.ts",
-    "type-check": "tsc --noEmit",
-    "dev": "tsx src/cli/index.ts",
-    "test": "pnpm run build && vitest run",
-    "test:watch": "vitest"
-  },
   "peerDependencies": {
     "@ai-sdk/anthropic": "^3.0.0",
     "@ai-sdk/google-vertex": "^4.0.0",
@@ -132,5 +122,15 @@
     "ai": "^6.0.110",
     "playwright": "^1.52.0",
     "yargs": "^17.7.2"
+  },
+  "scripts": {
+    "postinstall": "node ./scripts/postinstall.mjs; npx playwright install chromium",
+    "build": "pnpm run build:runtime && pnpm run build:cli",
+    "build:runtime": "tsup --config tsup.config.ts",
+    "build:cli": "tsup --config tsup.cli.config.ts",
+    "type-check": "tsc --noEmit",
+    "dev": "tsx src/cli/index.ts",
+    "test": "pnpm run build && vitest run",
+    "test:watch": "vitest"
   }
-}
+}

package/skill/SKILL.md

@@ -4,18 +4,19 @@ description: "Browser automation CLI for building integrations, with a network-f
 license: MIT
 metadata:
   author: saffron-health
-  version: "0.2.2"
+  version: "0.2.4"
 ---
 
 # Browser Integration with Libretto CLI
 
 Use the `npx libretto` CLI to automate web interactions, debug browser agent jobs, and prototype fixes.
 
-## CRITICAL: Session Access
+## Session Access
 
-Libretto sessions are **full-access by default**. You can use `exec` and `run` immediately after opening a session.
+Libretto sessions are **full-access by default** (no approval prompts). You can use `exec` immediately after opening a session. `run` starts its own workflow browser process and requires the target session to be available.
 
 **Rules:**
+
 - Always announce which session you opened and what page you are on.
 - Use `snapshot`, `network`, and `actions` first when debugging unknown page state.
 - Before any potentially mutating action (submit/save/delete, or non-idempotent API calls), describe what you are about to do and wait for explicit user confirmation.
@@ -27,14 +28,15 @@ If it's not obvious which element to click or what value to enter, **ask the use
 ## Commands
 
 ```bash
-npx libretto open <url> [--headless]   # Launch browser and navigate (headed by default)
+npx libretto open <url> [--headed|--headless]   # Launch browser and navigate (headed by default)
 npx libretto exec <code> [--visualize] # Execute Playwright TypeScript code (--visualize enables ghost cursor + highlight)
-npx libretto run <integrationFile> <integrationExport> # Execute integration actions
+npx libretto run <integrationFile> <integrationExport> [--params <json> | --params-file <path>] [--auth-profile <domain>] [--headed|--headless] # Execute integration actions
 npx libretto resume                    # Resume a paused workflow for the current session
 npx libretto snapshot --objective "<what to find>" [--context "<situational info>"]
 npx libretto save <url|domain>         # Save session (cookies, localStorage) to .libretto/profiles/
 npx libretto network                   # Show last 20 captured network requests
 npx libretto actions                   # Show last 20 captured user/agent actions
+npx libretto pages                     # List open pages in the session
 npx libretto close                     # Close the browser
 ```
 
@@ -65,13 +67,13 @@ Workflows pause by calling `await pause()` (imported from `"libretto"`). In prod
 
 ## Globals Available in `exec`
 
-`page`, `context`, `state`, `browser`, `networkLog({ last?, filter?, method? })`, `actionLog({ last?, filter?, action?, source? })`, `console`, `fetch`, `Buffer`, `URL`, `setTimeout`
+`page`, `context`, `state`, `browser`, `networkLog({ last?, filter?, method? })`, `actionLog({ last?, filter?, action?, source? })`, `console`, `fetch`, `Buffer`, `URL`, `setTimeout`, `setInterval`, `clearTimeout`, `clearInterval`
 
-The `state` object persists across `exec` calls within the same session — use it to carry values between commands.
+The `state` object is scoped to a single `exec` invocation and resets on the next call.
 
 ## CRITICAL: No try/catch in exec
 
-**Never use try/catch or .catch() in exec code.** Let errors throw so they surface as exec failures. When an exec fails, you get the full error message (e.g., "intercepts pointer events", "Timeout 30000ms exceeded") — use that to diagnose the problemand write a corrected exec.
+**Never use try/catch or .catch() in exec code.** Let errors throw so they surface as exec failures. When an exec fails, you get the full error message (e.g., "intercepts pointer events", "Timeout 30000ms exceeded") — use that to diagnose the problem and write a corrected exec.
 
 **Why:** A try/catch inside exec hides failures from you. A click that times out takes 30 seconds — if you retry it in a loop with try/catch, you'll silently burn minutes on the same broken selector with no way to recover. Without try/catch, the error comes back immediately and you can reason about what went wrong.
 
@@ -174,9 +176,9 @@ npx libretto exec --session browser-agent "await page.locator('.dropdown-trigger
 
 ## Snapshot — The Primary Observation Tool
 
-The `snapshot` command captures a PNG screenshot + HTML, sends both to a vision model (Gemini Flash), and returns an analysis with Playwright-ready selectors. `--objective` is required for analysis, and `--context` is optional (but recommended for better results). This is the single way to understand what's on the page — use it any time you need to inspect page structure, find elements, or debug what's happening.
+The `snapshot` command captures a PNG screenshot + HTML and (when `--objective` is provided) runs analysis through the configured AI runtime (`codex`, `claude`, or `gemini` via `npx libretto ai configure ...`). `--context` is optional (but recommended for better results). This is the single way to understand what's on the page — use it any time you need to inspect page structure, find elements, or debug what's happening.
 
-**Never use `page.screenshot()` via `exec` to understand the page.** Use the `snapshot` command instead — it captures the screenshot, HTML, and sends both to a vision model that returns actionable selectors. Raw screenshots give you an image with no analysis; `snapshot` gives you the answer.
+**Never use `page.screenshot()` via `exec` to understand the page.** Use the `snapshot` command instead — it captures the screenshot, HTML, and runs analysis with selectors. Raw screenshots give you an image with no analysis; `snapshot` gives you the answer.
 
 ### What to Put in `--objective`
 
@@ -224,7 +226,7 @@ When the snapshot doesn't give you enough detail — why an element is hidden, w
 
 ## Tips
 
-- **Never use `page.screenshot()` via `exec`.** Use `npx libretto snapshot` instead — it captures the viewport, sends the screenshot + HTML to a vision model, and returns actionable selectors. The `fullPage` option is especially dangerous — it scrolls the entire page to stitch a screenshot, which can crash JavaScript-heavy pages (especially EMR portals like eClinicalWorks).
+- **Never use `page.screenshot()` via `exec`.** Use `npx libretto snapshot` instead — it captures the viewport plus HTML and returns analyzed output with actionable selectors. The `fullPage` option is especially dangerous — it scrolls the entire page to stitch a screenshot, which can crash JavaScript-heavy pages (especially EMR portals like eClinicalWorks).
 - **Never run `exec` commands in parallel.** Always wait for one `exec` to finish before starting the next. Do not use `run_in_background` for `exec` calls. Running simultaneous `exec` calls opens multiple CDP connections to the same page, which corrupts the page state and kills the browser.
 - `open` requires an available session. If the session is already active, Libretto fails fast and asks you to close the existing session or use a different `--session`.
 - `run` also requires an available session, except for the specific case of a prior failed `run` in the same session; in that case Libretto releases the failed worker and allows rerun.
@@ -234,7 +236,7 @@ When the snapshot doesn't give you enough detail — why an element is hidden, w
 
 ## Network Logging
 
-Network requests are captured automatically when a browser is opened via `npx libretto open`. All non-static HTTP responses (excluding `.css`, `.js`, `.png`, `.jpg`, `.gif`, `.woff`, `.ico`, `.svg`, and `chrome-extension://` URLs) are logged to `.libretto/sessions/<session>/network.jsonl`.
+Network requests are captured automatically for Libretto-managed browser sessions (for example from `npx libretto open` and `npx libretto run`). Non-static HTTP responses are logged to `.libretto/sessions/<session>/network.jsonl`.
 
 ### CLI: `npx libretto network`
 
@@ -256,11 +258,11 @@ npx libretto exec "return await networkLog({ method: 'POST' })"
 
 Returns an array of objects with: `ts`, `method`, `url`, `status`, `contentType`, `postData` (POST/PUT/PATCH only, first 2000 chars), `size`, `durationMs`.
 
-**Note:** Network logging only works for sessions opened via `npx libretto open`. It does not capture requests for external sessions like `--session browser-agent`.
+**Note:** Network logging works for Libretto-managed sessions. It does not capture requests for external sessions like `--session browser-agent`.
 
 ## Action Logging
 
-Browser actions are captured automatically when a browser is opened via `npx libretto open`. Both user interactions (manual clicks, typing in the headed browser window) and agent actions (programmatic Playwright API calls via `exec`) are logged to `.libretto/sessions/<session>/actions.jsonl` with a `source` field of `'user'` or `'agent'` to distinguish the two.
+Browser actions are captured automatically for Libretto-managed browser sessions (for example from `npx libretto open` and `npx libretto run`). Both user interactions (manual clicks, typing in the headed browser window) and agent actions (programmatic Playwright API calls via `exec`) are logged to `.libretto/sessions/<session>/actions.jsonl` with a `source` field of `'user'` or `'agent'` to distinguish the two.
 
 ### CLI: `npx libretto actions`
 
@@ -284,7 +286,7 @@ npx libretto exec "return await actionLog({ action: 'click' })"
 
 Returns an array of objects with: `ts`, `action`, `source` (`'user'` | `'agent'`), `selector`, `value`, `url`, `duration`, `success`, `error`.
 
-**Note:** Action logging only works for sessions opened via `npx libretto open`. It does not capture actions for external sessions like `--session browser-agent`.
+**Note:** Action logging works for Libretto-managed sessions. It does not capture actions for external sessions like `--session browser-agent`.
 
 ## Workflow: Creating a New Integration
 
@@ -436,7 +438,7 @@ After completing interactive exploration, **always generate the TypeScript workf
 **STOP AND ASK BEFORE GENERATING CODE.** Once the interactive workflow is figured out, pause and ask:
 
 1. "Are there any existing files or patterns in the codebase you want me to reference?"
-2. "Do you want me to incorporate any of your manual browser interactions from the actions log (`npx libretto actions --source user`) into the generated code?"
+2. Check the action log for user interactions by running `npx libretto actions --source user`. If there are any recorded user interactions, ask: "I see you performed some manual interactions in the browser (clicks, form fills, etc.). Would you like me to incorporate any of those into the generated code?" — and briefly list what you found. If there are no user interactions, skip this question entirely.
 3. "Any other guidance for how the production code should be structured?"
 
 Wait for the user's response before proceeding. Then:
@@ -446,6 +448,6 @@ Wait for the user's response before proceeding. Then:
 
 ## Patient Safety Warning
 
-Browser automation jobs process real patient health information. The `npx libretto` CLI executes arbitrary code with full page access. **Never** execute code that submits forms, sends referrals, deletes data, or modifies patient records.
+Browser automation jobs process real patient health information. The `npx libretto` CLI executes arbitrary code with full page access. **Never execute mutating actions without explicit user confirmation first** (submits, sends, deletes, updates, or other side effects).
 
-See `apps/browser-agent/docs/interactive-debugging-workflow.md` for the complete debugging guide.
+For debugging steps, see the "Workflow: Interactive Debugging" section in this file.

package/skill/code-generation-rules.md

@@ -151,7 +151,7 @@ Use `page.evaluate()` only for operations that have no Playwright locator equiva
 
 A quick test: if the evaluate body contains `querySelector`, `querySelectorAll`, `textContent`, `click()`, `getAttribute()`, or iterates DOM elements, it should be rewritten with Playwright locators.
 
-When `page.evaluate()` is used for the acceptable cases above, use a string expression to avoid DOM type errors:
+When `page.evaluate()` is used for the acceptable cases above, keep the logic self-contained and return JSON-serializable values:
 
 ```typescript
 const data = (await page.evaluate(`(() => {
@@ -160,7 +160,7 @@ const data = (await page.evaluate(`(() => {
 })()`)) as string;
 ```
 
-Do not use `/// <reference lib="dom" />` or add `"dom"` to the tsconfig lib — this project's tsconfig intentionally excludes DOM types.
+Do not rely on broad DOM querying inside `page.evaluate()` for production flows when Playwright locators can express the same interaction.
 
 ## Network Request Methods
 
@@ -220,4 +220,4 @@ for (const post of posts) {
 
 ## Type Checking
 
-The generated file must pass `npx tsc --noEmit` before it's considered done. If there are DOM type errors (`document`, `HTMLElement`, `getComputedStyle`), convert to locator APIs or string-expression `page.evaluate()`.
+The generated file must pass `npx tsc --noEmit` before it's considered done. If there are type errors around DOM access, prefer locator APIs first, then use focused `page.evaluate()` only for browser-native APIs.

package/skill/integration-approach-selection.md

@@ -138,9 +138,9 @@ Extract data directly from the rendered page using selectors and `page.evaluate(
 | Site Profile | Primary Strategy | Supplement With |
 |---|---|---|
 | No bot protection, fetch not patched | **A** (`page.evaluate(fetch)`) | Playwright for navigation/auth |
-| No bot protection, fetch IS patched | **B** (`page.onResponse`) | Playwright for navigation; DOM extraction as fallback |
-| Bot protection detected, fetch not patched | **B** (`page.onResponse`) | Playwright for all navigation; cautious use of `page.evaluate(fetch)` only if needed |
-| Bot protection detected, fetch IS patched | **B** (`page.onResponse`) | Playwright for all navigation; DOM extraction as fallback |
+| No bot protection, fetch IS patched | **B** (`page.on('response', ...)`) | Playwright for navigation; DOM extraction as fallback |
+| Bot protection detected, fetch not patched | **B** (`page.on('response', ...)`) | Playwright for all navigation; cautious use of `page.evaluate(fetch)` only if needed |
+| Bot protection detected, fetch IS patched | **B** (`page.on('response', ...)`) | Playwright for all navigation; DOM extraction as fallback |
 | Server-rendered content (no API calls) | **C** (DOM extraction) | Playwright for all interaction |
 
 ---

package/dist/cli/cli.js

@@ -1,209 +0,0 @@
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import { registerAICommands } from "./commands/ai.js";
-import { registerBrowserCommands } from "./commands/browser.js";
-import { registerExecutionCommands } from "./commands/execution.js";
-import { registerLogCommands } from "./commands/logs.js";
-import { registerInitCommand } from "./commands/init.js";
-import { registerSnapshotCommands } from "./commands/snapshot.js";
-import {
-  closeLogger,
-  createLoggerForSession,
-  ensureLibrettoSetup
-} from "./core/context.js";
-import {
-  SESSION_DEFAULT,
-  validateSessionName
-} from "./core/session.js";
-const CLI_COMMANDS = /* @__PURE__ */ new Set([
-  "open",
-  "run",
-  "ai",
-  "save",
-  "exec",
-  "snapshot",
-  "network",
-  "actions",
-  "pages",
-  "resume",
-  "close",
-  "init",
-  "--help",
-  "-h",
-  "help"
-]);
-function printUsage() {
-  console.log(`Usage: libretto-cli <command> [--session <name>]
-
-Commands:
-  init [--skip-browsers] Initialize libretto (copy skills, install browsers)
-  open <url> [--headless] Launch browser and open URL (headed by default)
-                          Automatically loads saved profile if available
-  run <integrationFile> <integrationExport> [--params <json> | --params-file <path>] [--headed|--headless]  Run an exported Libretto workflow from a file
-  ai configure [preset] [-- <command prefix...>]  Configure AI runtime for analysis commands
-  save <url|domain>       Save current browser session (cookies, localStorage, etc.)
-  exec <code> [--visualize]  Execute Playwright typescript code (--visualize enables ghost cursor + highlight)
-  snapshot [--objective <text> --context <text>]  Capture PNG + HTML; analyze when objective is provided (context optional)
-  network [--last N] [--filter regex] [--method M] [--clear]  View captured network requests
-  actions [--last N] [--filter regex] [--action TYPE] [--source SOURCE] [--clear]  View captured actions
-  pages                   List open pages in the active session
-  resume                  Resume a paused workflow in the active session
-  close [--all] [--force]  Close the browser for the session, or all tracked sessions with --all
-
-Options:
-  --session <name>        Use a named session (default: "default")
-                          Built-in sessions: default, dev-server, browser-agent
-
-Examples:
-  libretto-cli open https://linkedin.com
-
-  # ... manually log in ...
-  libretto-cli save linkedin.com
-  # Next time you open linkedin.com, you'll be logged in automatically
-
-  libretto-cli exec "await page.locator('button:has-text(\\"Sign in\\")').click()"
-  libretto-cli exec "await page.fill('input[name=\\"email\\"]', 'test@example.com')"
-  libretto-cli ai configure codex
-  libretto-cli ai configure claude
-  libretto-cli ai configure gemini
-  libretto-cli ai configure <codex|claude|gemini> -- <command prefix...>
-  libretto-cli snapshot
-  libretto-cli snapshot --objective "Find the submit button" --context "Submitting a referral form, already filled in patient details"
-  libretto-cli resume --session default
-  libretto-cli close
-  libretto-cli close --all
-  libretto-cli close --all --force
-
-  # Multiple sessions
-  libretto-cli open https://site1.com --session test1
-  libretto-cli open https://site2.com --session test2
-  libretto-cli exec "return await page.title()" --session test1
-
-Available in exec:
-  page, context, state, browser, networkLog, actionLog
-
-Profiles:
-  Profiles are saved to .libretto/profiles/<domain>.json (git-ignored)
-  They persist cookies, localStorage, and session data across browser launches.
-  Local profiles are machine-local and are not shared with other users/environments.
-  Sessions can expire; if run fails auth, log in again and re-save the profile.
-
-Sessions:
-  Session state is stored in .libretto/sessions/<session>/state.json
-  CLI logs are stored in .libretto/sessions/<session>/logs.jsonl
-  Each session runs an isolated browser instance on a dynamic port.
-`);
-}
-function filterSessionArgs(args) {
-  const result = [];
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--session") {
-      i++;
-    } else {
-      result.push(args[i]);
-    }
-  }
-  return result;
-}
-function parseSessionForLog(rawArgs) {
-  const idx = rawArgs.indexOf("--session");
-  if (idx < 0) return SESSION_DEFAULT;
-  const value = rawArgs[idx + 1];
-  if (!value || value.startsWith("--") || CLI_COMMANDS.has(value)) {
-    return SESSION_DEFAULT;
-  }
-  try {
-    validateSessionName(value);
-    return value;
-  } catch {
-    return SESSION_DEFAULT;
-  }
-}
-function validateLegacySessionArg(rawArgs) {
-  const idx = rawArgs.indexOf("--session");
-  if (idx < 0) return;
-  const value = rawArgs[idx + 1];
-  if (!value || value.startsWith("--") || CLI_COMMANDS.has(value)) {
-    throw new Error(
-      "Usage: libretto-cli <command> [--session <name>]\nMissing or invalid --session value."
-    );
-  }
-  validateSessionName(value);
-}
-function initializeLogger(rawArgs) {
-  const sessionForLog = parseSessionForLog(rawArgs);
-  const logger = createLoggerForSession(sessionForLog);
-  logger.info("cli-start", {
-    args: rawArgs,
-    cwd: process.cwd(),
-    session: sessionForLog
-  });
-  return logger;
-}
-async function withCliLogger(rawArgs, run) {
-  const logger = initializeLogger(rawArgs);
-  try {
-    return await run(logger);
-  } finally {
-    await closeLogger(logger);
-  }
-}
-function createParser(logger) {
-  let parser = yargs(hideBin(process.argv)).scriptName("libretto-cli").parserConfiguration({ "populate--": true }).option("session", {
-    type: "string",
-    default: SESSION_DEFAULT,
-    describe: "Use a named session",
-    global: true
-  }).middleware((argv) => {
-    validateSessionName(String(argv.session));
-  }).exitProcess(false).help(false).version(false).fail((msg, err) => {
-    if (err) throw err;
-    throw new Error(msg || "Command failed");
-  });
-  parser = registerBrowserCommands(parser, logger);
-  parser = registerExecutionCommands(parser, logger);
-  parser = registerLogCommands(parser);
-  parser = registerAICommands(parser);
-  parser = registerSnapshotCommands(parser, logger);
-  parser = registerInitCommand(parser);
-  parser = parser.command("help", "Show usage", () => {
-  }, () => {
-    printUsage();
-  });
-  return parser;
-}
-async function runLibrettoCLI() {
-  const rawArgs = process.argv.slice(2);
-  let exitCode = 0;
-  ensureLibrettoSetup();
-  await withCliLogger(rawArgs, async (logger) => {
-    try {
-      validateLegacySessionArg(rawArgs);
-      const args = filterSessionArgs(rawArgs);
-      const command = args[0];
-      if (!command || command === "--help" || command === "-h" || command === "help") {
-        printUsage();
-        return;
-      }
-      if (!CLI_COMMANDS.has(command)) {
-        console.error(`Unknown command: ${command}
-`);
-        printUsage();
-        exitCode = 1;
-        return;
-      }
-      const parser = createParser(logger);
-      logger.info("cli-command", { command, args });
-      await parser.parseAsync();
-    } catch (err) {
-      logger.error("cli-error", { error: err, args: rawArgs });
-      const message = err instanceof Error ? err.message : String(err);
-      console.error(message);
-      exitCode = 1;
-    }
-  });
-  process.exit(exitCode);
-}
-export {
-  runLibrettoCLI
-};

package/dist/cli/commands/ai.js

@@ -1,21 +0,0 @@
-import { runAiConfigure } from "../core/ai-config.js";
-function registerAICommands(yargs) {
-  return yargs.command(
-    "ai configure [preset]",
-    "Configure AI runtime",
-    (cmd) => cmd.option("clear", { type: "boolean", default: false }),
-    (argv) => {
-      const customPrefix = Array.isArray(argv["--"]) ? argv["--"] : [];
-      runAiConfigure({
-        clear: Boolean(argv.clear),
-        preset: argv.preset,
-        customPrefix
-      }, {
-        configureCommandName: "libretto-cli ai configure"
-      });
-    }
-  );
-}
-export {
-  registerAICommands
-};

package/dist/cli/commands/browser.js

@@ -1,82 +0,0 @@
-import {
-  runClose as runCloseWithLogger,
-  runCloseAll as runCloseAllWithLogger,
-  runOpen,
-  runPages,
-  runSave
-} from "../core/browser.js";
-import { withSessionLogger } from "../core/context.js";
-function registerBrowserCommands(yargs, logger) {
-  return yargs.command(
-    "open [url]",
-    "Launch browser and open URL (headed by default)",
-    (cmd) => cmd.option("headed", {
-      type: "boolean",
-      default: false
-    }).option("headless", {
-      type: "boolean",
-      default: false
-    }),
-    async (argv) => {
-      const hasHeadedFlag = Boolean(argv.headed);
-      const hasHeadlessFlag = Boolean(argv.headless);
-      if (hasHeadedFlag && hasHeadlessFlag) {
-        throw new Error("Cannot pass both --headed and --headless.");
-      }
-      const headed = hasHeadedFlag || !hasHeadlessFlag;
-      const url = argv.url;
-      if (!url) {
-        throw new Error(
-          "Usage: libretto-cli open <url> [--headless] [--session <name>]"
-        );
-      }
-      await runOpen(url, headed, String(argv.session), logger);
-    }
-  ).command(
-    "save [urlOrDomain]",
-    "Save current browser session",
-    (cmd) => cmd,
-    async (argv) => {
-      const urlOrDomain = argv.urlOrDomain;
-      if (!urlOrDomain) {
-        throw new Error("Usage: libretto-cli save <url|domain> [--session <name>]");
-      }
-      await runSave(urlOrDomain, String(argv.session), logger);
-    }
-  ).command("pages", "List open pages in the session", (cmd) => cmd, async (argv) => {
-    await runPages(String(argv.session), logger);
-  }).command(
-    "close",
-    "Close the browser",
-    (cmd) => cmd.option("all", {
-      type: "boolean",
-      default: false,
-      describe: "Close all tracked sessions in this workspace"
-    }).option("force", {
-      type: "boolean",
-      default: false,
-      describe: "Force kill sessions that ignore SIGTERM (requires --all)"
-    }),
-    async (argv) => {
-      const closeAll = Boolean(argv.all);
-      const force = Boolean(argv.force);
-      if (force && !closeAll) {
-        throw new Error("Usage: libretto-cli close --all [--force]");
-      }
-      if (closeAll) {
-        await runCloseAllWithLogger(logger, { force });
-        return;
-      }
-      await runCloseWithLogger(String(argv.session), logger);
-    }
-  );
-}
-async function runClose(session) {
-  await withSessionLogger(session, async (logger) => {
-    await runCloseWithLogger(session, logger);
-  });
-}
-export {
-  registerBrowserCommands,
-  runClose
-};