profclaw 0.0.1-beta.1

package/dist/browser/adapters.js

@@ -0,0 +1,32 @@
+/**
+ * Browser Tools Adapters
+ *
+ * Uses unified adapter system from src/tools/adapters.ts
+ * This file provides browser-specific exports for backwards compatibility.
+ */
+import { toMCPSchema, toChatTools, createMCPHandler, } from '../tools/adapters.js';
+import { BROWSER_TOOLS } from './tools.js';
+// MCP Adapter (browser-specific)
+const MCP_PREFIX = 'profclaw__';
+/**
+ * MCP tool definitions for browser tools (with profclaw__ prefix)
+ */
+export const MCP_BROWSER_TOOLS = BROWSER_TOOLS.map((t) => toMCPSchema(t, MCP_PREFIX));
+/**
+ * Handle MCP browser tool call
+ */
+export const handleMCPBrowserTool = createMCPHandler(BROWSER_TOOLS, MCP_PREFIX);
+// Chat Execution Adapter (browser-specific)
+/**
+ * Chat execution tool definitions for browser tools
+ */
+export const CHAT_BROWSER_TOOLS = toChatTools(BROWSER_TOOLS);
+/**
+ * Get chat browser tool by name
+ */
+export function getChatBrowserTool(name) {
+    return CHAT_BROWSER_TOOLS.find((t) => t.name === name);
+}
+// Re-exports for backwards compatibility
+export { BROWSER_TOOLS, SAFE_BROWSER_TOOL_NAMES } from './tools.js';
+//# sourceMappingURL=adapters.js.map

