@phnx-labs/agents-cli 1.14.2 → 1.14.4

package/dist/index.js

@@ -9,6 +9,7 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { confirm, select } from '@inquirer/prompts';
@@ -41,13 +42,15 @@ import { registerRoutinesCommands } from './commands/routines.js';
 import { registerRunCommand } from './commands/exec.js';
 import { registerModelsCommand } from './commands/models.js';
 import { registerPruneCommand } from './commands/prune.js';
+import { registerTrashCommands } from './commands/trash.js';
 import { registerDoctorCommand } from './commands/doctor.js';
 import { registerSubagentsCommands } from './commands/subagents.js';
 import { registerPluginsCommands } from './commands/plugins.js';
 import { registerSyncCommand } from './commands/sync.js';
-import { registerRefreshMemoryCommand } from './commands/refresh-memory.js';
+import { registerRefreshRulesCommand } from './commands/refresh-rules.js';
 import { registerDriveCommands } from './commands/drive.js';
 import { registerPtyCommands } from './commands/pty.js';
+import { registerBrowserCommand } from './commands/browser.js';
 import { registerProfilesCommands } from './commands/profiles.js';
 import { registerSecretsCommands } from './commands/secrets.js';
 import { registerFactoryCommands } from './commands/factory.js';
@@ -59,7 +62,7 @@ import { isPromptCancelled } from './commands/utils.js';
 import { getAgentsDir } from './lib/state.js';
 import { AGENTS } from './lib/agents.js';
 import { getGlobalDefault } from './lib/versions.js';
-import { addShimsToPath, ensureShimCurrent, getPathShadowingExecutable, getPathSetupInstructions, hasAliasShadowingShim, isShimsInPath, listAgentsWithInstalledVersions, } from './lib/shims.js';
+import { addShimsToPath, ensureShimCurrent, getPathShadowingExecutable, getPathSetupInstructions, hasAliasShadowingShim, isShimsInPath, listAgentsWithInstalledVersions, removeLegacyUserShim, } from './lib/shims.js';
 const program = new Command();
 program
     .name('agents')
@@ -319,7 +322,7 @@ async function maybeBootstrapShimIntegration(requestedCommand) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         return;
     }
