458 lines
13 KiB
TypeScript
458 lines
13 KiB
TypeScript
#!/usr/bin/env bun
|
|
/**
|
|
* Lightweight CLI client for agent-browser
|
|
*
|
|
* This file contains ONLY the client logic (no Playwright imports).
|
|
* It can be compiled with Bun for fast startup times.
|
|
*
|
|
* The actual browser automation runs in a separate daemon process.
|
|
*/
|
|
|
|
import * as net from 'net';
|
|
import * as fs from 'fs';
|
|
import * as os from 'os';
|
|
import * as path from 'path';
|
|
import { spawn } from 'child_process';
|
|
|
|
// ============================================================================
|
|
// Configuration
|
|
// ============================================================================
|
|
|
|
const SESSION = process.env.AGENT_BROWSER_SESSION || 'default';
|
|
const SOCKET_PATH = path.join(os.tmpdir(), `agent-browser-${SESSION}.sock`);
|
|
const PID_FILE = path.join(os.tmpdir(), `agent-browser-${SESSION}.pid`);
|
|
|
|
// ============================================================================
|
|
// Daemon Management
|
|
// ============================================================================
|
|
|
|
function isDaemonRunning(): boolean {
|
|
if (!fs.existsSync(PID_FILE)) return false;
|
|
try {
|
|
const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
|
|
process.kill(pid, 0);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async function ensureDaemon(): Promise<void> {
|
|
if (isDaemonRunning() && fs.existsSync(SOCKET_PATH)) {
|
|
return;
|
|
}
|
|
|
|
// Find the daemon script - look relative to this script
|
|
const scriptDir = path.dirname(process.argv[1]);
|
|
let daemonPath = path.join(scriptDir, 'daemon.js');
|
|
|
|
// Fallback paths
|
|
if (!fs.existsSync(daemonPath)) {
|
|
daemonPath = path.join(scriptDir, '../dist/daemon.js');
|
|
}
|
|
if (!fs.existsSync(daemonPath)) {
|
|
daemonPath = path.join(process.cwd(), 'dist/daemon.js');
|
|
}
|
|
|
|
if (!fs.existsSync(daemonPath)) {
|
|
throw new Error(`Daemon not found. Looked in: ${daemonPath}`);
|
|
}
|
|
|
|
const child = spawn('node', [daemonPath], {
|
|
detached: true,
|
|
stdio: 'ignore',
|
|
env: { ...process.env, AGENT_BROWSER_DAEMON: '1', AGENT_BROWSER_SESSION: SESSION },
|
|
});
|
|
child.unref();
|
|
|
|
// Wait for socket
|
|
for (let i = 0; i < 50; i++) {
|
|
if (fs.existsSync(SOCKET_PATH)) return;
|
|
await new Promise(r => setTimeout(r, 100));
|
|
}
|
|
throw new Error('Failed to start daemon');
|
|
}
|
|
|
|
// ============================================================================
|
|
// Command Execution
|
|
// ============================================================================
|
|
|
|
interface Response {
|
|
id: string;
|
|
success: boolean;
|
|
data?: unknown;
|
|
error?: string;
|
|
}
|
|
|
|
async function sendCommand(cmd: Record<string, unknown>): Promise<Response> {
|
|
return new Promise((resolve, reject) => {
|
|
let buffer = '';
|
|
let resolved = false;
|
|
const socket = net.createConnection(SOCKET_PATH);
|
|
|
|
const cleanup = () => {
|
|
socket.removeAllListeners();
|
|
socket.destroy();
|
|
};
|
|
|
|
socket.on('connect', () => {
|
|
socket.write(JSON.stringify(cmd) + '\n');
|
|
});
|
|
|
|
socket.on('data', (data) => {
|
|
buffer += data.toString();
|
|
const idx = buffer.indexOf('\n');
|
|
if (idx !== -1 && !resolved) {
|
|
resolved = true;
|
|
try {
|
|
const response = JSON.parse(buffer.substring(0, idx)) as Response;
|
|
cleanup();
|
|
resolve(response);
|
|
} catch {
|
|
cleanup();
|
|
reject(new Error('Invalid JSON response'));
|
|
}
|
|
}
|
|
});
|
|
|
|
socket.on('error', (err) => {
|
|
if (!resolved) {
|
|
resolved = true;
|
|
cleanup();
|
|
reject(err);
|
|
}
|
|
});
|
|
|
|
socket.on('close', () => {
|
|
if (!resolved && buffer.trim()) {
|
|
resolved = true;
|
|
try {
|
|
resolve(JSON.parse(buffer.trim()) as Response);
|
|
} catch {
|
|
reject(new Error('Connection closed'));
|
|
}
|
|
}
|
|
});
|
|
|
|
setTimeout(() => {
|
|
if (!resolved) {
|
|
resolved = true;
|
|
cleanup();
|
|
reject(new Error('Timeout'));
|
|
}
|
|
}, 30000);
|
|
});
|
|
}
|
|
|
|
// ============================================================================
|
|
// Command Parsing
|
|
// ============================================================================
|
|
|
|
function parseCommand(parts: string[]): Record<string, unknown> | null {
|
|
if (parts.length === 0) return null;
|
|
|
|
const command = parts[0];
|
|
const rest = parts.slice(1);
|
|
const id = Math.random().toString(36).slice(2, 10);
|
|
|
|
switch (command) {
|
|
case 'open':
|
|
case 'goto':
|
|
case 'navigate':
|
|
return { id, action: 'navigate', url: rest[0]?.startsWith('http') ? rest[0] : `https://${rest[0]}` };
|
|
|
|
case 'click':
|
|
return { id, action: 'click', selector: rest[0] };
|
|
|
|
case 'fill':
|
|
return { id, action: 'fill', selector: rest[0], value: rest.slice(1).join(' ') };
|
|
|
|
case 'type':
|
|
return { id, action: 'type', selector: rest[0], text: rest.slice(1).join(' ') };
|
|
|
|
case 'hover':
|
|
return { id, action: 'hover', selector: rest[0] };
|
|
|
|
case 'snapshot': {
|
|
const opts: Record<string, unknown> = { id, action: 'snapshot' };
|
|
// Parse snapshot options from rest args
|
|
for (let i = 0; i < rest.length; i++) {
|
|
const arg = rest[i];
|
|
if (arg === '-i' || arg === '--interactive') {
|
|
opts.interactive = true;
|
|
} else if (arg === '-c' || arg === '--compact') {
|
|
opts.compact = true;
|
|
} else if (arg === '--depth' || arg === '-d') {
|
|
opts.maxDepth = parseInt(rest[++i], 10);
|
|
} else if (arg === '--selector' || arg === '-s') {
|
|
opts.selector = rest[++i];
|
|
}
|
|
}
|
|
return opts;
|
|
}
|
|
|
|
case 'screenshot':
|
|
return { id, action: 'screenshot', path: rest[0] };
|
|
|
|
case 'close':
|
|
case 'quit':
|
|
return { id, action: 'close' };
|
|
|
|
case 'get':
|
|
if (rest[0] === 'text') return { id, action: 'gettext', selector: rest[1] };
|
|
if (rest[0] === 'url') return { id, action: 'url' };
|
|
if (rest[0] === 'title') return { id, action: 'title' };
|
|
return null;
|
|
|
|
case 'press':
|
|
return { id, action: 'press', key: rest[0] };
|
|
|
|
case 'wait':
|
|
if (/^\d+$/.test(rest[0])) {
|
|
return { id, action: 'wait', timeout: parseInt(rest[0], 10) };
|
|
}
|
|
return { id, action: 'wait', selector: rest[0] };
|
|
|
|
case 'back':
|
|
return { id, action: 'back' };
|
|
|
|
case 'forward':
|
|
return { id, action: 'forward' };
|
|
|
|
case 'reload':
|
|
return { id, action: 'reload' };
|
|
|
|
case 'eval':
|
|
return { id, action: 'evaluate', script: rest.join(' ') };
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function parseBatchCommands(args: string[]): Record<string, unknown>[] {
|
|
const commands: Record<string, unknown>[] = [];
|
|
|
|
// Each argument after 'batch' is a command string
|
|
for (const arg of args) {
|
|
// Split the command string into parts
|
|
const parts = arg.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
|
|
const cleanParts = parts.map(p => p.replace(/^"|"$/g, ''));
|
|
|
|
const cmd = parseCommand(cleanParts);
|
|
if (cmd) {
|
|
commands.push(cmd);
|
|
}
|
|
}
|
|
|
|
return commands;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Output Formatting
|
|
// ============================================================================
|
|
|
|
function formatResponse(response: Response): string {
|
|
if (!response.success) {
|
|
return `\x1b[31m✗ Error:\x1b[0m ${response.error}`;
|
|
}
|
|
|
|
const data = response.data as Record<string, unknown>;
|
|
|
|
if (data?.url && data?.title) {
|
|
return `\x1b[32m✓\x1b[0m \x1b[1m${data.title}\x1b[0m\n\x1b[2m ${data.url}\x1b[0m`;
|
|
} else if (data?.snapshot) {
|
|
return String(data.snapshot);
|
|
} else if (data?.text !== undefined) {
|
|
return String(data.text);
|
|
} else if (data?.url) {
|
|
return String(data.url);
|
|
} else if (data?.title) {
|
|
return String(data.title);
|
|
} else if (data?.result !== undefined) {
|
|
return typeof data.result === 'object' ? JSON.stringify(data.result, null, 2) : String(data.result);
|
|
} else if (data?.closed) {
|
|
return '\x1b[32m✓\x1b[0m Browser closed';
|
|
} else {
|
|
return '\x1b[32m✓\x1b[0m Done';
|
|
}
|
|
}
|
|
|
|
function printResponse(response: Response, json: boolean): void {
|
|
if (json) {
|
|
console.log(JSON.stringify(response));
|
|
} else {
|
|
console.log(formatResponse(response));
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// Main
|
|
// ============================================================================
|
|
|
|
const HELP = `
|
|
agent-browser - fast browser automation CLI
|
|
|
|
Usage:
|
|
agent-browser <command> [args] [--json]
|
|
agent-browser batch <cmd1> <cmd2> ... [--json]
|
|
|
|
Commands:
|
|
open <url> Navigate to URL
|
|
click <sel> Click element (use @ref from snapshot)
|
|
fill <sel> <text> Fill input
|
|
type <sel> <text> Type text
|
|
hover <sel> Hover element
|
|
snapshot [options] Get accessibility tree with refs
|
|
screenshot [path] Take screenshot
|
|
get text <sel> Get text content
|
|
get url Get current URL
|
|
get title Get page title
|
|
press <key> Press keyboard key
|
|
wait <ms|sel> Wait for time or element
|
|
eval <js> Evaluate JavaScript
|
|
close Close browser
|
|
|
|
Snapshot Options:
|
|
-i, --interactive Only show interactive elements (buttons, links, inputs)
|
|
-c, --compact Remove empty structural elements
|
|
-d, --depth <n> Limit tree depth (e.g., --depth 3)
|
|
-s, --selector <sel> Scope snapshot to CSS selector
|
|
|
|
Batch Mode:
|
|
batch <cmd1> <cmd2> ... Execute multiple commands in sequence
|
|
Each command is a quoted string
|
|
|
|
Options:
|
|
--json Output JSON (for AI agents)
|
|
|
|
Examples:
|
|
agent-browser open example.com
|
|
agent-browser snapshot
|
|
agent-browser click @e2
|
|
agent-browser fill @e3 "hello"
|
|
|
|
# Batch mode - execute multiple commands efficiently
|
|
agent-browser batch "open example.com" "snapshot" "click a"
|
|
agent-browser batch "open google.com" "snapshot" "get title" --json
|
|
`;
|
|
|
|
async function runBatch(commands: Record<string, unknown>[], json: boolean): Promise<void> {
|
|
const results: Response[] = [];
|
|
let hasError = false;
|
|
|
|
for (const cmd of commands) {
|
|
try {
|
|
const response = await sendCommand(cmd);
|
|
results.push(response);
|
|
|
|
if (!json) {
|
|
// Print each result as we go for non-JSON mode
|
|
console.log(`\x1b[36m[${cmd.action}]\x1b[0m`);
|
|
console.log(formatResponse(response));
|
|
console.log();
|
|
}
|
|
|
|
if (!response.success) {
|
|
hasError = true;
|
|
break; // Stop on first error
|
|
}
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : String(err);
|
|
const errorResponse: Response = {
|
|
id: String(cmd.id),
|
|
success: false,
|
|
error: message,
|
|
};
|
|
results.push(errorResponse);
|
|
hasError = true;
|
|
|
|
if (!json) {
|
|
console.log(`\x1b[36m[${cmd.action}]\x1b[0m`);
|
|
console.log(`\x1b[31m✗ Error:\x1b[0m ${message}`);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (json) {
|
|
console.log(JSON.stringify({
|
|
success: !hasError,
|
|
results,
|
|
completed: results.length,
|
|
total: commands.length,
|
|
}));
|
|
} else {
|
|
console.log(`\x1b[2m─────────────────────────────────────\x1b[0m`);
|
|
console.log(`Completed ${results.length}/${commands.length} commands`);
|
|
}
|
|
|
|
process.exit(hasError ? 1 : 0);
|
|
}
|
|
|
|
async function main(): Promise<void> {
|
|
const args = process.argv.slice(2);
|
|
const json = args.includes('--json');
|
|
const cleanArgs = args.filter(a => !a.startsWith('--'));
|
|
|
|
if (cleanArgs.length === 0 || args.includes('--help') || args.includes('-h')) {
|
|
console.log(HELP);
|
|
process.exit(0);
|
|
}
|
|
|
|
// Check for batch mode
|
|
if (cleanArgs[0] === 'batch') {
|
|
const batchArgs = cleanArgs.slice(1);
|
|
if (batchArgs.length === 0) {
|
|
console.error('\x1b[31mBatch mode requires at least one command\x1b[0m');
|
|
console.log('\nExample: agent-browser batch "open example.com" "snapshot"');
|
|
process.exit(1);
|
|
}
|
|
|
|
const commands = parseBatchCommands(batchArgs);
|
|
if (commands.length === 0) {
|
|
console.error('\x1b[31mNo valid commands found\x1b[0m');
|
|
process.exit(1);
|
|
}
|
|
|
|
try {
|
|
await ensureDaemon();
|
|
await runBatch(commands, json);
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : String(err);
|
|
if (json) {
|
|
console.log(JSON.stringify({ success: false, error: message }));
|
|
} else {
|
|
console.error('\x1b[31m✗ Error:\x1b[0m', message);
|
|
}
|
|
process.exit(1);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Single command mode
|
|
const cmd = parseCommand(cleanArgs);
|
|
|
|
if (!cmd) {
|
|
console.error('\x1b[31mUnknown command:\x1b[0m', cleanArgs[0]);
|
|
process.exit(1);
|
|
}
|
|
|
|
try {
|
|
await ensureDaemon();
|
|
const response = await sendCommand(cmd);
|
|
printResponse(response, json);
|
|
process.exit(response.success ? 0 : 1);
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : String(err);
|
|
if (json) {
|
|
console.log(JSON.stringify({ success: false, error: message }));
|
|
} else {
|
|
console.error('\x1b[31m✗ Error:\x1b[0m', message);
|
|
}
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
main();
|