@phnx-labs/agents-cli 1.15.0 → 1.17.0

package/dist/index.js

@@ -3,7 +3,7 @@
  * CLI entry point for agents-cli.
  *
  * Registers all commands, handles update checks, auto-corrects typos,
- * and launches the first-run interactive init when appropriate.
+ * and launches the first-run interactive setup when appropriate.
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
@@ -26,7 +26,7 @@ const VERSION = packageJson.version;
 // Import command registrations
 import { registerPullCommand } from './commands/pull.js';
 import { registerRepoCommands } from './commands/repo.js';
-import { registerInitCommand, runInit } from './commands/init.js';
+import { registerSetupCommand, runSetup } from './commands/setup.js';
 import { registerStatusCommand } from './commands/status.js';
 import { registerViewCommand } from './commands/view.js';
 import { registerCommandsCommands } from './commands/commands.js';
@@ -46,6 +46,7 @@ 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 { registerWorkflowsCommands } from './commands/workflows.js';
 import { registerSyncCommand } from './commands/sync.js';
 import { registerRefreshRulesCommand } from './commands/refresh-rules.js';
 import { registerDriveCommands } from './commands/drive.js';
@@ -59,10 +60,9 @@ import { registerAliasCommand } from './commands/alias.js';
 import { registerBetaCommands } from './commands/beta.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 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, removeLegacyUserShim, } from './lib/shims.js';
+import { getGlobalDefault, listInstalledVersions } from './lib/versions.js';
+import { addShimsToPath, ensureShimCurrent, ensureVersionedAliasCurrent, getPathShadowingExecutable, getPathSetupInstructions, hasAliasShadowingShim, isShimsInPath, listAgentsWithInstalledVersions, removeLegacyUserShim, } from './lib/shims.js';
 const program = new Command();
 program
     .name('agents')
@@ -80,7 +80,7 @@ Install, configure, run, and dispatch AI coding agents from one place.
 Works with Claude, Codex, Gemini, Cursor, OpenCode, OpenClaw, and Droid.
 
 Quick start:
-  agents init                     First-time setup (interactive)
+  agents setup                    First-time setup (interactive)
   agents view                     See what's installed
   agents run <agent> ["prompt"]   Run an agent (interactive without prompt, headless with)
   agents sessions                 Browse past sessions across all agents
@@ -89,7 +89,8 @@ Agent versions:
   add <agent>[@version]           Install an agent CLI (e.g. agents add codex)
   remove <agent>[@version]        Uninstall a version
   use <agent>@<version>           Set the default version
-  prune [target]                  Remove orphan resources (commands/skills/hooks) and/or older duplicate version installs
+  prune [target]                  Remove orphan resources and older duplicate version installs (targets: commands, sessions, runs, trash)
+  trash                           Inspect and restore soft-deleted version directories
   view [agent[@version]]          List versions, or inspect one in detail
 
 Agent configuration (synced across versions):
@@ -98,7 +99,7 @@ Agent configuration (synced across versions):
   skills                          Knowledge packs (SKILL.md + supporting files)
   mcp                             MCP servers (stdio or HTTP)
   permissions                     Allow/deny rules for tool calls
-  hooks                           Shell scripts that run on agent events
+  hooks                           Shell scripts that run on agent events (hooks.yaml in agents.yaml)
   subagents                       Named sub-agent definitions
   plugins                         Bundles of skills, hooks, and scripts
 
@@ -106,19 +107,30 @@ Packages:
   search <query>                  Find MCP servers and skills in registries
   install <pkg>                   Install from registry (mcp:name, skill:user/repo)
 
-Run agents:
+Run and dispatch:
   run <agent|profile> [prompt]    Run an agent. Omit prompt for interactive mode.
   teams                           Coordinate multiple agents on shared work
   routines                        Run agents on a cron schedule (scheduler auto-starts)
-  sessions                        Browse and replay past runs
+  sessions                        Browse, search, and replay past runs (live-search in TTY; grouped by workspace)
+  browser                         Automate a browser — navigate, click, screenshot, console, network
+  pty                             Drive interactive terminal programs (REPLs, TUIs) via a persistent PTY session
 
