browsirai 0.1.0 → 0.2.0

package/dist/cli/commands/act.js

@@ -0,0 +1,1226 @@
+// src/cli/run.ts
+import pc from "picocolors";
+
+// src/chrome-launcher.ts
+import { execSync, spawn } from "child_process";
+import { existsSync, readFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import http from "http";
+import { join } from "path";
+import { homedir, tmpdir } from "os";
+import { createConnection } from "net";
+
+// src/cli/run.ts
+function parseFlags(args) {
+  const flags = {};
+  let positionalIndex = 0;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        const key2 = arg.slice(2, eqIdx);
+        const value = arg.slice(eqIdx + 1);
+        flags[key2] = value;
+      } else {
+        const key2 = arg.slice(2);
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[key2] = next;
+          i++;
+        } else {
+          flags[key2] = "true";
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1 && !/^-\d/.test(arg)) {
+      const chars = arg.slice(1);
+      if (chars.length === 1) {
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[chars] = next;
+          i++;
+        } else {
+          flags[chars] = "true";
+        }
+      } else {
+        for (const ch of chars) {
+          flags[ch] = "true";
+        }
+      }
+    } else {
+      flags[`_${positionalIndex}`] = arg;
+      positionalIndex++;
+    }
+  }
+  return flags;
+}
+
+// src/tools/browser-click.ts
+var MODIFIER_BITS = {
+  Alt: 1,
+  Control: 2,
+  Meta: 4,
+  Shift: 8
+};
+var REF_PATTERN = /^@e(\d+)$/;
+function calculateCenter(content) {
+  const x = (content[0] + content[2] + content[4] + content[6]) / 4;
+  const y = (content[1] + content[3] + content[5] + content[7]) / 4;
+  return { x: Math.round(x), y: Math.round(y) };
+}
+async function resolveElementCoordinates(cdp, params) {
+  let backendNodeId;
+  let nodeId;
+  if (params.ref) {
+    const match = REF_PATTERN.exec(params.ref);
+    if (!match) {
+      throw new Error(`Invalid ref format: ${params.ref}`);
+    }
+    backendNodeId = parseInt(match[1], 10);
+    await cdp.send("DOM.resolveNode", {
+      backendNodeId
+    });
+  } else if (params.selector) {
+    const docResponse = await cdp.send("DOM.getDocument");
+    const queryResponse = await cdp.send("DOM.querySelector", {
+      nodeId: docResponse.root.nodeId,
+      selector: params.selector
+    });
+    if (!queryResponse.nodeId || queryResponse.nodeId === 0) {
+      throw new Error(
+        `Element not found: no element matches selector "${params.selector}"`
+      );
+    }
+    nodeId = queryResponse.nodeId;
+  } else {
+    throw new Error("Either ref, selector, or coordinates (x, y) must be provided");
+  }
+  const scrollParams = {};
+  if (backendNodeId !== void 0) {
+    scrollParams.backendNodeId = backendNodeId;
+  } else if (nodeId !== void 0) {
+    scrollParams.nodeId = nodeId;
+  }
+  await cdp.send(
+    "DOM.scrollIntoViewIfNeeded",
+    scrollParams
+  );
+  const boxParams = {};
+  if (backendNodeId !== void 0) {
+    boxParams.backendNodeId = backendNodeId;
+  } else if (nodeId !== void 0) {
+    boxParams.nodeId = nodeId;
+  }
+  const boxResponse = await cdp.send("DOM.getBoxModel", boxParams);
+  const { content, width, height } = boxResponse.model;
+  if (width === 0 && height === 0) {
+    throw new Error(
+      "Element is not visible: zero-size box model. The element may be hidden or not rendered."
+    );
+  }
+  return calculateCenter(content);
+}
+function computeModifiers(modifiers) {
+  if (!modifiers || modifiers.length === 0) return 0;
+  let bits = 0;
+  for (const mod of modifiers) {
+    const bit = MODIFIER_BITS[mod];
+    if (bit !== void 0) {
+      bits |= bit;
+    }
+  }
+  return bits;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function browserClick(cdp, params) {
+  let x;
+  let y;
+  if (params.x !== void 0 && params.y !== void 0) {
+    x = params.x;
+    y = params.y;
+  } else {
+    const coords = await resolveElementCoordinates(cdp, params);
+    x = coords.x;
+    y = coords.y;
+  }
+  const button = params.button ?? "left";
+  let effectiveModifiers = params.modifiers ? [...params.modifiers] : [];
+  if (params.newTab) {
+    const isMac = typeof process !== "undefined" && process.platform === "darwin";
+    const newTabModifier = isMac ? "Meta" : "Control";
+    if (!effectiveModifiers.includes(newTabModifier)) {
+      effectiveModifiers.push(newTabModifier);
+    }
+  }
+  const modifiers = computeModifiers(effectiveModifiers);
+  if (params.doubleClick) {
+    await performDoubleClick(cdp, x, y, button, modifiers);
+  } else {
+    await performClick(cdp, x, y, button, modifiers);
+  }
+  return { success: true };
+}
+async function performClick(cdp, x, y, button, modifiers, clickCount = 1) {
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseMoved",
+    x,
+    y,
+    modifiers
+  });
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mousePressed",
+    x,
+    y,
+    button,
+    clickCount,
+    modifiers
+  });
+  await delay(50);
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseReleased",
+    x,
+    y,
+    button,
+    clickCount,
+    modifiers
+  });
+}
+async function performDoubleClick(cdp, x, y, button, modifiers) {
+  await performClick(cdp, x, y, button, modifiers, 1);
+  await performClick(cdp, x, y, button, modifiers, 2);
+}
+
+// src/tools/browser-fill-form.ts
+function parseRef(ref) {
+  const match = ref.match(/@?e(\d+)/);
+  if (!match) {
+    throw new Error(`Invalid ref format: ${ref}`);
+  }
+  return parseInt(match[1], 10);
+}
+async function resolveObjectId(cdp, field) {
+  if (field.ref) {
+    const backendNodeId = parseRef(field.ref);
+    const result = await cdp.send("DOM.resolveNode", {
+      backendNodeId
+    });
+    return result.object.objectId;
+  }
+  if (field.selector) {
+    const evalResult = await cdp.send("Runtime.evaluate", {
+      expression: `document.querySelector(${JSON.stringify(field.selector)})`,
+      returnByValue: false
+    });
+    if (evalResult.result.objectId) {
+      return evalResult.result.objectId;
+    }
+    const docResult = await cdp.send(
+      "DOM.getDocument",
+      {}
+    );
+    const queryResult = await cdp.send("DOM.querySelector", {
+      nodeId: docResult.root.nodeId,
+      selector: field.selector
+    });
+    const resolveResult = await cdp.send("DOM.resolveNode", {
+      nodeId: queryResult.nodeId
+    });
+    return resolveResult.object.objectId;
+  }
+  throw new Error(`Field "${field.name}" has neither ref nor selector`);
+}
+async function isReadonlyOrDisabled(cdp, objectId) {
+  const result = await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() { return this.readOnly || this.disabled; }`,
+    returnByValue: true
+  });
+  return result.result.value === true;
+}
+async function clickElement(cdp, field) {
+  let backendNodeId;
+  if (field.ref) {
+    backendNodeId = parseRef(field.ref);
+  }
+  if (backendNodeId !== void 0) {
+    await cdp.send("DOM.scrollIntoViewIfNeeded", {
+      backendNodeId
+    });
+  }
+  const boxResult = await cdp.send("DOM.getBoxModel", {
+    backendNodeId
+  });
+  const quad = boxResult.model.content;
+  const centerX = (quad[0] + quad[2] + quad[4] + quad[6]) / 4;
+  const centerY = (quad[1] + quad[3] + quad[5] + quad[7]) / 4;
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mousePressed",
+    x: centerX,
+    y: centerY,
+    button: "left",
+    clickCount: 1
+  });
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseReleased",
+    x: centerX,
+    y: centerY,
+    button: "left",
+    clickCount: 1
+  });
+}
+async function fillTextbox(cdp, field, objectId) {
+  if (field.ref) {
+    const backendNodeId = parseRef(field.ref);
+    await cdp.send("DOM.focus", {
+      backendNodeId
+    });
+  } else {
+    await cdp.send("Runtime.callFunctionOn", {
+      objectId,
+      functionDeclaration: `function() { this.focus(); }`,
+      returnByValue: true
+    });
+  }
+  await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() { this.value = ''; this.dispatchEvent(new Event('input', { bubbles: true })); }`,
+    returnByValue: true
+  });
+  await cdp.send("Input.insertText", {
+    text: field.value
+  });
+  await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() {
+      this.dispatchEvent(new Event('input', { bubbles: true }));
+      this.dispatchEvent(new Event('change', { bubbles: true }));
+    }`,
+    returnByValue: true
+  });
+}
+async function fillCombobox(cdp, _field, objectId, value) {
+  await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function(val) {
+      this.value = val;
+      this.dispatchEvent(new Event('input', { bubbles: true }));
+      this.dispatchEvent(new Event('change', { bubbles: true }));
+      return [val];
+    }`,
+    arguments: [{ value }],
+    returnByValue: true
+  });
+}
+async function fillSlider(cdp, _field, objectId, value) {
+  await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function(val) {
+      this.value = val;
+      this.dispatchEvent(new Event('input', { bubbles: true }));
+      this.dispatchEvent(new Event('change', { bubbles: true }));
+    }`,
+    arguments: [{ value }],
+    returnByValue: true
+  });
+}
+async function browserFillForm(cdp, params) {
+  let filledCount = 0;
+  const errors = [];
+  for (const field of params.fields) {
+    try {
+      const objectId = await resolveObjectId(cdp, field);
+      switch (field.type) {
+        case "textbox": {
+          const isBlocked = await isReadonlyOrDisabled(cdp, objectId);
+          if (isBlocked) {
+            errors.push({
+              field: field.name,
+              error: `Cannot fill readonly or disabled field "${field.name}"`
+            });
+            continue;
+          }
+          await fillTextbox(cdp, field, objectId);
+          filledCount++;
+          break;
+        }
+        case "checkbox": {
+          await clickElement(cdp, field);
+          filledCount++;
+          break;
+        }
+        case "radio": {
+          await clickElement(cdp, field);
+          filledCount++;
+          break;
+        }
+        case "combobox": {
+          await fillCombobox(cdp, field, objectId, field.value);
+          filledCount++;
+          break;
+        }
+        case "slider": {
+          await fillSlider(cdp, field, objectId, field.value);
+          filledCount++;
+          break;
+        }
+        default: {
+          await fillTextbox(cdp, field, objectId);
+          filledCount++;
+          break;
+        }
+      }
+    } catch (err) {
+      errors.push({
+        field: field.name,
+        error: err instanceof Error ? err.message : `Unknown error filling ${field.name}`
+      });
+    }
+  }
+  return {
+    success: errors.length === 0,
+    filledCount,
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+
+// src/tools/browser-type.ts
+function parseRef2(ref) {
+  const match = ref.match(/@e(\d+)/);
+  if (!match) {
+    throw new Error(`Invalid ref format: ${ref}`);
+  }
+  return parseInt(match[1], 10);
+}
+function getKeyCode(key2) {
+  if (key2.length === 1) {
+    return key2.toUpperCase().charCodeAt(0);
+  }
+  const codes = {
+    Enter: 13,
+    Tab: 9,
+    Backspace: 8
+  };
+  return codes[key2] ?? 0;
+}
+function getCode(key2) {
+  if (key2.length === 1) {
+    const upper = key2.toUpperCase();
+    if (upper >= "A" && upper <= "Z") return `Key${upper}`;
+    if (upper >= "0" && upper <= "9") return `Digit${upper}`;
+  }
+  return key2;
+}
+function delay2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function dispatchCharEvents(cdp, char) {
+  const keyCode = getKeyCode(char);
+  const code = getCode(char);
+  await cdp.send("Input.dispatchKeyEvent", {
+    type: "keyDown",
+    key: char,
+    code,
+    windowsVirtualKeyCode: keyCode,
+    text: char
+  });
+  await cdp.send("Input.dispatchKeyEvent", {
+    type: "char",
+    key: char,
+    code,
+    windowsVirtualKeyCode: keyCode,
+    text: char
+  });
+  await cdp.send("Input.dispatchKeyEvent", {
+    type: "keyUp",
+    key: char,
+    code,
+    windowsVirtualKeyCode: keyCode
+  });
+}
+async function browserType(cdp, params) {
+  if (params.ref) {
+    const backendNodeId = parseRef2(params.ref);
+    await cdp.send("DOM.focus", {
+      backendNodeId
+    });
+  }
+  if (!params.ref && params.selector) {
+    const evalResult = await cdp.send("Runtime.evaluate", {
+      expression: `document.querySelector(${JSON.stringify(params.selector)})`,
+      returnByValue: false
+    });
+    if (evalResult.result.objectId) {
+      await cdp.send("Runtime.callFunctionOn", {
+        objectId: evalResult.result.objectId,
+        functionDeclaration: `function() { this.focus(); }`,
+        returnByValue: true
+      });
+    }
+  }
+  if (params.slowly) {
+    for (let i = 0; i < params.text.length; i++) {
+      await dispatchCharEvents(cdp, params.text[i]);
+      if (i < params.text.length - 1) {
+        await delay2(50);
+      }
+    }
+  } else {
+    await cdp.send("Input.insertText", {
+      text: params.text
+    });
+  }
+  if (params.submit) {
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "keyDown",
+      key: "Enter",
+      code: "Enter",
+      windowsVirtualKeyCode: 13
+    });
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "keyUp",
+      key: "Enter",
+      code: "Enter",
+      windowsVirtualKeyCode: 13
+    });
+  }
+  return { success: true };
+}
+
+// src/tools/browser-press-key.ts
+var KEY_CODE_MAP = {
+  Enter: 13,
+  Tab: 9,
+  Escape: 27,
+  Backspace: 8,
+  Delete: 46,
+  ArrowLeft: 37,
+  ArrowUp: 38,
+  ArrowRight: 39,
+  ArrowDown: 40,
+  Home: 36,
+  End: 35,
+  PageUp: 33,
+  PageDown: 34,
+  Insert: 45,
+  Space: 32,
+  " ": 32,
+  F1: 112,
+  F2: 113,
+  F3: 114,
+  F4: 115,
+  F5: 116,
+  F6: 117,
+  F7: 118,
+  F8: 119,
+  F9: 120,
+  F10: 121,
+  F11: 122,
+  F12: 123,
+  Control: 17,
+  Shift: 16,
+  Alt: 18,
+  Meta: 91
+};
+var KEY_TO_CODE = {
+  Enter: "Enter",
+  Tab: "Tab",
+  Escape: "Escape",
+  Backspace: "Backspace",
+  Delete: "Delete",
+  ArrowLeft: "ArrowLeft",
+  ArrowUp: "ArrowUp",
+  ArrowRight: "ArrowRight",
+  ArrowDown: "ArrowDown",
+  Home: "Home",
+  End: "End",
+  PageUp: "PageUp",
+  PageDown: "PageDown",
+  Insert: "Insert",
+  Space: "Space",
+  " ": "Space",
+  Control: "ControlLeft",
+  Shift: "ShiftLeft",
+  Alt: "AltLeft",
+  Meta: "MetaLeft"
+};
+var KEY_TEXT_MAP = {
+  Enter: "\r",
+  Tab: "	",
+  Escape: "",
+  Space: " ",
+  Backspace: "\b"
+};
+var MODIFIER_BITS2 = {
+  Alt: 1,
+  Control: 2,
+  Meta: 4,
+  Shift: 8
+};
+function getKeyCode2(key2) {
+  if (KEY_CODE_MAP[key2] !== void 0) {
+    return KEY_CODE_MAP[key2];
+  }
+  if (key2.length === 1) {
+    return key2.toUpperCase().charCodeAt(0);
+  }
+  return 0;
+}
+function getCode2(key2) {
+  if (KEY_TO_CODE[key2] !== void 0) {
+    return KEY_TO_CODE[key2];
+  }
+  if (key2.length === 1) {
+    const upper = key2.toUpperCase();
+    if (upper >= "A" && upper <= "Z") {
+      return `Key${upper}`;
+    }
+    if (upper >= "0" && upper <= "9") {
+      return `Digit${upper}`;
+    }
+  }
+  return key2;
+}
+function getKeyText(key2) {
+  if (KEY_TEXT_MAP[key2] !== void 0) {
+    return KEY_TEXT_MAP[key2] || void 0;
+  }
+  if (key2.length === 1) {
+    return key2;
+  }
+  return void 0;
+}
+async function browserPressKey(cdp, params) {
+  const parts = params.key.split("+");
+  const mainKey = parts[parts.length - 1];
+  const modifierKeys = parts.slice(0, -1);
+  let modifiers = 0;
+  for (const mod of modifierKeys) {
+    if (MODIFIER_BITS2[mod] !== void 0) {
+      modifiers |= MODIFIER_BITS2[mod];
+    }
+  }
+  for (const mod of modifierKeys) {
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "keyDown",
+      key: mod,
+      code: getCode2(mod),
+      windowsVirtualKeyCode: getKeyCode2(mod),
+      modifiers
+    });
+  }
+  const text = getKeyText(mainKey);
+  const keyDownParams = {
+    type: "keyDown",
+    key: mainKey,
+    code: getCode2(mainKey),
+    windowsVirtualKeyCode: getKeyCode2(mainKey),
+    modifiers
+  };
+  if (text !== void 0) {
+    keyDownParams.text = text;
+  }
+  await cdp.send("Input.dispatchKeyEvent", keyDownParams);
+  if (text && modifierKeys.length === 0) {
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "char",
+      key: mainKey,
+      code: getCode2(mainKey),
+      windowsVirtualKeyCode: getKeyCode2(mainKey),
+      modifiers,
+      text
+    });
+  }
+  await cdp.send("Input.dispatchKeyEvent", {
+    type: "keyUp",
+    key: mainKey,
+    code: getCode2(mainKey),
+    windowsVirtualKeyCode: getKeyCode2(mainKey),
+    modifiers
+  });
+  for (let i = modifierKeys.length - 1; i >= 0; i--) {
+    const mod = modifierKeys[i];
+    await cdp.send("Input.dispatchKeyEvent", {
+      type: "keyUp",
+      key: mod,
+      code: getCode2(mod),
+      windowsVirtualKeyCode: getKeyCode2(mod),
+      modifiers: 0
+    });
+  }
+  return { success: true };
+}
+
+// src/tools/browser-hover.ts
+var REF_PATTERN2 = /^@?e(\d+)$/;
+function calculateCenter2(content) {
+  const x = (content[0] + content[2] + content[4] + content[6]) / 4;
+  const y = (content[1] + content[3] + content[5] + content[7]) / 4;
+  return { x: Math.round(x), y: Math.round(y) };
+}
+async function resolveElementCoordinates2(cdp, params) {
+  let backendNodeId;
+  let nodeId;
+  if (params.ref) {
+    const match = REF_PATTERN2.exec(params.ref);
+    if (!match) {
+      throw new Error(`Invalid ref format: ${params.ref}`);
+    }
+    backendNodeId = parseInt(match[1], 10);
+    await cdp.send("DOM.resolveNode", {
+      backendNodeId
+    });
+  } else if (params.selector) {
+    const docResponse = await cdp.send("DOM.getDocument");
+    const queryResponse = await cdp.send("DOM.querySelector", {
+      nodeId: docResponse.root.nodeId,
+      selector: params.selector
+    });
+    if (!queryResponse.nodeId || queryResponse.nodeId === 0) {
+      throw new Error(
+        `Element not found: no element matches selector "${params.selector}"`
+      );
+    }
+    nodeId = queryResponse.nodeId;
+  } else {
+    throw new Error("Either ref or selector must be provided");
+  }
+  const scrollParams = {};
+  if (backendNodeId !== void 0) {
+    scrollParams.backendNodeId = backendNodeId;
+  } else if (nodeId !== void 0) {
+    scrollParams.nodeId = nodeId;
+  }
+  await cdp.send("DOM.scrollIntoViewIfNeeded", scrollParams);
+  const boxParams = {};
+  if (backendNodeId !== void 0) {
+    boxParams.backendNodeId = backendNodeId;
+  } else if (nodeId !== void 0) {
+    boxParams.nodeId = nodeId;
+  }
+  const boxResponse = await cdp.send("DOM.getBoxModel", boxParams);
+  return calculateCenter2(boxResponse.model.content);
+}
+async function browserHover(cdp, params) {
+  const { x, y } = await resolveElementCoordinates2(cdp, params);
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseMoved",
+    x,
+    y
+  });
+  return { success: true };
+}
+
+// src/tools/browser-drag.ts
+var REF_PATTERN3 = /^@?e(\d+)$/;
+function calculateCenter3(content) {
+  const x = (content[0] + content[2] + content[4] + content[6]) / 4;
+  const y = (content[1] + content[3] + content[5] + content[7]) / 4;
+  return { x: Math.round(x), y: Math.round(y) };
+}
+async function resolveRefCoordinates(cdp, ref) {
+  const match = REF_PATTERN3.exec(ref);
+  if (!match) {
+    throw new Error(`Invalid ref format: ${ref}`);
+  }
+  const backendNodeId = parseInt(match[1], 10);
+  const opts = { timeout: 5e3 };
+  await cdp.send("DOM.resolveNode", {
+    backendNodeId
+  }, opts);
+  try {
+    await cdp.send("DOM.scrollIntoViewIfNeeded", {
+      backendNodeId
+    }, opts);
+  } catch {
+  }
+  const boxResponse = await cdp.send("DOM.getBoxModel", {
+    backendNodeId
+  }, opts);
+  return calculateCenter3(boxResponse.model.content);
+}
+function delay3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function interpolatePoints(startX, startY, endX, endY, steps = 8) {
+  const points = [];
+  for (let i = 1; i < steps; i++) {
+    const t = i / steps;
+    points.push({
+      x: Math.round(startX + (endX - startX) * t),
+      y: Math.round(startY + (endY - startY) * t)
+    });
+  }
+  return points;
+}
+async function browserDrag(cdp, params) {
+  let startX;
+  let startY;
+  if (params.startX !== void 0 && params.startY !== void 0) {
+    startX = params.startX;
+    startY = params.startY;
+  } else if (params.startRef) {
+    const coords = await resolveRefCoordinates(cdp, params.startRef);
+    startX = coords.x;
+    startY = coords.y;
+  } else {
+    throw new Error("Either startRef or startX/startY must be provided");
+  }
+  let endX;
+  let endY;
+  if (params.endX !== void 0 && params.endY !== void 0) {
+    endX = params.endX;
+    endY = params.endY;
+  } else if (params.endRef) {
+    const coords = await resolveRefCoordinates(cdp, params.endRef);
+    endX = coords.x;
+    endY = coords.y;
+  } else {
+    throw new Error("Either endRef or endX/endY must be provided");
+  }
+  const mouseOpts = { timeout: 3e3 };
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseMoved",
+    x: startX,
+    y: startY
+  }, mouseOpts);
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mousePressed",
+    x: startX,
+    y: startY,
+    button: "left",
+    clickCount: 1
+  }, mouseOpts);
+  const intermediatePoints = interpolatePoints(startX, startY, endX, endY, 4);
+  for (const point of intermediatePoints) {
+    await cdp.send("Input.dispatchMouseEvent", {
+      type: "mouseMoved",
+      x: point.x,
+      y: point.y
+    }, mouseOpts);
+    await delay3(10);
+  }
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseMoved",
+    x: endX,
+    y: endY
+  }, mouseOpts);
+  await cdp.send("Input.dispatchMouseEvent", {
+    type: "mouseReleased",
+    x: endX,
+    y: endY,
+    button: "left",
+    clickCount: 1
+  }, mouseOpts);
+  return { success: true };
+}
+
+// src/tools/browser-select-option.ts
+function refToBackendNodeId(ref) {
+  const match = /^@?e(\d+)$/.exec(ref);
+  if (!match) {
+    throw new Error(`Invalid ref format: ${ref}`);
+  }
+  return parseInt(match[1], 10);
+}
+async function browserSelectOption(cdp, params) {
+  const backendNodeId = refToBackendNodeId(params.ref);
+  const resolveResponse = await cdp.send("DOM.resolveNode", {
+    backendNodeId
+  });
+  const objectId = resolveResponse.object.objectId;
+  const valuesJson = JSON.stringify(params.values);
+  const result = await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() {
+      var select = this;
+      if (select.tagName !== 'SELECT') {
+        throw new Error('Element is not a SELECT');
+      }
+      var values = ${valuesJson};
+      var matched = [];
+
+      for (var i = 0; i < select.options.length; i++) {
+        var option = select.options[i];
+        var isMatch = values.indexOf(option.value) !== -1 ||
+                      values.indexOf(option.textContent.trim()) !== -1;
+        option.selected = isMatch;
+        if (isMatch) {
+          matched.push(option.value);
+        }
+      }
+
+      select.dispatchEvent(new Event('input', { bubbles: true }));
+      select.dispatchEvent(new Event('change', { bubbles: true }));
+
+      return matched;
+    }`,
+    returnByValue: true
+  });
+  const selected = result.result.value ?? [];
+  return {
+    success: true,
+    selected
+  };
+}
+
+// src/tools/browser-file-upload.ts
+var REF_PATTERN4 = /^@e(\d+)$/;
+async function browserFileUpload(cdp, params) {
+  const match = REF_PATTERN4.exec(params.ref);
+  if (!match) {
+    return {
+      success: false,
+      filesCount: 0,
+      error: `Invalid ref format: ${params.ref}. Expected @eN pattern (e.g. @e5).`
+    };
+  }
+  const backendNodeId = parseInt(match[1], 10);
+  const resolved = await cdp.send("DOM.resolveNode", {
+    backendNodeId
+  });
+  const objectId = resolved.object.objectId;
+  await cdp.send("DOM.setFileInputFiles", {
+    files: params.paths,
+    objectId
+  });
+  return {
+    success: true,
+    filesCount: params.paths.length
+  };
+}
+
+// src/tools/browser-handle-dialog.ts
+async function browserHandleDialog(cdp, params) {
+  const dialogParams = {
+    accept: params.accept
+  };
+  if (params.promptText !== void 0) {
+    dialogParams.promptText = params.promptText;
+  }
+  try {
+    await cdp.send("Page.handleJavaScriptDialog", dialogParams);
+    return { success: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("No dialog is showing") || message.includes("no dialog")) {
+      return {
+        success: false,
+        error: "No JavaScript dialog is currently pending. A dialog must be open before it can be handled."
+      };
+    }
+    return {
+      success: false,
+      error: `Failed to handle dialog: ${message}`
+    };
+  }
+}
+
+// src/cli/commands/act.ts
+function normaliseRef(input) {
+  const cleaned = input.startsWith("@") ? input.slice(1) : input;
+  const match = /^e(\d+)$/i.exec(cleaned);
+  if (!match) {
+    throw new Error(`Invalid ref format: ${input}. Expected @eN (e.g. @e5).`);
+  }
+  return `@e${match[1]}`;
+}
+function looksLikeRef(arg) {
+  return /^@?e\d+$/i.test(arg);
+}
+var click = {
+  name: "click",
+  description: "Click an element by ref or CSS selector",
+  usage: "browsirai click <ref-or-selector> [--newTab]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const target = flags._0;
+    if (!target) {
+      console.error("Usage: browsirai click <ref-or-selector> [--newTab]");
+      console.error("  Provide an @eN ref or CSS selector as the first argument.");
+      process.exit(1);
+    }
+    const newTab = flags.newTab === "true";
+    try {
+      if (looksLikeRef(target)) {
+        const ref = normaliseRef(target);
+        await browserClick(cdp, { ref, newTab });
+        console.log(`Clicked ${ref}`);
+      } else {
+        await browserClick(cdp, { selector: target, newTab });
+        console.log(`Clicked ${target}`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Click failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var fill = {
+  name: "fill",
+  description: "Fill a form field with a value",
+  usage: "browsirai fill <ref-or-selector> <value>",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const target = flags._0;
+    const value = flags._1;
+    if (!target || value === void 0) {
+      console.error("Usage: browsirai fill <ref-or-selector> <value>");
+      console.error("  Provide an @eN ref or CSS selector and a value.");
+      process.exit(1);
+    }
+    try {
+      const isRef = looksLikeRef(target);
+      const ref = isRef ? normaliseRef(target) : void 0;
+      const selector = isRef ? void 0 : target;
+      const label = isRef ? normaliseRef(target) : target;
+      await browserFillForm(cdp, {
+        fields: [
+          {
+            name: label,
+            type: "textbox",
+            ref,
+            selector,
+            value
+          }
+        ]
+      });
+      const displayValue = value.length > 40 ? value.slice(0, 40) + "..." : value;
+      console.log(`Filled ${label} with '${displayValue}'`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Fill failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var type = {
+  name: "type",
+  description: "Type text into the focused or specified element",
+  usage: "browsirai type <text> [--ref=@e3] [--submit] [--slowly]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const text = flags._0;
+    if (!text) {
+      console.error("Usage: browsirai type <text> [--ref=@e3] [--submit] [--slowly]");
+      console.error("  Provide the text to type as the first argument.");
+      process.exit(1);
+    }
+    const ref = flags.ref ? normaliseRef(flags.ref) : void 0;
+    const selector = flags.selector;
+    const submit = flags.submit === "true";
+    const slowly = flags.slowly === "true";
+    try {
+      await browserType(cdp, { text, ref, selector, slowly, submit });
+      const displayText = text.length > 40 ? text.slice(0, 40) + "..." : text;
+      const target = ref ?? selector ?? "focused element";
+      console.log(`Typed '${displayText}' into ${target}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Type failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var key = {
+  name: "press",
+  aliases: ["key"],
+  description: "Press a key or key combination",
+  usage: "browsirai press <key-combo>",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const keyCombo = flags._0;
+    if (!keyCombo) {
+      console.error("Usage: browsirai key <key-combo>");
+      console.error("  Examples: Enter, Tab, Control+c, Shift+Tab, Meta+a");
+      process.exit(1);
+    }
+    try {
+      await browserPressKey(cdp, { key: keyCombo });
+      console.log(`Pressed ${keyCombo}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Key press failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var hover = {
+  name: "hover",
+  description: "Hover over an element by ref or selector",
+  usage: "browsirai hover <ref-or-selector>",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const target = flags._0;
+    if (!target) {
+      console.error("Usage: browsirai hover <ref-or-selector>");
+      console.error("  Provide an @eN ref or CSS selector.");
+      process.exit(1);
+    }
+    try {
+      if (looksLikeRef(target)) {
+        const ref = normaliseRef(target);
+        await browserHover(cdp, { ref });
+        console.log(`Hovered ${ref}`);
+      } else {
+        await browserHover(cdp, { selector: target });
+        console.log(`Hovered ${target}`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Hover failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var drag = {
+  name: "drag",
+  description: "Drag from one element to another",
+  usage: "browsirai drag <startRef> <endRef>",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const startArg = flags._0;
+    const endArg = flags._1;
+    if (!startArg || !endArg) {
+      console.error("Usage: browsirai drag <startRef> <endRef>");
+      console.error("  Provide two @eN refs (source and target).");
+      process.exit(1);
+    }
+    try {
+      const startRef = normaliseRef(startArg);
+      const endRef = normaliseRef(endArg);
+      await browserDrag(cdp, { startRef, endRef });
+      console.log(`Dragged ${startRef} \u2192 ${endRef}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Drag failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var select = {
+  name: "select",
+  description: "Select option(s) in a <select> element",
+  usage: "browsirai select <ref> <value1> [value2...]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const refArg = flags._0;
+    if (!refArg) {
+      console.error("Usage: browsirai select <ref> <value1> [value2...]");
+      console.error("  Provide an @eN ref and one or more values to select.");
+      process.exit(1);
+    }
+    const values = [];
+    let i = 1;
+    while (flags[`_${i}`] !== void 0) {
+      values.push(flags[`_${i}`]);
+      i++;
+    }
+    if (values.length === 0) {
+      console.error("Usage: browsirai select <ref> <value1> [value2...]");
+      console.error("  Provide at least one value to select.");
+      process.exit(1);
+    }
+    try {
+      const ref = normaliseRef(refArg);
+      const result = await browserSelectOption(cdp, {
+        ref,
+        values,
+        element: ref
+      });
+      const displayValues = result.selected.length > 0 ? result.selected.map((v) => `'${v}'`).join(", ") : values.map((v) => `'${v}'`).join(", ");
+      console.log(`Selected ${displayValues} in ${ref}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Select failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var upload = {
+  name: "upload",
+  description: "Upload file(s) to a file input element",
+  usage: "browsirai upload <ref> <file1> [file2...]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const refArg = flags._0;
+    if (!refArg) {
+      console.error("Usage: browsirai upload <ref> <file1> [file2...]");
+      console.error("  Provide an @eN ref and one or more file paths.");
+      process.exit(1);
+    }
+    const paths = [];
+    let i = 1;
+    while (flags[`_${i}`] !== void 0) {
+      paths.push(flags[`_${i}`]);
+      i++;
+    }
+    if (paths.length === 0) {
+      console.error("Usage: browsirai upload <ref> <file1> [file2...]");
+      console.error("  Provide at least one file path to upload.");
+      process.exit(1);
+    }
+    try {
+      const ref = normaliseRef(refArg);
+      const result = await browserFileUpload(cdp, { ref, paths });
+      if (result.success) {
+        console.log(`Uploaded ${result.filesCount} file(s) to ${ref}`);
+      } else {
+        console.error(`Upload failed: ${result.error}`);
+        process.exit(1);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Upload failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var dialog = {
+  name: "dialog",
+  description: "Accept or dismiss a JavaScript dialog",
+  usage: "browsirai dialog <accept|dismiss> [--text=...]",
+  async run(cdp, args) {
+    const flags = parseFlags(args);
+    const action = flags._0;
+    if (!action || action !== "accept" && action !== "dismiss") {
+      console.error("Usage: browsirai dialog <accept|dismiss> [--text=...]");
+      console.error("  First argument must be 'accept' or 'dismiss'.");
+      process.exit(1);
+    }
+    const accept = action === "accept";
+    const promptText = flags.text;
+    try {
+      const result = await browserHandleDialog(cdp, {
+        accept,
+        promptText
+      });
+      if (result.success) {
+        console.log(`Dialog ${accept ? "accepted" : "dismissed"}`);
+      } else {
+        console.error(`Dialog handling failed: ${result.error}`);
+        process.exit(1);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Dialog failed: ${msg}`);
+      process.exit(1);
+    }
+  }
+};
+var actCommands = [
+  click,
+  fill,
+  type,
+  key,
+  hover,
+  drag,
+  select,
+  upload,
+  dialog
+];
+export {
+  actCommands
+};
+//# sourceMappingURL=act.js.map