tau-all-agent 0.1.0

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "tau-all-agent",
+  "version": "0.1.0",
+  "description": "Full Tau distribution for Pi",
+  "keywords": [
+    "pi-extension",
+    "pi-package",
+    "pi-skill"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/goncalossilva/tau.git",
+    "directory": "packages/tau-all-agent"
+  },
+  "type": "module",
+  "dependencies": {
+    "@anthropic-ai/sandbox-runtime": "^0.0.49",
+    "@mozilla/readability": "^0.6.0",
+    "jsdom": "^29.0.2",
+    "node-telegram-bot-api": "^0.67.0",
+    "puppeteer-core": "^24.40.0",
+    "turndown": "^7.2.4",
+    "turndown-plugin-gfm": "^1.0.2"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-agent-core": "*",
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "typebox": "*"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "pi": {
+    "extensions": [
+      "extensions/answer.ts",
+      "extensions/branch-term.ts",
+      "extensions/btw.ts",
+      "extensions/ghostty.ts",
+      "extensions/git-diff-stats.ts",
+      "extensions/git-pr-status.ts",
+      "extensions/insights.ts",
+      "extensions/interlude.ts",
+      "extensions/loop.ts",
+      "extensions/memory.ts",
+      "extensions/notify.ts",
+      "extensions/openai-fast.ts",
+      "extensions/openai-verbosity.ts",
+      "extensions/review.ts",
+      "extensions/sandbox/index.ts",
+      "extensions/usage/index.ts",
+      "extensions/websearch/index.ts",
+      "extensions/worktree.ts",
+      "extensions/telegram/index.ts"
+    ],
+    "skills": [
+      "skills/browser-tools",
+      "skills/git-clean-history",
+      "skills/git-commit",
+      "skills/oracle",
+      "skills/sentry",
+      "skills/update-changelog",
+      "skills/web-design",
+      "skills/homeassistant-ops",
+      "skills/openscad"
+    ]
+  },
+  "files": [
+    "extensions",
+    "skills",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/skills/browser-tools/SKILL.md

@@ -0,0 +1,253 @@
+---
+name: browser-tools
+description: Interactive browser automation via Chrome DevTools Protocol. Use when you need to interact with web pages, test frontends, or when user interaction with a visible browser is required.
+---
+
+# Browser Tools
+
+Chrome DevTools Protocol tools for agent-assisted web automation. These tools connect to a Chromium-based browser (Chromium/Chrome) running on `:9222` with remote debugging enabled.
+
+## Requirements
+
+Chromium or Google Chrome with remote debugging support. The scripts auto-detect common installs; set `BROWSER_TOOLS_BROWSER` or `BROWSER_TOOLS_EXECUTABLE` if auto-detection picks the wrong browser.
+
+## Setup
+
+When hacking on this skill from a source checkout:
+
+```bash
+npm install
+```
+
+## Tools
+
+Important: Always run commands from this skill directory.
+
+### Start Chromium / Chrome
+
+```bash
+"./scripts/browser-start.js"              # Dedicated tool profile
+"./scripts/browser-start.js" --profile    # Seed from your browser profile (cookies, logins)
+"./scripts/browser-start.js" --watch      # Start background JSONL logging
+"./scripts/browser-start.js" --browser chromium
+"./scripts/browser-start.js" --browser chrome
+```
+
+Launch a browser with remote debugging on `:9222`. Use `--profile` to preserve your authentication state. If a browser is already running on `:9222`, it is reused; launch options like `--browser`, `--executable`, and `--profile` only affect new browser instances.
+
+If the auto-detection picks the wrong browser, set:
+
+- `BROWSER_TOOLS_BROWSER=chromium` (or `chrome`)
+- `BROWSER_TOOLS_EXECUTABLE=/absolute/path/to/browser`
+- `BROWSER_TOOLS_PROFILE_SRC=/absolute/path/to/profile/dir` (optional; useful with `--executable --profile`)
+
+### Navigate
+
+```bash
+"./scripts/browser-nav.js" https://example.com
+"./scripts/browser-nav.js" https://example.com --new
+```
+
+Navigate to URLs. Use `--new` flag to open in a new tab instead of reusing current tab.
+
+### Evaluate JavaScript
+
+```bash
+"./scripts/browser-eval.js" 'document.title'
+"./scripts/browser-eval.js" 'document.querySelectorAll("a").length'
+"./scripts/browser-eval.js" 'const el = document.querySelector("textarea"); return el?.value'
+"./scripts/browser-eval.js" --file ./snippet.js
+printf 'return document.title\n' | "./scripts/browser-eval.js" --stdin
+```
+
+Execute JavaScript in the active tab. Code runs in async context. Expressions and statement bodies are both supported. Use `return` when passing statements or multi-line code.
+
+### Screenshot
+
+```bash
+"./scripts/browser-screenshot.js"
+```
+
+Capture current viewport and return temporary file path. Use this to visually inspect page state or verify UI changes.
+
+### Pick Elements
+
+```bash
+"./scripts/browser-pick.js" "Click the submit button"
+```
+
+Use this when the user wants to select specific DOM elements on the page. This launches an interactive picker: click elements to select them, Cmd/Ctrl+Click for multi-select, Enter to finish.
+
+### Dismiss cookie banners
+
+```bash
+"./scripts/browser-dismiss-cookies.js"          # Accept cookies
+"./scripts/browser-dismiss-cookies.js" --reject # Reject (where possible)
+```
+
+Run after navigation if cookie dialogs interfere with interaction.
+
+### Cookies
+
+```bash
+"./scripts/browser-cookies.js"
+"./scripts/browser-cookies.js" --format=netscape > cookies.txt
+```
+
+Display all cookies for the current tab including domain, path, httpOnly, and secure flags.
+
+The `--format=netscape` option outputs cookies in Netscape format for use with curl/wget (`curl -b cookies.txt`).
+
+### Extract Page Content
+
+```bash
+"./scripts/browser-content.js" https://example.com
+```
+
+Navigate to a URL and extract readable content as markdown. Uses Mozilla Readability for article extraction and Turndown for HTML-to-markdown conversion.
+
+### Background logging (console + errors + network)
+
+Start the watcher:
+
+```bash
+"./scripts/browser-watch.js"
+```
+
+Or launch the browser with logging enabled:
+
+```bash
+"./scripts/browser-start.js" --watch
+```
+
+Logs are written as JSONL to a temp directory by default:
+
+- Default: `/tmp/agent-browser-tools/logs/YYYY-MM-DD/<targetId>.jsonl`
+- Override: `BROWSER_TOOLS_LOG_ROOT=/some/dir`
+
+Tail the most recent log:
+
+```bash
+"./scripts/browser-logs-tail.js"           # dump and exit
+"./scripts/browser-logs-tail.js" --follow  # follow
+```
+
+Summarize network responses (status codes, failures):
+
+```bash
+"./scripts/browser-net-summary.js"
+"./scripts/browser-net-summary.js" --file /path/to/log.jsonl
+```
+
+### When to Use
+
+- Testing frontend code in a real browser
+- Interacting with pages that require JavaScript
+- When user needs to visually see or interact with a page
+- Debugging authentication or session issues
+- Scraping dynamic content that requires JS execution
+
+## Efficiency Guide
+
+### DOM Inspection Over Screenshots
+
+**Don't** lead with screenshots to inspect page state. **Do** prefer parsing the DOM directly first, and use screenshots when you need visual/layout verification:
+
+```javascript
+// Get page structure
+document.body.innerHTML.slice(0, 5000);
+
+// Find interactive elements
+Array.from(document.querySelectorAll('button, input, [role="button"]')).map((e) => ({
+  id: e.id,
+  text: e.textContent.trim(),
+  class: e.className,
+}));
+```
+
+### Complex Scripts in Single Calls
+
+Use one eval call for multi-step workflows. `browser-eval.js` supports statement bodies, `return`, and `await`:
+
+```javascript
+const data = document.querySelector("#target")?.textContent;
+const buttons = document.querySelectorAll("button");
+
+buttons[0]?.click();
+
+return {
+  data,
+  buttonCount: buttons.length,
+};
+```
+
+### Batch Interactions
+
+**Don't** make separate calls for each click. **Do** batch them:
+
+```javascript
+const actions = ["btn1", "btn2", "btn3"];
+actions.forEach((id) => document.getElementById(id)?.click());
+return "Done";
+```
+
+### Typing/Input Sequences
+
+For normal form inputs, set the value and dispatch events in one call:
+
+```javascript
+const input = document.querySelector('input[name="email"]');
+if (!input) return "Input not found";
+
+input.value = "user@example.com";
+input.dispatchEvent(new Event("input", { bubbles: true }));
+input.dispatchEvent(new Event("change", { bubbles: true }));
+
+document.querySelector('button[type="submit"]')?.click();
+return "Submitted";
+```
+
+### Reading App/Game State
+
+Extract structured state in one call:
+
+```javascript
+const state = {
+  score: document.querySelector(".score")?.textContent,
+  status: document.querySelector(".status")?.className,
+  items: Array.from(document.querySelectorAll(".item")).map((el) => ({
+    text: el.textContent,
+    active: el.classList.contains("active"),
+  })),
+};
+return state;
+```
+
+### Waiting for Updates
+
+If DOM updates after actions, wait inside the same eval call:
+
+```javascript
+document.querySelector("#submit")?.click();
+await new Promise((resolve) => setTimeout(resolve, 500));
+
+return {
+  status: document.querySelector(".status")?.textContent,
+};
+```
+
+### Investigate Before Interacting
+
+Always start by understanding the page structure:
+
+```javascript
+return {
+  title: document.title,
+  forms: document.forms.length,
+  buttons: document.querySelectorAll("button").length,
+  inputs: document.querySelectorAll("input").length,
+  mainContent: document.body.innerHTML.slice(0, 3000),
+};
+```
+
+Then target specific elements based on what you find.

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

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+import { Readability } from "@mozilla/readability";
+import { JSDOM } from "jsdom";
+import TurndownService from "turndown";
+import { gfm } from "turndown-plugin-gfm";
+import { connectBrowser, getActivePage } from "./utils.js";
+
+// Global timeout - exit if script takes too long
+const TIMEOUT = 30000;
+setTimeout(() => {
+  console.error("✗ Timeout after 30s");
+  process.exit(1);
+}, TIMEOUT).unref();
+
+const url = process.argv[2];
+
+if (!url) {
+  console.log("Usage: browser-content.js <url>");
+  console.log("\nExtracts readable content from a URL as markdown.");
+  console.log("\nExamples:");
+  console.log("  browser-content.js https://example.com");
+  console.log("  browser-content.js https://en.wikipedia.org/wiki/Rust_(programming_language)");
+  process.exit(1);
+}
+
+const browser = await connectBrowser();
+const page = await getActivePage(browser);
+
+await Promise.race([
+  page.goto(url, { waitUntil: "networkidle2" }),
+  new Promise((r) => setTimeout(r, 10000)),
+]).catch(() => {});
+
+// Get HTML via CDP (works even with TrustedScriptURL restrictions)
+const client = await page.createCDPSession();
+const { root } = await client.send("DOM.getDocument", {
+  depth: -1,
+  pierce: true,
+});
+const { outerHTML } = await client.send("DOM.getOuterHTML", {
+  nodeId: root.nodeId,
+});
+await client.detach();
+
+const finalUrl = page.url();
+
+// Extract with Readability
+const doc = new JSDOM(outerHTML, { url: finalUrl });
+const reader = new Readability(doc.window.document);
+const article = reader.parse();
+
+// Convert to markdown
+function htmlToMarkdown(html) {
+  const turndown = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+  });
+  turndown.use(gfm);
+  turndown.addRule("removeEmptyLinks", {
+    filter: (node) => node.nodeName === "A" && !node.textContent?.trim(),
+    replacement: () => "",
+  });
+  return turndown
+    .turndown(html)
+    .replace(/\[\\?\[\s*\\?\]\]\([^)]*\)/g, "")
+    .replace(/ +/g, " ")
+    .replace(/\s+,/g, ",")
+    .replace(/\s+\./g, ".")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+let content;
+if (article && article.content) {
+  content = htmlToMarkdown(article.content);
+} else {
+  // Fallback
+  const fallbackDoc = new JSDOM(outerHTML, { url: finalUrl });
+  const fallbackBody = fallbackDoc.window.document;
+  fallbackBody
+    .querySelectorAll("script, style, noscript, nav, header, footer, aside")
+    .forEach((el) => el.remove());
+  const main =
+    fallbackBody.querySelector("main, article, [role='main'], .content, #content") ||
+    fallbackBody.body;
+  const fallbackHtml = main?.innerHTML || "";
+  if (fallbackHtml.trim().length > 100) {
+    content = htmlToMarkdown(fallbackHtml);
+  } else {
+    content = "(Could not extract content)";
+  }
+}
+
+console.log(`URL: ${finalUrl}`);
+if (article?.title) console.log(`Title: ${article.title}`);
+console.log("");
+console.log(content);
+
+process.exit(0);

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

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+import { connectBrowser, getActivePage } from "./utils.js";
+
+const args = process.argv.slice(2);
+const format = args.includes("--format=netscape") ? "netscape" : "human";
+
+const browser = await connectBrowser();
+const page = await getActivePage(browser);
+
+const cookies = await page.cookies();
+
+if (format === "netscape") {
+  for (const cookie of cookies) {
+    const includeSubdomains = cookie.domain.startsWith(".") ? "TRUE" : "FALSE";
+    const secure = cookie.secure ? "TRUE" : "FALSE";
+    const expiry = cookie.expires > 0 ? Math.floor(cookie.expires) : "0";
+    console.log(
+      `${cookie.domain}\t${includeSubdomains}\t${cookie.path}\t${secure}\t${expiry}\t${cookie.name}\t${cookie.value}`,
+    );
+  }
+} else {
+  for (const cookie of cookies) {
+    console.log(`${cookie.name}: ${cookie.value}`);
+    console.log(`  domain: ${cookie.domain}`);
+    console.log(`  path: ${cookie.path}`);
+    console.log(`  httpOnly: ${cookie.httpOnly}`);
+    console.log(`  secure: ${cookie.secure}`);
+    console.log("");
+  }
+}
+
+await browser.disconnect();