-    if (requestedCommand === 'sync' || requestedCommand === 'refresh-memory') {
+    if (requestedCommand === 'sync' || requestedCommand === 'refresh-rules') {
         return;
     }
     const installedAgents = listAgentsWithInstalledVersions();
@@ -336,6 +339,13 @@ async function maybeBootstrapShimIntegration(requestedCommand) {
     for (const notice of createdOrUpdated) {
         console.log(chalk.green(notice));
     }
+    // Best-effort: remove leftover ~/.agents/shims/<cli> files from the pre-split
+    // layout BEFORE running detection. These cause false-positive "shadowing"
+    // results that make the repair prompt loop forever (the prompt user said
+    // "yes" to never deletes the file; next invocation finds it again).
+    for (const agent of installedAgents) {
+        removeLegacyUserShim(agent);
+    }
     const defaultAgents = installedAgents.filter((agent) => getGlobalDefault(agent));
     const shadowed = defaultAgents
         .map((agent) => ({ agent, shadowedBy: getPathShadowingExecutable(agent) }))
@@ -348,6 +358,15 @@ async function maybeBootstrapShimIntegration(requestedCommand) {
     if (shadowed.length === 0 && isShimsInPath()) {
         return;
     }
+    // Suppress repeated prompts within the same shell. A successful rc-file
+    // edit doesn't reload the parent shell, so the next invocation sees the
+    // same PATH and re-fires detection. The sentinel survives only as long as
+    // the parent shell process — once the user opens a new terminal, the
+    // PPID changes and the prompt is allowed again.
+    const sentinelPath = path.join(os.tmpdir(), `agents-shim-prompted-${process.ppid}`);
+    if (fs.existsSync(sentinelPath)) {
+        return;
+    }
     const affected = [];
     for (const { agent, shadowedBy } of shadowed) {
         affected.push(`${AGENTS[agent].cliCommand} -> ${shadowedBy}`);
@@ -368,6 +387,10 @@ async function maybeBootstrapShimIntegration(requestedCommand) {
     if (!shouldRepair) {
         console.log(chalk.yellow('Shim integration still needs attention.'));
         console.log(chalk.gray(getPathSetupInstructions()));
+        try {
+            fs.writeFileSync(sentinelPath, '1');
+        }
+        catch { /* best-effort */ }
         return;
     }
     const pathResult = addShimsToPath();
@@ -383,6 +406,10 @@ async function maybeBootstrapShimIntegration(requestedCommand) {
         console.log(chalk.green(`Repaired shim PATH setup in ~/${pathResult.rcFile}`));
     }
     console.log(chalk.gray(getPathSetupInstructions()));
+    try {
+        fs.writeFileSync(sentinelPath, '1');
+    }
+    catch { /* best-effort */ }
 }
 // Register all commands
 registerViewCommand(program);
@@ -424,6 +451,7 @@ registerRoutinesCommands(program);
 registerRunCommand(program);
 registerModelsCommand(program);
 registerPruneCommand(program);
+registerTrashCommands(program);
 registerDoctorCommand(program);
 // Deprecated 'exec' alias for 'run'
 program
@@ -440,12 +468,13 @@ registerProfilesCommands(program);
 registerSecretsCommands(program);
 registerBetaCommands(program);
 registerSyncCommand(program);
-registerRefreshMemoryCommand(program);
+registerRefreshRulesCommand(program);
 registerDriveCommands(program);
 registerFactoryCommands(program);
 registerUsageCommand(program);
 registerAliasCommand(program);
 registerPtyCommands(program);
+registerBrowserCommand(program);
 // Deprecated 'jobs' and 'cron' aliases for 'routines'
 for (const alias of ['jobs', 'cron']) {
     program
@@ -610,6 +639,35 @@ if (!firstRun && requestedCommand && SYSTEM_REPO_COMMANDS.has(requestedCommand))
     const { ensureInitialized } = await import('./commands/init.js');
     await ensureInitialized(program);
 }
+// One-shot idempotent migrations (split-layout, legacy file moves).
+// Each step is internally guarded by existence checks so it's safe to run
+// every invocation. A sentinel file in the system dir short-circuits the
+// scan once a migration version has run, so the hot path stays cheap.
+// AGENTS_SKIP_MIGRATION=1 disables the bootstrap-time run for tests and
+// scripted invocations that prepare their own legacy fixtures.
+if (process.env.AGENTS_SKIP_MIGRATION !== '1') {
+    try {
+        const { runMigration } = await import('./lib/migrate.js');
+        const sentinel = path.join(getAgentsDir(), '.migrated');
+        const sentinelValue = `${VERSION}-v2`;
+        let needRun = true;
+        try {
+            if (fs.existsSync(sentinel) && fs.readFileSync(sentinel, 'utf-8').trim() === sentinelValue) {
+                needRun = false;
+            }
+        }
+        catch { /* best-effort — fall through to run */ }
+        if (needRun) {
+            runMigration();
+            try {
+                fs.mkdirSync(path.dirname(sentinel), { recursive: true });
+                fs.writeFileSync(sentinel, sentinelValue);
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    catch { /* migration must never block CLI startup */ }
+}
 try {
     await maybeBootstrapShimIntegration(requestedCommand);
     await program.parseAsync();

package/dist/lib/agents.js

@@ -155,7 +155,7 @@ export const AGENTS = {
         format: 'markdown',
         variableSyntax: '$ARGUMENTS',
         supportsHooks: true,
-        capabilities: { hooks: true, mcp: true, allowlist: true, skills: true, commands: true, plugins: true, memoryImports: true },
+        capabilities: { hooks: true, mcp: true, allowlist: true, skills: true, commands: true, plugins: true, rulesImports: true },
     },
     // codex hooks: gated to >= 0.116.0 (introduced [features] codex_hooks flag).
     codex: {
@@ -192,7 +192,7 @@ export const AGENTS = {
         supportsHooks: true,
         nativeAgentsSkillsDir: true,
         // gemini hooks: shipped in v0.26.0 (Jan 2026); older binaries silently ignore the `hooks` key.
-        capabilities: { hooks: { since: '0.26.0' }, mcp: true, allowlist: false, skills: true, commands: true, plugins: false, memoryImports: true },
+        capabilities: { hooks: { since: '0.26.0' }, mcp: true, allowlist: false, skills: true, commands: true, plugins: false, rulesImports: true },
     },
     cursor: {
         id: 'cursor',

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

@@ -0,0 +1,24 @@
+type EventHandler = (params: Record<string, unknown>) => void;
+export declare class CDPClient {
+    private ws;
+    private messageId;
+    private pending;
+    private eventHandlers;
+    connect(wsUrl: string): Promise<void>;
+    send<T = unknown>(method: string, params?: Record<string, unknown>, sessionId?: string): Promise<T>;
+    on(event: string, handler: EventHandler): void;
+    off(event: string, handler: EventHandler): void;
+    close(): void;
+    get connected(): boolean;
+    get isOpen(): boolean;
+    private handleMessage;
+    private handleClose;
+}
+export declare function discoverBrowserWsUrl(port: number, host?: string): Promise<string>;
+export declare function listTargets(port: number, host?: string): Promise<Array<{
+    id: string;
+    type: string;
+    title: string;
+    url: string;
+}>>;
+export {};

package/dist/lib/browser/cdp.js

@@ -0,0 +1,94 @@
+export class CDPClient {
+    ws = null;
+    messageId = 0;
+    pending = new Map();
+    eventHandlers = new Map();
+    async connect(wsUrl) {
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(wsUrl);
+            this.ws.onopen = () => resolve();
+            this.ws.onerror = (ev) => reject(new Error('WebSocket error'));
+            this.ws.onclose = () => this.handleClose();
+            this.ws.onmessage = (ev) => this.handleMessage(String(ev.data));
+        });
+    }
+    async send(method, params, sessionId) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('CDP connection not open');
+        }
+        const id = ++this.messageId;
+        const message = sessionId
+            ? JSON.stringify({ id, method, params, sessionId })
+            : JSON.stringify({ id, method, params });
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve: resolve, reject });
+            this.ws.send(message);
+        });
+    }
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers.get(event).add(handler);
+    }
+    off(event, handler) {
+        this.eventHandlers.get(event)?.delete(handler);
+    }
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    get connected() {
+        return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+    }
+    get isOpen() {
+        return this.connected;
+    }
+    handleMessage(data) {
+        const msg = JSON.parse(data);
+        if ('id' in msg) {
+            const pending = this.pending.get(msg.id);
+            if (pending) {
+                this.pending.delete(msg.id);
+                if ('error' in msg) {
+                    pending.reject(new Error(msg.error.message || 'CDP error'));
+                }
+                else {
+                    pending.resolve(msg.result);
+                }
+            }
+        }
+        else if ('method' in msg) {
+            const handlers = this.eventHandlers.get(msg.method);
+            if (handlers) {
+                for (const handler of handlers) {
+                    handler(msg.params || {});
+                }
+            }
+        }
+    }
+    handleClose() {
+        for (const pending of this.pending.values()) {
+            pending.reject(new Error('CDP connection closed'));
+        }
+        this.pending.clear();
+        this.ws = null;
+    }
+}
+export async function discoverBrowserWsUrl(port, host = 'localhost') {
+    const response = await fetch(`http://${host}:${port}/json/version`);
+    if (!response.ok) {
+        throw new Error(`Failed to discover browser: ${response.status}`);
+    }
+    const data = (await response.json());
+    return data.webSocketDebuggerUrl;
+}
+export async function listTargets(port, host = 'localhost') {
+    const response = await fetch(`http://${host}:${port}/json`);
+    if (!response.ok) {
+        throw new Error(`Failed to list targets: ${response.status}`);
+    }
+    return response.json();
+}

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

@@ -0,0 +1,16 @@
+import type { ChromeOptions } from './types.js';
+import type { BrowserType } from './types.js';
+export declare function findBrowserPath(browserType: BrowserType): string;
+export interface LaunchResult {
+    pid: number;
+    port: number;
+    wsUrl: string;
+}
+export declare function launchBrowser(profileName: string, browserType: BrowserType, port: number, options?: ChromeOptions, secrets?: string): Promise<LaunchResult>;
+export declare function attachToChrome(port: number): Promise<string>;
+export declare function killChrome(pid: number): void;
+export declare function getRunningChromeInfo(profileName: string): {
+    pid: number;
+    port: number;
+} | null;
+export declare function allocatePort(): number;

package/dist/lib/browser/chrome.js

@@ -0,0 +1,157 @@
+import { spawn, execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { getProfileRuntimeDir } from './profiles.js';
+import { discoverBrowserWsUrl } from './cdp.js';
+import { readBundle, resolveBundleEnv, bundleExists } from '../secrets/bundles.js';
+const BROWSER_PATHS = {
+    darwin: {
+        chrome: [
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+            '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+        ],
+        comet: ['/Applications/Comet.app/Contents/MacOS/Comet'],
+        chromium: ['/Applications/Chromium.app/Contents/MacOS/Chromium'],
+        brave: ['/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'],
+        edge: ['/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge'],
+    },
+    linux: {
+        chrome: ['/usr/bin/google-chrome', '/usr/bin/google-chrome-stable'],
+        comet: [],
+        chromium: ['/usr/bin/chromium', '/usr/bin/chromium-browser', '/snap/bin/chromium'],
+        brave: ['/usr/bin/brave-browser', '/usr/bin/brave'],
+        edge: ['/usr/bin/microsoft-edge'],
+    },
+    win32: {
+        chrome: [
+            'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+            'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+        ],
+        comet: [],
+        chromium: [],
+        brave: [
+            'C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe',
+        ],
+        edge: [
+            'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
+        ],
+    },
+};
+export function findBrowserPath(browserType) {
+    const platform = os.platform();
+    const platformPaths = BROWSER_PATHS[platform];
+    if (!platformPaths) {
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+    const candidates = platformPaths[browserType] || [];
+    for (const p of candidates) {
+        if (fs.existsSync(p)) {
+            return p;
+        }
+    }
+    throw new Error(`Browser "${browserType}" not found. Install it first.`);
+}
+export async function launchBrowser(profileName, browserType, port, options = {}, secrets) {
+    const browserPath = findBrowserPath(browserType);
+    const runtimeDir = getProfileRuntimeDir(profileName);
+    const userDataDir = path.join(runtimeDir, 'chrome-data');
+    fs.mkdirSync(userDataDir, { recursive: true });
+    const args = [
+        `--remote-debugging-port=${port}`,
+        `--user-data-dir=${userDataDir}`,
+        '--remote-allow-origins=*',
+        '--disable-background-timer-throttling',
+        '--disable-backgrounding-occluded-windows',
+        '--disable-renderer-backgrounding',
+        ...(options.headless ? ['--headless=new'] : []),
+        ...(options.args || []),
+    ];
+    let env = { ...process.env };
+    if (secrets && bundleExists(secrets)) {
+        try {
+            const bundle = readBundle(secrets);
+            const bundleEnv = resolveBundleEnv(bundle);
+            env = { ...env, ...bundleEnv };
+        }
+        catch {
+            // Bundle failed to resolve, continue without secrets
+        }
+    }
+    const child = spawn(browserPath, args, {
+        detached: true,
+        stdio: 'ignore',
+        env,
+    });
+    child.unref();
+    const pid = child.pid;
+    fs.writeFileSync(path.join(runtimeDir, 'pid'), String(pid));
+    fs.writeFileSync(path.join(runtimeDir, 'port'), String(port));
+    let wsUrl = null;
+    for (let i = 0; i < 30; i++) {
+        await sleep(200);
+        try {
+            wsUrl = await discoverBrowserWsUrl(port);
+            break;
+        }
+        catch {
+            // Chrome still starting
+        }
+    }
+    if (!wsUrl) {
+        throw new Error('Chrome failed to start within 6 seconds');
+    }
+    return { pid, port, wsUrl };
+}
+export async function attachToChrome(port) {
+    return discoverBrowserWsUrl(port);
+}
+export function killChrome(pid) {
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch {
+        // Process already dead
+    }
+}
+export function getRunningChromeInfo(profileName) {
+    const runtimeDir = getProfileRuntimeDir(profileName);
+    const pidFile = path.join(runtimeDir, 'pid');
+    const portFile = path.join(runtimeDir, 'port');
+    if (!fs.existsSync(pidFile) || !fs.existsSync(portFile)) {
+        return null;
+    }
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+    const port = parseInt(fs.readFileSync(portFile, 'utf-8').trim(), 10);
+    if (!isProcessRunning(pid)) {
+        fs.unlinkSync(pidFile);
+        fs.unlinkSync(portFile);
+        return null;
+    }
+    return { pid, port };
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function allocatePort() {
+    const base = 9200;
+    const max = 9300;
+    for (let port = base; port < max; port++) {
+        try {
+            execSync(`lsof -i :${port}`, { stdio: 'ignore' });
+        }
+        catch {
+            return port;
+        }
+    }
+    throw new Error('No available ports in range 9200-9300');
+}

package/dist/lib/browser/drivers/local.d.ts

@@ -0,0 +1,8 @@
+import { CDPClient } from '../cdp.js';
+import type { BrowserProfile } from '../types.js';
+export interface LocalConnection {
+    cdp: CDPClient;
+    port: number;
+    pid: number;
+}
+export declare function connectLocal(endpoint: string, profile: BrowserProfile): Promise<LocalConnection>;

package/dist/lib/browser/drivers/local.js

@@ -0,0 +1,22 @@
+import { CDPClient, discoverBrowserWsUrl } from '../cdp.js';
+import { launchBrowser, allocatePort } from '../chrome.js';
+export async function connectLocal(endpoint, profile) {
+    const url = new URL(endpoint);
+    if (url.protocol !== 'cdp:') {
+        throw new Error(`Invalid local endpoint: ${endpoint}`);
+    }
+    const port = parseInt(url.port, 10) || 9222;
+    try {
+        const wsUrl = await discoverBrowserWsUrl(port);
+        const cdp = new CDPClient();
+        await cdp.connect(wsUrl);
+        return { cdp, port, pid: 0 };
+    }
+    catch {
+        const newPort = allocatePort();
+        const { pid, wsUrl } = await launchBrowser(profile.name, profile.browser, newPort, profile.chrome, profile.secrets);
+        const cdp = new CDPClient();
+        await cdp.connect(wsUrl);
+        return { cdp, port: newPort, pid };
+    }
+}

package/dist/lib/browser/drivers/ssh.d.ts

@@ -0,0 +1,9 @@
+import { CDPClient } from '../cdp.js';
+import type { BrowserProfile } from '../types.js';
+export interface SSHConnection {
+    cdp: CDPClient;
+    port: number;
+    pid: number;
+    cleanup: () => void;
+}
+export declare function connectSSH(endpoint: string, profile: BrowserProfile): Promise<SSHConnection>;

package/dist/lib/browser/drivers/ssh.js

@@ -0,0 +1,129 @@
+import { spawn } from 'child_process';
+import * as net from 'net';
+import { CDPClient, discoverBrowserWsUrl } from '../cdp.js';
+import { allocatePort } from '../chrome.js';
+export async function connectSSH(endpoint, profile) {
+    const url = new URL(endpoint);
+    if (url.protocol !== 'ssh:') {
+        throw new Error(`Invalid SSH endpoint: ${endpoint}`);
+    }
+    const user = url.username || process.env.USER || 'root';
+    const host = url.hostname;
+    const remotePort = parseInt(url.searchParams.get('port') || '9222', 10);
+    const localPort = allocatePort();
+    try {
+        await ensureRemoteBrowser(user, host, profile.browser, remotePort);
+    }
+    catch {
+        // Browser may already be running, continue
+    }
+    const tunnel = await startSSHTunnel(user, host, localPort, remotePort);
+    try {
+        await waitForPort(localPort, 8000);
+    }
+    catch {
+        tunnel.kill();
+        throw new Error(`SSH tunnel failed to establish to ${host}`);
+    }
+    const wsUrl = await discoverBrowserWsUrl(localPort);
+    const cdp = new CDPClient();
+    await cdp.connect(wsUrl);
+    return {
+        cdp,
+        port: localPort,
+        pid: tunnel.pid || 0,
+        cleanup: () => {
+            cdp.close();
+            tunnel.kill();
+        },
+    };
+}
+function startSSHTunnel(user, host, localPort, remotePort) {
+    return new Promise((resolve, reject) => {
+        const args = [
+            '-L',
+            `${localPort}:127.0.0.1:${remotePort}`,
+            `${user}@${host}`,
+            '-N',
+            '-o',
+            'StrictHostKeyChecking=accept-new',
+            '-o',
+            'BatchMode=yes',
+            '-o',
+            'ConnectTimeout=10',
+        ];
+        const tunnel = spawn('ssh', args, {
+            stdio: ['ignore', 'ignore', 'pipe'],
+            detached: false,
+        });
+        let stderr = '';
+        tunnel.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        tunnel.on('error', (err) => {
+            reject(new Error(`SSH tunnel failed: ${err.message}`));
+        });
+        setTimeout(() => {
+            if (tunnel.killed) {
+                reject(new Error(`SSH tunnel died: ${stderr}`));
+            }
+            else {
+                resolve(tunnel);
+            }
+        }, 500);
+    });
+}
+async function waitForPort(port, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            await tryConnect(port);
+            return;
+        }
+        catch {
+            await sleep(200);
+        }
+    }
+    throw new Error(`Port ${port} not ready after ${timeoutMs}ms`);
+}
+function tryConnect(port) {
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection({ port, host: '127.0.0.1' });
+        socket.on('connect', () => {
+            socket.destroy();
+            resolve();
+        });
+        socket.on('error', reject);
+    });
+}
+async function ensureRemoteBrowser(user, host, browserType, port) {
+    const browserPaths = {
+        chrome: '/Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome',
+        comet: '/Applications/Comet.app/Contents/MacOS/Comet',
+        chromium: '/Applications/Chromium.app/Contents/MacOS/Chromium',
+        brave: '/Applications/Brave\\ Browser.app/Contents/MacOS/Brave\\ Browser',
+        edge: '/Applications/Microsoft\\ Edge.app/Contents/MacOS/Microsoft\\ Edge',
+    };
+    const browserPath = browserPaths[browserType];
+    if (!browserPath) {
+        throw new Error(`Unknown browser type: ${browserType}`);
+    }
+    const remoteCmd = `${browserPath} --remote-debugging-port=${port} '--remote-allow-origins=*' --disable-background-timer-throttling --user-data-dir=/tmp/agents-browser-${port} </dev/null >/dev/null 2>&1 &`;
+    return new Promise((resolve, reject) => {
+        const child = spawn('ssh', [
+            `${user}@${host}`,
+            '-o',
+            'BatchMode=yes',
+            remoteCmd,
+        ], { stdio: 'ignore' });
+        child.on('close', () => resolve());
+        child.on('error', reject);
+        setTimeout(() => {
+            child.kill();
+            resolve();
+        }, 2000);
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './profiles.js';
+export * from './cdp.js';
+export * from './chrome.js';
+export * from './service.js';

package/dist/lib/browser/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './profiles.js';
+export * from './cdp.js';
+export * from './chrome.js';
+export * from './service.js';

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

@@ -0,0 +1,6 @@
+import type { CDPClient } from './cdp.js';
+export declare function clickAtCoords(cdp: CDPClient, sessionId: string, x: number, y: number): Promise<void>;
+export declare function hoverAtCoords(cdp: CDPClient, sessionId: string, x: number, y: number): Promise<void>;
+export declare function typeText(cdp: CDPClient, sessionId: string, text: string): Promise<void>;
+export declare function pressKey(cdp: CDPClient, sessionId: string, keyName: string): Promise<void>;
+export declare function focusNode(cdp: CDPClient, sessionId: string, backendNodeId: number): Promise<void>;