@phnx-labs/agents-cli 1.14.2 → 1.14.3

package/dist/lib/browser/input.js

@@ -0,0 +1,52 @@
+export async function clickAtCoords(cdp, sessionId, x, y) {
+    await cdp.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 }, sessionId);
+    await cdp.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 }, sessionId);
+}
+export async function hoverAtCoords(cdp, sessionId, x, y) {
+    await cdp.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y }, sessionId);
+}
+export async function typeText(cdp, sessionId, text) {
+    for (const char of text) {
+        await cdp.send('Input.dispatchKeyEvent', { type: 'keyDown', text: char }, sessionId);
+        await cdp.send('Input.dispatchKeyEvent', { type: 'keyUp', text: char }, sessionId);
+    }
+}
+const KEY_CODES = {
+    Enter: { key: 'Enter', code: 'Enter', keyCode: 13 },
+    Tab: { key: 'Tab', code: 'Tab', keyCode: 9 },
+    Escape: { key: 'Escape', code: 'Escape', keyCode: 27 },
+    Backspace: { key: 'Backspace', code: 'Backspace', keyCode: 8 },
+    Delete: { key: 'Delete', code: 'Delete', keyCode: 46 },
+    ArrowUp: { key: 'ArrowUp', code: 'ArrowUp', keyCode: 38 },
+    ArrowDown: { key: 'ArrowDown', code: 'ArrowDown', keyCode: 40 },
+    ArrowLeft: { key: 'ArrowLeft', code: 'ArrowLeft', keyCode: 37 },
+    ArrowRight: { key: 'ArrowRight', code: 'ArrowRight', keyCode: 39 },
+    Home: { key: 'Home', code: 'Home', keyCode: 36 },
+    End: { key: 'End', code: 'End', keyCode: 35 },
+    PageUp: { key: 'PageUp', code: 'PageUp', keyCode: 33 },
+    PageDown: { key: 'PageDown', code: 'PageDown', keyCode: 34 },
+    Space: { key: ' ', code: 'Space', keyCode: 32 },
+};
+export async function pressKey(cdp, sessionId, keyName) {
+    const keyInfo = KEY_CODES[keyName];
+    if (!keyInfo) {
+        throw new Error(`Unknown key: ${keyName}. Valid: ${Object.keys(KEY_CODES).join(', ')}`);
+    }
+    await cdp.send('Input.dispatchKeyEvent', {
+        type: 'keyDown',
+        key: keyInfo.key,
+        code: keyInfo.code,
+        windowsVirtualKeyCode: keyInfo.keyCode,
+        nativeVirtualKeyCode: keyInfo.keyCode,
+    }, sessionId);
+    await cdp.send('Input.dispatchKeyEvent', {
+        type: 'keyUp',
+        key: keyInfo.key,
+        code: keyInfo.code,
+        windowsVirtualKeyCode: keyInfo.keyCode,
+        nativeVirtualKeyCode: keyInfo.keyCode,
+    }, sessionId);
+}
+export async function focusNode(cdp, sessionId, backendNodeId) {
+    await cdp.send('DOM.focus', { backendNodeId }, sessionId);
+}

package/dist/lib/browser/ipc.d.ts

@@ -0,0 +1,12 @@
+import { BrowserService } from './service.js';
+import type { IPCRequest, IPCResponse } from './types.js';
+export declare function getSocketPath(): string;
+export declare class BrowserIPCServer {
+    private server;
+    private service;
+    constructor(service: BrowserService);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+}
+export declare function sendIPCRequest(request: IPCRequest): Promise<IPCResponse>;

package/dist/lib/browser/ipc.js