-Credentials:
+Credentials and profiles:
   profiles                        Bundles of (host CLI, endpoint, model, auth)
-  secrets                         Keychain-backed env bundles injected at spawn
+  secrets                         Keychain-backed env bundles; use 'secrets exec <bundle> -- <cmd>' to inject into a subprocess
 
-Helpers:
-  beta                            Enable preview features like drive and factory
-  pty                             Drive interactive terminal programs (REPLs, TUIs)
+Diagnostics:
+  doctor [agent[@version]]        Diagnose CLI availability, sync status, and resource divergence
+  usage [agent]                   Show rate-limit and quota usage per agent
+
+Config sync:
+  drive                           Sync session history across machines via rsync
+  pull                            Clone or pull the system repo at ~/.agents-system/
+  repo init --path <dir>          Scaffold your own editable repo from a template
+  repo add <path|gh:user/repo>    Merge an extra repo after the system repo
+
+Beta features:
+  beta                            Enable preview features (factory, drive, and more)
 
 Automation tips:
   Pass explicit names/IDs         Avoid pickers: agents sessions <id> --markdown
@@ -127,11 +139,6 @@ Automation tips:
   Use agent@version targets       e.g. --agents claude@2.1.79,codex@default
   Non-TTY shells apply defaults   Omitted required selections fail with a plain hint
 
-Config sync (portable setup via git):
-  pull                            Clone or pull the system repo at ~/.agents-system/
-  repo init --path <dir>          Scaffold your own editable repo from a template
-  repo add <path|gh:user/repo>    Merge an extra repo after the system repo
-
 Options:
   -V, --version                   Show version number
   -h, --help                      Show help
@@ -199,7 +206,8 @@ async function showWhatsNew(fromVersion, toVersion) {
     }
 }
 const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
