@btraut/browser-bridge 0.4.3 → 0.6.0

package/extension/dist/background.js

@@ -92,6 +92,318 @@ var sanitizeDriveErrorInfo = (error) => {
   };
 };
 
+// packages/extension/src/site-permissions.ts
+var SITE_ALLOWLIST_KEY = "siteAllowlist";
+var PERMISSION_PROMPT_WAIT_MS_KEY = "permissionPromptWaitMs";
+var DEFAULT_PERMISSION_PROMPT_WAIT_MS = 3e4;
+var SITE_PERMISSIONS_MODE_KEY = "sitePermissionsMode";
+var DEFAULT_SITE_PERMISSIONS_MODE = "granular";
+var siteKeyFromUrl = (rawUrl) => {
+  if (!rawUrl || typeof rawUrl !== "string") {
+    return null;
+  }
+  try {
+    const parsed = new URL(rawUrl);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return null;
+    }
+    if (!parsed.hostname) {
+      return null;
+    }
+    return parsed.port ? `${parsed.hostname}:${parsed.port}` : parsed.hostname;
+  } catch {
+    return null;
+  }
+};
+var isAllowlistEntry = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const v = value;
+  return typeof v.createdAt === "string" && typeof v.lastUsedAt === "string";
+};
+var normalizeSiteKey = (siteKey) => siteKey.toLowerCase();
+var readAllowlistRaw = async () => {
+  return await new Promise((resolve) => {
+    chrome.storage.local.get(
+      [SITE_ALLOWLIST_KEY],
+      (result) => {
+        const raw = result?.[SITE_ALLOWLIST_KEY];
+        if (!raw || typeof raw !== "object") {
+          resolve({});
+          return;
+        }
+        const out = {};
+        for (const [k, v] of Object.entries(raw)) {
+          if (typeof k !== "string") {
+            continue;
+          }
+          if (!isAllowlistEntry(v)) {
+            continue;
+          }
+          out[normalizeSiteKey(k)] = v;
+        }
+        resolve(out);
+      }
+    );
+  });
+};
+var writeAllowlistRaw = async (allowlist) => {
+  return await new Promise((resolve) => {
+    chrome.storage.local.set(
+      { [SITE_ALLOWLIST_KEY]: allowlist },
+      () => resolve()
+    );
+  });
+};
+var readSitePermissionsMode = async () => {
+  return await new Promise((resolve) => {
+    chrome.storage.local.get(
+      [SITE_PERMISSIONS_MODE_KEY],
+      (result) => {
+        const raw = result?.[SITE_PERMISSIONS_MODE_KEY];
+        if (raw === "granular" || raw === "bypass") {
+          resolve(raw);
+          return;
+        }
+        resolve(DEFAULT_SITE_PERMISSIONS_MODE);
+      }
+    );
+  });
+};
+var readPermissionPromptWaitMs = async () => {
+  return await new Promise((resolve) => {
+    chrome.storage.local.get(
+      [PERMISSION_PROMPT_WAIT_MS_KEY],
+      (result) => {
+        const raw = result?.[PERMISSION_PROMPT_WAIT_MS_KEY];
+        if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {
+          resolve(raw);
+          return;
+        }
+        if (typeof raw === "string") {
+          const parsed = Number(raw);
+          if (Number.isFinite(parsed) && parsed > 0) {
+            resolve(parsed);
+            return;
+          }
+        }
+        resolve(DEFAULT_PERMISSION_PROMPT_WAIT_MS);
+      }
+    );
+  });
+};
+var isSiteAllowed = async (siteKey) => {
+  const key = normalizeSiteKey(siteKey);
+  const allowlist = await readAllowlistRaw();
+  return Boolean(allowlist[key]);
+};
+var allowSiteAlways = async (siteKey, now = /* @__PURE__ */ new Date()) => {
+  const key = normalizeSiteKey(siteKey);
+  const allowlist = await readAllowlistRaw();
+  const nowIso2 = now.toISOString();
+  const existing = allowlist[key];
+  allowlist[key] = {
+    createdAt: existing?.createdAt ?? nowIso2,
+    lastUsedAt: nowIso2
+  };
+  await writeAllowlistRaw(allowlist);
+};
+var touchSiteLastUsed = async (siteKey, now = /* @__PURE__ */ new Date()) => {
+  const key = normalizeSiteKey(siteKey);
+  const allowlist = await readAllowlistRaw();
+  const existing = allowlist[key];
+  if (!existing) {
+    return;
+  }
+  allowlist[key] = { ...existing, lastUsedAt: now.toISOString() };
+  await writeAllowlistRaw(allowlist);
+};
+
+// packages/extension/src/permission-prompt.ts
+var PERMISSION_PROMPT_PORT_NAME = "permission_prompt";
+var defaultMakeRequestId = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `perm-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+};
+var defaultOpenWindow = async (url) => {
+  return await new Promise((resolve, reject) => {
+    chrome.windows.create(
+      {
+        type: "popup",
+        url,
+        focused: true,
+        width: 460,
+        height: 420
+      },
+      (win) => {
+        const err = chrome.runtime.lastError;
+        if (err) {
+          reject(new Error(err.message));
+          return;
+        }
+        const windowId = win?.id;
+        if (typeof windowId !== "number") {
+          reject(new Error("Prompt window id missing."));
+          return;
+        }
+        resolve(windowId);
+      }
+    );
+  });
+};
+var defaultCloseWindow = async (windowId) => {
+  return await new Promise((resolve) => {
+    chrome.windows.remove(windowId, () => resolve());
+  });
+};
+var delay = async (ms) => {
+  return await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+};
+var PermissionPromptController = class {
+  constructor(deps) {
+    this.stateBySite = /* @__PURE__ */ new Map();
+    this.stateByRequestId = /* @__PURE__ */ new Map();
+    this.stateByWindowId = /* @__PURE__ */ new Map();
+    this.deps = {
+      openWindow: deps?.openWindow ?? defaultOpenWindow,
+      closeWindow: deps?.closeWindow ?? defaultCloseWindow,
+      getWaitMs: deps?.getWaitMs ?? readPermissionPromptWaitMs,
+      persistAlwaysAllow: deps?.persistAlwaysAllow ?? allowSiteAlways,
+      makeRequestId: deps?.makeRequestId ?? defaultMakeRequestId
+    };
+  }
+  async requestPermission(request) {
+    const siteKey = request.siteKey.toLowerCase();
+    let state = this.stateBySite.get(siteKey);
+    if (!state) {
+      const requestId = this.deps.makeRequestId();
+      state = {
+        siteKey,
+        action: request.action,
+        requestId,
+        windowId: null,
+        decided: null,
+        waiters: /* @__PURE__ */ new Set()
+      };
+      this.stateBySite.set(siteKey, state);
+      this.stateByRequestId.set(requestId, state);
+      const url = this.buildPromptUrl(state);
+      const windowId = await this.deps.openWindow(url);
+      state.windowId = windowId;
+      this.stateByWindowId.set(windowId, state);
+      if (state.decided) {
+        await this.deps.closeWindow(windowId);
+        this.cleanupState(state);
+      }
+    }
+    const waitMs = await this.deps.getWaitMs();
+    const decision = await this.waitForDecisionOrTimeout(state, waitMs);
+    if (!decision) {
+      return { kind: "timed_out", waitMs };
+    }
+    return { kind: decision };
+  }
+  handleConnect(port) {
+    if (!port || typeof port !== "object") {
+      return;
+    }
+    const p = port;
+    if (p.name !== PERMISSION_PROMPT_PORT_NAME) {
+      return;
+    }
+    const onMessage = p.onMessage;
+    if (!onMessage || typeof onMessage.addListener !== "function") {
+      return;
+    }
+    onMessage.addListener((message) => {
+      void this.handlePortMessage(message).catch((error) => {
+        console.error(
+          "PermissionPromptController handlePortMessage failed:",
+          error
+        );
+      });
+    });
+  }
+  handleWindowRemoved(windowId) {
+    const state = this.stateByWindowId.get(windowId);
+    if (!state) {
+      return;
+    }
+    this.cleanupState(state);
+  }
+  buildPromptUrl(state) {
+    const base = chrome.runtime.getURL("permission.html");
+    const u = new URL(base);
+    u.searchParams.set("requestId", state.requestId);
+    u.searchParams.set("site", state.siteKey);
+    u.searchParams.set("action", state.action);
+    return u.toString();
+  }
+  async waitForDecisionOrTimeout(state, waitMs) {
+    if (state.decided) {
+      return state.decided;
+    }
+    let waiter = null;
+    const decisionPromise = new Promise((resolve) => {
+      waiter = resolve;
+      state.waiters.add(resolve);
+    });
+    const winner = await Promise.race([
+      decisionPromise,
+      delay(waitMs).then(() => null)
+    ]);
+    if (winner === null && waiter) {
+      state.waiters.delete(waiter);
+    }
+    return winner;
+  }
+  async handlePortMessage(message) {
+    if (!message || typeof message !== "object") {
+      return;
+    }
+    const m = message;
+    if (m.type !== "decision") {
+      return;
+    }
+    const requestId = m.requestId;
+    const decision = m.decision;
+    if (typeof requestId !== "string" || requestId.length === 0) {
+      return;
+    }
+    if (decision !== "allow_once" && decision !== "allow_always" && decision !== "deny") {
+      return;
+    }
+    const state = this.stateByRequestId.get(requestId);
+    if (!state) {
+      return;
+    }
+    state.decided = decision;
+    if (decision === "allow_always") {
+      await this.deps.persistAlwaysAllow(state.siteKey);
+    }
+    for (const waiter of state.waiters) {
+      waiter(decision);
+    }
+    state.waiters.clear();
+    if (typeof state.windowId === "number") {
+      await this.deps.closeWindow(state.windowId);
+      this.cleanupState(state);
+    }
+  }
+  cleanupState(state) {
+    this.stateBySite.delete(state.siteKey);
+    this.stateByRequestId.delete(state.requestId);
+    if (typeof state.windowId === "number") {
+      this.stateByWindowId.delete(state.windowId);
+    }
+  }
+};
+
 // packages/extension/src/background.ts
 var DEFAULT_CORE_PORT = 3210;
 var CORE_PORT_KEY = "corePort";
@@ -100,12 +412,15 @@ 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 AGENT_TAB_ID_KEY = "agentTabId";
+var AGENT_TAB_GROUP_TITLE = "\u{1F309} Browser Bridge";
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
 var makeEventId = /* @__PURE__ */ (() => {
   let counter = 0;
   return () => `evt-${Date.now()}-${counter += 1}`;
 })();
 var lastActiveAtByTab = /* @__PURE__ */ new Map();
+var agentTabId = null;
 var ensureLastActiveAt = (tabId) => {
   const existing = lastActiveAtByTab.get(tabId);
   if (existing) {
@@ -353,36 +668,194 @@ var getActiveTabId = async () => {
   }
   throw new Error("No active tab found.");
 };
-var sendToTab = async (tabId, action, params) => {
+var clearAgentTarget = () => {
+  agentTabId = null;
+  void writeAgentTabId(null);
+};
+var queryActiveTabIdInWindow = async (windowId) => {
+  const tabs = await wrapChromeCallback(
+    (callback) => chrome.tabs.query({ active: true, windowId }, callback)
+  );
+  const first = tabs[0];
+  if (first && typeof first.id === "number") {
+    return first.id;
+  }
+  const anyTabs = await wrapChromeCallback(
+    (callback) => chrome.tabs.query({ windowId }, callback)
+  );
+  const fallback = anyTabs[0];
+  if (fallback && typeof fallback.id === "number") {
+    return fallback.id;
+  }
+  throw new Error("No tab found for window.");
+};
+var ensureAgentTabGroup = async (tabId, windowId) => {
+  if (typeof chrome.tabs?.group !== "function") {
+    return;
+  }
+  if (!chrome.tabGroups || typeof chrome.tabGroups.update !== "function") {
+    return;
+  }
+  try {
+    const groupId = await wrapChromeCallback(
+      (callback) => chrome.tabs.group(
+        { tabIds: tabId, createProperties: { windowId } },
+        callback
+      )
+    );
+    await wrapChromeVoid(
+      (callback) => chrome.tabGroups.update(
+        groupId,
+        { title: AGENT_TAB_GROUP_TITLE },
+        () => callback()
+      )
+    );
+  } catch (error) {
+    console.debug("Failed to create/update agent tab group.", error);
+  }
+};
+var createAgentWindow = async () => {
+  const created = await wrapChromeCallback(
+    (callback) => chrome.windows.create({ url: "about:blank", focused: true }, callback)
+  );
+  const windowId = created.id;
+  if (typeof windowId !== "number") {
+    throw new Error("Failed to create agent window.");
+  }
+  const tabId = await queryActiveTabIdInWindow(windowId);
+  await ensureAgentTabGroup(tabId, windowId);
+  return tabId;
+};
+var readAgentTabId = async () => {
   return await new Promise((resolve) => {
-    const message = { action, params };
-    chrome.tabs.sendMessage(tabId, message, (response) => {
+    chrome.storage.local.get(
+      [AGENT_TAB_ID_KEY],
+      (result) => {
+        const raw = result?.[AGENT_TAB_ID_KEY];
+        resolve(typeof raw === "number" && Number.isFinite(raw) ? raw : null);
+      }
+    );
+  });
+};
+var writeAgentTabId = async (tabId) => {
+  await new Promise((resolve, reject) => {
+    const done = () => {
       const error = chrome.runtime.lastError;
       if (error) {
-        resolve({
-          ok: false,
-          error: {
-            code: "EVALUATION_FAILED",
-            message: error.message,
-            retryable: false
-          }
-        });
+        reject(new Error(error.message));
         return;
       }
-      if (!response || typeof response !== "object") {
-        resolve({
-          ok: false,
-          error: {
-            code: "EVALUATION_FAILED",
-            message: "Empty response from content script.",
-            retryable: false
-          }
-        });
-        return;
+      resolve();
+    };
+    if (tabId === null) {
+      chrome.storage.local.remove([AGENT_TAB_ID_KEY], done);
+      return;
+    }
+    chrome.storage.local.set({ [AGENT_TAB_ID_KEY]: tabId }, done);
+  }).catch((error) => {
+    console.debug("Failed to persist agentTabId.", error);
+  });
+};
+var getOrCreateAgentTabId = async () => {
+  if (agentTabId !== null) {
+    try {
+      const tab = await getTab(agentTabId);
+      const url = tab.url;
+      if (typeof url === "string" && isRestrictedUrl(url)) {
+        throw new Error(`Agent tab points at restricted URL: ${url}`);
+      }
+      return agentTabId;
+    } catch {
+      clearAgentTarget();
+    }
+  }
+  const stored = await readAgentTabId();
+  if (stored !== null) {
+    try {
+      const tab = await getTab(stored);
+      const url = tab.url;
+      if (typeof url === "string" && isRestrictedUrl(url)) {
+        throw new Error(`Stored agent tab points at restricted URL: ${url}`);
       }
-      resolve(response);
+      agentTabId = stored;
+      ensureLastActiveAt(stored);
+      markTabActive(stored);
+      return stored;
+    } catch {
+      await writeAgentTabId(null);
+    }
+  }
+  const tabId = await createAgentWindow();
+  agentTabId = tabId;
+  ensureLastActiveAt(tabId);
+  markTabActive(tabId);
+  await writeAgentTabId(tabId);
+  return tabId;
+};
+var getDefaultTabId = async () => {
+  try {
+    return await getOrCreateAgentTabId();
+  } catch (error) {
+    console.warn(
+      "Failed to create agent window/tab; falling back to active tab.",
+      error
+    );
+    return await getActiveTabId();
+  }
+};
+var sendToTab = async (tabId, action, params) => {
+  const attemptSend = async () => {
+    return await new Promise((resolve) => {
+      const message = { action, params };
+      chrome.tabs.sendMessage(tabId, message, (response) => {
+        const error = chrome.runtime.lastError;
+        if (error) {
+          resolve({
+            ok: false,
+            error: {
+              code: "EVALUATION_FAILED",
+              message: error.message,
+              retryable: false
+            }
+          });
+          return;
+        }
+        if (!response || typeof response !== "object") {
+          resolve({
+            ok: false,
+            error: {
+              code: "EVALUATION_FAILED",
+              message: "Empty response from content script.",
+              retryable: false
+            }
+          });
+          return;
+        }
+        resolve(response);
+      });
     });
-  });
+  };
+  const MAX_ATTEMPTS = 5;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+    const result = await attemptSend();
+    if (result.ok) {
+      return result;
+    }
+    const message = result.error?.message;
+    const isNoReceiver = typeof message === "string" && message.toLowerCase().includes("receiving end does not exist");
+    if (!isNoReceiver || attempt === MAX_ATTEMPTS) {
+      return result;
+    }
+    await delayMs(200);
+  }
+  return {
+    ok: false,
+    error: {
+      code: "INTERNAL",
+      message: "Failed to send message to content script.",
+      retryable: false
+    }
+  };
 };
 var waitForDomContentLoaded = async (tabId, timeoutMs) => {
   return await new Promise((resolve, reject) => {
@@ -447,13 +920,13 @@ var DriveSocket = class {
     if (this.reconnectTimer !== null) {
       return;
     }
-    const delay = this.reconnectDelayMs;
+    const delay2 = this.reconnectDelayMs;
     this.reconnectTimer = self.setTimeout(() => {
       this.reconnectTimer = null;
       void this.connect().catch((error) => {
         console.error("DriveSocket reconnect failed:", error);
       });
-    }, delay);
+    }, delay2);
     this.reconnectDelayMs = Math.min(
       this.maxReconnectDelayMs,
       this.reconnectDelayMs * 2
@@ -573,10 +1046,17 @@ var DriveSocket = class {
   }
   async handleRequest(message) {
     let driveMessage = null;
+    let gatedSiteKey = null;
+    let touchGatedSiteOnSuccess = false;
     const respondOk = (result) => {
       if (!driveMessage) {
         return;
       }
+      if (touchGatedSiteOnSuccess && gatedSiteKey) {
+        void touchSiteLastUsed(gatedSiteKey).catch((error) => {
+          console.error("Failed to touch site allowlist entry:", error);
+        });
+      }
       const response = {
         id: driveMessage.id,
         action: driveMessage.action,
@@ -609,6 +1089,159 @@ var DriveSocket = class {
         return;
       }
       driveMessage = message;
+      const gatedActions = /* @__PURE__ */ new Set([
+        "drive.navigate",
+        "drive.go_back",
+        "drive.go_forward",
+        "drive.back",
+        "drive.forward",
+        "drive.click",
+        "drive.hover",
+        "drive.select",
+        "drive.type",
+        "drive.fill_form",
+        "drive.drag",
+        "drive.handle_dialog",
+        "drive.key",
+        "drive.key_press",
+        "drive.scroll",
+        "drive.screenshot",
+        "drive.wait_for"
+      ]);
+      const gateDriveAction = async () => {
+        const action = message.action;
+        if (!gatedActions.has(action)) {
+          return { ok: true, siteKey: null, touchOnSuccess: false };
+        }
+        const params = message.params ?? {};
+        let siteKey = null;
+        if (action === "drive.navigate") {
+          const url = params.url;
+          if (typeof url !== "string" || url.length === 0) {
+            return { ok: true, siteKey: null, touchOnSuccess: false };
+          }
+          if (isRestrictedUrl(url)) {
+            return {
+              ok: false,
+              error: {
+                code: "NOT_SUPPORTED",
+                message: "Navigation is not supported for this URL.",
+                retryable: false,
+                details: { url }
+              }
+            };
+          }
+          siteKey = siteKeyFromUrl(url);
+          if (!siteKey) {
+            return {
+              ok: false,
+              error: {
+                code: "INVALID_ARGUMENT",
+                message: "Unable to resolve site permission key for url.",
+                retryable: false,
+                details: { url }
+              }
+            };
+          }
+        } else {
+          const tabId = params.tab_id;
+          if (tabId !== void 0 && typeof tabId !== "number") {
+            return { ok: true, siteKey: null, touchOnSuccess: false };
+          }
+          const resolvedTabId = typeof tabId === "number" ? tabId : await getDefaultTabId();
+          const tab = await getTab(resolvedTabId);
+          const url = tab.url;
+          if (typeof url !== "string" || url.length === 0) {
+            return {
+              ok: false,
+              error: {
+                code: "FAILED_PRECONDITION",
+                message: "Active tab URL is unavailable for permission gating.",
+                retryable: false,
+                details: { tab_id: resolvedTabId }
+              }
+            };
+          }
+          if (isRestrictedUrl(url)) {
+            const message2 = action === "drive.screenshot" ? "Screenshots are not supported for this URL." : "This action is not supported for this URL.";
+            return {
+              ok: false,
+              error: {
+                code: "NOT_SUPPORTED",
+                message: message2,
+                retryable: false,
+                details: { url }
+              }
+            };
+          }
+          siteKey = siteKeyFromUrl(url);
+          if (!siteKey) {
+            return {
+              ok: false,
+              error: {
+                code: "FAILED_PRECONDITION",
+                message: "Unable to resolve site permission key for active tab.",
+                retryable: false,
+                details: { url, tab_id: resolvedTabId }
+              }
+            };
+          }
+        }
+        if (await readSitePermissionsMode() === "bypass") {
+          return { ok: true, siteKey, touchOnSuccess: false };
+        }
+        if (await isSiteAllowed(siteKey)) {
+          return { ok: true, siteKey, touchOnSuccess: true };
+        }
+        const decision = await permissionPrompts.requestPermission({
+          siteKey,
+          action
+        });
+        if (decision.kind === "timed_out") {
+          return {
+            ok: false,
+            error: {
+              code: "PERMISSION_PROMPT_TIMEOUT",
+              message: `Permission prompt timed out for ${siteKey}.`,
+              retryable: true,
+              details: {
+                reason: "prompt_timed_out",
+                site: siteKey,
+                action,
+                wait_ms: decision.waitMs
+              }
+            }
+          };
+        }
+        if (decision.kind === "deny") {
+          return {
+            ok: false,
+            error: {
+              code: "PERMISSION_DENIED",
+              message: `User denied Browser Bridge permission for ${siteKey}.`,
+              retryable: false,
+              details: {
+                reason: "user_denied",
+                site: siteKey,
+                action,
+                next_step: "Ask the user to approve the permission prompt (Allow/Always allow) or allow the site in the extension options page, then retry the command."
+              }
+            }
+          };
+        }
+        if (decision.kind === "allow_always") {
+          await allowSiteAlways(siteKey);
+          return { ok: true, siteKey, touchOnSuccess: true };
+        }
+        return { ok: true, siteKey, touchOnSuccess: false };
+      };
+      const gated = await gateDriveAction();
+      if (!gated.ok) {
+        respondError(gated.error);
+        return;
+      }
+      gatedSiteKey = gated.siteKey;
+      touchGatedSiteOnSuccess = gated.touchOnSuccess;
       switch (message.action) {
         case "drive.ping": {
           respondOk({ ok: true });
@@ -635,7 +1268,7 @@ var DriveSocket = class {
             return;
           }
           if (tabId === void 0) {
-            tabId = await getActiveTabId();
+            tabId = await getDefaultTabId();
           }
           const waitMode = params.wait === "none" || params.wait === "domcontentloaded" ? params.wait : "domcontentloaded";
           await wrapChromeVoid(
@@ -672,7 +1305,7 @@ var DriveSocket = class {
             return;
           }
           if (tabId === void 0) {
-            tabId = await getActiveTabId();
+            tabId = await getDefaultTabId();
           }
           try {
             const isBack = message.action === "drive.go_back" || message.action === "drive.back";
@@ -753,6 +1386,9 @@ var DriveSocket = class {
           await wrapChromeVoid(
             (callback) => chrome.tabs.remove(tabId, () => callback())
           );
+          if (agentTabId === tabId) {
+            clearAgentTarget();
+          }
           lastActiveAtByTab.delete(tabId);
           respondOk({ ok: true });
           this.sendTabReport();
@@ -788,7 +1424,7 @@ var DriveSocket = class {
             return;
           }
           if (tabId === void 0) {
-            tabId = await getActiveTabId();
+            tabId = await getDefaultTabId();
           }
           const error = await this.ensureDebuggerAttached(tabId);
           if (error) {
@@ -836,7 +1472,7 @@ var DriveSocket = class {
             return;
           }
           if (tabId === void 0) {
-            tabId = await getActiveTabId();
+            tabId = await getDefaultTabId();
           }
           const result = await sendToTab(
             tabId,
@@ -862,7 +1498,7 @@ var DriveSocket = class {
             return;
           }
           if (tabId === void 0) {
-            tabId = await getActiveTabId();
+            tabId = await getDefaultTabId();
           }
           const mode = params.mode === "full_page" || params.mode === "viewport" || params.mode === "element" ? params.mode : "viewport";
           const format = params.format === "jpeg" || params.format === "webp" ? params.format : "png";
@@ -1600,6 +2236,13 @@ var DebuggerTimeoutError = class extends Error {
   }
 };
 var socket = new DriveSocket();
+var permissionPrompts = new PermissionPromptController();
+chrome.runtime.onConnect.addListener((port) => {
+  permissionPrompts.handleConnect(port);
+});
+chrome.windows.onRemoved.addListener((windowId) => {
+  permissionPrompts.handleWindowRemoved(windowId);
+});
 chrome.tabs.onActivated.addListener((activeInfo) => {
   markTabActive(activeInfo.tabId);
   socket.sendTabReport();
@@ -1623,6 +2266,9 @@ chrome.tabs.onUpdated.addListener(
   }
 );
 chrome.tabs.onRemoved.addListener((tabId) => {
+  if (agentTabId === tabId) {
+    clearAgentTarget();
+  }
   lastActiveAtByTab.delete(tabId);
   socket.sendTabReport();
 });