@@ -0,0 +1,223 @@
+import * as net from 'net';
+import * as fs from 'fs';
+import * as path from 'path';
+import { getAgentsDir } from '../state.js';
+import { startDaemon } from '../daemon.js';
+const SOCKET_NAME = 'browser.sock';
+export function getSocketPath() {
+    return path.join(getAgentsDir(), SOCKET_NAME);
+}
+export class BrowserIPCServer {
+    server = null;
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    async start() {
+        const socketPath = getSocketPath();
+        if (fs.existsSync(socketPath)) {
+            fs.unlinkSync(socketPath);
+        }
+        this.server = net.createServer((socket) => {
+            let buffer = '';
+            socket.on('data', async (data) => {
+                buffer += data.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const request = JSON.parse(line);
+                        const response = await this.handleRequest(request);
+                        socket.write(JSON.stringify(response) + '\n');
+                    }
+                    catch (err) {
+                        const error = err instanceof Error ? err.message : 'Unknown error';
+                        socket.write(JSON.stringify({ ok: false, error }) + '\n');
+                    }
+                }
+            });
+            socket.on('error', () => {
+                // Client disconnected
+            });
+        });
+        return new Promise((resolve, reject) => {
+            this.server.listen(socketPath, () => {
+                fs.chmodSync(socketPath, 0o600);
+                resolve();
+            });
+            this.server.on('error', reject);
+        });
+    }
+    async stop() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+        const socketPath = getSocketPath();
+        if (fs.existsSync(socketPath)) {
+            fs.unlinkSync(socketPath);
+        }
+        await this.service.shutdown();
+    }
+    async handleRequest(request) {
+        switch (request.action) {
+            case 'start': {
+                if (!request.profile) {
+                    return { ok: false, error: 'Profile required' };
+                }
+                const result = await this.service.start(request.profile, request.task);
+                return { ok: true, task: result.task, windowTargetId: result.windowTargetId };
+            }
+            case 'stop': {
+                if (request.task) {
+                    const result = await this.service.stop(request.task);
+                    return { ok: result.ok, error: result.ok ? undefined : 'Task not found' };
+                }
+                if (request.profile) {
+                    await this.service.stopProfile(request.profile);
+                    return { ok: true };
+                }
+                return { ok: false, error: 'Task or profile required' };
+            }
+            case 'status': {
+                const profiles = await this.service.status(request.profile);
+                return { ok: true, profiles };
+            }
+            case 'navigate': {
+                if (!request.task || !request.url) {
+                    return { ok: false, error: 'Task and URL required' };
+                }
+                const result = await this.service.navigate(request.task, request.url, request.profile);
+                return { ok: true, tabId: result.tabId };
+            }
+            case 'tabs': {
+                const tabs = await this.service.tabs(request.task, request.profile);
+                return { ok: true, tabs };
+            }
+            case 'close': {
+                if (!request.task) {
+                    return { ok: false, error: 'Task required' };
+                }
+                await this.service.close(request.task, request.tabId);
+                return { ok: true };
+            }
+            case 'evaluate': {
+                if (!request.task || request.tabId === undefined || !request.expr) {
+                    return { ok: false, error: 'Task, tabId, and expression required' };
+                }
+                const result = await this.service.evaluate(request.task, request.tabId, request.expr);
+                return { ok: true, result };
+            }
+            case 'screenshot': {
+                if (!request.task) {
+                    return { ok: false, error: 'Task required' };
+                }
+                const resultPath = await this.service.screenshot(request.task, request.tabId, request.path);
+                return { ok: true, path: resultPath };
+            }
+            case 'refs': {
+                if (!request.task) {
+                    return { ok: false, error: 'Task required' };
+                }
+                const { refs } = await this.service.refs(request.task, request.tabId, {
+                    interactive: request.interactive ?? true,
+                    limit: request.limit ?? 500,
+                });
+                return { ok: true, refs };
+            }
+            case 'click': {
+                if (!request.task || !request.tabId || request.ref === undefined) {
+                    return { ok: false, error: 'Task, tabId, and ref required' };
+                }
+                await this.service.click(request.task, request.tabId, request.ref);
+                return { ok: true };
+            }
+            case 'type': {
+                if (!request.task || !request.tabId || request.ref === undefined || !request.text) {
+                    return { ok: false, error: 'Task, tabId, ref, and text required' };
+                }
+                await this.service.type(request.task, request.tabId, request.ref, request.text);
+                return { ok: true };
+            }
+            case 'press': {
+                if (!request.task || !request.tabId || !request.key) {
+                    return { ok: false, error: 'Task, tabId, and key required' };
+                }
+                await this.service.press(request.task, request.tabId, request.key);
+                return { ok: true };
+            }
+            case 'hover': {
+                if (!request.task || !request.tabId || request.ref === undefined) {
+                    return { ok: false, error: 'Task, tabId, and ref required' };
+                }
+                await this.service.hover(request.task, request.tabId, request.ref);
+                return { ok: true };
+            }
+            default:
+                return { ok: false, error: `Unknown action: ${request.action}` };
+        }
+    }
+}
+export async function sendIPCRequest(request) {
+    const socketPath = getSocketPath();
+    if (!fs.existsSync(socketPath)) {
+        await fs.promises.mkdir(path.dirname(socketPath), { recursive: true });
+        startDaemon();
+        if (!fs.existsSync(socketPath)) {
+            await new Promise((resolve, reject) => {
+                const socketDir = path.dirname(socketPath);
+                const socketName = path.basename(socketPath);
+                const watcher = fs.watch(socketDir, (_event, file) => {
+                    if (file === socketName) {
+                        clearTimeout(timeout);
+                        watcher.close();
+                        resolve();
+                    }
+                });
+                watcher.on('error', (error) => {
+                    clearTimeout(timeout);
+                    watcher.close();
+                    reject(error);
+                });
+                const timeout = setTimeout(() => {
+                    watcher.close();
+                    reject(new Error('Timeout waiting for browser daemon socket'));
+                }, 6000);
+                if (fs.existsSync(socketPath)) {
+                    clearTimeout(timeout);
+                    watcher.close();
+                    resolve();
+                }
+            });
+        }
+        if (!fs.existsSync(socketPath)) {
+            throw new Error('Failed to start browser daemon');
+        }
+    }
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection(socketPath);
+        let buffer = '';
+        socket.on('connect', () => {
+            socket.write(JSON.stringify(request) + '\n');
+        });
+        socket.on('data', (data) => {
+            buffer += data.toString();
+            const idx = buffer.indexOf('\n');
+            if (idx !== -1) {
+                const response = JSON.parse(buffer.slice(0, idx));
+                socket.end();
+                resolve(response);
+            }
+        });
+        socket.on('error', (err) => {
+            reject(new Error(`IPC error: ${err.message}`));
+        });
+        socket.on('close', () => {
+            if (!buffer.includes('\n')) {
+                reject(new Error('Connection closed before response'));
+            }
+        });
+    });
+}