-const UPDATE_CHECK_FILE = path.join(getAgentsDir(), '.update-check');
+import { getUpdateCheckPath, getMigratedSentinelPath, getUserAgentsDir } from './lib/state.js';
+const UPDATE_CHECK_FILE = getUpdateCheckPath();
 /** Read the cached update-check state from disk. Returns null if the file is missing or corrupt. */
 function readUpdateCache() {
     try {
@@ -335,6 +343,12 @@ async function maybeBootstrapShimIntegration(requestedCommand) {
         if (status !== 'current') {
             createdOrUpdated.push(`${status === 'created' ? 'Created' : 'Updated'} ${AGENTS[agent].cliCommand} shim`);
         }
+        for (const version of listInstalledVersions(agent)) {
+            const aliasStatus = ensureVersionedAliasCurrent(agent, version);
+            if (aliasStatus !== 'current') {
+                createdOrUpdated.push(`${aliasStatus === 'created' ? 'Created' : 'Updated'} ${AGENTS[agent].cliCommand}@${version} alias`);
+            }
+        }
     }
     for (const notice of createdOrUpdated) {
         console.log(chalk.green(notice));
@@ -444,6 +458,7 @@ program
 registerMcpCommands(program);
 registerSubagentsCommands(program);
 registerPluginsCommands(program);
+registerWorkflowsCommands(program);
 registerVersionsCommands(program);
 registerPackagesCommands(program);
 registerDaemonCommands(program);
@@ -526,7 +541,7 @@ program
 });
 registerPullCommand(program);
 registerRepoCommands(program);
-registerInitCommand(program);
+registerSetupCommand(program);
 applyGlobalHelpConventions(program);
 /** Calculate the Levenshtein edit distance between two strings. */
 function levenshtein(a, b) {
@@ -582,7 +597,7 @@ await checkForUpdates();
 // status marker that we'll print on the *next* invocation.
 const { spawnDetachedSync } = await import('./lib/auto-pull.js');
 spawnDetachedSync();
-// First-run experience: no args + no config yet + TTY -> launch interactive init.
+// First-run experience: no args + no config yet + TTY -> launch interactive setup.
 // Skipped when stdin/stdout isn't a terminal (CI, pipes) or when user passes any args.
 const passedArgs = process.argv.slice(2);
 const requestedCommand = passedArgs.find((arg) => !arg.startsWith('-'));
@@ -613,14 +628,14 @@ async function registerLazyCommands() {
     }
 }
 await registerLazyCommands();
-const metaFilePath = path.join(getAgentsDir(), 'agents.yaml');
+const metaFilePath = path.join(getUserAgentsDir(), 'agents.yaml');
 const firstRun = passedArgs.length === 0 &&
     !fs.existsSync(metaFilePath) &&
     process.stdin.isTTY &&
     process.stdout.isTTY;
 if (firstRun) {
     try {
-        await runInit(program);
+        await runSetup(program);
     }
     catch (err) {
         if (!(err instanceof Error && err.name === 'ExitPromptError')) {
@@ -629,14 +644,11 @@ if (firstRun) {
     }
     process.exit(0);
 }
-// Commands that require the system repo to be cloned first.
-const SYSTEM_REPO_COMMANDS = new Set([
-    'view', 'status', 'skills', 'rules', 'commands', 'hooks',
-    'mcp', 'permissions', 'versions', 'packages', 'sync',
-    'subagents', 'repo', 'plugins', 'doctor',
-]);
-if (!firstRun && requestedCommand && SYSTEM_REPO_COMMANDS.has(requestedCommand)) {
-    const { ensureInitialized } = await import('./commands/init.js');
+// Every command requires the system repo to be cloned first. `setup` is the
+// only exemption — it's the command that does the cloning.
+const SETUP_EXEMPT_COMMANDS = new Set(['setup', 'help']);
+if (!firstRun && requestedCommand && !SETUP_EXEMPT_COMMANDS.has(requestedCommand)) {
+    const { ensureInitialized } = await import('./commands/setup.js');
     await ensureInitialized(program);
 }
 // One-shot idempotent migrations (split-layout, legacy file moves).
@@ -648,8 +660,8 @@ if (!firstRun && requestedCommand && SYSTEM_REPO_COMMANDS.has(requestedCommand))
 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`;
+        const sentinel = getMigratedSentinelPath();
+        const sentinelValue = `${VERSION}-v8`;
         let needRun = true;
         try {
             if (fs.existsSync(sentinel) && fs.readFileSync(sentinel, 'utf-8').trim() === sentinelValue) {
@@ -658,7 +670,7 @@ if (process.env.AGENTS_SKIP_MIGRATION !== '1') {
         }
         catch { /* best-effort — fall through to run */ }
         if (needRun) {
-            runMigration();
+            await runMigration();
             try {
                 fs.mkdirSync(path.dirname(sentinel), { recursive: true });
                 fs.writeFileSync(sentinel, sentinelValue);

package/dist/lib/agents.js

@@ -16,7 +16,7 @@ import * as os from 'os';
 import * as TOML from 'smol-toml';
 import chalk from 'chalk';
 import { walkForFiles } from './fs-walk.js';
-import { getVersionsDir, getShimsDir, getAgentsDir } from './state.js';
+import { getVersionsDir, getShimsDir, getCliVersionCachePath } from './state.js';
 import { resolveVersion, getVersionHomePath, getBinaryPath } from './versions.js';
 import { loadClaudeOauth } from './usage.js';
 const execFileAsync = promisify(execFile);
@@ -29,7 +29,7 @@ const HOME = os.homedir();
 export const CODEX_HOOKS_MIN_VERSION = '0.116.0';
 /** Minimum Gemini CLI version that supports the hooks system (v0.26.0, Jan 2026). */
 export const GEMINI_HOOKS_MIN_VERSION = '0.26.0';
-const CLI_VERSION_CACHE_PATH = path.join(getAgentsDir(), '.cli-version-cache.json');
+const CLI_VERSION_CACHE_PATH = getCliVersionCachePath();
 let cliVersionCache = null;
 function loadCliVersionCache() {
     if (cliVersionCache)

package/dist/lib/auto-pull-worker.js

@@ -9,14 +9,13 @@
  * Lock mtime under 5 min => skip (another invocation already in flight).
  */
 import * as fs from 'fs';
-import * as path from 'path';
 import { simpleGit } from 'simple-git';
 import { tryAutoPull, isGitRepo } from './git.js';
-import { getSystemAgentsDir, getUserAgentsDir, getEnabledExtraRepos, } from './state.js';
+import { getSystemAgentsDir, getUserAgentsDir, getEnabledExtraRepos, getFetchCacheDir, } from './state.js';
 import { lockFilePath, statusFilePath } from './auto-pull.js';
 const LOCK_TTL_MS = 5 * 60 * 1000;
 function ensureFetchDir() {
-    const dir = path.join(getSystemAgentsDir(), '.fetch');
+    const dir = getFetchCacheDir();
     if (!fs.existsSync(dir)) {
         try {
             fs.mkdirSync(dir, { recursive: true });

package/dist/lib/auto-pull.js

@@ -13,10 +13,10 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
-import { getSystemAgentsDir } from './state.js';
+import { getFetchCacheDir } from './state.js';
 /** Where lock files and per-repo status markers live. */
 function fetchStateDir() {
-    return path.join(getSystemAgentsDir(), '.fetch');
+    return getFetchCacheDir();
 }
 /** Per-repo lock file path. mtime acts as a recency check. */
 export function lockFilePath(alias) {

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

@@ -14,7 +14,13 @@ export declare class CDPClient {
     private handleMessage;
     private handleClose;
 }
-export declare function discoverBrowserWsUrl(port: number, host?: string): Promise<string>;
+export interface BrowserDiscovery {
+    wsUrl: string;
+    browser: string;
+}
+export declare function discoverBrowserWsUrl(port: number, host?: string): Promise<BrowserDiscovery>;
+export declare function normalizeBrowserName(s: string): string;
+export declare function verifyBrowserIdentity(reported: string, expected: string, port: number, host?: string): void;
 export declare function listTargets(port: number, host?: string): Promise<Array<{
     id: string;
     type: string;

package/dist/lib/browser/cdp.js

@@ -83,7 +83,38 @@ export async function discoverBrowserWsUrl(port, host = 'localhost') {
         throw new Error(`Failed to discover browser: ${response.status}`);
     }
     const data = (await response.json());
-    return data.webSocketDebuggerUrl;
+    const browserField = data.Browser || data.Product || '';
+    return {
+        wsUrl: data.webSocketDebuggerUrl,
+        browser: normalizeBrowserName(browserField),
+    };
+}
+export function normalizeBrowserName(s) {
+    if (!s)
+        return 'unknown';
+    return s.split('/')[0].trim().toLowerCase().replace(/\s+/g, '-');
+}
+export function verifyBrowserIdentity(reported, expected, port, host = 'localhost') {
+    if (expected === 'custom')
+        return;
+    if (reported === 'unknown')
+        return;
+    const matches = {
+        chrome: ['chrome', 'google-chrome', 'headlesschrome'],
+        chromium: ['chromium', 'headlesschrome', 'chrome'],
+        // Comet reports itself as plain "Chrome/<version>" in /json/version — it
+        // doesn't override the Chromium branding. Accept chrome here so attaching
+        // to a Comet instance doesn't trip a false "identity mismatch".
+        comet: ['comet', 'chrome'],
+        brave: ['brave', 'brave-browser', 'chrome'],
+        edge: ['edge', 'microsoft-edge', 'msedge', 'chrome'],
+    };
+    const accepted = matches[expected] || [expected];
+    if (accepted.includes(reported))
+        return;
+    const target = host === 'localhost' || host === '127.0.0.1' ? `port ${port}` : `${host}:${port}`;
+    throw new Error(`Browser identity mismatch: profile expects "${expected}" but ${target} is serving "${reported}". ` +
+        `Stop the running browser (e.g. \`pkill -f ${reported}\`) or update the profile to browser=${reported}, then retry.`);
 }
 export async function listTargets(port, host = 'localhost') {
     const response = await fetch(`http://${host}:${port}/json`);

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

@@ -14,3 +14,13 @@ export declare function getRunningChromeInfo(profileName: string): {
     port: number;
 } | null;
 export declare function allocatePort(): number;
+export interface PortOccupant {
+    pid: number;
+    command: string;
+}
+/**
+ * Identify the process listening on a TCP port via lsof. Returns null when nothing is bound.
+ * Used for clearer error messages when a profile's configured port is taken by a non-debug
+ * process (e.g. Comet running without --remote-debugging-port).
+ */
+export declare function getPortOccupant(port: number): PortOccupant | null;

package/dist/lib/browser/chrome.js

@@ -69,6 +69,7 @@ export async function launchBrowser(profileName, browserType, port, options = {}
     const runtimeDir = getProfileRuntimeDir(profileName);
     const userDataDir = path.join(runtimeDir, 'chrome-data');
     fs.mkdirSync(userDataDir, { recursive: true });
+    const viewport = options.viewport ?? { width: 1512, height: 982 };
     const args = [
         `--remote-debugging-port=${port}`,
         `--user-data-dir=${userDataDir}`,
@@ -77,6 +78,10 @@ export async function launchBrowser(profileName, browserType, port, options = {}
         '--disable-backgrounding-occluded-windows',
         '--disable-renderer-backgrounding',
         ...(options.headless ? ['--headless=new'] : []),
+        `--window-size=${viewport.width},${viewport.height}`,
+        ...(viewport.x !== undefined && viewport.y !== undefined
+            ? [`--window-position=${viewport.x},${viewport.y}`]
+            : []),
         ...(options.args || []),
     ];
     let env = { ...process.env };
@@ -103,7 +108,8 @@ export async function launchBrowser(profileName, browserType, port, options = {}
     for (let i = 0; i < 30; i++) {
         await sleep(200);
         try {
-            wsUrl = await discoverBrowserWsUrl(port);
+            const result = await discoverBrowserWsUrl(port);
+            wsUrl = result.wsUrl;
             break;
         }
         catch {
@@ -116,7 +122,8 @@ export async function launchBrowser(profileName, browserType, port, options = {}
     return { pid, port, wsUrl };
 }
 export async function attachToChrome(port) {
-    return discoverBrowserWsUrl(port);
+    const { wsUrl } = await discoverBrowserWsUrl(port);
+    return wsUrl;
 }
 export function killChrome(pid) {
     try {
@@ -147,7 +154,11 @@ function isProcessRunning(pid) {
         process.kill(pid, 0);
         return true;
     }
-    catch {
+    catch (err) {
+        // EPERM means the process exists but we lack permission to signal it —
+        // treat as alive. ESRCH means the process does not exist.
+        if (err && err.code === 'EPERM')
+            return true;
         return false;
     }
 }
@@ -167,3 +178,30 @@ export function allocatePort() {
     }
     throw new Error('No available ports in range 9200-9300');
 }
+/**
+ * Identify the process listening on a TCP port via lsof. Returns null when nothing is bound.
+ * Used for clearer error messages when a profile's configured port is taken by a non-debug
+ * process (e.g. Comet running without --remote-debugging-port).
+ */
+export function getPortOccupant(port) {
+    try {
+        const out = execSync(`lsof -nP -iTCP:${port} -sTCP:LISTEN -Fpcn`, {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        let pid = 0;
+        let command = '';
+        for (const line of out.split('\n')) {
+            if (line.startsWith('p'))
+                pid = parseInt(line.slice(1), 10) || 0;
+            else if (line.startsWith('c') && !command)
+                command = line.slice(1);
+        }
+        if (!pid)
+            return null;
+        return { pid, command: command || 'unknown' };
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { DeviceDescriptor } from './types.js';
+export declare const DEVICES: Record<string, DeviceDescriptor>;
+export declare function getDevice(name: string): DeviceDescriptor | undefined;
+export declare function listDevices(): string[];

package/dist/lib/browser/devices.js

@@ -0,0 +1,27 @@
+export const DEVICES = {
+    'iPhone 14': {
+        width: 390,
+        height: 844,
+        deviceScaleFactor: 3,
+        mobile: true,
+    },
+    'iPad': {
+        width: 768,
+        height: 1024,
+        deviceScaleFactor: 2,
+        mobile: true,
+    },
+    'MacBook Pro': {
+        width: 1440,
+        height: 900,
+        deviceScaleFactor: 2,
+        mobile: false,
+    },
+};
+export function getDevice(name) {
+    const key = Object.keys(DEVICES).find((k) => k.toLowerCase() === name.toLowerCase());
+    return key ? DEVICES[key] : undefined;
+}
+export function listDevices() {
+    return Object.keys(DEVICES);
+}

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

@@ -1,5 +1,5 @@
-import { CDPClient, discoverBrowserWsUrl } from '../cdp.js';
-import { launchBrowser, allocatePort } from '../chrome.js';
+import { CDPClient, discoverBrowserWsUrl, verifyBrowserIdentity } from '../cdp.js';
+import { launchBrowser, getPortOccupant } from '../chrome.js';
 export async function connectLocal(endpoint, profile) {
     const url = new URL(endpoint);
     if (url.protocol !== 'cdp:') {
@@ -7,14 +7,30 @@ export async function connectLocal(endpoint, profile) {
     }
     const port = parseInt(url.port, 10) || 9222;
     try {
-        const wsUrl = await discoverBrowserWsUrl(port);
+        const { wsUrl, browser } = await discoverBrowserWsUrl(port);
+        verifyBrowserIdentity(browser, profile.browser, 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, profile.binary);
+    catch (err) {
+        if (err instanceof Error && err.message.startsWith('Browser identity mismatch')) {
+            throw err;
+        }
+        // Distinguish "nothing listening on this port" (fine to launch fresh) from
+        // "something is listening but it's not a debuggable browser" (bail loudly —
+        // silently launching on a different port leads to confusing `pid 0` and
+        // `CDP connection not open` errors downstream).
+        const occupant = getPortOccupant(port);
+        if (occupant) {
+            throw new Error(`Port ${port} is occupied by ${occupant.command} (pid ${occupant.pid}) but is ` +
+                `not serving the Chrome DevTools Protocol. Either stop that process ` +
+                `(\`kill ${occupant.pid}\`) or restart it with \`--remote-debugging-port=${port}\` ` +
+                `so profile "${profile.name}" can attach.`);
+        }
+        const newPort = port;
+        const chromeOpts = { ...profile.chrome, viewport: profile.viewport };
+        const { pid, wsUrl } = await launchBrowser(profile.name, profile.browser, newPort, chromeOpts, profile.secrets, profile.binary);
         const cdp = new CDPClient();
         await cdp.connect(wsUrl);
         return { cdp, port: newPort, pid };

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

@@ -1,6 +1,6 @@
 import { spawn } from 'child_process';
 import * as net from 'net';
-import { CDPClient, discoverBrowserWsUrl } from '../cdp.js';
+import { CDPClient, discoverBrowserWsUrl, verifyBrowserIdentity } from '../cdp.js';
 import { allocatePort } from '../chrome.js';
 export async function connectSSH(endpoint, profile) {
     const url = new URL(endpoint);
@@ -25,7 +25,14 @@ export async function connectSSH(endpoint, profile) {
         tunnel.kill();
         throw new Error(`SSH tunnel failed to establish to ${host}`);
     }
-    const wsUrl = await discoverBrowserWsUrl(localPort);
+    const { wsUrl, browser } = await discoverBrowserWsUrl(localPort);
+    try {
+        verifyBrowserIdentity(browser, profile.browser, remotePort, host);
+    }
+    catch (err) {
+        tunnel.kill();
+        throw err;
+    }
     const cdp = new CDPClient();
     await cdp.connect(wsUrl);
     return {

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

@@ -1,6 +1,7 @@
 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 scrollAtCoords(cdp: CDPClient, sessionId: string, x: number, y: number, deltaX: number, deltaY: 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>;

package/dist/lib/browser/input.js

@@ -5,6 +5,9 @@ export async function clickAtCoords(cdp, sessionId, x, y) {
 export async function hoverAtCoords(cdp, sessionId, x, y) {
     await cdp.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y }, sessionId);
 }
+export async function scrollAtCoords(cdp, sessionId, x, y, deltaX, deltaY) {
+    await cdp.send('Input.dispatchMouseEvent', { type: 'mouseWheel', x, y, deltaX, deltaY }, sessionId);
+}
 export async function typeText(cdp, sessionId, text) {
     for (const char of text) {
         await cdp.send('Input.dispatchKeyEvent', { type: 'keyDown', text: char }, sessionId);