browsirai 0.1.1 → 0.2.1

package/dist/cli/commands/net.js

@@ -0,0 +1,556 @@
+// src/cli/commands/net.ts
+import pc2 from "picocolors";
+import { writeFileSync as writeFileSync2 } from "fs";
+
+// 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 key = arg.slice(2, eqIdx);
+        const value = arg.slice(eqIdx + 1);
+        flags[key] = value;
+      } else {
+        const key = arg.slice(2);
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = "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-intercept.ts
+var activeRoutes = /* @__PURE__ */ new Map();
+var activeAborts = /* @__PURE__ */ new Map();
+var fetchEnabled = false;
+var handlerAttached = false;
+function matchGlob(pattern, url) {
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "___DOUBLESTAR___").replace(/\*/g, "[^/]*").replace(/___DOUBLESTAR___/g, ".*");
+  return new RegExp(`^${regex}$`).test(url);
+}
+async function syncFetchPatterns(cdp) {
+  const patterns = [
+    ...Array.from(activeRoutes.keys()),
+    ...Array.from(activeAborts.keys())
+  ].map((p) => ({ urlPattern: p }));
+  if (patterns.length === 0) {
+    if (fetchEnabled) {
+      await cdp.send("Fetch.disable");
+      fetchEnabled = false;
+    }
+    return;
+  }
+  await cdp.send("Fetch.enable", { patterns });
+  fetchEnabled = true;
+  if (!handlerAttached) {
+    cdp.on("Fetch.requestPaused", async (params) => {
+      const url = params.request.url;
+      const requestId = params.requestId;
+      try {
+        for (const [pattern] of activeAborts) {
+          if (matchGlob(pattern, url)) {
+            await cdp.send("Fetch.failRequest", {
+              requestId,
+              reason: "BlockedByClient"
+            });
+            return;
+          }
+        }
+        for (const [pattern, rule] of activeRoutes) {
+          if (matchGlob(pattern, url)) {
+            const responseHeaders = Object.entries(rule.headers).map(
+              ([name, value]) => ({ name, value })
+            );
+            await cdp.send("Fetch.fulfillRequest", {
+              requestId,
+              responseCode: rule.status,
+              body: btoa(rule.body),
+              responseHeaders
+            });
+            return;
+          }
+        }
+        await cdp.send("Fetch.continueRequest", { requestId });
+      } catch {
+      }
+    });
+    handlerAttached = true;
+  }
+}
+async function browserRoute(cdp, params) {
+  const body = typeof params.body === "object" && params.body !== null ? JSON.stringify(params.body) : String(params.body);
+  const status = params.status ?? 200;
+  const headers = params.headers ?? { "Content-Type": "application/json" };
+  const rule = {
+    urlPattern: params.url,
+    body,
+    status,
+    headers
+  };
+  activeRoutes.set(params.url, rule);
+  await syncFetchPatterns(cdp);
+  return {
+    url: params.url,
+    status,
+    activeRoutes: activeRoutes.size
+  };
+}
+async function browserAbort(cdp, params) {
+  const rule = {
+    urlPattern: params.url
+  };
+  activeAborts.set(params.url, rule);
+  await syncFetchPatterns(cdp);
+  return {
+    url: params.url,
+    activeAborts: activeAborts.size
+  };
+}
+async function browserUnroute(cdp, params) {
+  let removed = 0;
+  if (params.all) {
+    removed = activeRoutes.size + activeAborts.size;
+    activeRoutes.clear();
+    activeAborts.clear();
+  } else if (params.url) {
+    if (activeRoutes.delete(params.url)) removed++;
+    if (activeAborts.delete(params.url)) removed++;
+  }
+  await syncFetchPatterns(cdp);
+  return {
+    removed,
+    remaining: activeRoutes.size + activeAborts.size
+  };
+}
+
+// src/tools/browser-session-state.ts
+import { writeFileSync, readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+function getStatesDir() {
+  return join2(homedir2(), ".browsirai", "states");
+}
+function ensureStatesDir() {
+  const dir = getStatesDir();
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  return dir;
+}
+function getStatePath(name) {
+  return join2(getStatesDir(), `${name}.json`);
+}
+async function browserSaveState(cdp, params) {
+  const { name } = params;
+  const cookieResponse = await cdp.send("Network.getAllCookies");
+  const cookies = cookieResponse.cookies ?? [];
+  const urlResponse = await cdp.send("Runtime.evaluate", {
+    expression: "window.location.href",
+    returnByValue: true
+  });
+  const url = urlResponse.result.value ?? "";
+  const localStorageResponse = await cdp.send("Runtime.evaluate", {
+    expression: "JSON.stringify(Object.entries(localStorage))",
+    returnByValue: true
+  });
+  const localStorageEntries = JSON.parse(
+    localStorageResponse.result.value ?? "[]"
+  );
+  const localStorage = Object.fromEntries(localStorageEntries);
+  const sessionStorageResponse = await cdp.send("Runtime.evaluate", {
+    expression: "JSON.stringify(Object.entries(sessionStorage))",
+    returnByValue: true
+  });
+  const sessionStorageEntries = JSON.parse(
+    sessionStorageResponse.result.value ?? "[]"
+  );
+  const sessionStorage = Object.fromEntries(sessionStorageEntries);
+  const dir = ensureStatesDir();
+  const filePath = join2(dir, `${name}.json`);
+  const stateFile = {
+    version: 1,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    url,
+    cookies,
+    localStorage,
+    sessionStorage
+  };
+  writeFileSync(filePath, JSON.stringify(stateFile, null, 2), "utf-8");
+  return {
+    name,
+    path: filePath,
+    cookies: cookies.length,
+    localStorage: localStorageEntries.length,
+    sessionStorage: sessionStorageEntries.length
+  };
+}
+async function browserLoadState(cdp, params) {
+  const { name, url: customUrl } = params;
+  const filePath = getStatePath(name);
+  if (!existsSync2(filePath)) {
+    throw new Error(`State file not found: ${filePath}`);
+  }
+  const stateFile = JSON.parse(readFileSync2(filePath, "utf-8"));
+  const targetUrl = customUrl ?? stateFile.url;
+  if (targetUrl) {
+    await cdp.send("Page.enable");
+    await cdp.send("Page.navigate", { url: targetUrl });
+  }
+  if (stateFile.cookies.length > 0) {
+    await cdp.send("Network.setCookies", { cookies: stateFile.cookies });
+  }
+  const localEntries = Object.entries(stateFile.localStorage);
+  if (localEntries.length > 0) {
+    const localScript = localEntries.map(([k, v]) => `localStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`).join(";");
+    await cdp.send("Runtime.evaluate", {
+      expression: localScript,
+      returnByValue: true
+    });
+  }
+  const sessionEntries = Object.entries(stateFile.sessionStorage);
+  if (sessionEntries.length > 0) {
+    const sessionScript = sessionEntries.map(([k, v]) => `sessionStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`).join(";");
+    await cdp.send("Runtime.evaluate", {
+      expression: sessionScript,
+      returnByValue: true
+    });
+  }
+  await cdp.send("Page.reload");
+  return {
+    name,
+    cookies: stateFile.cookies.length,
+    localStorage: localEntries.length,
+    sessionStorage: sessionEntries.length
+  };
+}
+
+// src/tools/browser-diff.ts
+async function captureScreenshot(cdp, selector) {
+  const captureParams = { format: "png" };
+  if (selector) {
+    const doc = await cdp.send("DOM.getDocument", {});
+    const queryResult = await cdp.send("DOM.querySelector", {
+      nodeId: doc.root.nodeId,
+      selector
+    });
+    if (!queryResult.nodeId) {
+      throw new Error(`Element not found: ${selector}`);
+    }
+    const boxModel = await cdp.send("DOM.getBoxModel", {
+      nodeId: queryResult.nodeId
+    });
+    const content = boxModel.model.content;
+    captureParams.clip = {
+      x: content[0],
+      y: content[1],
+      width: content[2] - content[0],
+      height: content[5] - content[1],
+      scale: 1
+    };
+  }
+  const screenshot = await cdp.send(
+    "Page.captureScreenshot",
+    captureParams
+  );
+  return screenshot.data;
+}
+function buildComparisonExpression(threshold) {
+  return [
+    "(async () => {",
+    "  const beforeSrc = window._diffBefore;",
+    "  const afterSrc = window._diffAfter;",
+    "",
+    "  const loadImg = (src) => new Promise((res, rej) => {",
+    "    const img = new Image();",
+    "    img.onload = () => res(img);",
+    "    img.onerror = (e) => rej(new Error('Failed to load image'));",
+    "    img.src = src;",
+    "  });",
+    "",
+    "  const img1 = await loadImg('data:image/png;base64,' + beforeSrc);",
+    "  const img2 = await loadImg('data:image/png;base64,' + afterSrc);",
+    "",
+    "  const w = Math.max(img1.width, img2.width);",
+    "  const h = Math.max(img1.height, img2.height);",
+    "",
+    "  const c1 = document.createElement('canvas');",
+    "  c1.width = w; c1.height = h;",
+    "  const ctx1 = c1.getContext('2d');",
+    "  ctx1.drawImage(img1, 0, 0);",
+    "",
+    "  const c2 = document.createElement('canvas');",
+    "  c2.width = w; c2.height = h;",
+    "  const ctx2 = c2.getContext('2d');",
+    "  ctx2.drawImage(img2, 0, 0);",
+    "",
+    "  const d1 = ctx1.getImageData(0, 0, w, h).data;",
+    "  const d2 = ctx2.getImageData(0, 0, w, h).data;",
+    "",
+    "  const diff = document.createElement('canvas');",
+    "  diff.width = w; diff.height = h;",
+    "  const dCtx = diff.getContext('2d');",
+    "  dCtx.drawImage(img2, 0, 0);",
+    "  const dData = dCtx.getImageData(0, 0, w, h);",
+    "",
+    "  let diffCount = 0;",
+    "  const threshold = " + threshold + ";",
+    "  for (let i = 0; i < d1.length; i += 4) {",
+    "    const dr = Math.abs(d1[i] - d2[i]);",
+    "    const dg = Math.abs(d1[i+1] - d2[i+1]);",
+    "    const db = Math.abs(d1[i+2] - d2[i+2]);",
+    "    if (dr > threshold || dg > threshold || db > threshold) {",
+    "      diffCount++;",
+    "      dData.data[i] = 255;",
+    "      dData.data[i+1] = 0;",
+    "      dData.data[i+2] = 0;",
+    "      dData.data[i+3] = 200;",
+    "    }",
+    "  }",
+    "",
+    "  dCtx.putImageData(dData, 0, 0);",
+    "  const diffBase64 = diff.toDataURL('image/png').split(',')[1];",
+    "",
+    "  const total = w * h;",
+    "  return JSON.stringify({",
+    "    diffPercentage: parseFloat((diffCount / total * 100).toFixed(4)),",
+    "    totalPixels: total,",
+    "    diffPixels: diffCount,",
+    "    identical: (diffCount / total) < 0.001,",
+    "    diffImage: diffBase64,",
+    "    width: w,",
+    "    height: h",
+    "  });",
+    "})()"
+  ].join("\n");
+}
+async function browserDiff(cdp, params) {
+  const threshold = params.threshold ?? 30;
+  let beforeBase64;
+  if (params.before === "current") {
+    beforeBase64 = await captureScreenshot(cdp, params.selector);
+  } else {
+    beforeBase64 = params.before;
+  }
+  let afterBase64;
+  if (!params.after || params.after === "current") {
+    afterBase64 = await captureScreenshot(cdp, params.selector);
+  } else {
+    afterBase64 = params.after;
+  }
+  await cdp.send("Runtime.evaluate", {
+    expression: "window._diffBefore = " + JSON.stringify(beforeBase64) + ";",
+    returnByValue: true
+  });
+  await cdp.send("Runtime.evaluate", {
+    expression: "window._diffAfter = " + JSON.stringify(afterBase64) + ";",
+    returnByValue: true
+  });
+  const result = await cdp.send("Runtime.evaluate", {
+    expression: buildComparisonExpression(threshold),
+    awaitPromise: true,
+    returnByValue: true
+  });
+  if (result.exceptionDetails) {
+    throw new Error(
+      "Diff comparison failed: " + result.exceptionDetails.text
+    );
+  }
+  await cdp.send("Runtime.evaluate", {
+    expression: "delete window._diffBefore; delete window._diffAfter;",
+    returnByValue: true
+  });
+  return JSON.parse(result.result.value);
+}
+
+// src/cli/commands/net.ts
+var routeCommand = {
+  name: "route",
+  description: "Intercept matching requests with a custom response",
+  usage: 'browsirai route <urlPattern> [--status=200] [--body="..."] [--contentType=application/json]',
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const urlPattern = flags._0;
+    if (!urlPattern) {
+      console.error(pc2.red("Error: URL pattern is required."));
+      console.log(pc2.dim(`Usage: ${routeCommand.usage}`));
+      process.exit(1);
+    }
+    const status = flags.status ? parseInt(flags.status, 10) : 200;
+    const body = flags.body ?? "{}";
+    const contentType = flags.contentType ?? "application/json";
+    const result = await browserRoute(cdp, {
+      url: urlPattern,
+      body,
+      status,
+      headers: { "Content-Type": contentType }
+    });
+    console.log(
+      pc2.green(`Routing ${pc2.bold(result.url)} \u2192 ${result.status} (custom response)`)
+    );
+    console.log(pc2.dim(`Active routes: ${result.activeRoutes}`));
+  }
+};
+var abortCommand = {
+  name: "abort",
+  description: "Block matching requests",
+  usage: "browsirai abort <urlPattern>",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const urlPattern = flags._0;
+    if (!urlPattern) {
+      console.error(pc2.red("Error: URL pattern is required."));
+      console.log(pc2.dim(`Usage: ${abortCommand.usage}`));
+      process.exit(1);
+    }
+    const result = await browserAbort(cdp, { url: urlPattern });
+    console.log(
+      pc2.green(`Blocking requests matching ${pc2.bold(result.url)}`)
+    );
+    console.log(pc2.dim(`Active abort rules: ${result.activeAborts}`));
+  }
+};
+var unrouteCommand = {
+  name: "unroute",
+  description: "Remove intercept rules",
+  usage: "browsirai unroute [urlPattern] [--all]",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const urlPattern = flags._0;
+    const removeAll = flags.all === "true";
+    if (!urlPattern && !removeAll) {
+      console.error(pc2.red("Error: Provide a URL pattern or --all."));
+      console.log(pc2.dim(`Usage: ${unrouteCommand.usage}`));
+      process.exit(1);
+    }
+    const result = await browserUnroute(cdp, {
+      url: urlPattern,
+      all: removeAll
+    });
+    if (removeAll) {
+      console.log(pc2.green(`Removed all routes (${result.removed} rules cleared)`));
+    } else {
+      console.log(pc2.green(`Removed route for ${pc2.bold(urlPattern)} (${result.removed} removed)`));
+    }
+    console.log(pc2.dim(`Remaining rules: ${result.remaining}`));
+  }
+};
+var saveCommand = {
+  name: "save",
+  description: "Save browser session state (cookies, storage)",
+  usage: "browsirai save <name>",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const name = flags._0;
+    if (!name) {
+      console.error(pc2.red("Error: State name is required."));
+      console.log(pc2.dim(`Usage: ${saveCommand.usage}`));
+      process.exit(1);
+    }
+    const result = await browserSaveState(cdp, { name });
+    console.log(pc2.green(`State saved as '${pc2.bold(result.name)}'`));
+    console.log(pc2.dim(`  Path: ${result.path}`));
+    console.log(pc2.dim(`  Cookies: ${result.cookies}`));
+    console.log(pc2.dim(`  localStorage: ${result.localStorage}`));
+    console.log(pc2.dim(`  sessionStorage: ${result.sessionStorage}`));
+  }
+};
+var loadCommand = {
+  name: "load",
+  description: "Load a saved browser session state",
+  usage: "browsirai load <name> [--url=https://...]",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const name = flags._0;
+    if (!name) {
+      console.error(pc2.red("Error: State name is required."));
+      console.log(pc2.dim(`Usage: ${loadCommand.usage}`));
+      process.exit(1);
+    }
+    const result = await browserLoadState(cdp, {
+      name,
+      url: flags.url
+    });
+    console.log(pc2.green(`State '${pc2.bold(result.name)}' loaded`));
+    console.log(pc2.dim(`  Cookies: ${result.cookies}`));
+    console.log(pc2.dim(`  localStorage: ${result.localStorage}`));
+    console.log(pc2.dim(`  sessionStorage: ${result.sessionStorage}`));
+  }
+};
+var diffCommand = {
+  name: "diff",
+  description: "Pixel-by-pixel screenshot comparison",
+  usage: "browsirai diff [--selector=...] [--threshold=30] [--output=diff.png]",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const selector = flags.selector;
+    const threshold = flags.threshold ? parseInt(flags.threshold, 10) : 30;
+    const output = flags.output;
+    const result = await browserDiff(cdp, {
+      before: "current",
+      after: "current",
+      selector,
+      threshold
+    });
+    if (output) {
+      const imageBuffer = Buffer.from(result.diffImage, "base64");
+      writeFileSync2(output, imageBuffer);
+      console.log(pc2.dim(`Diff image saved to ${output}`));
+    }
+    const pct = result.diffPercentage.toFixed(2);
+    const status = result.identical ? pc2.green("identical") : pc2.yellow(`${pct}% changed`);
+    console.log(
+      `Diff: ${status} (${result.diffPixels.toLocaleString()} pixels, ${result.width}x${result.height})`
+    );
+  }
+};
+var netCommands = [
+  routeCommand,
+  abortCommand,
+  unrouteCommand,
+  saveCommand,
+  loadCommand,
+  diffCommand
+];
+export {
+  netCommands
+};
+//# sourceMappingURL=net.js.map