package/dist/browser/cli.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env npx tsx
+/**
+ * Browser Automation CLI
+ *
+ * Command-line interface for testing browser automation tools.
+ * This simulates how AI agents will call these tools.
+ *
+ * Usage:
+ *   npx tsx src/browser/cli.ts navigate https://example.com
+ *   npx tsx src/browser/cli.ts snapshot
+ *   npx tsx src/browser/cli.ts click e5
+ *   npx tsx src/browser/cli.ts type e3 "search query"
+ *   npx tsx src/browser/cli.ts search "button"
+ *   npx tsx src/browser/cli.ts screenshot
+ *   npx tsx src/browser/cli.ts pages
+ *   npx tsx src/browser/cli.ts close
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/browser/cli.js

@@ -0,0 +1,277 @@
+#!/usr/bin/env npx tsx
+/**
+ * Browser Automation CLI
+ *
+ * Command-line interface for testing browser automation tools.
+ * This simulates how AI agents will call these tools.
+ *
+ * Usage:
+ *   npx tsx src/browser/cli.ts navigate https://example.com
+ *   npx tsx src/browser/cli.ts snapshot
+ *   npx tsx src/browser/cli.ts click e5
+ *   npx tsx src/browser/cli.ts type e3 "search query"
+ *   npx tsx src/browser/cli.ts search "button"
+ *   npx tsx src/browser/cli.ts screenshot
+ *   npx tsx src/browser/cli.ts pages
+ *   npx tsx src/browser/cli.ts close
+ */
+import { getBrowserService, resetBrowserService } from './service.js';
+import { formatSnapshotResponse, formatSearchResponse } from './service.js';
+const browser = getBrowserService();
+async function main() {
+    const [, , command, ...args] = process.argv;
+    if (!command) {
+        printHelp();
+        process.exit(1);
+    }
+    try {
+        switch (command) {
+            case 'navigate':
+            case 'nav':
+            case 'goto': {
+                const url = args[0];
+                if (!url) {
+                    console.error('Error: URL required');
+                    console.log('Usage: navigate <url>');
+                    process.exit(1);
+                }
+                console.log(`Navigating to ${url}...`);
+                const result = await browser.navigate(url);
+                console.log(`✓ Navigated to: ${result.url}`);
+                console.log(`  Page ID: ${result.pageId}`);
+                console.log(`  Title: ${result.title}`);
+                // Also capture snapshot
+                const snapshot = await browser.snapshot({ pageId: result.pageId });
+                console.log('\n' + formatSnapshotResponse(snapshot));
+                break;
+            }
+            case 'snapshot':
+            case 'snap': {
+                const pageId = args[0];
+                const interactive = args.includes('--interactive') || args.includes('-i');
+                const compress = !args.includes('--no-compress');
+                console.log('Capturing snapshot...');
+                const snapshot = await browser.snapshot({
+                    pageId,
+                    compress,
+                    interactive,
+                });
+                console.log(formatSnapshotResponse(snapshot));
+                break;
+            }
+            case 'click': {
+                const ref = args[0];
+                if (!ref) {
+                    console.error('Error: Element ref required');
+                    console.log('Usage: click <ref> [--page <pageId>]');
+                    process.exit(1);
+                }
+                const pageId = getArg(args, '--page', '-p');
+                console.log(`Clicking element ${ref}...`);
+                const result = await browser.click({ ref, pageId });
+                console.log(`✓ Clicked: ${result.ref}`);
+                console.log(`  Executed: ${result.executed}`);
+                // Show updated snapshot
+                const snapshot = await browser.snapshot({ pageId });
+                console.log('\n' + formatSnapshotResponse(snapshot));
+                break;
+            }
+            case 'type': {
+                const ref = args[0];
+                const text = args[1];
+                if (!ref || !text) {
+                    console.error('Error: Element ref and text required');
+                    console.log('Usage: type <ref> "<text>" [--submit] [--clear]');
+                    process.exit(1);
+                }
+                const pageId = getArg(args, '--page', '-p');
+                const submit = args.includes('--submit') || args.includes('-s');
+                const clear = args.includes('--clear') || args.includes('-c');
+                console.log(`Typing "${text}" into ${ref}...`);
+                const result = await browser.type({ ref, text, pageId, submit, clear });
+                console.log(`✓ Typed: "${result.text}"`);
+                console.log(`  Executed:\n${result.executed}`);
+                // Show updated snapshot
+                const snapshot = await browser.snapshot({ pageId });
+                console.log('\n' + formatSnapshotResponse(snapshot));
+                break;
+            }
+            case 'search':
+            case 'find': {
+                const pattern = args[0];
+                if (!pattern) {
+                    console.error('Error: Search pattern required');
+                    console.log('Usage: search <pattern> [--limit <n>]');
+                    process.exit(1);
+                }
+                const pageId = getArg(args, '--page', '-p');
+                const limitStr = getArg(args, '--limit', '-l');
+                const limit = limitStr ? parseInt(limitStr, 10) : 20;
+                const ignoreCase = !args.includes('--case-sensitive');
+                console.log(`Searching for "${pattern}"...`);
+                const results = await browser.search({ pattern, pageId, limit, ignoreCase });
+                console.log(formatSearchResponse(results));
+                break;
+            }
+            case 'screenshot':
+            case 'ss': {
+                const pageId = getArg(args, '--page', '-p');
+                const fullPage = args.includes('--full') || args.includes('-f');
+                const ref = getArg(args, '--ref', '-r');
+                const output = getArg(args, '--output', '-o') || 'screenshot.png';
+                console.log('Taking screenshot...');
+                const result = await browser.screenshot({ pageId, fullPage, ref });
+                // Save to file
+                const fs = await import('fs');
+                const buffer = Buffer.from(result.base64, 'base64');
+                fs.writeFileSync(output, buffer);
+                console.log(`✓ Screenshot saved: ${output} (${buffer.length} bytes)`);
+                break;
+            }
+            case 'pages':
+            case 'list':
+            case 'tabs': {
+                const pages = await browser.listPages();
+                if (pages.length === 0) {
+                    console.log('No open pages. Use "navigate <url>" to open a page.');
+                }
+                else {
+                    console.log(`Open pages (${pages.length}):\n`);
+                    pages.forEach((p, i) => {
+                        console.log(`${i + 1}. [${p.id}] ${p.title}`);
+                        console.log(`   URL: ${p.url}`);
+                    });
+                }
+                break;
+            }
+            case 'close': {
+                const pageId = args[0];
+                if (pageId) {
+                    console.log(`Closing page ${pageId}...`);
+                    await browser.closePage(pageId);
+                    console.log(`✓ Page ${pageId} closed`);
+                }
+                else {
+                    console.log('Closing browser...');
+                    await browser.close();
+                    console.log('✓ Browser closed');
+                }
+                break;
+            }
+            case 'status': {
+                const status = browser.getStatus();
+                console.log('Browser Status:');
+                console.log(`  Running: ${status.running ? 'Yes' : 'No'}`);
+                console.log(`  Pages: ${status.pages}`);
+                console.log(`  Headless: ${status.config.headless}`);
+                console.log(`  Timeout: ${status.config.timeout}ms`);
+                break;
+            }
+            case 'demo': {
+                // Full demo workflow
+                console.log('=== Browser Automation Demo ===\n');
+                console.log('1. Navigating to GitHub...');
+                const nav = await browser.navigate('https://github.com');
+                console.log(`   ✓ Loaded: ${nav.title}\n`);
+                console.log('2. Capturing snapshot...');
+                const snapshot = await browser.snapshot({ pageId: nav.pageId, interactive: true });
+                console.log(`   ✓ Found ${snapshot.refs.size} elements\n`);
+                console.log('   Snapshot preview:');
+                console.log(snapshot.snapshot.split('\n').slice(0, 15).map(l => '   ' + l).join('\n'));
+                console.log('   ...\n');
+                console.log('3. Searching for "Sign in"...');
+                const search = await browser.search({ pattern: 'Sign in', pageId: nav.pageId });
+                console.log(`   ✓ Found ${search.matchCount} matches`);
+                if (search.results.length > 0) {
+                    console.log(`   First match: ${search.results[0].ref} - "${search.results[0].name}"\n`);
+                }
+                console.log('4. Taking screenshot...');
+                const ss = await browser.screenshot({ pageId: nav.pageId });
+                console.log(`   ✓ Screenshot: ${ss.base64.length} bytes\n`);
+                console.log('5. Closing browser...');
+                await browser.close();
+                console.log('   ✓ Done!\n');
+                console.log('=== Demo Complete ===');
+                break;
+            }
+            case 'help':
+            case '-h':
+            case '--help':
+                printHelp();
+                break;
+            default:
+                console.error(`Unknown command: ${command}`);
+                printHelp();
+                process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+function getArg(args, ...flags) {
+    for (const flag of flags) {
+        const idx = args.indexOf(flag);
+        if (idx !== -1 && args[idx + 1]) {
+            return args[idx + 1];
+        }
+    }
+    return undefined;
+}
+function printHelp() {
+    console.log(`
+Browser Automation CLI - Test browser tools for AI agents
+
+USAGE:
+  npx tsx src/browser/cli.ts <command> [options]
+
+COMMANDS:
+  navigate <url>         Navigate to URL (alias: nav, goto)
+  snapshot               Capture accessibility snapshot (alias: snap)
+  click <ref>            Click element by ref
+  type <ref> "<text>"    Type text into element
+  search <pattern>       Search content with regex (alias: find)
+  screenshot             Take screenshot (alias: ss)
+  pages                  List open pages (alias: list, tabs)
+  close [pageId]         Close page or browser
+  status                 Show browser status
+  demo                   Run full demo workflow
+  help                   Show this help
+
+OPTIONS:
+  --page, -p <id>        Specify page ID
+  --interactive, -i      Only interactive elements (snapshot)
+  --no-compress          Don't compress snapshot
+  --submit, -s           Press Enter after typing
+  --clear, -c            Clear field before typing
+  --full, -f             Full page screenshot
+  --ref, -r <ref>        Screenshot specific element
+  --output, -o <file>    Screenshot output file
+  --limit, -l <n>        Search result limit
+
+EXAMPLES:
+  # Navigate and get snapshot
+  npx tsx src/browser/cli.ts navigate https://example.com
+
+  # Search for buttons
+  npx tsx src/browser/cli.ts search "button|submit"
+
+  # Click an element
+  npx tsx src/browser/cli.ts click e5
+
+  # Type and submit
+  npx tsx src/browser/cli.ts type e3 "hello world" --submit
+
+  # Full demo
+  npx tsx src/browser/cli.ts demo
+`);
+}
+// Handle cleanup on exit
+process.on('SIGINT', async () => {
+    console.log('\nCleaning up...');
+    await resetBrowserService();
+    process.exit(0);
+});
+main().catch(console.error);
+//# sourceMappingURL=cli.js.map

package/dist/browser/compression.d.ts

@@ -0,0 +1,32 @@
+/**
+ * DOM Compression Algorithm
+ *
+ * Intelligent compression of accessibility trees to reduce token usage.
+ * Based on Better Playwright MCP - achieves ~90% reduction.
+ *
+ * Techniques:
+ * 1. List Folding - Collapse repetitive list items
+ * 2. Text Truncation - Limit long text content
+ * 3. Interactive-Only Mode - Filter non-interactive elements
+ */
+import type { SnapshotNode } from './types.js';
+/**
+ * Compress a snapshot tree
+ */
+export declare function compressTree(tree: SnapshotNode, options?: {
+    interactive?: boolean;
+    maxTextLength?: number;
+}): SnapshotNode;
+/**
+ * Convert compressed tree to YAML string
+ */
+export declare function treeToYaml(tree: SnapshotNode, indent?: number): string;
+/**
+ * Get compression statistics
+ */
+export declare function getCompressionStats(originalTree: SnapshotNode, compressedTree: SnapshotNode): {
+    original: number;
+    compressed: number;
+    reduction: number;
+};
+//# sourceMappingURL=compression.d.ts.map

package/dist/browser/compression.js

@@ -0,0 +1,269 @@
+/**
+ * DOM Compression Algorithm
+ *
+ * Intelligent compression of accessibility trees to reduce token usage.
+ * Based on Better Playwright MCP - achieves ~90% reduction.
+ *
+ * Techniques:
+ * 1. List Folding - Collapse repetitive list items
+ * 2. Text Truncation - Limit long text content
+ * 3. Interactive-Only Mode - Filter non-interactive elements
+ */
+// Configuration
+const MAX_TEXT_LENGTH = 100;
+const MIN_SIMILAR_TO_FOLD = 3;
+const MAX_CHILDREN_BEFORE_FOLD = 5;
+// Roles considered interactive
+const INTERACTIVE_ROLES = new Set([
+    'button',
+    'link',
+    'textbox',
+    'checkbox',
+    'radio',
+    'combobox',
+    'listbox',
+    'slider',
+    'spinbutton',
+    'searchbox',
+    'switch',
+    'tab',
+    'tablist',
+    'menuitem',
+    'menu',
+    'menubar',
+    'option',
+    'dialog',
+    'alertdialog',
+    'form',
+    // Also include navigation landmarks
+    'navigation',
+    'main',
+    'banner',
+    'complementary',
+    'contentinfo',
+    'search',
+]);
+// Roles that contain repeated items
+const LIST_CONTAINER_ROLES = new Set([
+    'list',
+    'listbox',
+    'menu',
+    'menubar',
+    'tablist',
+    'tree',
+    'grid',
+    'rowgroup',
+    'table',
+]);
+/**
+ * Check if two nodes are similar enough to fold
+ */
+function areNodesSimilar(a, b) {
+    // Same role is required
+    if (a.role !== b.role)
+        return false;
+    // Check children count similarity
+    const aChildCount = a.children?.length ?? 0;
+    const bChildCount = b.children?.length ?? 0;
+    // Allow slight variation in children count
+    if (Math.abs(aChildCount - bChildCount) > 2)
+        return false;
+    // Check attribute similarity
+    const aAttrs = new Set([
+        a.checked ? 'checked' : null,
+        a.selected ? 'selected' : null,
+        a.disabled ? 'disabled' : null,
+    ].filter(Boolean));
+    const bAttrs = new Set([
+        b.checked ? 'checked' : null,
+        b.selected ? 'selected' : null,
+        b.disabled ? 'disabled' : null,
+    ].filter(Boolean));
+    // If attributes differ significantly, not similar
+    for (const attr of aAttrs) {
+        if (!bAttrs.has(attr))
+            return false;
+    }
+    return true;
+}
+/**
+ * Fold similar consecutive children
+ */
+function foldSimilarChildren(children) {
+    if (children.length <= MAX_CHILDREN_BEFORE_FOLD) {
+        return children;
+    }
+    const result = [];
+    let i = 0;
+    while (i < children.length) {
+        const current = children[i];
+        const similarNodes = [current];
+        // Find consecutive similar nodes
+        let j = i + 1;
+        while (j < children.length && areNodesSimilar(current, children[j])) {
+            similarNodes.push(children[j]);
+            j++;
+        }
+        if (similarNodes.length >= MIN_SIMILAR_TO_FOLD) {
+            // Keep first item, fold the rest
+            const firstNode = { ...similarNodes[0] };
+            firstNode.similarCount = similarNodes.length - 1;
+            firstNode.similarRefs = similarNodes.slice(1).map(n => n.ref);
+            result.push(firstNode);
+        }
+        else {
+            // Keep all items
+            result.push(...similarNodes);
+        }
+        i = j;
+    }
+    return result;
+}
+/**
+ * Truncate long text
+ */
+function truncateText(text, maxLength = MAX_TEXT_LENGTH) {
+    if (!text)
+        return text;
+    if (text.length <= maxLength)
+        return text;
+    return text.slice(0, maxLength - 3) + '...';
+}
+/**
+ * Check if a node or its descendants are interactive
+ */
+function hasInteractiveDescendant(node) {
+    if (INTERACTIVE_ROLES.has(node.role))
+        return true;
+    if (node.children) {
+        return node.children.some(child => hasInteractiveDescendant(child));
+    }
+    return false;
+}
+/**
+ * Compress a snapshot tree
+ */
+export function compressTree(tree, options = {}) {
+    const { interactive = false, maxTextLength = MAX_TEXT_LENGTH } = options;
+    function compress(node) {
+        // In interactive mode, filter non-interactive nodes
+        if (interactive && !hasInteractiveDescendant(node)) {
+            return null;
+        }
+        // Create a copy of the node
+        const compressed = {
+            role: node.role,
+            ref: node.ref,
+        };
+        // Copy relevant properties with truncation
+        if (node.name)
+            compressed.name = truncateText(node.name, maxTextLength);
+        if (node.value)
+            compressed.value = truncateText(node.value, maxTextLength);
+        if (node.checked !== undefined)
+            compressed.checked = node.checked;
+        if (node.selected !== undefined)
+            compressed.selected = node.selected;
+        if (node.disabled !== undefined)
+            compressed.disabled = node.disabled;
+        if (node.required !== undefined)
+            compressed.required = node.required;
+        if (node.expanded !== undefined)
+            compressed.expanded = node.expanded;
+        if (node.level !== undefined)
+            compressed.level = node.level;
+        // Process children
+        if (node.children && node.children.length > 0) {
+            // Recursively compress children
+            const compressedChildren = node.children
+                .map(child => compress(child))
+                .filter((child) => child !== null);
+            // Apply list folding for list containers
+            if (LIST_CONTAINER_ROLES.has(node.role)) {
+                compressed.children = foldSimilarChildren(compressedChildren);
+            }
+            else {
+                compressed.children = compressedChildren;
+            }
+        }
+        return compressed;
+    }
+    const result = compress(tree);
+    return result || tree;
+}
+/**
+ * Convert compressed tree to YAML string
+ */
+export function treeToYaml(tree, indent = 0) {
+    const lines = [];
+    const prefix = '  '.repeat(indent);
+    // Build the main line
+    let line = `${prefix}- ${tree.role}`;
+    if (tree.name) {
+        line += ` "${tree.name}"`;
+    }
+    // Add attributes
+    const attrs = [];
+    if (tree.checked)
+        attrs.push('checked');
+    if (tree.selected)
+        attrs.push('selected');
+    if (tree.disabled)
+        attrs.push('disabled');
+    if (tree.required)
+        attrs.push('required');
+    if (tree.expanded !== undefined)
+        attrs.push(tree.expanded ? 'expanded' : 'collapsed');
+    if (tree.level !== undefined)
+        attrs.push(`level=${tree.level}`);
+    // Add ref
+    attrs.push(`ref=${tree.ref}`);
+    if (attrs.length > 0) {
+        line += ` [${attrs.join(', ')}]`;
+    }
+    // Handle folded nodes
+    if (tree.similarCount && tree.similarRefs) {
+        line += ` (... and ${tree.similarCount} more similar)`;
+        line += ` [refs: ${tree.similarRefs.slice(0, 5).join(', ')}${tree.similarRefs.length > 5 ? ', ...' : ''}]`;
+    }
+    lines.push(line);
+    // Add value on next line if present
+    if (tree.value) {
+        lines.push(`${prefix}  value: "${tree.value}"`);
+    }
+    // Process children
+    if (tree.children) {
+        for (const child of tree.children) {
+            lines.push(treeToYaml(child, indent + 1));
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Get compression statistics
+ */
+export function getCompressionStats(originalTree, compressedTree) {
+    function countNodes(node) {
+        let count = 1;
+        if (node.children) {
+            count += node.children.reduce((sum, child) => sum + countNodes(child), 0);
+        }
+        // Add similar nodes count
+        if (node.similarCount) {
+            count += node.similarCount;
+        }
+        return count;
+    }
+    function countVisibleNodes(node) {
+        let count = 1;
+        if (node.children) {
+            count += node.children.reduce((sum, child) => sum + countVisibleNodes(child), 0);
+        }
+        return count;
+    }
+    const original = countNodes(originalTree);
+    const compressed = countVisibleNodes(compressedTree);
+    const reduction = Math.round((1 - compressed / original) * 100);
+    return { original, compressed, reduction };
+}
+//# sourceMappingURL=compression.js.map