package/dist/lib/browser/profiles.d.ts

@@ -0,0 +1,11 @@
+import type { BrowserProfile } from './types.js';
+export type { BrowserProfile } from './types.js';
+export declare function getBrowserProfilesDir(): string;
+export declare function getBrowserRuntimeDir(): string;
+export declare function getProfilePath(name: string): string;
+export declare function getProfileRuntimeDir(name: string): string;
+export declare function listProfiles(): Promise<BrowserProfile[]>;
+export declare function getProfile(name: string): Promise<BrowserProfile | null>;
+export declare function createProfile(profile: BrowserProfile): Promise<void>;
+export declare function updateProfile(profile: BrowserProfile): Promise<void>;
+export declare function deleteProfile(name: string): Promise<void>;

package/dist/lib/browser/profiles.js

@@ -0,0 +1,61 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as yaml from 'yaml';
+import { getUserAgentsDir } from '../state.js';
+export function getBrowserProfilesDir() {
+    return path.join(getUserAgentsDir(), 'browser', 'profiles');
+}
+export function getBrowserRuntimeDir() {
+    const agentsDir = path.join(os.homedir(), '.agents');
+    return path.join(agentsDir, 'browser');
+}
+export function getProfilePath(name) {
+    return path.join(getBrowserProfilesDir(), `${name}.yaml`);
+}
+export function getProfileRuntimeDir(name) {
+    return path.join(getBrowserRuntimeDir(), name);
+}
+export async function listProfiles() {
+    const dir = getBrowserProfilesDir();
+    if (!fs.existsSync(dir))
+        return [];
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith('.yaml'));
+    const profiles = [];
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(dir, file), 'utf-8');
+        const profile = yaml.parse(content);
+        profiles.push(profile);
+    }
+    return profiles;
+}
+export async function getProfile(name) {
+    const filePath = getProfilePath(name);
+    if (!fs.existsSync(filePath))
+        return null;
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return yaml.parse(content);
+}
+export async function createProfile(profile) {
+    const dir = getBrowserProfilesDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = getProfilePath(profile.name);
+    if (fs.existsSync(filePath)) {
+        throw new Error(`Profile "${profile.name}" already exists`);
+    }
+    fs.writeFileSync(filePath, yaml.stringify(profile), 'utf-8');
+}
+export async function updateProfile(profile) {
+    const filePath = getProfilePath(profile.name);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Profile "${profile.name}" does not exist`);
+    }
+    fs.writeFileSync(filePath, yaml.stringify(profile), 'utf-8');
+}
+export async function deleteProfile(name) {
+    const filePath = getProfilePath(name);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Profile "${name}" does not exist`);
+    }
+    fs.unlinkSync(filePath);
+}

