@btraut/browser-bridge 0.7.3 → 0.8.1

package/extension/dist/background.js

@@ -418,6 +418,10 @@ var DEBUGGER_PROTOCOL_VERSION = "1.3";
 var DEBUGGER_IDLE_TIMEOUT_KEY = "debuggerIdleTimeoutMs";
 var DEFAULT_DEBUGGER_IDLE_TIMEOUT_MS = 15e3;
 var DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS = 1e4;
+var DEFAULT_SEND_TO_TAB_TIMEOUT_MS = 1e4;
+var HISTORY_DISPATCH_TIMEOUT_MS = 2e3;
+var HISTORY_NAVIGATION_SIGNAL_TIMEOUT_MS = 8e3;
+var HISTORY_POST_NAV_DOM_GRACE_TIMEOUT_MS = 2e3;
 var AGENT_TAB_ID_KEY = "agentTabId";
 var AGENT_TAB_GROUP_TITLE = "\u{1F309} Browser Bridge";
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
@@ -809,14 +813,42 @@ var getDefaultTabId = async () => {
     return await getActiveTabId();
   }
 };
-var sendToTab = async (tabId, action, params) => {
+var sendToTab = async (tabId, action, params, options) => {
+  const timeoutMs = typeof options?.timeoutMs === "number" && Number.isFinite(options.timeoutMs) ? Math.max(1, Math.floor(options.timeoutMs)) : DEFAULT_SEND_TO_TAB_TIMEOUT_MS;
   const attemptSend = async () => {
     return await new Promise((resolve) => {
       const message = { action, params };
+      let settled = false;
+      const finish = (result) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        if (timeout !== void 0) {
+          clearTimeout(timeout);
+        }
+        resolve(result);
+      };
+      let timeout;
+      timeout = self.setTimeout(() => {
+        finish({
+          ok: false,
+          error: {
+            code: "TIMEOUT",
+            message: `Timed out waiting for content response after ${timeoutMs}ms.`,
+            retryable: true,
+            details: {
+              action,
+              tab_id: tabId,
+              timeout_ms: timeoutMs
+            }
+          }
+        });
+      }, timeoutMs);
       chrome.tabs.sendMessage(tabId, message, (response) => {
         const error = chrome.runtime.lastError;
         if (error) {
-          resolve({
+          finish({
             ok: false,
             error: {
               code: "EVALUATION_FAILED",
@@ -827,7 +859,7 @@ var sendToTab = async (tabId, action, params) => {
           return;
         }
         if (!response || typeof response !== "object") {
-          resolve({
+          finish({
             ok: false,
             error: {
               code: "EVALUATION_FAILED",
@@ -837,7 +869,7 @@ var sendToTab = async (tabId, action, params) => {
           });
           return;
         }
-        resolve(response);
+        finish(response);
       });
     });
   };
@@ -863,6 +895,67 @@ var sendToTab = async (tabId, action, params) => {
     }
   };
 };
+var waitForHistoryNavigationSignal = async (tabId, timeoutMs) => {
+  return await new Promise((resolve, reject) => {
+    let timeout;
+    const cleanup = () => {
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+      }
+      chrome.webNavigation.onCommitted.removeListener(onCommitted);
+      chrome.webNavigation.onHistoryStateUpdated.removeListener(
+        onHistoryStateUpdated
+      );
+      chrome.webNavigation.onReferenceFragmentUpdated.removeListener(
+        onReferenceFragmentUpdated
+      );
+      chrome.tabs.onUpdated.removeListener(onTabUpdated);
+    };
+    const resolveSignal = () => {
+      cleanup();
+      resolve();
+    };
+    const onCommitted = (details) => {
+      if (details.tabId !== tabId || details.frameId !== 0) {
+        return;
+      }
+      resolveSignal();
+    };
+    const onHistoryStateUpdated = (details) => {
+      if (details.tabId !== tabId || details.frameId !== 0) {
+        return;
+      }
+      resolveSignal();
+    };
+    const onReferenceFragmentUpdated = (details) => {
+      if (details.tabId !== tabId || details.frameId !== 0) {
+        return;
+      }
+      resolveSignal();
+    };
+    const onTabUpdated = (updatedTabId, changeInfo) => {
+      if (updatedTabId !== tabId) {
+        return;
+      }
+      if (typeof changeInfo.url !== "string" || changeInfo.url.length === 0) {
+        return;
+      }
+      resolveSignal();
+    };
+    chrome.webNavigation.onCommitted.addListener(onCommitted);
+    chrome.webNavigation.onHistoryStateUpdated.addListener(
+      onHistoryStateUpdated
+    );
+    chrome.webNavigation.onReferenceFragmentUpdated.addListener(
+      onReferenceFragmentUpdated
+    );
+    chrome.tabs.onUpdated.addListener(onTabUpdated);
+    timeout = self.setTimeout(() => {
+      cleanup();
+      reject(new Error("Timed out waiting for history navigation signal."));
+    }, timeoutMs);
+  });
+};
 var waitForDomContentLoaded = async (tabId, timeoutMs) => {
   return await new Promise((resolve, reject) => {
     let timeout;
@@ -1313,21 +1406,37 @@ var DriveSocket = class {
           if (tabId === void 0) {
             tabId = await getDefaultTabId();
           }
-          const result = await sendToTab(tabId, message.action);
-          if (!result.ok) {
+          const navigationSignal = waitForHistoryNavigationSignal(
+            tabId,
+            HISTORY_NAVIGATION_SIGNAL_TIMEOUT_MS
+          );
+          const result = await sendToTab(
+            tabId,
+            message.action,
+            void 0,
+            {
+              timeoutMs: HISTORY_DISPATCH_TIMEOUT_MS
+            }
+          );
+          if (!result.ok && result.error.code !== "TIMEOUT") {
             respondError(result.error);
             return;
           }
           markTabActive(tabId);
           try {
-            await waitForDomContentLoaded(tabId, 3e4);
-          } catch (error) {
-            respondError({
-              code: "TIMEOUT",
-              message: error instanceof Error ? error.message : "Timed out waiting.",
-              retryable: true
-            });
-            return;
+            await navigationSignal;
+            try {
+              await waitForDomContentLoaded(
+                tabId,
+                HISTORY_POST_NAV_DOM_GRACE_TIMEOUT_MS
+              );
+            } catch {
+            }
+          } catch {
+            if (!result.ok) {
+              respondError(result.error);
+              return;
+            }
           }
           respondOk({ ok: true });
           return;
@@ -1445,14 +1554,447 @@ var DriveSocket = class {
           }
           return;
         }
-        case "drive.click":
-        case "drive.hover":
-        case "drive.select":
-        case "drive.type":
-        case "drive.fill_form":
-        case "drive.drag":
-        case "drive.key":
-        case "drive.key_press":
+        case "drive.click": {
+          const params = message.params ?? {};
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getDefaultTabId();
+          }
+          const clickCount = params.click_count;
+          const count = typeof clickCount === "number" && Number.isFinite(clickCount) ? Math.max(1, Math.floor(clickCount)) : 1;
+          const error = await this.ensureDebuggerAttached(tabId);
+          if (error) {
+            respondError(error);
+            return;
+          }
+          const pointResult = await this.resolveLocatorPoint(
+            tabId,
+            params.locator
+          );
+          if (!pointResult.ok) {
+            respondError(pointResult.error);
+            return;
+          }
+          const { x, y } = pointResult.point;
+          self.setTimeout(() => {
+            void this.dispatchCdpClick(tabId, x, y, count).catch(
+              (error2) => {
+                console.debug("Deferred CDP click failed.", error2);
+              }
+            );
+          }, 0);
+          respondOk({ ok: true });
+          return;
+        }
+        case "drive.hover": {
+          const params = message.params ?? {};
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getDefaultTabId();
+          }
+          const error = await this.ensureDebuggerAttached(tabId);
+          if (error) {
+            respondError(error);
+            return;
+          }
+          const pointResult = await this.resolveLocatorPoint(
+            tabId,
+            params.locator
+          );
+          if (!pointResult.ok) {
+            respondError(pointResult.error);
+            return;
+          }
+          const { x, y } = pointResult.point;
+          const waitMs = typeof params.delay_ms === "number" && Number.isFinite(params.delay_ms) ? Math.min(Math.max(params.delay_ms, 0), 1e4) : 0;
+          try {
+            await this.dispatchCdpMouseMove(tabId, x, y, 0);
+            if (waitMs > 0) {
+              await delayMs(waitMs);
+            }
+            const snapshot = await sendToTab(
+              tabId,
+              "drive.snapshot_html"
+            );
+            if (!snapshot.ok) {
+              respondError(snapshot.error);
+              return;
+            }
+            respondOk(snapshot.result ?? { format: "html", snapshot: "" });
+          } catch (error2) {
+            const info = mapDebuggerErrorMessage(
+              error2 instanceof Error ? error2.message : "Hover dispatch failed."
+            );
+            respondError(info);
+          }
+          return;
+        }
+        case "drive.drag": {
+          const params = message.params ?? {};
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getDefaultTabId();
+          }
+          const error = await this.ensureDebuggerAttached(tabId);
+          if (error) {
+            respondError(error);
+            return;
+          }
+          const fromResult = await this.resolveLocatorPoint(
+            tabId,
+            params.from
+          );
+          if (!fromResult.ok) {
+            respondError(fromResult.error);
+            return;
+          }
+          const toResult = await this.resolveLocatorPoint(
+            tabId,
+            params.to
+          );
+          if (!toResult.ok) {
+            respondError(toResult.error);
+            return;
+          }
+          const steps = typeof params.steps === "number" && Number.isFinite(params.steps) ? Math.max(1, Math.min(50, Math.floor(params.steps))) : 12;
+          try {
+            await this.dispatchCdpDrag(
+              tabId,
+              fromResult.point,
+              toResult.point,
+              steps
+            );
+            respondOk({ ok: true });
+          } catch (error2) {
+            const info = mapDebuggerErrorMessage(
+              error2 instanceof Error ? error2.message : "Drag dispatch failed."
+            );
+            respondError(info);
+          }
+          return;
+        }
+        case "drive.key_press": {
+          const params = message.params ?? {};
+          const key = params.key;
+          if (typeof key !== "string" || key.length === 0) {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "key must be a non-empty string.",
+              retryable: false
+            });
+            return;
+          }
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getDefaultTabId();
+          }
+          const error = await this.ensureDebuggerAttached(tabId);
+          if (error) {
+            respondError(error);
+            return;
+          }
+          try {
+            await this.dispatchCdpKeyPress(
+              tabId,
+              key,
+              params.modifiers
+            );
+            respondOk({ ok: true });
+          } catch (error2) {
+            const info = mapDebuggerErrorMessage(
+              error2 instanceof Error ? error2.message : "Keyboard dispatch failed."
+            );
+            respondError(info);
+          }
+          return;
+        }
+        case "drive.key": {
+          const params = message.params ?? {};
+          const key = params.key;
+          if (typeof key !== "string" || key.length === 0) {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "key must be a non-empty string.",
+              retryable: false
+            });
+            return;
+          }
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getDefaultTabId();
+          }
+          const count = typeof params.repeat === "number" && Number.isFinite(params.repeat) ? Math.max(1, Math.min(50, Math.floor(params.repeat))) : 1;
+          const error = await this.ensureDebuggerAttached(tabId);
+          if (error) {
+            respondError(error);
+            return;
+          }
+          try {
+            for (let i = 0; i < count; i += 1) {
+              await this.dispatchCdpKeyPress(
+                tabId,
+                key,
+                params.modifiers
+              );
+            }
+            respondOk({ ok: true });
+          } catch (error2) {
+            const info = mapDebuggerErrorMessage(
+              error2 instanceof Error ? error2.message : "Keyboard dispatch failed."
+            );
+            respondError(info);
+          }
+          return;
+        }
+        case "drive.type": {
+          const params = message.params ?? {};
+          const text = params.text;
+          if (typeof text !== "string") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "text must be a string.",
+              retryable: false
+            });
+            return;
+          }
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getDefaultTabId();
+          }
+          const error = await this.ensureDebuggerAttached(tabId);
+          if (error) {
+            respondError(error);
+            return;
+          }
+          const result = await this.performCdpType(tabId, {
+            locator: params.locator,
+            text,
+            clear: Boolean(params.clear),
+            submit: Boolean(params.submit)
+          });
+          if (!result.ok) {
+            respondError(result.error);
+            return;
+          }
+          respondOk({ ok: true });
+          return;
+        }
+        case "drive.select": {
+          const params = message.params ?? {};
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getDefaultTabId();
+          }
+          const error = await this.ensureDebuggerAttached(tabId);
+          if (error) {
+            respondError(error);
+            return;
+          }
+          const pointResult = await this.resolveLocatorPoint(
+            tabId,
+            params.locator
+          );
+          if (!pointResult.ok) {
+            respondError(pointResult.error);
+            return;
+          }
+          try {
+            await this.dispatchCdpClick(
+              tabId,
+              pointResult.point.x,
+              pointResult.point.y,
+              1
+            );
+          } catch (error2) {
+            const info = mapDebuggerErrorMessage(
+              error2 instanceof Error ? error2.message : "Select click failed."
+            );
+            respondError(info);
+            return;
+          }
+          const selectResult = await sendToTab(
+            tabId,
+            "drive.select",
+            params
+          );
+          if (!selectResult.ok) {
+            respondError(selectResult.error);
+            return;
+          }
+          respondOk(selectResult.result ?? { ok: true });
+          return;
+        }
+        case "drive.fill_form": {
+          const params = message.params ?? {};
+          const fields = params.fields;
+          if (!Array.isArray(fields) || fields.length === 0) {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "fields must be a non-empty array.",
+              retryable: false
+            });
+            return;
+          }
+          let tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            respondError({
+              code: "INVALID_ARGUMENT",
+              message: "tab_id must be a number when provided.",
+              retryable: false
+            });
+            return;
+          }
+          if (tabId === void 0) {
+            tabId = await getDefaultTabId();
+          }
+          const error = await this.ensureDebuggerAttached(tabId);
+          if (error) {
+            respondError(error);
+            return;
+          }
+          let filled = 0;
+          const errors = [];
+          for (let index = 0; index < fields.length; index += 1) {
+            const field = fields[index];
+            if (!field || typeof field !== "object") {
+              errors.push(`Field ${index} is not an object.`);
+              continue;
+            }
+            const record = field;
+            const value = record.value;
+            if (typeof value !== "string" && typeof value !== "boolean") {
+              errors.push(`Field ${index} has invalid value.`);
+              continue;
+            }
+            const selector = typeof record.selector === "string" ? record.selector : void 0;
+            const locator = record.locator && typeof record.locator === "object" ? record.locator : selector ? { css: selector } : void 0;
+            let resolvedType = typeof record.type === "string" && record.type.length > 0 ? record.type : "auto";
+            if (resolvedType === "auto") {
+              const detected = await sendToTab(
+                tabId,
+                "drive.detect_field_type",
+                { locator: record.locator, selector }
+              );
+              if (!detected.ok) {
+                errors.push(`Field ${index} could not be resolved.`);
+                continue;
+              }
+              const payload2 = detected.result;
+              if (!payload2 || typeof payload2 !== "object") {
+                errors.push(`Field ${index} returned invalid type payload.`);
+                continue;
+              }
+              const detectedType = payload2.fieldType;
+              if (typeof detectedType !== "string" || detectedType.length === 0) {
+                errors.push(`Field ${index} returned invalid field type.`);
+                continue;
+              }
+              resolvedType = detectedType;
+            }
+            if ((resolvedType === "text" || resolvedType === "contentEditable") && locator) {
+              const typed = await this.performCdpType(tabId, {
+                locator,
+                text: String(value),
+                clear: true,
+                submit: Boolean(record.submit)
+              });
+              if (!typed.ok) {
+                errors.push(
+                  `Field ${index} could not be filled: ${typed.error.message}`
+                );
+                continue;
+              }
+              filled += 1;
+              continue;
+            }
+            const fallback = await sendToTab(
+              tabId,
+              "drive.fill_form",
+              {
+                fields: [field]
+              }
+            );
+            if (!fallback.ok) {
+              errors.push(
+                `Field ${index} could not be filled: ${fallback.error.message}`
+              );
+              continue;
+            }
+            const payload = fallback.result;
+            if (!payload || typeof payload !== "object") {
+              errors.push(`Field ${index} returned invalid fallback payload.`);
+              continue;
+            }
+            const fallbackFilled = payload.filled;
+            if (typeof fallbackFilled === "number" && Number.isFinite(fallbackFilled) && fallbackFilled > 0) {
+              filled += 1;
+              continue;
+            }
+            errors.push(`Field ${index} could not be filled.`);
+          }
+          respondOk({
+            filled,
+            attempted: fields.length,
+            errors: errors.length > 0 ? errors : []
+          });
+          return;
+        }
         case "drive.scroll":
         case "drive.wait_for": {
           const params = message.params ?? {};
@@ -1468,10 +2010,14 @@ var DriveSocket = class {
           if (tabId === void 0) {
             tabId = await getDefaultTabId();
           }
+          const timeoutMs = message.action === "drive.wait_for" && typeof params.timeout_ms === "number" && Number.isFinite(params.timeout_ms) ? Math.max(1, Math.floor(params.timeout_ms) + 1e3) : void 0;
           const result = await sendToTab(
             tabId,
             message.action,
-            params
+            params,
+            {
+              timeoutMs
+            }
           );
           if (result.ok) {
             respondOk(result.result ?? { ok: true });
@@ -1856,6 +2402,290 @@ var DriveSocket = class {
       });
     }
   }
