mitsupi 1.0.0

package/skills/web-browser/scripts/logs-tail.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+import { existsSync, readdirSync, readFileSync, statSync, watch } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LOG_ROOT = join(homedir(), ".cache/agent-web/logs");
+
+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((path) => statSafe(path)?.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((path) => ({ path, mtime: statSafe(path)?.mtimeMs || 0 }))
+    .sort((a, b) => b.mtime - a.mtime);
+  return files[0]?.path || null;
+}
+
+function statSafe(path) {
+  try {
+    return statSync(path);
+  } catch {
+    return null;
+  }
+}
+
+const argIndex = process.argv.indexOf("--file");
+const filePath = argIndex !== -1 ? process.argv[argIndex + 1] : findLatestFile();
+const follow = process.argv.includes("--follow");
+
+if (!filePath) {
+  console.error("✗ No log file found");
+  process.exit(1);
+}
+
+function readAll() {
+  if (!existsSync(filePath)) return;
+  const data = readFileSync(filePath, "utf8");
+  if (data.length > 0) process.stdout.write(data);
+}
+
+let offset = 0;
+
+function readNew() {
+  if (!existsSync(filePath)) return;
+  const data = readFileSync(filePath, "utf8");
+  if (data.length <= offset) return;
+  const chunk = data.slice(offset);
+  offset = data.length;
+  process.stdout.write(chunk);
+}
+
+try {
+  readAll();
+  if (!follow) process.exit(0);
+  offset = statSafe(filePath)?.size || 0;
+  watch(filePath, { persistent: true }, () => readNew());
+  console.log(`✓ tailing ${filePath}`);
+} catch (e) {
+  console.error("✗ tail failed:", e.message);
+  process.exit(1);
+}