package/dist/lib/browser/refs.d.ts

@@ -0,0 +1,21 @@
+import type { CDPClient } from './cdp.js';
+export interface RefOpts {
+    interactive?: boolean;
+    limit?: number;
+    compact?: boolean;
+}
+export interface RefNode {
+    ref: number;
+    role: string;
+    name: string;
+    attrs: string[];
+    backendNodeId?: number;
+}
+export declare function getRefs(cdp: CDPClient, sessionId: string, opts?: RefOpts): Promise<{
+    refs: string;
+    nodeMap: Map<number, RefNode>;
+}>;
+export declare function resolveRefToCoords(cdp: CDPClient, sessionId: string, nodeMap: Map<number, RefNode>, ref: number): Promise<{
+    x: number;
+    y: number;
+}>;

package/dist/lib/browser/refs.js

@@ -0,0 +1,88 @@
+const INTERACTIVE_ROLES = new Set([
+    'button',
+    'link',
+    'textbox',
+    'checkbox',
+    'radio',
+    'combobox',
+    'listbox',
+    'option',
+    'menuitem',
+    'tab',
+    'slider',
+    'spinbutton',
+    'searchbox',
+    'switch',
+    'menuitemcheckbox',
+    'menuitemradio',
+    'treeitem',
+]);
+export async function getRefs(cdp, sessionId, opts = {}) {
+    const { interactive = true, limit = 500, compact = false } = opts;
+    const { nodes } = (await cdp.send('Accessibility.getFullAXTree', {}, sessionId));
+    const nodeMap = new Map();
+    const lines = [];
+    let refCounter = 1;
+    for (const node of nodes) {
+        if (refCounter > limit)
+            break;
+        const role = node.role?.value?.toLowerCase() || '';
+        if (!role || role === 'none' || role === 'generic')
+            continue;
+        if (interactive && !INTERACTIVE_ROLES.has(role))
+            continue;
+        const name = node.name?.value || '';
+        const attrs = [];
+        for (const prop of node.properties || []) {
+            const propName = prop.name;
+            const propValue = prop.value?.value;
+            if (propName === 'disabled' && propValue === true)
+                attrs.push('disabled');
+            if (propName === 'checked' && propValue === true)
+                attrs.push('checked');
+            if (propName === 'selected' && propValue === true)
+                attrs.push('selected');
+            if (propName === 'expanded' && propValue === true)
+                attrs.push('expanded');
+            if (propName === 'required' && propValue === true)
+                attrs.push('required');
+            if (propName === 'readonly' && propValue === true)
+                attrs.push('readonly');
+            if (propName === 'invalid' && propValue === true)
+                attrs.push('invalid');
+        }
+        const ref = refCounter++;
+        const refNode = {
+            ref,
+            role,
+            name,
+            attrs,
+            backendNodeId: node.backendDOMNodeId,
+        };
+        nodeMap.set(ref, refNode);
+        const attrStr = attrs.length > 0 ? ` [${attrs.join('] [')}]` : '';
+        const nameStr = name ? ` "${truncate(name, 50)}"` : '';
+        const line = compact
+            ? `${role}${nameStr} [ref=${ref}]${attrStr}`
+            : `- ${role}${nameStr} [ref=${ref}]${attrStr}`;
+        lines.push(line);
+    }
+    return { refs: lines.join('\n'), nodeMap };
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 1) + '…';
+}
+export async function resolveRefToCoords(cdp, sessionId, nodeMap, ref) {
+    const node = nodeMap.get(ref);
+    if (!node)
+        throw new Error(`Ref ${ref} not found`);
+    if (!node.backendNodeId)
+        throw new Error(`Ref ${ref} has no DOM node`);
+    const { model } = (await cdp.send('DOM.getBoxModel', { backendNodeId: node.backendNodeId }, sessionId));
+    const [x1, y1, x2, y2, x3, y3, x4, y4] = model.content;
+    const centerX = (x1 + x2 + x3 + x4) / 4;
+    const centerY = (y1 + y2 + y3 + y4) / 4;
+    return { x: centerX, y: centerY };
+}

