@phnx-labs/agents-cli 1.14.7 → 1.16.0

package/dist/lib/browser/service.js

@@ -1,75 +1,153 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { CDPClient, discoverBrowserWsUrl } from './cdp.js';
-import { getProfile, getProfileRuntimeDir, getBrowserRuntimeDir } from './profiles.js';
-import { killChrome, getRunningChromeInfo } from './chrome.js';
+import { CDPClient, discoverBrowserWsUrl, verifyBrowserIdentity } from './cdp.js';
+import { getProfile, getProfileRuntimeDir, getBrowserRuntimeDir, listProfiles, extractConfiguredPort, } from './profiles.js';
+import { killChrome, getRunningChromeInfo, launchBrowser, allocatePort } from './chrome.js';
 import { connectLocal } from './drivers/local.js';
 import { connectSSH } from './drivers/ssh.js';
-import { generateTaskId, isValidTaskId, } from './types.js';
+import { generateTaskId, generateShortId, generateFunName, } from './types.js';
 import { getRefs, resolveRefToCoords } from './refs.js';
 import { clickAtCoords, hoverAtCoords, typeText, pressKey, focusNode } from './input.js';
 import { emit } from '../events.js';
 export class BrowserService {
     connections = new Map();
-    async start(profileName, taskId) {
+    forkingProfiles = new Set();
+    // Per-task storage for console, errors, network, downloads
+    consoleLogs = new Map();
+    pageErrors = new Map();
+    networkRequests = new Map();
+    pendingDownloads = new Map();
+    enabledSessions = new Map(); // sessionId -> enabled domains
+    async start(profileName, opts = {}) {
         const profile = await getProfile(profileName);
         if (!profile) {
             throw new Error(`Profile "${profileName}" not found`);
         }
-        const finalTaskId = taskId || generateTaskId();
-        if (!isValidTaskId(finalTaskId)) {
-            throw new Error(`Invalid task ID "${finalTaskId}". Must be lowercase alphanumeric with hyphens.`);
-        }
+        const taskName = opts.taskName || generateFunName();
+        const taskId = generateTaskId();
         let conn = this.connections.get(profileName);
-        if (!conn) {
+        let effectiveProfileName = profileName;
+        if (conn && conn.electron && conn.tasks.size > 0) {
+            if (this.forkingProfiles.has(profileName)) {
+                while (this.forkingProfiles.has(profileName)) {
+                    await new Promise((r) => setTimeout(r, 50));
+                }
+                const existingFork = this.findAvailableFork(profileName);
+                if (existingFork) {
+                    conn = existingFork.conn;
+                    effectiveProfileName = existingFork.name;
+                }
+                else {
+                    throw new Error(`Fork in progress but no available fork found for "${profileName}"`);
+                }
+            }
+            else {
+                this.forkingProfiles.add(profileName);
+                try {
+                    const { forkName, connection } = await this.forkElectronProfile(profile);
+                    conn = connection;
+                    effectiveProfileName = forkName;
+                }
+                finally {
+                    this.forkingProfiles.delete(profileName);
+                }
+            }
+        }
+        else if (!conn) {
             conn = await this.connectProfile(profile);
             this.connections.set(profileName, conn);
         }
-        if (conn.tasks.has(finalTaskId)) {
-            const task = conn.tasks.get(finalTaskId);
-            return { task: finalTaskId, windowTargetId: task.windowTargetId };
-        }
-        const { windowTargetId } = await this.createTaskWindow(conn, finalTaskId);
         const task = {
-            id: finalTaskId,
-            profile: profileName,
-            windowTargetId,
-            tabIds: [],
+            id: taskId,
+            name: taskName,
+            profile: effectiveProfileName,
+            tabs: {},
+            currentTabId: undefined,
             createdAt: Date.now(),
             pid: conn.pid,
         };
-        conn.tasks.set(finalTaskId, task);
-        await this.saveTaskState(profileName, conn.tasks);
-        emit('browser.launch', { profile: profileName, task: finalTaskId, pid: conn.pid });
-        return { task: finalTaskId, windowTargetId };
+        // For Electron, get the existing window as the tab
+        if (conn.electron) {
+            const windowId = await this.getOrCreateWindow(conn);
+            if (windowId) {
+                const shortId = generateShortId();
+                task.tabs[shortId] = windowId;
+                task.currentTabId = shortId;
+            }
+        }
+        conn.tasks.set(taskName, task);
+        await this.saveTaskState(effectiveProfileName, conn.tasks);
+        emit('browser.launch', { profile: effectiveProfileName, task: taskName, pid: conn.pid });
+        // If URL provided, create tab directly (no about:blank)
+        let tabId;
+        if (opts.url && !conn.electron) {
+            const result = (await conn.cdp.send('Target.createTarget', {
+                url: opts.url,
+            }));
+            const shortId = generateShortId();
+            task.tabs[shortId] = result.targetId;
+            task.currentTabId = shortId;
+            this.invalidateTargetCache(conn);
+            await this.saveTaskState(effectiveProfileName, conn.tasks);
+            tabId = shortId;
+        }
+        else if (opts.url && conn.electron) {
+            const result = await this.navigate(taskName, opts.url, effectiveProfileName);
+            tabId = result.tabId;
+        }
+        return { task: taskId, name: taskName, tabId };
     }
-    async stop(taskId) {
+    async stop(taskName) {
         for (const [profileName, conn] of this.connections) {
-            const task = conn.tasks.get(taskId);
+            const task = conn.tasks.get(taskName);
             if (task) {
-                await Promise.all(task.tabIds.map((tabId) => conn.cdp.send('Target.closeTarget', { targetId: tabId }).catch(() => {
+                // Get domains from tabs before closing (for history)
+                const domains = new Set();
+                try {
+                    const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
+                    for (const cdpId of Object.values(task.tabs)) {
+                        const target = targetInfos.find((t) => t.targetId === cdpId);
+                        if (target?.url) {
+                            try {
+                                const domain = new URL(target.url).hostname.replace(/^www\./, '');
+                                if (domain && domain !== 'blank')
+                                    domains.add(domain);
+                            }
+                            catch {
+                                // invalid URL
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // CDP not responding
+                }
+                // Save to history before closing
+                await this.saveToHistory(task, Array.from(domains));
+                // Close task's tabs (not the window - it's shared)
+                await Promise.all(Object.values(task.tabs).map((cdpId) => conn.cdp.send('Target.closeTarget', { targetId: cdpId }).catch(() => {
                     // Tab already closed
                 })));
-                for (const tabId of task.tabIds) {
-                    conn.sessionCache.delete(tabId);
+                for (const cdpId of Object.values(task.tabs)) {
+                    conn.sessionCache.delete(cdpId);
                 }
                 this.invalidateTargetCache(conn);
-                if (task.windowTargetId) {
-                    try {
-                        await conn.cdp.send('Target.closeTarget', { targetId: task.windowTargetId });
-                    }
-                    catch {
-                        // Window already closed
-                    }
-                }
-                conn.tasks.delete(taskId);
+                conn.tasks.delete(taskName);
                 await this.saveTaskState(profileName, conn.tasks);
-                emit('browser.close', { profile: profileName, task: taskId });
+                emit('browser.close', { profile: profileName, task: taskName });
+                if (conn.forkedFrom && conn.tasks.size === 0) {
+                    conn.cdp.close();
+                    killChrome(conn.pid);
+                    this.connections.delete(profileName);
+                }
                 return { ok: true, profile: profileName };
             }
         }
         return { ok: false };
     }
+    async done(taskName) {
+        return this.stop(taskName);
+    }
     async stopProfile(profileName) {
         const conn = this.connections.get(profileName);
         if (conn) {
@@ -91,27 +169,118 @@ export class BrowserService {
     }
     async navigate(taskId, url, profileName) {
         const { conn, task } = await this.findTask(taskId, profileName);
+        // If we have a current tab, navigate in it (reuse)
+        const currentShortId = task.currentTabId;
+        if (currentShortId && task.tabs[currentShortId]) {
+            const cdpTargetId = task.tabs[currentShortId];
+            const sessionId = await this.getSessionId(conn, cdpTargetId);
+            await conn.cdp.send('Page.navigate', { url }, sessionId);
+            await this.saveTaskState(task.profile, conn.tasks);
+            return { tabId: currentShortId, url, created: false };
+        }
+        // No current tab - create one
         if (conn.electron) {
-            const tabId = task.windowTargetId || task.tabIds[0];
-            if (!tabId) {
+            const cdpTargetId = conn.windowId;
+            if (!cdpTargetId) {
                 throw new Error('No existing tab to navigate in Electron app');
             }
-            const sessionId = await this.getSessionId(conn, tabId);
+            const shortId = generateShortId();
+            const sessionId = await this.getSessionId(conn, cdpTargetId);
             await conn.cdp.send('Page.navigate', { url }, sessionId);
-            if (!task.tabIds.includes(tabId)) {
-                task.tabIds.push(tabId);
-            }
+            task.tabs[shortId] = cdpTargetId;
+            task.currentTabId = shortId;
             await this.saveTaskState(task.profile, conn.tasks);
-            return { tabId, url };
+            return { tabId: shortId, url, created: true };
         }
+        // Chrome: create new tab
         const result = (await conn.cdp.send('Target.createTarget', {
             url,
         }));
-        const tabId = result.targetId;
-        task.tabIds.push(tabId);
+        const shortId = generateShortId();
+        task.tabs[shortId] = result.targetId;
+        task.currentTabId = shortId;
         this.invalidateTargetCache(conn);
         await this.saveTaskState(task.profile, conn.tasks);
-        return { tabId, url };
+        return { tabId: shortId, url, created: true };
+    }
+    async tabAdd(taskId, url, profileName) {
+        const { conn, task } = await this.findTask(taskId, profileName);
+        if (conn.electron) {
+            throw new Error('Electron apps do not support opening additional tabs');
+        }
+        const result = (await conn.cdp.send('Target.createTarget', {
+            url,
+        }));
+        const shortId = generateShortId();
+        task.tabs[shortId] = result.targetId;
+        task.currentTabId = shortId; // new tab becomes current
+        this.invalidateTargetCache(conn);
+        await this.saveTaskState(task.profile, conn.tasks);
+        return { tabId: shortId, url };
+    }
+    async tabFocus(taskId, tabHint) {
+        const { conn, task } = await this.findTask(taskId);
+        const resolvedTabId = await this.resolveTabHint(conn, task, tabHint);
+        task.currentTabId = resolvedTabId;
+        await this.saveTaskState(task.profile, conn.tasks);
+        return { tabId: resolvedTabId };
+    }
+    async tabList(taskId) {
+        const { conn, task } = await this.findTask(taskId);
+        const targets = (await conn.cdp.send('Target.getTargets'));
+        const tabs = [];
+        for (const [shortId, cdpId] of Object.entries(task.tabs)) {
+            const target = targets.targetInfos.find((t) => t.targetId === cdpId);
+            if (target) {
+                tabs.push({
+                    id: shortId,
+                    url: target.url,
+                    title: target.title,
+                    current: shortId === task.currentTabId,
+                });
+            }
+        }
+        return tabs;
+    }
+    async resolveTabHint(conn, task, hint) {
+        // Exact match
+        if (task.tabs[hint])
+            return hint;
+        // Prefix match
+        const byPrefix = Object.keys(task.tabs).filter((id) => id.startsWith(hint));
+        if (byPrefix.length === 1)
+            return byPrefix[0];
+        if (byPrefix.length > 1) {
+            throw new Error(`Ambiguous tab hint "${hint}" — matches ${byPrefix.length} tabs`);
+        }
+        // URL substring match
+        const targets = (await conn.cdp.send('Target.getTargets'));
+        const matches = [];
+        for (const [shortId, cdpId] of Object.entries(task.tabs)) {
+            const target = targets.targetInfos.find((t) => t.targetId === cdpId);
+            if (target && target.url.includes(hint)) {
+                matches.push(shortId);
+            }
+        }
+        if (matches.length === 1)
+            return matches[0];
+        if (matches.length > 1) {
+            throw new Error(`Ambiguous tab hint "${hint}" — matches ${matches.length} tabs by URL`);
+        }
+        throw new Error(`Tab "${hint}" not found`);
+    }
+    resolveCurrentTab(task) {
+        const tabIds = Object.keys(task.tabs);
+        const id = task.currentTabId ?? tabIds[tabIds.length - 1];
+        if (!id)
+            throw new Error('No tabs open for this task');
+        return id;
+    }
+    getCdpTargetId(task, shortId) {
+        const cdpId = task.tabs[shortId];
+        if (!cdpId)
+            throw new Error(`Tab ${shortId} not found`);
+        return cdpId;
     }
     async tabs(taskId, profileName) {
         if (taskId) {
@@ -127,42 +296,53 @@ export class BrowserService {
         }
         return allTabs;
     }
-    async close(taskId, tabId) {
+    async tabClose(taskId, tabHint) {
         const { conn, task } = await this.findTask(taskId);
-        if (tabId !== undefined) {
-            await conn.cdp.send('Target.closeTarget', { targetId: tabId });
-            task.tabIds = task.tabIds.filter((id) => id !== tabId);
-            conn.sessionCache.delete(tabId);
+        if (tabHint !== undefined) {
+            const shortId = await this.resolveTabHint(conn, task, tabHint);
+            const cdpId = task.tabs[shortId];
+            if (cdpId) {
+                await conn.cdp.send('Target.closeTarget', { targetId: cdpId });
+                conn.sessionCache.delete(cdpId);
+                delete task.tabs[shortId];
+                // Update currentTabId if we closed the current tab
+                if (task.currentTabId === shortId) {
+                    const remaining = Object.keys(task.tabs);
+                    task.currentTabId = remaining.length > 0 ? remaining[remaining.length - 1] : undefined;
+                }
+            }
         }
         else {
-            await Promise.all(task.tabIds.map((id) => conn.cdp.send('Target.closeTarget', { targetId: id }).catch(() => { })));
-            for (const id of task.tabIds) {
-                conn.sessionCache.delete(id);
+            // Close all tabs
+            await Promise.all(Object.values(task.tabs).map((cdpId) => conn.cdp.send('Target.closeTarget', { targetId: cdpId }).catch(() => { })));
+            for (const cdpId of Object.values(task.tabs)) {
+                conn.sessionCache.delete(cdpId);
             }
-            task.tabIds = [];
+            task.tabs = {};
+            task.currentTabId = undefined;
         }
         this.invalidateTargetCache(conn);
         await this.saveTaskState(task.profile, conn.tasks);
     }
-    async evaluate(taskId, tabId, expression) {
-        const { conn } = await this.findTask(taskId);
-        const target = await this.getTarget(conn, tabId);
+    async evaluate(taskId, tabHint, expression) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
         if (!target) {
-            throw new Error(`Tab ${tabId} not found`);
+            throw new Error(`Tab ${shortId} not found`);
         }
         const sessionId = await this.getSessionId(conn, target.targetId);
         const result = (await conn.cdp.send('Runtime.evaluate', { expression, returnByValue: true }, sessionId));
         return result.result.value;
     }
-    async screenshot(taskId, tabId, outputPath) {
+    async screenshot(taskId, tabHint, outputPath) {
         const { conn, task } = await this.findTask(taskId);
-        const targetTabId = tabId ?? task.tabIds[task.tabIds.length - 1];
-        if (targetTabId === undefined) {
-            throw new Error('No tabs open for this task');
-        }
-        const target = await this.getTarget(conn, targetTabId);
+        const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
         if (!target) {
-            throw new Error(`Tab ${targetTabId} not found`);
+            throw new Error(`Tab ${shortId} not found`);
         }
         const sessionId = await this.getSessionId(conn, target.targetId);
         const { data } = (await conn.cdp.send('Page.captureScreenshot', { format: 'jpeg', quality: 70 }, sessionId));
@@ -176,39 +356,42 @@ export class BrowserService {
                 quality -= 10;
             }
         }
-        const sessionsDir = path.join(getBrowserRuntimeDir(), 'sessions', taskId);
+        const sessionsDir = path.join(getBrowserRuntimeDir(), 'sessions', task.name);
         const finalPath = outputPath || path.join(sessionsDir, `${Date.now()}.jpg`);
         await fs.promises.mkdir(path.dirname(finalPath), { recursive: true });
         await fs.promises.writeFile(finalPath, buffer);
         return finalPath;
     }
     refsCache = new Map();
-    async refs(taskId, tabId, opts = {}) {
+    async refs(taskId, tabHint, opts = {}) {
         const { conn, task } = await this.findTask(taskId);
-        const targetTabId = tabId || task.tabIds[task.tabIds.length - 1];
-        if (!targetTabId)
-            throw new Error('No tabs open for this task');
-        const target = await this.getTarget(conn, targetTabId);
+        const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
-            throw new Error(`Tab ${targetTabId} not found`);
+            throw new Error(`Tab ${shortId} not found`);
         const sessionId = await this.getSessionId(conn, target.targetId);
         return getRefs(conn.cdp, sessionId, opts);
     }
-    async click(taskId, tabId, ref) {
-        const { conn } = await this.findTask(taskId);
-        const target = await this.getTarget(conn, tabId);
+    async click(taskId, ref, tabHint) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
-            throw new Error(`Tab ${tabId} not found`);
+            throw new Error(`Tab ${shortId} not found`);
         const sessionId = await this.getSessionId(conn, target.targetId);
         const { nodeMap } = await getRefs(conn.cdp, sessionId, { interactive: false, limit: 1000 });
         const { x, y } = await resolveRefToCoords(conn.cdp, sessionId, nodeMap, ref);
         await clickAtCoords(conn.cdp, sessionId, x, y);
     }
-    async type(taskId, tabId, ref, text) {
-        const { conn } = await this.findTask(taskId);
-        const target = await this.getTarget(conn, tabId);
+    async type(taskId, ref, text, tabHint) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
-            throw new Error(`Tab ${tabId} not found`);
+            throw new Error(`Tab ${shortId} not found`);
         const sessionId = await this.getSessionId(conn, target.targetId);
         const { nodeMap } = await getRefs(conn.cdp, sessionId, { interactive: false, limit: 1000 });
         const node = nodeMap.get(ref);
@@ -219,50 +402,427 @@ export class BrowserService {
         }
         await typeText(conn.cdp, sessionId, text);
     }
-    async press(taskId, tabId, key) {
-        const { conn } = await this.findTask(taskId);
-        const target = await this.getTarget(conn, tabId);
+    async press(taskId, key, tabHint) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
-            throw new Error(`Tab ${tabId} not found`);
+            throw new Error(`Tab ${shortId} not found`);
         const sessionId = await this.getSessionId(conn, target.targetId);
         await pressKey(conn.cdp, sessionId, key);
     }
-    async hover(taskId, tabId, ref) {
-        const { conn } = await this.findTask(taskId);
-        const target = await this.getTarget(conn, tabId);
+    async hover(taskId, ref, tabHint) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
-            throw new Error(`Tab ${tabId} not found`);
+            throw new Error(`Tab ${shortId} not found`);
         const sessionId = await this.getSessionId(conn, target.targetId);
         const { nodeMap } = await getRefs(conn.cdp, sessionId, { interactive: false, limit: 1000 });
         const { x, y } = await resolveRefToCoords(conn.cdp, sessionId, nodeMap, ref);
         await hoverAtCoords(conn.cdp, sessionId, x, y);
     }
     async status(profileName) {
+        const seen = new Set();
         const statuses = [];
-        if (profileName) {
-            const status = await this.getProfileStatus(profileName);
-            if (status)
+        const candidates = profileName ? [profileName] : Array.from(this.connections.keys());
+        for (const name of candidates) {
+            const status = await this.getProfileStatus(name);
+            if (status) {
                 statuses.push(status);
+                seen.add(name);
+            }
         }
-        else {
-            for (const name of this.connections.keys()) {
-                const status = await this.getProfileStatus(name);
-                if (status)
-                    statuses.push(status);
+        if (!profileName) {
+            const profiles = await listProfiles();
+            for (const profile of profiles) {
+                if (seen.has(profile.name))
+                    continue;
+                const reconciled = await this.reconcileFromDisk(profile.name);
+                if (reconciled)
+                    statuses.push(reconciled);
             }
         }
+        else if (!seen.has(profileName)) {
+            const reconciled = await this.reconcileFromDisk(profileName);
+            if (reconciled)
+                statuses.push(reconciled);
+        }
         return statuses;
     }
+    async reconcileFromDisk(profileName) {
+        const info = getRunningChromeInfo(profileName);
+        if (!info)
+            return null;
+        const profile = await getProfile(profileName);
+        const tasks = this.loadTaskState(profileName);
+        const taskStatuses = [];
+        for (const [, task] of tasks) {
+            taskStatuses.push({
+                id: task.id,
+                name: task.name,
+                tabCount: Object.keys(task.tabs).length,
+                currentTabId: task.currentTabId,
+                createdAt: task.createdAt,
+            });
+        }
+        const configuredPort = profile ? extractConfiguredPort(profile) : undefined;
+        return {
+            name: profileName,
+            running: true,
+            port: info.port,
+            pid: info.pid,
+            configuredPort: configuredPort !== info.port ? configuredPort : undefined,
+            tasks: taskStatuses,
+        };
+    }
+    // ─── Viewport & Device Emulation ──────────────────────────────────────────────
+    async setViewport(taskId, width, height, options = {}) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
+        if (!target)
+            throw new Error(`Tab ${shortId} not found`);
+        const sessionId = await this.getSessionId(conn, target.targetId);
+        await conn.cdp.send('Emulation.setDeviceMetricsOverride', {
+            width,
+            height,
+            deviceScaleFactor: options.deviceScaleFactor ?? 1,
+            mobile: options.mobile ?? false,
+        }, sessionId);
+    }
+    async setDevice(taskId, deviceName, tabHint) {
+        const { getDevice } = await import('./devices.js');
+        const device = getDevice(deviceName);
+        if (!device) {
+            const { listDevices } = await import('./devices.js');
+            throw new Error(`Unknown device "${deviceName}". Available: ${listDevices().join(', ')}`);
+        }
+        await this.setViewport(taskId, device.width, device.height, {
+            mobile: device.mobile,
+            deviceScaleFactor: device.deviceScaleFactor,
+            tabHint,
+        });
+    }
+    // ─── Console & Errors ────────────────────────────────────────────────────────
+    async enableRuntimeForSession(conn, sessionId) {
+        const key = `${sessionId}:Runtime`;
+        if (this.enabledSessions.get(sessionId)?.has('Runtime'))
+            return;
+        await conn.cdp.send('Runtime.enable', {}, sessionId);
+        if (!this.enabledSessions.has(sessionId)) {
+            this.enabledSessions.set(sessionId, new Set());
+        }
+        this.enabledSessions.get(sessionId).add('Runtime');
+        conn.cdp.on('Runtime.consoleAPICalled', (params) => {
+            if (params.sessionId !== sessionId)
+                return;
+            const taskId = this.findTaskBySession(conn, sessionId);
+            if (!taskId)
+                return;
+            const entry = {
+                level: params.type === 'warning' ? 'warn' : params.type,
+                text: params.args?.map((a) => a.value ?? a.description ?? '').join(' ') || '',
+                timestamp: Date.now(),
+                url: params.stackTrace?.callFrames?.[0]?.url,
+                line: params.stackTrace?.callFrames?.[0]?.lineNumber,
+            };
+            if (!this.consoleLogs.has(taskId))
+                this.consoleLogs.set(taskId, []);
+            const logs = this.consoleLogs.get(taskId);
+            logs.push(entry);
+            if (logs.length > 1000)
+                logs.shift();
+        });
+        conn.cdp.on('Runtime.exceptionThrown', (params) => {
+            if (params.sessionId !== sessionId)
+                return;
+            const taskId = this.findTaskBySession(conn, sessionId);
+            if (!taskId)
+                return;
+            const ex = params.exceptionDetails;
+            const entry = {
+                message: ex.exception?.description || ex.text || 'Unknown error',
+                stack: ex.stackTrace?.callFrames?.map((f) => `  at ${f.functionName || '<anonymous>'} (${f.url}:${f.lineNumber})`).join('\n'),
+                timestamp: Date.now(),
+                url: ex.url,
+                line: ex.lineNumber,
+            };
+            if (!this.pageErrors.has(taskId))
+                this.pageErrors.set(taskId, []);
+            const errors = this.pageErrors.get(taskId);
+            errors.push(entry);
+            if (errors.length > 500)
+                errors.shift();
+        });
+    }
+    async getConsoleLogs(taskId, options = {}) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
+        if (!target)
+            throw new Error(`Tab ${shortId} not found`);
+        const sessionId = await this.getSessionId(conn, target.targetId);
+        await this.enableRuntimeForSession(conn, sessionId);
+        let logs = this.consoleLogs.get(taskId) || [];
+        if (options.level) {
+            logs = logs.filter((l) => l.level === options.level);
+        }
+        if (options.clear) {
+            this.consoleLogs.set(taskId, []);
+        }
+        return logs;
+    }
+    async getErrors(taskId, options = {}) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
+        if (!target)
+            throw new Error(`Tab ${shortId} not found`);
+        const sessionId = await this.getSessionId(conn, target.targetId);
+        await this.enableRuntimeForSession(conn, sessionId);
+        const errors = this.pageErrors.get(taskId) || [];
+        if (options.clear) {
+            this.pageErrors.set(taskId, []);
+        }
+        return errors;
+    }
+    // ─── Network Requests ────────────────────────────────────────────────────────
+    async enableNetworkForSession(conn, sessionId, taskId) {
+        if (this.enabledSessions.get(sessionId)?.has('Network'))
+            return;
+        await conn.cdp.send('Network.enable', {}, sessionId);
+        if (!this.enabledSessions.has(sessionId)) {
+            this.enabledSessions.set(sessionId, new Set());
+        }
+        this.enabledSessions.get(sessionId).add('Network');
+        const requestMap = new Map();
+        conn.cdp.on('Network.requestWillBeSent', (params) => {
+            if (params.sessionId !== sessionId)
+                return;
+            const req = {
+                id: params.requestId,
+                url: params.request.url,
+                method: params.request.method,
+                timestamp: Date.now(),
+            };
+            requestMap.set(params.requestId, req);
+            if (!this.networkRequests.has(taskId))
+                this.networkRequests.set(taskId, []);
+            const reqs = this.networkRequests.get(taskId);
+            reqs.push(req);
+            if (reqs.length > 500)
+                reqs.shift();
+        });
+        conn.cdp.on('Network.responseReceived', (params) => {
+            if (params.sessionId !== sessionId)
+                return;
+            const req = requestMap.get(params.requestId);
+            if (req) {
+                req.status = params.response.status;
+                req.mimeType = params.response.mimeType;
+            }
+        });
+    }
+    async getNetworkRequests(taskId, options = {}) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
+        if (!target)
+            throw new Error(`Tab ${shortId} not found`);
+        const sessionId = await this.getSessionId(conn, target.targetId);
+        await this.enableNetworkForSession(conn, sessionId, taskId);
+        let requests = this.networkRequests.get(taskId) || [];
+        if (options.filter) {
+            const f = options.filter.toLowerCase();
+            requests = requests.filter((r) => r.url.toLowerCase().includes(f));
+        }
+        if (options.clear) {
+            this.networkRequests.set(taskId, []);
+        }
+        return requests;
+    }
+    async getResponseBody(taskId, urlPattern, options = {}) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
+        if (!target)
+            throw new Error(`Tab ${shortId} not found`);
+        const sessionId = await this.getSessionId(conn, target.targetId);
+        await this.enableNetworkForSession(conn, sessionId, taskId);
+        const timeout = options.timeout ?? 30000;
+        const maxChars = options.maxChars ?? 200000;
+        const start = Date.now();
+        const pattern = urlPattern.includes('*')
+            ? new RegExp(urlPattern.replace(/\*/g, '.*'), 'i')
+            : null;
+        while (Date.now() - start < timeout) {
+            const requests = this.networkRequests.get(taskId) || [];
+            const match = requests.find((r) => pattern ? pattern.test(r.url) : r.url.includes(urlPattern));
+            if (match && match.status) {
+                try {
+                    const { body, base64Encoded } = (await conn.cdp.send('Network.getResponseBody', { requestId: match.id }, sessionId));
+                    const text = base64Encoded ? Buffer.from(body, 'base64').toString('utf-8') : body;
+                    return text.slice(0, maxChars);
+                }
+                catch {
+                    // Request may have been evicted, continue waiting
+                }
+            }
+            await new Promise((r) => setTimeout(r, 200));
+        }
+        throw new Error(`No response matching "${urlPattern}" within ${timeout}ms`);
+    }
+    // ─── Wait Conditions ─────────────────────────────────────────────────────────
+    async wait(taskId, type, value, options = {}) {
+        const timeout = options.timeout ?? 30000;
+        if (type === 'time') {
+            await new Promise((r) => setTimeout(r, typeof value === 'number' ? value : parseInt(value, 10)));
+            return;
+        }
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
+        if (!target)
+            throw new Error(`Tab ${shortId} not found`);
+        const sessionId = await this.getSessionId(conn, target.targetId);
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+            let condition = false;
+            if (type === 'selector') {
+                const result = (await conn.cdp.send('Runtime.evaluate', { expression: `!!document.querySelector(${JSON.stringify(value)})`, returnByValue: true }, sessionId));
+                condition = result.result.value === true;
+            }
+            else if (type === 'url') {
+                const result = (await conn.cdp.send('Runtime.evaluate', { expression: 'location.href', returnByValue: true }, sessionId));
+                const pattern = value.includes('*')
+                    ? new RegExp(value.replace(/\*/g, '.*'), 'i')
+                    : null;
+                condition = pattern ? pattern.test(result.result.value) : result.result.value.includes(value);
+            }
+            else if (type === 'function') {
+                const result = (await conn.cdp.send('Runtime.evaluate', { expression: `!!(${value})`, returnByValue: true }, sessionId));
+                condition = result.result.value === true;
+            }
+            else if (type === 'load') {
+                const result = (await conn.cdp.send('Runtime.evaluate', { expression: 'document.readyState', returnByValue: true }, sessionId));
+                if (value === 'domcontentloaded') {
+                    condition = result.result.value !== 'loading';
+                }
+                else if (value === 'load' || value === 'complete') {
+                    condition = result.result.value === 'complete';
+                }
+                else if (value === 'networkidle') {
+                    // Simplified: check if document is complete
+                    condition = result.result.value === 'complete';
+                }
+            }
+            if (condition)
+                return;
+            await new Promise((r) => setTimeout(r, 100));
+        }
+        throw new Error(`Wait condition "${type}:${value}" not met within ${timeout}ms`);
+    }
+    // ─── Downloads ───────────────────────────────────────────────────────────────
+    async setDownloadPath(taskId, downloadPath, tabHint) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
+        if (!target)
+            throw new Error(`Tab ${shortId} not found`);
+        const sessionId = await this.getSessionId(conn, target.targetId);
+        await conn.cdp.send('Browser.setDownloadBehavior', {
+            behavior: 'allow',
+            downloadPath,
+            eventsEnabled: true,
+        }, sessionId);
+        this.pendingDownloads.set(taskId, { path: downloadPath, completed: false });
+        conn.cdp.on('Browser.downloadProgress', (params) => {
+            if (params.state === 'completed') {
+                const dl = this.pendingDownloads.get(taskId);
+                if (dl) {
+                    dl.completed = true;
+                    dl.filename = params.suggestedFilename;
+                }
+            }
+        });
+    }
+    async waitForDownload(taskId, timeout = 60000) {
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+            const dl = this.pendingDownloads.get(taskId);
+            if (dl?.completed) {
+                const fullPath = dl.filename ? `${dl.path}/${dl.filename}` : dl.path;
+                this.pendingDownloads.delete(taskId);
+                return fullPath;
+            }
+            await new Promise((r) => setTimeout(r, 200));
+        }
+        throw new Error(`Download not completed within ${timeout}ms`);
+    }
+    // ─── Helpers ─────────────────────────────────────────────────────────────────
+    findTaskBySession(conn, sessionId) {
+        for (const [taskId, task] of conn.tasks) {
+            for (const tabId of Object.values(task.tabs)) {
+                if (conn.sessionCache.get(tabId) === sessionId) {
+                    return taskId;
+                }
+            }
+        }
+        return undefined;
+    }
     async shutdown() {
         for (const [, conn] of this.connections) {
             conn.cdp.close();
         }
         this.connections.clear();
     }
+    findAvailableFork(profileName) {
+        for (const [name, conn] of this.connections) {
+            if (conn.forkedFrom === profileName && conn.tasks.size === 0) {
+                return { name, conn };
+            }
+        }
+        return null;
+    }
+    async forkElectronProfile(profile) {
+        let forkNum = 2;
+        while (this.connections.has(`${profile.name}.${forkNum}`)) {
+            forkNum++;
+        }
+        const forkName = `${profile.name}.${forkNum}`;
+        const port = allocatePort();
+        const chromeOpts = { ...profile.chrome, viewport: profile.viewport };
+        const { pid, wsUrl } = await launchBrowser(forkName, profile.browser, port, chromeOpts, profile.secrets, profile.binary);
+        const cdp = new CDPClient();
+        await cdp.connect(wsUrl);
+        await this.enableDomains(cdp);
+        const connection = {
+            cdp,
+            port,
+            pid,
+            electron: true,
+            forkedFrom: profile.name,
+            tasks: new Map(),
+            sessionCache: new Map(),
+        };
+        this.connections.set(forkName, connection);
+        return { forkName, connection };
+    }
     async connectProfile(profile) {
         const existingInfo = getRunningChromeInfo(profile.name);
         if (existingInfo) {
-            const wsUrl = await discoverBrowserWsUrl(existingInfo.port);
+            const { wsUrl, browser } = await discoverBrowserWsUrl(existingInfo.port);
+            verifyBrowserIdentity(browser, profile.browser, existingInfo.port);
             const cdp = new CDPClient();
             await cdp.connect(wsUrl);
             await this.enableDomains(cdp);
@@ -282,7 +842,10 @@ export class BrowserService {
                 if (conn)
                     return conn;
             }
-            catch {
+            catch (err) {
+                if (err instanceof Error && err.message.startsWith('Browser identity mismatch')) {
+                    throw err;
+                }
                 // Try next endpoint
             }
         }
@@ -329,7 +892,8 @@ export class BrowserService {
         }
         if (url.protocol === 'http:' || url.protocol === 'https:') {
             const port = parseInt(url.port || (url.protocol === 'https:' ? '443' : '80'), 10);
-            const wsUrl = await discoverBrowserWsUrl(port, url.hostname);
+            const { wsUrl, browser } = await discoverBrowserWsUrl(port, url.hostname);
+            verifyBrowserIdentity(browser, profile.browser, port, url.hostname);
             const cdp = new CDPClient();
             await cdp.connect(wsUrl);
             await this.enableDomains(cdp);
@@ -347,17 +911,30 @@ export class BrowserService {
     async enableDomains(cdp) {
         await cdp.send('Target.setDiscoverTargets', { discover: true });
     }
-    async createTaskWindow(conn, _taskId) {
-        if (conn.electron) {
+    async getOrCreateWindow(conn) {
+        // Already have a window for this profile?
+        if (conn.windowId) {
+            // Verify it still exists via CDP
             const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
-            const pageTarget = targetInfos.find((t) => t.type === 'page');
-            return { windowTargetId: pageTarget?.targetId };
+            if (targetInfos.some((t) => t.targetId === conn.windowId && t.type === 'page')) {
+                return conn.windowId;
+            }
+            // Window was closed, fall through to find/create new
+        }
+        // Check if browser already has a page target we can use
+        const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
+        const existing = targetInfos.find((t) => t.type === 'page');
+        if (existing) {
+            conn.windowId = existing.targetId;
+            return existing.targetId;
         }
+        // First ever use - create window
         const result = (await conn.cdp.send('Target.createTarget', {
             url: 'about:blank',
             newWindow: true,
         }));
-        return { windowTargetId: result.targetId };
+        conn.windowId = result.targetId;
+        return result.targetId;
     }
     async findTask(taskId, profileName) {
         if (profileName) {
@@ -381,37 +958,74 @@ export class BrowserService {
     }
     async getTabsForTask(cdp, task) {
         const targets = (await cdp.send('Target.getTargets'));
-        return task.tabIds
-            .map((id) => {
-            const target = targets.targetInfos.find((t) => t.targetId === id);
-            if (!target)
-                return null;
-            return {
-                id,
-                url: target.url,
-                title: target.title,
-                task: task.id,
-            };
-        })
-            .filter((t) => t !== null);
+        const tabs = [];
+        for (const [shortId, cdpId] of Object.entries(task.tabs)) {
+            const target = targets.targetInfos.find((t) => t.targetId === cdpId);
+            if (target) {
+                tabs.push({
+                    id: shortId,
+                    url: target.url,
+                    title: target.title,
+                    task: task.name,
+                });
+            }
+        }
+        return tabs;
     }
     async getProfileStatus(profileName) {
         const conn = this.connections.get(profileName);
         if (!conn)
             return null;
+        // Fetch all targets once for efficiency
+        let targets = [];
+        try {
+            const result = (await conn.cdp.send('Target.getTargets'));
+            targets = result.targetInfos;
+        }
+        catch {
+            // CDP not responding, fall back to metadata only
+        }
         const tasks = [];
         for (const [, task] of conn.tasks) {
+            const tabs = [];
+            const domainSet = new Set();
+            for (const [shortId, cdpId] of Object.entries(task.tabs)) {
+                const target = targets.find((t) => t.targetId === cdpId);
+                if (target) {
+                    tabs.push({
+                        id: shortId,
+                        url: target.url,
+                        title: target.title,
+                        current: shortId === task.currentTabId,
+                    });
+                    try {
+                        const domain = new URL(target.url).hostname.replace(/^www\./, '');
+                        if (domain && domain !== 'blank')
+                            domainSet.add(domain);
+                    }
+                    catch {
+                        // invalid URL
+                    }
+                }
+            }
             tasks.push({
                 id: task.id,
-                tabCount: task.tabIds.length,
+                name: task.name,
+                tabCount: Object.keys(task.tabs).length,
+                currentTabId: task.currentTabId,
                 createdAt: task.createdAt,
+                tabs: tabs.length > 0 ? tabs : undefined,
+                domains: domainSet.size > 0 ? Array.from(domainSet) : undefined,
             });
         }
+        const profile = await getProfile(profileName);
+        const configuredPort = profile ? extractConfiguredPort(profile) : undefined;
         return {
             name: profileName,
             running: true,
             port: conn.port,
             pid: conn.pid,
+            configuredPort: configuredPort !== conn.port ? configuredPort : undefined,
             tasks,
         };
     }
@@ -451,6 +1065,76 @@ export class BrowserService {
             return new Map();
         }
         const state = JSON.parse(fs.readFileSync(tasksFile, 'utf-8'));
-        return new Map(Object.entries(state));
+        const tasks = new Map();
+        let needsMigration = false;
+        for (const [key, raw] of Object.entries(state)) {
+            const task = raw;
+            // Migrate old format (tabIds array) to new format (tabs object)
+            if (Array.isArray(task.tabIds) && !task.tabs) {
+                needsMigration = true;
+                const tabs = {};
+                for (const cdpId of task.tabIds) {
+                    const shortId = generateShortId();
+                    tabs[shortId] = cdpId;
+                }
+                const tabIds = Object.keys(tabs);
+                tasks.set(key, {
+                    id: task.id,
+                    name: task.name || key,
+                    profile: task.profile,
+                    tabs,
+                    currentTabId: tabIds.length > 0 ? tabIds[tabIds.length - 1] : undefined,
+                    createdAt: task.createdAt,
+                    pid: task.pid,
+                });
+            }
+            else {
+                tasks.set(key, task);
+            }
+        }
+        // Save migrated data back to disk
+        if (needsMigration) {
+            const migratedState = Object.fromEntries(tasks);
+            fs.writeFileSync(tasksFile, JSON.stringify(migratedState, null, 2));
+        }
+        return tasks;
+    }
+    async saveToHistory(task, domains) {
+        const historyDir = getBrowserRuntimeDir();
+        await fs.promises.mkdir(historyDir, { recursive: true });
+        const historyFile = path.join(historyDir, 'history.json');
+        let history = [];
+        if (fs.existsSync(historyFile)) {
+            try {
+                history = JSON.parse(fs.readFileSync(historyFile, 'utf-8'));
+            }
+            catch {
+                // Corrupted file, start fresh
+            }
+        }
+        history.unshift({
+            id: task.id,
+            name: task.name,
+            profile: task.profile,
+            createdAt: task.createdAt,
+            endedAt: Date.now(),
+            domains,
+            tabCount: Object.keys(task.tabs).length,
+        });
+        // Keep only last 50 entries
+        history = history.slice(0, 50);
+        await fs.promises.writeFile(historyFile, JSON.stringify(history, null, 2));
+    }
+    async getHistory(limit = 10) {
+        const historyFile = path.join(getBrowserRuntimeDir(), 'history.json');
+        if (!fs.existsSync(historyFile))
+            return [];
+        try {
+            const history = JSON.parse(fs.readFileSync(historyFile, 'utf-8'));
+            return history.slice(0, limit);
+        }
+        catch {
+            return [];
+        }
     }
 }