@btraut/browser-bridge 0.3.0 → 0.4.2

package/extension/dist/background.js

@@ -1,3 +1,97 @@
+// packages/extension/src/error-sanitizer.ts
+var TRAILING_PUNCTUATION_RE = /[.,;:!?]+$/;
+var stripTrailingPunctuation = (value) => {
+  const match = value.match(TRAILING_PUNCTUATION_RE);
+  if (!match) {
+    return { core: value, trailing: "" };
+  }
+  const trailing = match[0] ?? "";
+  return { core: value.slice(0, -trailing.length), trailing };
+};
+var sanitizeUrlToken = (token) => {
+  const { core, trailing } = stripTrailingPunctuation(token);
+  try {
+    const parsed = new URL(core);
+    if (parsed.protocol === "file:") {
+      return `file://[redacted]${trailing}`;
+    }
+    if (parsed.origin && parsed.origin !== "null") {
+      return `${parsed.origin}${trailing}`;
+    }
+    if (parsed.protocol && parsed.host) {
+      return `${parsed.protocol}//${parsed.host}${trailing}`;
+    }
+    if (parsed.protocol) {
+      return `${parsed.protocol}${trailing}`;
+    }
+  } catch {
+  }
+  const fallback = core.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):\/\/([^/\s]+)/);
+  if (fallback?.[1] && fallback?.[2]) {
+    return `${fallback[1]}://${fallback[2]}${trailing}`;
+  }
+  return `[redacted url]${trailing}`;
+};
+var URL_TOKEN_RE = /\b(?:https?|wss?|chrome-extension|chrome|chrome-devtools|devtools|edge|brave|file):\/\/[^\s"'<>)}\]]+/gi;
+var VIEW_SOURCE_RE = /\bview-source:(https?:\/\/[^\s"'<>)}\]]+)/gi;
+var sanitizeUrls = (message) => {
+  let next = message.replace(VIEW_SOURCE_RE, (_match, inner) => {
+    return `view-source:${sanitizeUrlToken(inner)}`;
+  });
+  next = next.replace(URL_TOKEN_RE, (match) => sanitizeUrlToken(match));
+  return next;
+};
+var extractBasename = (value) => {
+  const trimmed = value.trim();
+  const lastSlash = Math.max(
+    trimmed.lastIndexOf("/"),
+    trimmed.lastIndexOf("\\")
+  );
+  if (lastSlash < 0) {
+    return trimmed;
+  }
+  return trimmed.slice(lastSlash + 1);
+};
+var sanitizeWindowsPaths = (message) => {
+  const windowsPathRe = /\b[A-Za-z]:\\(?:[^\s"')\]}]+\\)+[^\s"')\]}]+(?::\d+(?::\d+)?)?/g;
+  return message.replace(windowsPathRe, (match) => extractBasename(match));
+};
+var sanitizeUnixPaths = (message) => {
+  const unixPathRe = /\/(?:Users|home|var|private|tmp|opt|etc|Library|Applications|Volumes|System)(?:\/[^\s"')\]}]+)+(?::\d+(?::\d+)?)?/g;
+  return message.replace(unixPathRe, (match) => extractBasename(match));
+};
+var sanitizeChromeErrorMessage = (message) => {
+  let next = message;
+  next = sanitizeUrls(next);
+  next = sanitizeWindowsPaths(next);
+  next = sanitizeUnixPaths(next);
+  return next;
+};
+var sanitizeUnknown = (value) => {
+  if (typeof value === "string") {
+    return sanitizeChromeErrorMessage(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeUnknown(entry));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const record = value;
+  const next = {};
+  for (const [key, entry] of Object.entries(record)) {
+    next[key] = sanitizeUnknown(entry);
+  }
+  return next;
+};
+var sanitizeDriveErrorInfo = (error) => {
+  return {
+    ...error,
+    message: sanitizeChromeErrorMessage(error.message),
+    ...error.details ? { details: sanitizeUnknown(error.details) } : {}
+  };
+};
+
 // packages/extension/src/background.ts
 var DEFAULT_CORE_PORT = 3210;
 var CORE_PORT_KEY = "corePort";
@@ -48,6 +142,59 @@ var wrapChromeVoid = (invoker) => {
     });
   });
 };
+var delayMs = async (ms) => {
+  if (!Number.isFinite(ms) || ms <= 0) {
+    return;
+  }
+  await new Promise((resolve) => {
+    self.setTimeout(resolve, ms);
+  });
+};
+var parseDataUrl = (dataUrl) => {
+  const match = /^data:([^;]+);base64,(.*)$/s.exec(dataUrl);
+  if (!match) {
+    return null;
+  }
+  return { mime: match[1] ?? "application/octet-stream", base64: match[2] };
+};
+var arrayBufferToBase64 = (buffer) => {
+  const bytes = new Uint8Array(buffer);
+  const chunkSize = 32768;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    const chunk = bytes.subarray(i, i + chunkSize);
+    binary += String.fromCharCode(...chunk);
+  }
+  return btoa(binary);
+};
+var renderDataUrlToFormat = async (dataUrl, format, quality) => {
+  const parsed = parseDataUrl(dataUrl);
+  if (!parsed) {
+    throw new Error("Invalid screenshot data URL.");
+  }
+  const blob = await (await fetch(dataUrl)).blob();
+  const bitmap = await createImageBitmap(blob);
+  try {
+    const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("Canvas context unavailable.");
+    }
+    ctx.drawImage(bitmap, 0, 0);
+    const mime = format === "jpeg" ? "image/jpeg" : format === "webp" ? "image/webp" : "image/png";
+    const q = typeof quality === "number" && Number.isFinite(quality) ? Math.max(0, Math.min(1, quality / 100)) : void 0;
+    const out = format === "png" ? await canvas.convertToBlob({ type: mime }) : await canvas.convertToBlob({ type: mime, quality: q });
+    const base64 = arrayBufferToBase64(await out.arrayBuffer());
+    return {
+      mime,
+      data_base64: base64,
+      width_px: bitmap.width,
+      height_px: bitmap.height
+    };
+  } finally {
+    bitmap.close();
+  }
+};
 var readCorePort = async () => {
   return await new Promise((resolve) => {
     chrome.storage.local.get(
@@ -446,7 +593,7 @@ var DriveSocket = class {
         id: driveMessage.id,
         action: driveMessage.action,
         status: "error",
-        error
+        error: sanitizeDriveErrorInfo(error)
       };
       this.sendMessage(response);
     };
@@ -703,6 +850,366 @@ var DriveSocket = class {
           }
           return;
         }
+        case "drive.screenshot": {
+          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 getActiveTabId();
+          }
+          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";
+          const quality = typeof params.quality === "number" && Number.isFinite(params.quality) ? Math.max(0, Math.min(100, Math.floor(params.quality))) : void 0;
+          const tab = await getTab(tabId);
+          const url = tab.url;
+          if (typeof url === "string" && isRestrictedUrl(url)) {
+            respondError({
+              code: "NOT_SUPPORTED",
+              message: "Screenshots are not supported for this URL.",
+              retryable: false,
+              details: { url }
+            });
+            return;
+          }
+          const windowId = tab.windowId;
+          if (typeof windowId !== "number") {
+            respondError({
+              code: "TAB_NOT_FOUND",
+              message: "window_id missing for tab.",
+              retryable: false
+            });
+            return;
+          }
+          if (typeof OffscreenCanvas === "undefined") {
+            respondError({
+              code: "NOT_SUPPORTED",
+              message: "OffscreenCanvas is unavailable in this extension host.",
+              retryable: false
+            });
+            return;
+          }
+          const captureVisible = async () => {
+            return await wrapChromeCallback(
+              (callback) => chrome.tabs.captureVisibleTab(
+                windowId,
+                { format: "png" },
+                callback
+              )
+            );
+          };
+          const scrollTo = async (top, left) => {
+            const result = await sendToTab(tabId, "drive.scroll", {
+              top,
+              left,
+              behavior: "auto",
+              tab_id: tabId
+            });
+            if (!result.ok) {
+              throw new Error(result.error.message);
+            }
+          };
+          const getMetaInfo = async () => {
+            const meta = await sendToTab(
+              tabId,
+              "drive.screenshot_meta"
+            );
+            if (!meta.ok) {
+              throw new Error(meta.error.message);
+            }
+            const payload = meta.result;
+            if (!payload || typeof payload !== "object") {
+              throw new Error("Invalid screenshot metadata response.");
+            }
+            const record = payload;
+            const viewportHeight = record.viewportHeight;
+            const scrollHeight = record.scrollHeight;
+            const scrollY = record.scrollY;
+            const scrollX = record.scrollX;
+            const dpr = record.devicePixelRatio;
+            if (typeof viewportHeight !== "number" || !Number.isFinite(viewportHeight) || viewportHeight <= 0) {
+              throw new Error(
+                "viewportHeight missing from screenshot metadata."
+              );
+            }
+            if (typeof scrollHeight !== "number" || !Number.isFinite(scrollHeight) || scrollHeight <= 0) {
+              throw new Error("scrollHeight missing from screenshot metadata.");
+            }
+            const devicePixelRatio = typeof dpr === "number" && Number.isFinite(dpr) && dpr > 0 ? dpr : 1;
+            const fullHeightPx = Math.round(scrollHeight * devicePixelRatio);
+            const maxHeightPx = 5e4;
+            if (fullHeightPx > maxHeightPx) {
+              throw new Error(
+                `Page is too tall to capture (max ${maxHeightPx}px).`
+              );
+            }
+            const maxScrollY = Math.max(0, scrollHeight - viewportHeight);
+            const step = viewportHeight;
+            const positions = [];
+            for (let y = 0; y < maxScrollY; y += step) {
+              positions.push(y);
+            }
+            positions.push(maxScrollY);
+            const maxTiles = 200;
+            if (positions.length > maxTiles) {
+              throw new Error(
+                `Page requires too many tiles to capture (${positions.length}).`
+              );
+            }
+            return {
+              viewportHeight,
+              scrollHeight,
+              scrollY: typeof scrollY === "number" && Number.isFinite(scrollY) ? scrollY : 0,
+              scrollX: typeof scrollX === "number" && Number.isFinite(scrollX) ? scrollX : 0,
+              devicePixelRatio,
+              fullHeightPx,
+              positions
+            };
+          };
+          const canvasToResult = async (canvas) => {
+            const mime = format === "jpeg" ? "image/jpeg" : format === "webp" ? "image/webp" : "image/png";
+            const q = typeof quality === "number" && Number.isFinite(quality) ? Math.max(0, Math.min(1, quality / 100)) : void 0;
+            const blob = format === "png" ? await canvas.convertToBlob({ type: mime }) : await canvas.convertToBlob({ type: mime, quality: q });
+            const base64 = arrayBufferToBase64(await blob.arrayBuffer());
+            return {
+              mime,
+              data_base64: base64,
+              width_px: canvas.width,
+              height_px: canvas.height
+            };
+          };
+          const captureFullPageCanvas = async (metaInfo) => {
+            try {
+              await scrollTo(0, 0);
+              await delayMs(100);
+              const firstDataUrl = await captureVisible();
+              const firstBlob = await (await fetch(firstDataUrl)).blob();
+              const firstBitmap = await createImageBitmap(firstBlob);
+              const canvas = new OffscreenCanvas(
+                firstBitmap.width,
+                metaInfo.fullHeightPx
+              );
+              const ctx = canvas.getContext("2d");
+              if (!ctx) {
+                firstBitmap.close();
+                throw new Error("Canvas context unavailable.");
+              }
+              const drawTile = (bitmap, yCss) => {
+                const destY = Math.round(yCss * metaInfo.devicePixelRatio);
+                const remaining = metaInfo.fullHeightPx - destY;
+                if (remaining <= 0) {
+                  return;
+                }
+                const drawHeight = Math.min(bitmap.height, remaining);
+                ctx.drawImage(
+                  bitmap,
+                  0,
+                  0,
+                  bitmap.width,
+                  drawHeight,
+                  0,
+                  destY,
+                  bitmap.width,
+                  drawHeight
+                );
+              };
+              drawTile(firstBitmap, 0);
+              firstBitmap.close();
+              for (const y of metaInfo.positions.slice(1)) {
+                await scrollTo(y, 0);
+                await delayMs(100);
+                const dataUrl = await captureVisible();
+                const blob = await (await fetch(dataUrl)).blob();
+                const bitmap = await createImageBitmap(blob);
+                drawTile(bitmap, y);
+                bitmap.close();
+              }
+              return canvas;
+            } finally {
+              try {
+                await scrollTo(metaInfo.scrollY, metaInfo.scrollX);
+              } catch {
+              }
+            }
+          };
+          if (mode === "viewport") {
+            try {
+              const dataUrl = await captureVisible();
+              const rendered = await renderDataUrlToFormat(
+                dataUrl,
+                format,
+                quality
+              );
+              respondOk(rendered);
+            } catch (error) {
+              respondError({
+                code: "ARTIFACT_IO_ERROR",
+                message: error instanceof Error ? error.message : "Failed to capture screenshot.",
+                retryable: false
+              });
+            }
+            return;
+          }
+          if (mode === "element") {
+            const selector = params.selector;
+            if (typeof selector !== "string" || selector.trim().length === 0) {
+              respondError({
+                code: "INVALID_ARGUMENT",
+                message: "selector must be a non-empty string.",
+                retryable: false
+              });
+              return;
+            }
+            let metaInfo;
+            try {
+              metaInfo = await getMetaInfo();
+            } catch (error) {
+              respondError({
+                code: "EVALUATION_FAILED",
+                message: error instanceof Error ? error.message : "Failed to read screenshot metadata.",
+                retryable: false
+              });
+              return;
+            }
+            const element = await sendToTab(
+              tabId,
+              "drive.screenshot_element",
+              { selector }
+            );
+            if (!element.ok) {
+              respondError(element.error);
+              return;
+            }
+            const payload = element.result;
+            if (!payload || typeof payload !== "object") {
+              respondError({
+                code: "EVALUATION_FAILED",
+                message: "Invalid element metadata response.",
+                retryable: false
+              });
+              return;
+            }
+            const record = payload;
+            const viewportLeft = record.viewportLeft;
+            const viewportTop = record.viewportTop;
+            const viewportWidth = record.viewportWidth;
+            const viewportHeight = record.viewportHeight;
+            const width = record.width;
+            const height = record.height;
+            const pageX = record.pageX;
+            const pageY = record.pageY;
+            const dpr = record.devicePixelRatio;
+            const devicePixelRatio = typeof dpr === "number" && Number.isFinite(dpr) && dpr > 0 ? dpr : metaInfo.devicePixelRatio;
+            if (typeof viewportLeft !== "number" || typeof viewportTop !== "number" || typeof viewportWidth !== "number" || typeof viewportHeight !== "number" || typeof width !== "number" || typeof height !== "number" || typeof pageX !== "number" || typeof pageY !== "number" || !Number.isFinite(viewportLeft) || !Number.isFinite(viewportTop) || !Number.isFinite(viewportWidth) || !Number.isFinite(viewportHeight) || !Number.isFinite(width) || !Number.isFinite(height) || !Number.isFinite(pageX) || !Number.isFinite(pageY)) {
+              respondError({
+                code: "EVALUATION_FAILED",
+                message: "Invalid element bounding box metadata.",
+                retryable: false
+              });
+              return;
+            }
+            const fitsInViewport = viewportLeft >= 0 && viewportTop >= 0 && viewportLeft + width <= viewportWidth && viewportTop + height <= viewportHeight;
+            const cropW = Math.max(1, Math.round(width * devicePixelRatio));
+            const cropH = Math.max(1, Math.round(height * devicePixelRatio));
+            try {
+              if (fitsInViewport) {
+                const dataUrl = await captureVisible();
+                const blob = await (await fetch(dataUrl)).blob();
+                const bitmap = await createImageBitmap(blob);
+                try {
+                  const cropX2 = Math.max(
+                    0,
+                    Math.round(viewportLeft * devicePixelRatio)
+                  );
+                  const cropY2 = Math.max(
+                    0,
+                    Math.round(viewportTop * devicePixelRatio)
+                  );
+                  const srcW2 = Math.min(cropW, bitmap.width - cropX2);
+                  const srcH2 = Math.min(cropH, bitmap.height - cropY2);
+                  if (srcW2 <= 0 || srcH2 <= 0) {
+                    throw new Error("Element is outside screenshot bounds.");
+                  }
+                  const cropCanvas2 = new OffscreenCanvas(srcW2, srcH2);
+                  const ctx2 = cropCanvas2.getContext("2d");
+                  if (!ctx2) {
+                    throw new Error("Canvas context unavailable.");
+                  }
+                  ctx2.drawImage(
+                    bitmap,
+                    cropX2,
+                    cropY2,
+                    srcW2,
+                    srcH2,
+                    0,
+                    0,
+                    srcW2,
+                    srcH2
+                  );
+                  respondOk(await canvasToResult(cropCanvas2));
+                } finally {
+                  bitmap.close();
+                }
+                return;
+              }
+              const fullCanvas = await captureFullPageCanvas(metaInfo);
+              const cropX = Math.max(0, Math.round(pageX * devicePixelRatio));
+              const cropY = Math.max(0, Math.round(pageY * devicePixelRatio));
+              const srcW = Math.min(cropW, fullCanvas.width - cropX);
+              const srcH = Math.min(cropH, fullCanvas.height - cropY);
+              if (srcW <= 0 || srcH <= 0) {
+                throw new Error("Element is outside screenshot bounds.");
+              }
+              const cropCanvas = new OffscreenCanvas(srcW, srcH);
+              const ctx = cropCanvas.getContext("2d");
+              if (!ctx) {
+                throw new Error("Canvas context unavailable.");
+              }
+              ctx.drawImage(
+                fullCanvas,
+                cropX,
+                cropY,
+                srcW,
+                srcH,
+                0,
+                0,
+                srcW,
+                srcH
+              );
+              respondOk(await canvasToResult(cropCanvas));
+            } catch (error) {
+              respondError({
+                code: "ARTIFACT_IO_ERROR",
+                message: error instanceof Error ? error.message : "Failed to capture element screenshot.",
+                retryable: false
+              });
+            } finally {
+              try {
+                await scrollTo(metaInfo.scrollY, metaInfo.scrollX);
+              } catch {
+              }
+            }
+            return;
+          }
+          try {
+            const metaInfo = await getMetaInfo();
+            const canvas = await captureFullPageCanvas(metaInfo);
+            respondOk(await canvasToResult(canvas));
+          } catch (error) {
+            respondError({
+              code: "ARTIFACT_IO_ERROR",
+              message: error instanceof Error ? error.message : "Failed to capture full page screenshot.",
+              retryable: false
+            });
+          }
+          return;
+        }
         default:
           respondError({
             code: "NOT_IMPLEMENTED",
@@ -733,7 +1240,7 @@ var DriveSocket = class {
         id: message.id,
         action: message.action,
         status: "error",
-        error
+        error: sanitizeDriveErrorInfo(error)
       });
     };
     try {