package/skills/web-browser/scripts/nav.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+import { connect } from "./cdp.js";
+
+const DEBUG = process.env.DEBUG === "1";
+const log = DEBUG ? (...args) => console.error("[debug]", ...args) : () => {};
+
+const url = process.argv[2];
+const newTab = process.argv[3] === "--new";
+
+if (!url) {
+  console.log("Usage: nav.js <url> [--new]");
+  console.log("\nExamples:");
+  console.log("  nav.js https://example.com       # Navigate current tab");
+  console.log("  nav.js https://example.com --new # Open in new tab");
+  process.exit(1);
+}
+
+// Global timeout
+const globalTimeout = setTimeout(() => {
+  console.error("✗ Global timeout exceeded (45s)");
+  process.exit(1);
+}, 45000);
+
+try {
+  log("connecting...");
+  const cdp = await connect(5000);
+
+  log("getting pages...");
+  let targetId;
+
+  if (newTab) {
+    log("creating new tab...");
+    const { targetId: newTargetId } = await cdp.send("Target.createTarget", {
+      url: "about:blank",
+    });
+    targetId = newTargetId;
+  } else {
+    const pages = await cdp.getPages();
+    const page = pages.at(-1);
+    if (!page) {
+      console.error("✗ No active tab found");
+      process.exit(1);
+    }
+    targetId = page.targetId;
+  }
+
+  log("attaching to page...");
+  const sessionId = await cdp.attachToPage(targetId);
+
+  log("navigating...");
+  await cdp.navigate(sessionId, url);
+
+  console.log(newTab ? "✓ Opened:" : "✓ Navigated to:", url);
+
+  log("closing...");
+  cdp.close();
+  log("done");
+} catch (e) {
+  console.error("✗", e.message);
+  process.exit(1);
+} finally {
+  clearTimeout(globalTimeout);
+  setTimeout(() => process.exit(0), 100);
+}

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

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LOG_ROOT = join(homedir(), ".cache/agent-web/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((path) => statSafe(path)?.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((path) => ({ path, mtime: statSafe(path)?.mtimeMs || 0 }))
+    .sort((a, b) => b.mtime - a.mtime);
+  return files[0]?.path || null;
+}
+
+const argIndex = process.argv.indexOf("--file");
+const filePath = argIndex !== -1 ? process.argv[argIndex + 1] : 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,
+      });
+    }
+  }
+} 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})`);
+  }
+  if (failures.length > 10) {
+    console.log(`- ... ${failures.length - 10} more`);
+  }
+}

package/skills/web-browser/scripts/package-lock.json

@@ -0,0 +1,33 @@
+{
+  "name": "scripts",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "ws": "^8.18.0"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

package/skills/web-browser/scripts/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "dependencies": {
+    "ws": "^8.18.0"
+  }
+}

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

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+import { connect } from "./cdp.js";
+
+const DEBUG = process.env.DEBUG === "1";
+const log = DEBUG ? (...args) => console.error("[debug]", ...args) : () => {};
+
+const message = process.argv.slice(2).join(" ");
+if (!message) {
+  console.log("Usage: pick.js 'message'");
+  console.log("\nExample:");
+  console.log('  pick.js "Click the submit button"');
+  process.exit(1);
+}
+
+// Global timeout - 5 minutes for interactive picking
+const globalTimeout = setTimeout(() => {
+  console.error("✗ Global timeout exceeded (5m)");
+  process.exit(1);
+}, 300000);
+
+const PICK_SCRIPT = `(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);
+  });
+}`;
+
+try {
+  log("connecting...");
+  const cdp = await connect(5000);
+
+  log("getting pages...");
+  const pages = await cdp.getPages();
+  const page = pages.at(-1);
+
+  if (!page) {
+    console.error("✗ No active tab found");
+    process.exit(1);
+  }
+
+  log("attaching to page...");
+  const sessionId = await cdp.attachToPage(page.targetId);
+
+  log("waiting for user pick...");
+  const expression = `(${PICK_SCRIPT})(${JSON.stringify(message)})`;
+  const result = await cdp.evaluate(sessionId, expression, 300000);
+
+  log("formatting result...");
+  if (Array.isArray(result)) {
+    for (let i = 0; i < result.length; i++) {
+      if (i > 0) console.log("");
+      for (const [key, value] of Object.entries(result[i])) {
+        console.log(`${key}: ${value}`);
+      }
+    }
+  } else if (typeof result === "object" && result !== null) {
+    for (const [key, value] of Object.entries(result)) {
+      console.log(`${key}: ${value}`);
+    }
+  } else {
+    console.log(result);
+  }
+
+  log("closing...");
+  cdp.close();
+  log("done");
+} catch (e) {
+  console.error("✗", e.message);
+  process.exit(1);
+} finally {
+  clearTimeout(globalTimeout);
+  setTimeout(() => process.exit(0), 100);
+}

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

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { writeFileSync } from "node:fs";
+import { connect } from "./cdp.js";
+
+const DEBUG = process.env.DEBUG === "1";
+const log = DEBUG ? (...args) => console.error("[debug]", ...args) : () => {};
+
+// Global timeout
+const globalTimeout = setTimeout(() => {
+  console.error("✗ Global timeout exceeded (15s)");
+  process.exit(1);
+}, 15000);
+
+try {
+  log("connecting...");
+  const cdp = await connect(5000);
+
+  log("getting pages...");
+  const pages = await cdp.getPages();
+  const page = pages.at(-1);
+
+  if (!page) {
+    console.error("✗ No active tab found");
+    process.exit(1);
+  }
+
+  log("attaching to page...");
+  const sessionId = await cdp.attachToPage(page.targetId);
+
+  log("taking screenshot...");
+  const data = await cdp.screenshot(sessionId);
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const filename = `screenshot-${timestamp}.png`;
+  const filepath = join(tmpdir(), filename);
+
+  writeFileSync(filepath, data);
+  console.log(filepath);
+
+  log("closing...");
+  cdp.close();
+  log("done");
+} catch (e) {
+  console.error("✗", e.message);
+  process.exit(1);
+} finally {
+  clearTimeout(globalTimeout);
+  setTimeout(() => process.exit(0), 100);
+}

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

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+import { spawn, execSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const useProfile = process.argv[2] === "--profile";
+
+if (process.argv[2] && process.argv[2] !== "--profile") {
+  console.log("Usage: start.ts [--profile]");
+  console.log("\nOptions:");
+  console.log(
+    "  --profile  Copy your default Chrome profile (cookies, logins)",
+  );
+  console.log("\nExamples:");
+  console.log("  start.ts            # Start with fresh profile");
+  console.log("  start.ts --profile  # Start with your Chrome profile");
+  process.exit(1);
+}
+
+// Kill existing Chrome
+try {
+  execSync("killall 'Google Chrome'", { stdio: "ignore" });
+} catch {}
+
+// Wait a bit for processes to fully die
+await new Promise((r) => setTimeout(r, 1000));
+
+// Setup profile directory
+execSync("mkdir -p ~/.cache/scraping", { stdio: "ignore" });
+
+if (useProfile) {
+  // Sync profile with rsync (much faster on subsequent runs)
+  execSync(
+    `rsync -a --delete "${process.env["HOME"]}/Library/Application Support/Google/Chrome/" ~/.cache/scraping/`,
+    { stdio: "pipe" },
+  );
+}
+
+// Start Chrome in background (detached so Node can exit)
+spawn(
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  [
+    "--remote-debugging-port=9222",
+    `--user-data-dir=${process.env["HOME"]}/.cache/scraping`,
+    "--profile-directory=Default",
+    "--disable-search-engine-choice-screen",
+    "--no-first-run",
+    "--disable-features=ProfilePicker",
+  ],
+  { detached: true, stdio: "ignore" },
+).unref();
+
+// Wait for Chrome to be ready by checking the debugging endpoint
+let connected = false;
+for (let i = 0; i < 30; i++) {
+  try {
+    const response = await fetch("http://localhost:9222/json/version");
+    if (response.ok) {
+      connected = true;
+      break;
+    }
+  } catch {
+    await new Promise((r) => setTimeout(r, 500));
+  }
+}
+
+if (!connected) {
+  console.error("✗ Failed to connect to Chrome");
+  process.exit(1);
+}
+
+// Start background watcher for logs/network (detached)
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const watcherPath = join(scriptDir, "watch.js");
+spawn(process.execPath, [watcherPath], { detached: true, stdio: "ignore" }).unref();
+
+console.log(
+  `✓ Chrome started on :9222${useProfile ? " with your profile" : ""}`,
+);