browser-pilot 0.0.1

package/dist/cli.mjs

@@ -0,0 +1,827 @@
+#!/usr/bin/env bun
+import "./chunk-ZIQA4JOT.mjs";
+import {
+  connect
+} from "./chunk-FI55U7JS.mjs";
+import "./chunk-BCOZUKWS.mjs";
+import {
+  getBrowserWebSocketUrl
+} from "./chunk-R3PS4PCM.mjs";
+import {
+  addBatchToPage
+} from "./chunk-YEHK2XY3.mjs";
+
+// src/cli/commands/actions.ts
+var ACTIONS_HELP = `
+bp actions - Complete action reference
+
+All actions are JSON objects with "action" field. Use with 'bp exec'.
+
+NAVIGATION
+  {"action": "goto", "url": "https://..."}
+    Navigate to URL.
+
+  {"action": "wait", "waitFor": "navigation"}
+    Wait for page navigation to complete.
+
+  {"action": "wait", "waitFor": "networkIdle"}
+    Wait for network activity to settle.
+
+  {"action": "wait", "timeout": 2000}
+    Simple delay in milliseconds.
+
+INTERACTION
+  {"action": "click", "selector": "#button"}
+  {"action": "click", "selector": ["#primary", ".fallback"]}
+    Click element. Multi-selector tries each until success.
+
+  {"action": "fill", "selector": "#input", "value": "text"}
+  {"action": "fill", "selector": "#input", "value": "text", "clear": false}
+    Fill input field. Clears first by default.
+
+  {"action": "type", "selector": "#input", "value": "text", "delay": 50}
+    Type character-by-character (for autocomplete).
+
+  {"action": "select", "selector": "#dropdown", "value": "option-value"}
+    Select native <select> option by value.
+
+  {"action": "select", "trigger": ".dropdown", "option": ".item", "value": "Label", "match": "text"}
+    Custom dropdown: click trigger, then click matching option.
+
+  {"action": "check", "selector": "#checkbox"}
+  {"action": "uncheck", "selector": "#checkbox"}
+    Check/uncheck checkbox or radio.
+
+  {"action": "submit", "selector": "form"}
+  {"action": "submit", "selector": "#btn", "method": "click"}
+    Submit form. Methods: enter | click | enter+click (default).
+
+  {"action": "press", "key": "Enter"}
+  {"action": "press", "key": "Escape"}
+  {"action": "press", "key": "Tab"}
+    Press key. Common keys: Enter, Tab, Escape, Backspace, Delete, ArrowUp/Down/Left/Right.
+
+  {"action": "focus", "selector": "#input"}
+  {"action": "hover", "selector": ".menu-item"}
+    Focus or hover element.
+
+  {"action": "scroll", "selector": "#footer"}
+  {"action": "scroll", "x": 0, "y": 1000}
+  {"action": "scroll", "direction": "down", "amount": 500}
+    Scroll to element, coordinates, or by direction (up/down/left/right).
+
+WAITING
+  {"action": "wait", "selector": ".loaded", "waitFor": "visible"}
+  {"action": "wait", "selector": ".spinner", "waitFor": "hidden"}
+  {"action": "wait", "selector": "#element", "waitFor": "attached"}
+  {"action": "wait", "selector": "#removed", "waitFor": "detached"}
+    Wait for element state. States: visible | hidden | attached | detached.
+
+  {"action": "wait", "timeout": 1000}
+    Simple delay (milliseconds).
+
+CONTENT EXTRACTION
+  {"action": "snapshot"}
+    Get accessibility tree (best for understanding page structure).
+
+  {"action": "screenshot"}
+  {"action": "screenshot", "fullPage": true, "format": "jpeg", "quality": 80}
+    Capture screenshot. Formats: png | jpeg | webp.
+
+  {"action": "evaluate", "value": "document.title"}
+    Run JavaScript and return result.
+
+IFRAME NAVIGATION
+  {"action": "switchFrame", "selector": "iframe#checkout"}
+    Switch context to an iframe. All subsequent actions target the iframe content.
+
+  {"action": "switchToMain"}
+    Switch back to the main document from an iframe.
+
+  Example iframe workflow:
+    [
+      {"action": "switchFrame", "selector": "iframe#payment"},
+      {"action": "fill", "selector": "#card-number", "value": "4242424242424242"},
+      {"action": "fill", "selector": "#expiry", "value": "12/25"},
+      {"action": "switchToMain"},
+      {"action": "click", "selector": "#submit-order"}
+    ]
+
+  Note: Cross-origin iframes cannot be accessed due to browser security.
+
+DIALOG HANDLING
+  Use --dialog flag: bp exec --dialog accept '[...]'
+  Modes: accept (click OK), dismiss (click Cancel)
+
+  WARNING: Without --dialog flag, native dialogs (alert/confirm/prompt) will
+  block ALL automation until manual intervention.
+
+COMMON OPTIONS (all actions)
+  "timeout": 5000        Override default timeout (ms)
+  "optional": true       Don't fail if element not found
+
+REF SELECTORS (from snapshot)
+  After taking a snapshot, use refs directly:
+    bp snapshot -s dev --format text   # Shows: button "Submit" [ref=e4]
+    bp exec '{"action":"click","selector":"ref:e4"}'
+
+  Refs are stable until navigation. Prefix with "ref:" to use.
+  Example: {"action":"fill","selector":"ref:e23","value":"hello"}
+
+MULTI-SELECTOR PATTERN
+  All selectors accept arrays: ["#id", ".class", "[aria-label=X]"]
+  Tries each in order until one succeeds.
+  Combine refs with CSS fallbacks: ["ref:e4", "#submit", ".btn"]
+
+SELECTOR PRIORITY (Most to Least Reliable)
+  1. ref:eN               - From snapshot, most reliable for AI agents
+  2. [data-testid="..."]  - Explicit test hooks
+  3. #id                  - Reliable if IDs are stable
+  4. [aria-label="..."]   - Good for buttons without testids
+  5. Multi-selector array - Fallback pattern for compatibility
+
+SHADOW DOM
+  Selectors automatically pierce shadow DOM (1-2 levels). No special syntax needed.
+  For deeper nesting (3+ levels), use refs from snapshot - they work at any depth.
+
+:has-text() SELECTOR
+  Matches elements containing text content.
+  Does NOT match aria-label - use [aria-label="..."] instead.
+  Example: button:has-text("Submit") matches <button>Submit</button>
+           button[aria-label="Submit"] matches <button aria-label="Submit">X</button>
+
+EXAMPLES
+  # Login flow
+  bp exec '[
+    {"action":"goto","url":"https://app.example.com/login"},
+    {"action":"fill","selector":"#email","value":"user@example.com"},
+    {"action":"fill","selector":"#password","value":"secret"},
+    {"action":"submit","selector":"form"},
+    {"action":"wait","waitFor":"navigation"},
+    {"action":"snapshot"}
+  ]'
+
+  # Handle cookie banner then extract content
+  bp exec '[
+    {"action":"goto","url":"https://example.com"},
+    {"action":"click","selector":"#accept-cookies","optional":true,"timeout":3000},
+    {"action":"snapshot"}
+  ]'
+
+  # Use ref from snapshot
+  bp snapshot --format text  # Note the refs
+  bp exec '{"action":"click","selector":"ref:e4"}'
+
+  # Scroll and wait
+  bp exec '[
+    {"action":"scroll","direction":"down","amount":1000},
+    {"action":"wait","timeout":500},
+    {"action":"scroll","direction":"down","amount":1000}
+  ]'
+
+  # Handle dialogs
+  bp exec --dialog accept '[
+    {"action":"click","selector":"#delete-btn"},
+    {"action":"wait","selector":"#success-message","waitFor":"visible"}
+  ]'
+`;
+async function actionsCommand() {
+  console.log(ACTIONS_HELP);
+}
+
+// src/cli/session.ts
+import { homedir } from "os";
+import { join } from "path";
+var SESSION_DIR = join(homedir(), ".browser-pilot", "sessions");
+async function ensureSessionDir() {
+  const fs = await import("fs/promises");
+  await fs.mkdir(SESSION_DIR, { recursive: true });
+}
+async function saveSession(session) {
+  await ensureSessionDir();
+  const fs = await import("fs/promises");
+  const filePath = join(SESSION_DIR, `${session.id}.json`);
+  await fs.writeFile(filePath, JSON.stringify(session, null, 2));
+}
+async function loadSession(id) {
+  const fs = await import("fs/promises");
+  const filePath = join(SESSION_DIR, `${id}.json`);
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Session not found: ${id}`);
+    }
+    throw error;
+  }
+}
+async function updateSession(id, updates) {
+  const session = await loadSession(id);
+  const updated = {
+    ...session,
+    ...updates,
+    lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveSession(updated);
+  return updated;
+}
+async function deleteSession(id) {
+  const fs = await import("fs/promises");
+  const filePath = join(SESSION_DIR, `${id}.json`);
+  try {
+    await fs.unlink(filePath);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+async function listSessions() {
+  await ensureSessionDir();
+  const fs = await import("fs/promises");
+  try {
+    const files = await fs.readdir(SESSION_DIR);
+    const sessions = [];
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        try {
+          const content = await fs.readFile(join(SESSION_DIR, file), "utf-8");
+          sessions.push(JSON.parse(content));
+        } catch {
+        }
+      }
+    }
+    return sessions.sort(
+      (a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime()
+    );
+  } catch {
+    return [];
+  }
+}
+function generateSessionId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${timestamp}-${random}`;
+}
+async function getDefaultSession() {
+  const sessions = await listSessions();
+  return sessions[0] ?? null;
+}
+
+// src/cli/commands/close.ts
+async function closeCommand(args, globalOptions) {
+  let session;
+  if (globalOptions.session) {
+    session = await loadSession(globalOptions.session);
+  } else if (args[0]) {
+    session = await loadSession(args[0]);
+  } else {
+    session = await getDefaultSession();
+    if (!session) {
+      throw new Error('No session found. Specify a session ID or run "bp list" to see sessions.');
+    }
+  }
+  try {
+    const browser = await connect({
+      provider: session.provider,
+      wsUrl: session.wsUrl,
+      debug: globalOptions.trace
+    });
+    await browser.close();
+  } catch {
+  }
+  await deleteSession(session.id);
+  output(
+    {
+      success: true,
+      sessionId: session.id,
+      message: "Session closed"
+    },
+    globalOptions.output
+  );
+}
+
+// src/cli/commands/connect.ts
+function parseConnectArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--provider" || arg === "-p") {
+      options.provider = args[++i];
+    } else if (arg === "--url") {
+      options.url = args[++i];
+    } else if (arg === "--name" || arg === "-n") {
+      options.name = args[++i];
+    } else if (arg === "--resume" || arg === "-r") {
+      options.resume = args[++i];
+    } else if (arg === "--api-key") {
+      options.apiKey = args[++i];
+    } else if (arg === "--project-id") {
+      options.projectId = args[++i];
+    }
+  }
+  return options;
+}
+async function connectCommand(args, globalOptions) {
+  const options = parseConnectArgs(args);
+  if (options.resume || globalOptions.session) {
+    const sessionId2 = options.resume || globalOptions.session;
+    const session2 = await loadSession(sessionId2);
+    output(
+      {
+        success: true,
+        resumed: true,
+        sessionId: session2.id,
+        provider: session2.provider,
+        currentUrl: session2.currentUrl
+      },
+      globalOptions.output
+    );
+    return;
+  }
+  const provider = options.provider ?? "generic";
+  let wsUrl = options.url;
+  if (provider === "generic" && !wsUrl) {
+    try {
+      wsUrl = await getBrowserWebSocketUrl("localhost:9222");
+    } catch {
+      throw new Error(
+        "Could not auto-discover browser. Specify --url or start Chrome with --remote-debugging-port=9222"
+      );
+    }
+  }
+  const connectOptions = {
+    provider,
+    debug: globalOptions.trace,
+    wsUrl,
+    apiKey: options.apiKey,
+    projectId: options.projectId
+  };
+  const browser = await connect(connectOptions);
+  const page = await browser.page();
+  const currentUrl = await page.url();
+  const sessionId = options.name ?? generateSessionId();
+  const session = {
+    id: sessionId,
+    provider,
+    wsUrl: browser.wsUrl,
+    providerSessionId: browser.sessionId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+    currentUrl,
+    metadata: browser.metadata
+  };
+  await saveSession(session);
+  await browser.disconnect();
+  output(
+    {
+      success: true,
+      sessionId,
+      provider,
+      currentUrl,
+      metadata: browser.metadata
+    },
+    globalOptions.output
+  );
+}
+
+// src/cli/commands/exec.ts
+function parseExecArgs(args) {
+  const options = {};
+  let actionsJson;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--dialog") {
+      const value = args[++i];
+      if (value === "accept" || value === "dismiss") {
+        options.dialog = value;
+      } else {
+        throw new Error('--dialog must be "accept" or "dismiss"');
+      }
+    } else if (!actionsJson && !arg.startsWith("-")) {
+      actionsJson = arg;
+    }
+  }
+  return { actionsJson, options };
+}
+async function execCommand(args, globalOptions) {
+  const { actionsJson, options: execOptions } = parseExecArgs(args);
+  let session;
+  if (globalOptions.session) {
+    session = await loadSession(globalOptions.session);
+  } else {
+    session = await getDefaultSession();
+    if (!session) {
+      throw new Error('No session found. Run "bp connect" first.');
+    }
+  }
+  if (!actionsJson) {
+    throw new Error(
+      `No actions provided. Usage: bp exec '{"action":"goto","url":"..."}'
+
+Run 'bp actions' for complete action reference.`
+    );
+  }
+  let actions;
+  try {
+    actions = JSON.parse(actionsJson);
+  } catch {
+    throw new Error(
+      "Invalid JSON. Actions must be valid JSON.\n\nRun 'bp actions' for complete action reference."
+    );
+  }
+  const browser = await connect({
+    provider: session.provider,
+    wsUrl: session.wsUrl,
+    debug: globalOptions.trace
+  });
+  try {
+    const page = addBatchToPage(await browser.page());
+    if (execOptions.dialog) {
+      await page.onDialog(async (dialog) => {
+        if (execOptions.dialog === "accept") {
+          await dialog.accept();
+        } else {
+          await dialog.dismiss();
+        }
+      });
+    }
+    const steps = Array.isArray(actions) ? actions : [actions];
+    const result = await page.batch(steps);
+    const currentUrl = await page.url();
+    await updateSession(session.id, { currentUrl });
+    output(
+      {
+        success: result.success,
+        stoppedAtIndex: result.stoppedAtIndex,
+        steps: result.steps.map((s) => ({
+          action: s.action,
+          success: s.success,
+          durationMs: s.durationMs,
+          selectorUsed: s.selectorUsed,
+          error: s.error,
+          text: s.text,
+          result: s.result
+        })),
+        totalDurationMs: result.totalDurationMs,
+        currentUrl
+      },
+      globalOptions.output
+    );
+  } finally {
+    await browser.disconnect();
+  }
+}
+
+// src/cli/commands/list.ts
+async function listCommand(_args, globalOptions) {
+  const sessions = await listSessions();
+  if (globalOptions.output === "json") {
+    output(sessions, "json");
+    return;
+  }
+  if (sessions.length === 0) {
+    console.log("No active sessions.");
+    console.log('Run "bp connect" to create a new session.');
+    return;
+  }
+  console.log("Active Sessions:\n");
+  for (const session of sessions) {
+    const age = getAge(new Date(session.lastActivity));
+    console.log(`  ${session.id}`);
+    console.log(`    Provider: ${session.provider}`);
+    console.log(`    URL: ${session.currentUrl}`);
+    console.log(`    Last activity: ${age}`);
+    console.log("");
+  }
+}
+function getAge(date) {
+  const now = Date.now();
+  const diff = now - date.getTime();
+  const seconds = Math.floor(diff / 1e3);
+  if (seconds < 60) return "just now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+// src/cli/commands/screenshot.ts
+function parseScreenshotArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--output" || arg === "-o") {
+      options.outputPath = args[++i];
+    } else if (arg === "--format" || arg === "-f") {
+      options.format = args[++i];
+    } else if (arg === "--quality" || arg === "-q") {
+      options.quality = parseInt(args[++i], 10);
+    } else if (arg === "--full-page" || arg === "--fullpage") {
+      options.fullPage = true;
+    }
+  }
+  return options;
+}
+async function screenshotCommand(args, globalOptions) {
+  const options = parseScreenshotArgs(args);
+  let session;
+  if (globalOptions.session) {
+    session = await loadSession(globalOptions.session);
+  } else {
+    session = await getDefaultSession();
+    if (!session) {
+      throw new Error('No session found. Run "bp connect" first.');
+    }
+  }
+  const browser = await connect({
+    provider: session.provider,
+    wsUrl: session.wsUrl,
+    debug: globalOptions.trace
+  });
+  try {
+    const page = await browser.page();
+    const screenshotData = await page.screenshot({
+      format: options.format ?? "png",
+      quality: options.quality,
+      fullPage: options.fullPage ?? false
+    });
+    if (options.outputPath) {
+      const buffer = Buffer.from(screenshotData, "base64");
+      await Bun.write(options.outputPath, buffer);
+      output(
+        {
+          success: true,
+          path: options.outputPath,
+          size: buffer.length,
+          format: options.format ?? "png"
+        },
+        globalOptions.output
+      );
+    } else {
+      if (globalOptions.output === "json") {
+        output({ data: screenshotData, format: options.format ?? "png" }, "json");
+      } else {
+        console.log(screenshotData);
+      }
+    }
+  } finally {
+    await browser.disconnect();
+  }
+}
+
+// src/cli/commands/snapshot.ts
+function parseSnapshotArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--format" || arg === "-f") {
+      options.format = args[++i];
+    }
+  }
+  return options;
+}
+async function snapshotCommand(args, globalOptions) {
+  const options = parseSnapshotArgs(args);
+  let session;
+  if (globalOptions.session) {
+    session = await loadSession(globalOptions.session);
+  } else {
+    session = await getDefaultSession();
+    if (!session) {
+      throw new Error('No session found. Run "bp connect" first.');
+    }
+  }
+  const browser = await connect({
+    provider: session.provider,
+    wsUrl: session.wsUrl,
+    debug: globalOptions.trace
+  });
+  try {
+    const page = await browser.page();
+    const snapshot = await page.snapshot();
+    await updateSession(session.id, { currentUrl: snapshot.url });
+    switch (options.format) {
+      case "interactive":
+        output(snapshot.interactiveElements, globalOptions.output);
+        break;
+      case "text":
+        console.log(snapshot.text);
+        break;
+      default:
+        output(snapshot, globalOptions.output);
+        break;
+    }
+  } finally {
+    await browser.disconnect();
+  }
+}
+
+// src/cli/commands/text.ts
+function parseTextArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--selector" || arg === "-s") {
+      options.selector = args[++i];
+    }
+  }
+  return options;
+}
+async function textCommand(args, globalOptions) {
+  const options = parseTextArgs(args);
+  let session;
+  if (globalOptions.session) {
+    session = await loadSession(globalOptions.session);
+  } else {
+    session = await getDefaultSession();
+    if (!session) {
+      throw new Error('No session found. Run "bp connect" first.');
+    }
+  }
+  const browser = await connect({
+    provider: session.provider,
+    wsUrl: session.wsUrl,
+    debug: globalOptions.trace
+  });
+  try {
+    const page = await browser.page();
+    const text = await page.text(options.selector);
+    const currentUrl = await page.url();
+    await updateSession(session.id, { currentUrl });
+    if (globalOptions.output === "json") {
+      output({ text, url: currentUrl, selector: options.selector }, "json");
+    } else {
+      console.log(text);
+    }
+  } finally {
+    await browser.disconnect();
+  }
+}
+
+// src/cli/index.ts
+var HELP = `
+bp - Browser automation CLI for AI agents
+
+Usage:
+  bp <command> [options]
+
+Commands:
+  connect     Create or resume browser session
+  exec        Execute actions on current session
+  snapshot    Get page accessibility snapshot (includes element refs)
+  text        Extract text content from page
+  screenshot  Take screenshot
+  close       Close session
+  list        List all sessions
+  actions     Show all available actions with examples
+
+Global Options:
+  -s, --session <id>    Session ID to use
+  -o, --output <fmt>    Output format: json | pretty (default: pretty)
+  --trace               Enable execution tracing
+  -h, --help            Show this help message
+
+Exec Options:
+  --dialog <mode>       Auto-handle dialogs: accept | dismiss
+
+Ref Selectors (Recommended for AI Agents):
+  1. Take snapshot:     bp snapshot --format text
+     Output shows:      button "Submit" [ref=e4], textbox "Email" [ref=e5]
+  2. Use ref directly:  bp exec '{"action":"click","selector":"ref:e4"}'
+
+  Refs are stable until navigation. Combine with CSS fallbacks:
+    {"selector": ["ref:e4", "#submit", "button[type=submit]"]}
+
+Examples:
+  # Connect to browser
+  bp connect --provider generic --name dev
+
+  # Navigate and get snapshot with refs
+  bp exec '{"action":"goto","url":"https://example.com"}'
+  bp snapshot --format text
+
+  # Use ref from snapshot (most reliable)
+  bp exec '{"action":"click","selector":"ref:e4"}'
+  bp exec '{"action":"fill","selector":"ref:e5","value":"test@example.com"}'
+
+  # Handle native dialogs (alert/confirm/prompt)
+  bp exec --dialog accept '{"action":"click","selector":"#delete-btn"}'
+
+  # Batch multiple actions
+  bp exec '[
+    {"action":"fill","selector":"ref:e5","value":"user@example.com"},
+    {"action":"click","selector":"ref:e4"},
+    {"action":"snapshot"}
+  ]'
+
+Run 'bp actions' for complete action reference.
+`;
+function parseGlobalOptions(args) {
+  const options = {
+    output: "pretty"
+  };
+  const remaining = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-s" || arg === "--session") {
+      options.session = args[++i];
+    } else if (arg === "-o" || arg === "--output") {
+      options.output = args[++i];
+    } else if (arg === "--trace") {
+      options.trace = true;
+    } else if (arg === "-h" || arg === "--help") {
+      options.help = true;
+    } else {
+      remaining.push(arg);
+    }
+  }
+  return { options, remaining };
+}
+function output(data, format = "pretty") {
+  if (format === "json") {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    if (typeof data === "string") {
+      console.log(data);
+    } else if (typeof data === "object" && data !== null) {
+      prettyPrint(data);
+    } else {
+      console.log(data);
+    }
+  }
+}
+function prettyPrint(obj, indent = 0) {
+  const prefix = "  ".repeat(indent);
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      console.log(`${prefix}${key}:`);
+      prettyPrint(value, indent + 1);
+    } else if (Array.isArray(value)) {
+      console.log(`${prefix}${key}: [${value.length} items]`);
+    } else {
+      console.log(`${prefix}${key}: ${value}`);
+    }
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  const command = args[0];
+  const { options, remaining } = parseGlobalOptions(args.slice(1));
+  if (options.help && !command) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  try {
+    switch (command) {
+      case "connect":
+        await connectCommand(remaining, options);
+        break;
+      case "exec":
+        await execCommand(remaining, options);
+        break;
+      case "snapshot":
+        await snapshotCommand(remaining, options);
+        break;
+      case "text":
+        await textCommand(remaining, options);
+        break;
+      case "screenshot":
+        await screenshotCommand(remaining, options);
+        break;
+      case "close":
+        await closeCommand(remaining, options);
+        break;
+      case "list":
+        await listCommand(remaining, options);
+        break;
+      case "actions":
+        await actionsCommand();
+        break;
+      case "help":
+      case "--help":
+      case "-h":
+        console.log(HELP);
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.log(HELP);
+        process.exit(1);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+}
+main();
+export {
+  output
+};