package/dist/lib/browser/service.d.ts

@@ -0,0 +1,45 @@
+import { type TabInfo, type ProfileStatus } from './types.js';
+import { type RefOpts, type RefNode } from './refs.js';
+export declare class BrowserService {
+    private connections;
+    start(profileName: string, taskId?: string): Promise<{
+        task: string;
+        windowTargetId?: string;
+    }>;
+    stop(taskId: string): Promise<{
+        ok: boolean;
+        profile?: string;
+    }>;
+    stopProfile(profileName: string): Promise<void>;
+    navigate(taskId: string, url: string, profileName?: string): Promise<{
+        tabId: string;
+        url: string;
+    }>;
+    tabs(taskId?: string, profileName?: string): Promise<TabInfo[]>;
+    close(taskId: string, tabId?: string): Promise<void>;
+    evaluate(taskId: string, tabId: string, expression: string): Promise<unknown>;
+    screenshot(taskId: string, tabId?: string, outputPath?: string): Promise<string>;
+    private refsCache;
+    refs(taskId: string, tabId?: string, opts?: RefOpts): Promise<{
+        refs: string;
+        nodeMap: Map<number, RefNode>;
+    }>;
+    click(taskId: string, tabId: string, ref: number): Promise<void>;
+    type(taskId: string, tabId: string, ref: number, text: string): Promise<void>;
+    press(taskId: string, tabId: string, key: string): Promise<void>;
+    hover(taskId: string, tabId: string, ref: number): Promise<void>;
+    status(profileName?: string): Promise<ProfileStatus[]>;
+    shutdown(): Promise<void>;
+    private connectProfile;
+    private connectEndpoint;
+    private enableDomains;
+    private createTaskWindow;
+    private findTask;
+    private getTabsForTask;
+    private getProfileStatus;
+    private getTarget;
+    private getSessionId;
+    private invalidateTargetCache;
+    private saveTaskState;
+    private loadTaskState;
+}