+  async dispatchCdpClick(tabId, x, y, clickCount) {
+    await this.dispatchCdpMouseMove(tabId, x, y, 0);
+    for (let i = 0; i < clickCount; i += 1) {
+      const normalizedClickCount = i + 1;
+      await this.sendDebuggerCommand(
+        tabId,
+        "Input.dispatchMouseEvent",
+        {
+          type: "mousePressed",
+          x,
+          y,
+          button: "left",
+          clickCount: normalizedClickCount
+        },
+        DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
+      );
+      await this.sendDebuggerCommand(
+        tabId,
+        "Input.dispatchMouseEvent",
+        {
+          type: "mouseReleased",
+          x,
+          y,
+          button: "left",
+          clickCount: normalizedClickCount
+        },
+        DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
+      );
+    }
+    this.touchDebuggerSession(tabId);
+  }
+  async dispatchCdpMouseMove(tabId, x, y, buttons) {
+    await this.sendDebuggerCommand(
+      tabId,
+      "Input.dispatchMouseEvent",
+      {
+        type: "mouseMoved",
+        x,
+        y,
+        button: "none",
+        buttons
+      },
+      DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
+    );
+  }
+  async dispatchCdpDrag(tabId, from, to, steps) {
+    await this.dispatchCdpMouseMove(tabId, from.x, from.y, 0);
+    await this.sendDebuggerCommand(
+      tabId,
+      "Input.dispatchMouseEvent",
+      {
+        type: "mousePressed",
+        x: from.x,
+        y: from.y,
+        button: "left",
+        clickCount: 1
+      },
+      DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
+    );
+    for (let i = 1; i <= steps; i += 1) {
+      const progress = i / steps;
+      const x = from.x + (to.x - from.x) * progress;
+      const y = from.y + (to.y - from.y) * progress;
+      await this.dispatchCdpMouseMove(tabId, x, y, 1);
+      await delayMs(10);
+    }
+    await this.sendDebuggerCommand(
+      tabId,
+      "Input.dispatchMouseEvent",
+      {
+        type: "mouseReleased",
+        x: to.x,
+        y: to.y,
+        button: "left",
+        clickCount: 1
+      },
+      DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
+    );
+    this.touchDebuggerSession(tabId);
+  }
+  async resolveLocatorPoint(tabId, locator) {
+    const point = await sendToTab(tabId, "drive.locator_point", {
+      locator
+    });
+    if (!point.ok) {
+      return point;
+    }
+    const payload = point.result;
+    if (!payload || typeof payload !== "object") {
+      return {
+        ok: false,
+        error: {
+          code: "EVALUATION_FAILED",
+          message: "Invalid locator point payload.",
+          retryable: false
+        }
+      };
+    }
+    const record = payload;
+    const x = record.x;
+    const y = record.y;
+    if (typeof x !== "number" || !Number.isFinite(x) || typeof y !== "number" || !Number.isFinite(y)) {
+      return {
+        ok: false,
+        error: {
+          code: "EVALUATION_FAILED",
+          message: "Invalid locator point coordinates.",
+          retryable: false
+        }
+      };
+    }
+    return { ok: true, point: { x, y } };
+  }
+  async performCdpType(tabId, options) {
+    const targetPoint = await sendToTab(tabId, "drive.type_target_point", {
+      locator: options.locator
+    });
+    if (!targetPoint.ok) {
+      return targetPoint;
+    }
+    const payload = targetPoint.result;
+    if (!payload || typeof payload !== "object") {
+      return {
+        ok: false,
+        error: {
+          code: "EVALUATION_FAILED",
+          message: "Invalid type target payload.",
+          retryable: false
+        }
+      };
+    }
+    const record = payload;
+    const x = record.x;
+    const y = record.y;
+    if (typeof x !== "number" || !Number.isFinite(x) || typeof y !== "number" || !Number.isFinite(y)) {
+      return {
+        ok: false,
+        error: {
+          code: "EVALUATION_FAILED",
+          message: "Invalid type target coordinates.",
+          retryable: false
+        }
+      };
+    }
+    try {
+      await this.dispatchCdpClick(tabId, x, y, 1);
+      if (options.clear) {
+        const clearResult = await sendToTab(
+          tabId,
+          "drive.clear_active_editable"
+        );
+        if (!clearResult.ok) {
+          return clearResult;
+        }
+      }
+      if (options.text.length > 0) {
+        await this.sendDebuggerCommand(
+          tabId,
+          "Input.insertText",
+          { text: options.text },
+          DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
+        );
+      }
+      if (options.submit) {
+        await this.dispatchCdpKeyPress(tabId, "Enter", void 0);
+      }
+      this.touchDebuggerSession(tabId);
+      return { ok: true };
+    } catch (error) {
+      return {
+        ok: false,
+        error: mapDebuggerErrorMessage(
+          error instanceof Error ? error.message : "Type dispatch failed."
+        )
+      };
+    }
+  }
+  normalizeModifierMask(modifiers) {
+    const MOD_ALT = 1;
+    const MOD_CTRL = 2;
+    const MOD_META = 4;
+    const MOD_SHIFT = 8;
+    let mask = 0;
+    if (Array.isArray(modifiers)) {
+      for (const modifier of modifiers) {
+        if (typeof modifier !== "string") {
+          continue;
+        }
+        const normalized = modifier.toLowerCase();
+        if (normalized === "alt") {
+          mask |= MOD_ALT;
+        } else if (normalized === "ctrl") {
+          mask |= MOD_CTRL;
+        } else if (normalized === "meta") {
+          mask |= MOD_META;
+        } else if (normalized === "shift") {
+          mask |= MOD_SHIFT;
+        }
+      }
+      return mask;
+    }
+    if (!modifiers || typeof modifiers !== "object") {
+      return mask;
+    }
+    const record = modifiers;
+    if (record.alt) {
+      mask |= MOD_ALT;
+    }
+    if (record.ctrl) {
+      mask |= MOD_CTRL;
+    }
+    if (record.meta) {
+      mask |= MOD_META;
+    }
+    if (record.shift) {
+      mask |= MOD_SHIFT;
+    }
+    return mask;
+  }
+  keyToCode(key) {
+    const map = {
+      Enter: "Enter",
+      Tab: "Tab",
+      Escape: "Escape",
+      Esc: "Escape",
+      Backspace: "Backspace",
+      Delete: "Delete",
+      ArrowUp: "ArrowUp",
+      ArrowDown: "ArrowDown",
+      ArrowLeft: "ArrowLeft",
+      ArrowRight: "ArrowRight",
+      Home: "Home",
+      End: "End",
+      PageUp: "PageUp",
+      PageDown: "PageDown",
+      " ": "Space",
+      Space: "Space"
+    };
+    if (map[key]) {
+      return map[key];
+    }
+    if (key.length === 1) {
+      if (/[a-zA-Z]/.test(key)) {
+        return `Key${key.toUpperCase()}`;
+      }
+      if (/[0-9]/.test(key)) {
+        return `Digit${key}`;
+      }
+    }
+    return key;
+  }
+  async dispatchCdpKeyPress(tabId, key, modifiers) {
+    const code = this.keyToCode(key);
+    const modifierMask = this.normalizeModifierMask(modifiers);
+    const isTextInput = key.length === 1 && (modifierMask & (1 | 2 | 4)) === 0;
+    const keyDownParams = {
+      type: "keyDown",
+      key,
+      code,
+      modifiers: modifierMask
+    };
+    if (isTextInput) {
+      keyDownParams.text = key;
+      keyDownParams.unmodifiedText = key;
+    }
+    await this.sendDebuggerCommand(
+      tabId,
+      "Input.dispatchKeyEvent",
+      keyDownParams,
+      DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
+    );
+    await this.sendDebuggerCommand(
+      tabId,
+      "Input.dispatchKeyEvent",
+      {
+        type: "keyUp",
+        key,
+        code,
+        modifiers: modifierMask
+      },
+      DEFAULT_DEBUGGER_COMMAND_TIMEOUT_MS
+    );
+    this.touchDebuggerSession(tabId);
+  }
   async handleDebuggerRequest(message) {
     const respondAck = (result) => {
       this.sendMessage({