tau-all-agent 0.1.0

package/skills/browser-tools/scripts/browser-net-summary.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+/**
+ * Summarize network activity from browser-watch JSONL logs.
+ *
+ * Usage:
+ *   browser-net-summary.js              # summarize latest log
+ *   browser-net-summary.js --file <path>
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const DEFAULT_TMP = process.platform === "win32" ? tmpdir() : "/tmp";
+
+const LOG_ROOT =
+  process.env.BROWSER_TOOLS_LOG_ROOT || join(DEFAULT_TMP, "agent-browser-tools", "logs");
+
+function statSafe(path) {
+  try {
+    return statSync(path);
+  } catch {
+    return null;
+  }
+}
+
+function findLatestFile() {
+  if (!existsSync(LOG_ROOT)) return null;
+
+  const dirs = readdirSync(LOG_ROOT)
+    .filter((name) => /^\d{4}-\d{2}-\d{2}$/.test(name))
+    .map((name) => join(LOG_ROOT, name))
+    .filter((p) => statSafe(p)?.isDirectory())
+    .sort();
+
+  if (dirs.length === 0) return null;
+
+  const latestDir = dirs[dirs.length - 1];
+  const files = readdirSync(latestDir)
+    .filter((name) => name.endsWith(".jsonl"))
+    .map((name) => join(latestDir, name))
+    .map((p) => ({ path: p, mtime: statSafe(p)?.mtimeMs || 0 }))
+    .sort((a, b) => b.mtime - a.mtime);
+
+  return files[0]?.path || null;
+}
+
+const args = process.argv.slice(2);
+let filePath = null;
+const fileIdx = args.indexOf("--file");
+if (fileIdx !== -1) filePath = args[fileIdx + 1];
+if (!filePath) filePath = findLatestFile();
+
+if (!filePath) {
+  console.error("✗ No log file found");
+  process.exit(1);
+}
+
+const statusCounts = new Map();
+const failures = [];
+let totalResponses = 0;
+let totalRequests = 0;
+
+try {
+  const data = readFileSync(filePath, "utf8");
+  const lines = data.split("\n").filter(Boolean);
+
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    if (entry.type === "network.request") {
+      totalRequests += 1;
+    } else if (entry.type === "network.response") {
+      totalResponses += 1;
+      const status = String(entry.status ?? "unknown");
+      statusCounts.set(status, (statusCounts.get(status) || 0) + 1);
+    } else if (entry.type === "network.failure") {
+      failures.push({
+        requestId: entry.requestId,
+        errorText: entry.errorText,
+        url: entry.url,
+      });
+    }
+  }
+} catch (e) {
+  console.error("✗ summary failed:", e.message);
+  process.exit(1);
+}
+
+console.log(`file: ${filePath}`);
+console.log(`requests: ${totalRequests}`);
+console.log(`responses: ${totalResponses}`);
+
+const statuses = Array.from(statusCounts.entries()).sort((a, b) => Number(a[0]) - Number(b[0]));
+for (const [status, count] of statuses) {
+  console.log(`status ${status}: ${count}`);
+}
+
+if (failures.length > 0) {
+  console.log("failures:");
+  for (const failure of failures.slice(0, 10)) {
+    console.log(
+      `- ${failure.errorText || "unknown"} (${failure.requestId || "?"}) ${failure.url || ""}`.trim(),
+    );
+  }
+  if (failures.length > 10) {
+    console.log(`- ... ${failures.length - 10} more`);
+  }
+}

package/skills/browser-tools/scripts/browser-pick.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+import { connectBrowser, getActivePage, printResult } from "./utils.js";
+
+const message = process.argv.slice(2).join(" ");
+if (!message) {
+  console.log("Usage: browser-pick.js 'message'");
+  console.log("\nExample:");
+  console.log('  browser-pick.js "Click the submit button"');
+  process.exit(1);
+}
+
+const browser = await connectBrowser();
+const page = await getActivePage(browser);
+
+// Inject pick() helper into current page
+await page.evaluate(() => {
+  if (!window.pick) {
+    window.pick = async (message) => {
+      if (!message) {
+        throw new Error("pick() requires a message parameter");
+      }
+      return new Promise((resolve) => {
+        const selections = [];
+        const selectedElements = new Set();
+
+        const overlay = document.createElement("div");
+        overlay.style.cssText =
+          "position:fixed;top:0;left:0;width:100%;height:100%;z-index:2147483647;pointer-events:none";
+
+        const highlight = document.createElement("div");
+        highlight.style.cssText =
+          "position:absolute;border:2px solid #3b82f6;background:rgba(59,130,246,0.1);transition:all 0.1s";
+        overlay.appendChild(highlight);
+
+        const banner = document.createElement("div");
+        banner.style.cssText =
+          "position:fixed;bottom:20px;left:50%;transform:translateX(-50%);background:#1f2937;color:white;padding:12px 24px;border-radius:8px;font:14px sans-serif;box-shadow:0 4px 12px rgba(0,0,0,0.3);pointer-events:auto;z-index:2147483647";
+
+        const updateBanner = () => {
+          banner.textContent = `${message} (${selections.length} selected, Cmd/Ctrl+click to add, Enter to finish, ESC to cancel)`;
+        };
+        updateBanner();
+
+        document.body.append(banner, overlay);
+
+        const cleanup = () => {
+          document.removeEventListener("mousemove", onMove, true);
+          document.removeEventListener("click", onClick, true);
+          document.removeEventListener("keydown", onKey, true);
+          overlay.remove();
+          banner.remove();
+          selectedElements.forEach((el) => {
+            el.style.outline = "";
+          });
+        };
+
+        const onMove = (e) => {
+          const el = document.elementFromPoint(e.clientX, e.clientY);
+          if (!el || overlay.contains(el) || banner.contains(el)) return;
+          const r = el.getBoundingClientRect();
+          highlight.style.cssText = `position:absolute;border:2px solid #3b82f6;background:rgba(59,130,246,0.1);top:${r.top}px;left:${r.left}px;width:${r.width}px;height:${r.height}px`;
+        };
+
+        const buildElementInfo = (el) => {
+          const parents = [];
+          let current = el.parentElement;
+          while (current && current !== document.body) {
+            const parentInfo = current.tagName.toLowerCase();
+            const id = current.id ? `#${current.id}` : "";
+            const cls = current.className
+              ? `.${current.className.trim().split(/\s+/).join(".")}`
+              : "";
+            parents.push(parentInfo + id + cls);
+            current = current.parentElement;
+          }
+
+          return {
+            tag: el.tagName.toLowerCase(),
+            id: el.id || null,
+            class: el.className || null,
+            text: el.textContent?.trim().slice(0, 200) || null,
+            html: el.outerHTML.slice(0, 500),
+            parents: parents.join(" > "),
+          };
+        };
+
+        const onClick = (e) => {
+          if (banner.contains(e.target)) return;
+          e.preventDefault();
+          e.stopPropagation();
+          const el = document.elementFromPoint(e.clientX, e.clientY);
+          if (!el || overlay.contains(el) || banner.contains(el)) return;
+
+          if (e.metaKey || e.ctrlKey) {
+            if (!selectedElements.has(el)) {
+              selectedElements.add(el);
+              el.style.outline = "3px solid #10b981";
+              selections.push(buildElementInfo(el));
+              updateBanner();
+            }
+          } else {
+            cleanup();
+            const info = buildElementInfo(el);
+            resolve(selections.length > 0 ? selections : info);
+          }
+        };
+
+        const onKey = (e) => {
+          if (e.key === "Escape") {
+            e.preventDefault();
+            cleanup();
+            resolve(null);
+          } else if (e.key === "Enter" && selections.length > 0) {
+            e.preventDefault();
+            cleanup();
+            resolve(selections);
+          }
+        };
+
+        document.addEventListener("mousemove", onMove, true);
+        document.addEventListener("click", onClick, true);
+        document.addEventListener("keydown", onKey, true);
+      });
+    };
+  }
+});
+
+const result = await page.evaluate((msg) => window.pick(msg), message);
+
+printResult(result);
+
+await browser.disconnect();

package/skills/browser-tools/scripts/browser-screenshot.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { connectBrowser, getActivePage } from "./utils.js";
+
+const browser = await connectBrowser();
+const page = await getActivePage(browser);
+
+const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+const filename = `screenshot-${timestamp}.png`;
+const filepath = join(tmpdir(), filename);
+
+await page.screenshot({ path: filepath });
+
+console.log(filepath);
+
+await browser.disconnect();

package/skills/browser-tools/scripts/browser-start.js

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+
+import { spawn, execSync } from "node:child_process";
+import fs from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import puppeteer from "puppeteer-core";
+
+const args = process.argv.slice(2);
+let useProfile = false;
+let startWatch = false;
+let browserChoice = "auto"; // auto|chromium|chrome
+let executableOverride = undefined;
+let profileSrcOverride = undefined;
+
+const usage = () => {
+  console.log(
+    "Usage: browser-start.js [--profile] [--watch] [--browser <chromium|chrome>] [--executable <path>]",
+  );
+  console.log("\nOptions:");
+  console.log("  --profile              Copy your browser profile (cookies, logins)");
+  console.log("  --watch                Start browser-watch.js in the background (JSONL logs)");
+  console.log("  --browser <name>       Select browser: chromium, chrome (default: auto)");
+  console.log("  --executable <path>    Explicit browser executable path");
+  console.log("\nEnv:");
+  console.log("  BROWSER_TOOLS_BROWSER  chromium|chrome (overrides auto)");
+  console.log("  BROWSER_TOOLS_EXECUTABLE  Explicit executable path (overrides auto)");
+  console.log("  BROWSER_TOOLS_PROFILE_SRC  Profile directory to rsync from (overrides auto)");
+  console.log(
+    "  BROWSER_TOOLS_LOG_ROOT  Directory for browser-watch logs (defaults to /tmp/agent-browser-tools/logs)",
+  );
+};
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (arg === "--profile") {
+    useProfile = true;
+  } else if (arg === "--watch") {
+    startWatch = true;
+  } else if (arg === "--browser") {
+    browserChoice = args[++i] ?? "";
+  } else if (arg.startsWith("--browser=")) {
+    browserChoice = arg.split("=", 2)[1] ?? "";
+  } else if (arg === "--executable") {
+    executableOverride = args[++i];
+  } else if (arg.startsWith("--executable=")) {
+    executableOverride = arg.split("=", 2)[1];
+  } else {
+    usage();
+    process.exit(1);
+  }
+}
+
+browserChoice = process.env.BROWSER_TOOLS_BROWSER || browserChoice;
+executableOverride = process.env.BROWSER_TOOLS_EXECUTABLE || executableOverride;
+profileSrcOverride = process.env.BROWSER_TOOLS_PROFILE_SRC || profileSrcOverride;
+
+if (!["auto", "chromium", "chrome"].includes(browserChoice)) {
+  usage();
+  process.exit(1);
+}
+
+const SCRAPING_DIR = `${process.env.HOME}/.cache/browser-tools`;
+
+const startWatcher = () => {
+  const scriptDir = dirname(fileURLToPath(import.meta.url));
+  const watcherPath = join(scriptDir, "browser-watch.js");
+  spawn(process.execPath, [watcherPath], { detached: true, stdio: "ignore" }).unref();
+};
+
+const connectToRunningBrowser = async () => {
+  try {
+    return await puppeteer.connect({
+      browserURL: "http://127.0.0.1:9222",
+      defaultViewport: null,
+    });
+  } catch {
+    return null;
+  }
+};
+
+const runningBrowser = await connectToRunningBrowser();
+if (runningBrowser) {
+  await runningBrowser.disconnect();
+  if (startWatch) startWatcher();
+  console.log(`✓ Browser already running on :9222${startWatch ? " (watch enabled)" : ""}`);
+  process.exit(0);
+}
+
+const findExecutable = (candidates) => {
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    if (candidate.includes("/")) {
+      if (fs.existsSync(candidate)) return candidate;
+      continue;
+    }
+    try {
+      const found = execSync(`command -v "${candidate}"`, {
+        stdio: ["ignore", "pipe", "ignore"],
+      })
+        .toString()
+        .trim();
+      if (found) return found;
+    } catch {}
+  }
+  return null;
+};
+
+const getDefaultProfileSrc = (kind) =>
+  kind === "chrome"
+    ? process.platform === "darwin"
+      ? `${process.env.HOME}/Library/Application Support/Google/Chrome/`
+      : `${process.env.HOME}/.config/google-chrome/`
+    : process.platform === "darwin"
+      ? `${process.env.HOME}/Library/Application Support/Chromium/`
+      : `${process.env.HOME}/.config/chromium/`;
+
+const buildBrowserConfig = ({ label, candidates, profileSrc }) => ({
+  label,
+  candidates,
+  executable: findExecutable(candidates),
+  profileSrc,
+});
+
+const getBrowserSelection = () => {
+  if (executableOverride) {
+    const label =
+      browserChoice === "chrome" ? "Chrome" : browserChoice === "chromium" ? "Chromium" : "Browser";
+
+    return {
+      selected: buildBrowserConfig({
+        label,
+        candidates: [executableOverride],
+        profileSrc:
+          profileSrcOverride ||
+          (browserChoice === "auto" ? null : getDefaultProfileSrc(browserChoice)),
+      }),
+    };
+  }
+
+  const chromium = buildBrowserConfig({
+    label: "Chromium",
+    candidates:
+      process.platform === "darwin"
+        ? [
+            "/Applications/Chromium.app/Contents/MacOS/Chromium",
+            `${process.env.HOME}/Applications/Chromium.app/Contents/MacOS/Chromium`,
+          ]
+        : ["chromium", "chromium-browser"],
+    profileSrc: profileSrcOverride || getDefaultProfileSrc("chromium"),
+  });
+
+  const chrome = buildBrowserConfig({
+    label: "Chrome",
+    candidates:
+      process.platform === "darwin"
+        ? [
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            `${process.env.HOME}/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`,
+          ]
+        : ["google-chrome", "google-chrome-stable", "chrome"],
+    profileSrc: profileSrcOverride || getDefaultProfileSrc("chrome"),
+  });
+
+  return {
+    selected:
+      browserChoice === "chromium"
+        ? chromium
+        : browserChoice === "chrome"
+          ? chrome
+          : chromium.executable
+            ? chromium
+            : chrome,
+    all: { chromium, chrome },
+  };
+};
+
+const printMissingBrowserError = ({ selected, all }) => {
+  if (executableOverride) {
+    console.error(`✗ ${selected.label} executable not found: ${executableOverride}`);
+    console.error("  Pass a valid path or command via --executable or BROWSER_TOOLS_EXECUTABLE.");
+    return;
+  }
+
+  if (browserChoice === "auto" && all) {
+    console.error("✗ No Chromium or Chrome executable found.");
+    console.error(`  Chromium checked: ${all.chromium.candidates.join(", ")}`);
+    console.error(`  Chrome checked: ${all.chrome.candidates.join(", ")}`);
+    console.error("  Install one of them or pass --executable <path>.");
+    return;
+  }
+
+  console.error(`✗ ${selected.label} executable not found.`);
+  console.error(`  Checked: ${selected.candidates.join(", ")}`);
+  console.error("  Install it, use --browser auto, or pass --executable <path>.");
+};
+
+const browserSelection = getBrowserSelection();
+const browserConfig = browserSelection.selected;
+if (!browserConfig.executable) {
+  printMissingBrowserError(browserSelection);
+  process.exit(1);
+}
+
+// Setup profile directory
+execSync(`mkdir -p "${SCRAPING_DIR}"`, { stdio: "ignore" });
+
+// Remove SingletonLock to allow new instance
+try {
+  execSync(
+    `rm -f "${SCRAPING_DIR}/SingletonLock" "${SCRAPING_DIR}/SingletonSocket" "${SCRAPING_DIR}/SingletonCookie"`,
+    { stdio: "ignore" },
+  );
+} catch {}
+
+if (useProfile) {
+  if (!browserConfig.profileSrc) {
+    console.error("✗ Cannot infer a profile directory for --executable in auto mode.");
+    console.error("  Also pass --browser <chromium|chrome> or set BROWSER_TOOLS_PROFILE_SRC.");
+    process.exit(1);
+  }
+
+  console.log("Syncing profile...");
+  try {
+    execSync(
+      `rsync -a --delete \
+			--exclude='SingletonLock' \
+			--exclude='SingletonSocket' \
+			--exclude='SingletonCookie' \
+			--exclude='*/Sessions/*' \
+			--exclude='*/Current Session' \
+			--exclude='*/Current Tabs' \
+			--exclude='*/Last Session' \
+			--exclude='*/Last Tabs' \
+			"${browserConfig.profileSrc}" "${SCRAPING_DIR}/"`,
+      { stdio: "pipe" },
+    );
+  } catch {
+    console.error(`✗ Failed to sync profile from: ${browserConfig.profileSrc}`);
+    process.exit(1);
+  }
+}
+
+// Start browser with flags to force new instance
+spawn(
+  browserConfig.executable,
+  [
+    "--remote-debugging-port=9222",
+    `--user-data-dir=${SCRAPING_DIR}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+  ],
+  { detached: true, stdio: "ignore" },
+).unref();
+
+// Wait for the browser to be ready
+let connected = false;
+for (let i = 0; i < 30; i++) {
+  try {
+    const browser = await puppeteer.connect({
+      browserURL: "http://127.0.0.1:9222",
+      defaultViewport: null,
+    });
+    await browser.disconnect();
+    connected = true;
+    break;
+  } catch {
+    await new Promise((r) => setTimeout(r, 500));
+  }
+}
+
+if (!connected) {
+  console.error("✗ Failed to connect to browser");
+  process.exit(1);
+}
+
+if (startWatch) startWatcher();
+
+console.log(
+  `✓ ${browserConfig.label} started on :9222${useProfile ? " with your profile" : ""}${startWatch ? " (watch enabled)" : ""}`,
+);