@pasko70/pibo 1.1.0 → 1.2.0

package/dist/tools/browser-use-cdp.js

@@ -1,5 +1,52 @@
 const DEFAULT_CDP_URL = 'http://127.0.0.1:56663';
 const DEFAULT_TIMEOUT_MS = 2500;
+async function isCdpPortReachable(port) {
+    try {
+        const response = await fetchWithTimeout(`http://127.0.0.1:${port}/json/version`, 800);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function discoverCdpUrl() {
+    const candidates = [];
+    if (process.env.BROWSER_USE_HOME) {
+        candidates.push(join(process.env.BROWSER_USE_HOME, 'pibo-cdp'));
+    }
+    if (process.env.HOME) {
+        candidates.push(join(process.env.HOME, '.pibo', 'tools', 'browser-use', 'home', 'pibo-cdp'));
+        candidates.push(join(process.env.HOME, '.browser-use', 'pibo-cdp'));
+    }
+    for (const stateDir of candidates) {
+        try {
+            if (!existsSync(stateDir))
+                continue;
+            const entries = readdirSync(stateDir)
+                .filter((f) => f.endsWith('.port'))
+                .map((f) => {
+                const path = join(stateDir, f);
+                const portText = readFileSync(path, 'utf-8').trim();
+                const port = Number.parseInt(portText, 10);
+                const mtime = statSync(path).mtimeMs;
+                return { port, mtime, valid: Number.isFinite(port) && port > 0 };
+            })
+                .filter((e) => e.valid)
+                .sort((a, b) => b.mtime - a.mtime);
+            for (const entry of entries) {
+                if (await isCdpPortReachable(entry.port)) {
+                    return `http://127.0.0.1:${entry.port}`;
+                }
+            }
+        }
+        catch {
+            // ignore discovery errors for this candidate
+        }
+    }
+    return DEFAULT_CDP_URL;
+}
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
 const CHAT_TARGET_PROBE = `(() => {
   const text = String(document.body?.innerText || "");
   const textareas = [...document.querySelectorAll("textarea")].map((textarea) => ({
@@ -14,7 +61,7 @@ const CHAT_TARGET_PROBE = `(() => {
   };
 })()`;
 export async function listBrowserUseCdpTargets(options = {}) {
-    const cdpUrl = normalizeCdpUrl(options.cdpUrl);
+    const cdpUrl = await normalizeCdpUrl(options.cdpUrl);
     const probe = options.probe !== false;
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const targets = await fetchChromeTargets(cdpUrl, timeoutMs);
@@ -48,13 +95,18 @@ export function formatBrowserUseTargets(targets) {
     return lines.join('\n');
 }
 export function printAttachChatExports(target, cdpUrl = DEFAULT_CDP_URL) {
-    console.log(`export PIBO_CDP_URL=${shellQuote(normalizeCdpUrl(cdpUrl))}`);
+    console.log(`export PIBO_CDP_URL=${shellQuote(cdpUrl)}`);
     console.log(`export PIBO_CDP_TARGET_ID=${shellQuote(target.id)}`);
     console.log(`export PIBO_CDP_TARGET_WS=${shellQuote(target.webSocketDebuggerUrl ?? '')}`);
     console.log(`export PIBO_CHAT_URL=${shellQuote(target.url)}`);
 }
-function normalizeCdpUrl(value) {
-    return (value || DEFAULT_CDP_URL).replace(/\/+$/, '');
+export function normalizeCdpUrlSync(value) {
+    return value.replace(/\/+$/, '');
+}
+async function normalizeCdpUrl(value) {
+    if (value)
+        return normalizeCdpUrlSync(value);
+    return (await discoverCdpUrl()).replace(/\/+$/, '');
 }
 async function fetchChromeTargets(cdpUrl, timeoutMs) {
     const response = await fetchWithTimeout(`${cdpUrl}/json/list`, timeoutMs);

package/dist/tools/browser-use-leases.js

@@ -1,8 +1,10 @@
+import { spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { ErrorCode, formatCliError } from '../cli-errors.js';
 import { BROWSER_USE_DEFAULT_PROFILE } from './browser-use-wrapper.js';
+import { browserPoolPaths, loadBrowserPoolState, releaseBrowserPoolLease, saveBrowserPoolState, withBrowserPoolLock, } from './browser-pool.js';
 const REGISTRY_VERSION = 1;
 const DEFAULT_APP = 'pibo-chat';
 const DEFAULT_TTL_MINUTES = 8 * 60;
@@ -36,6 +38,27 @@ function appPoolDir(status, app) {
 function browserUseHome(status) {
     return status.homeDir;
 }
+function browserPoolWorkerId() {
+    return process.env.PIBO_BROWSER_POOL_WORKER_ID || process.env.PIBO_COMPUTE_WORKER_ID || process.env.HOSTNAME || 'local';
+}
+function browserPoolId() {
+    return process.env.PIBO_BROWSER_POOL_ID || 'default';
+}
+function browserPoolRootDir(status) {
+    return process.env.PIBO_BROWSER_POOL_ROOT || join(browserUseHome(status), 'pibo-browser-pool');
+}
+function browserPoolLeaseIdForSession(sessionName) {
+    return `browser-use:${safeSessionName(sessionName)}`;
+}
+function browserPoolIdentityForLease(status, lease) {
+    return {
+        workerId: lease.browserPoolWorkerId || browserPoolWorkerId(),
+        poolId: lease.browserPoolId || browserPoolId(),
+    };
+}
+function browserPoolRootForLease(status, lease) {
+    return lease.browserPoolRootDir || browserPoolRootDir(status);
+}
 function authTemplateDir(status) {
     if (process.env.PIBO_BROWSER_USE_AUTH_TEMPLATE_DIR) {
         return process.env.PIBO_BROWSER_USE_AUTH_TEMPLATE_DIR;
@@ -46,9 +69,11 @@ function defaultTemplateDir(status) {
     const preferred = authTemplateDir(status);
     if (existsSync(preferred))
         return preferred;
-    return join(status.homeDir, 'chrome-profiles', BROWSER_USE_DEFAULT_PROFILE);
+    // Never fall back to the active default profile (it may be running).
+    // Create an empty template directory so leases get clean profiles.
+    return preferred;
 }
-function readRegistry(status) {
+export function readRegistry(status) {
     const path = registryPath(status);
     if (!existsSync(path))
         return { version: REGISTRY_VERSION, leases: [] };
@@ -92,7 +117,7 @@ async function withRegistryLock(status, action) {
         await rm(lock, { recursive: true, force: true });
     }
 }
-function isExpired(lease, now = new Date()) {
+export function isExpired(lease, now = new Date()) {
     return new Date(lease.expiresAt).getTime() <= now.getTime();
 }
 function safeSessionName(sessionName) {
@@ -134,25 +159,92 @@ function killLeaseProcess(status, lease) {
         // Process already exited.
     }
 }
+async function releaseAssociatedBrowserPoolLease(status, lease) {
+    if (!lease.browserPoolLeaseId)
+        return;
+    const identity = browserPoolIdentityForLease(status, lease);
+    const paths = browserPoolPaths(browserPoolRootForLease(status, lease), identity);
+    await releaseBrowserPoolLease(paths, identity, { leaseId: lease.browserPoolLeaseId });
+}
+async function reapAssociatedBrowserPoolLeaseProcess(status, lease) {
+    if (!lease.browserPoolLeaseId)
+        return false;
+    const identity = browserPoolIdentityForLease(status, lease);
+    const paths = browserPoolPaths(browserPoolRootForLease(status, lease), identity);
+    return withBrowserPoolLock(paths.lockPath, { holder: `auth-lease-reap:${lease.id}` }, async () => {
+        const state = await loadBrowserPoolState(paths.statePath, { ...identity, onMissing: 'empty', onMalformed: 'empty' });
+        if (!browserPoolStateMatchesAuthLease(state, lease))
+            return false;
+        const terminated = await terminateManagedBrowserProcess(state);
+        const reapedAt = nowIso();
+        await saveBrowserPoolState(paths.statePath, {
+            ...state,
+            state: terminated ? 'stale' : state.state,
+            activeLeaseId: undefined,
+            activeLeaseCount: 0,
+            holder: undefined,
+            lastUsedAt: reapedAt,
+            idleExpiresAt: undefined,
+            cleanupStatus: terminated ? 'success' : 'skipped',
+            lastError: terminated ? 'Expired auth lease reaped managed browser process' : 'No live managed browser process to reap',
+        });
+        return terminated;
+    });
+}
+function browserPoolStateMatchesAuthLease(state, lease) {
+    return state.state === 'leased'
+        && state.activeLeaseId === lease.browserPoolLeaseId
+        && Boolean(state.userDataDir)
+        && resolve(state.userDataDir) === resolve(lease.userDataDir);
+}
+async function terminateManagedBrowserProcess(state) {
+    if (!state.pid || !processIsAlive(state.pid))
+        return false;
+    const target = state.processGroupId && state.processGroupId === state.pid ? -state.processGroupId : state.pid;
+    try {
+        process.kill(target, 'SIGTERM');
+    }
+    catch {
+        return false;
+    }
+    if (!(await waitForProcessExit(state.pid, 1000))) {
+        try {
+            process.kill(target, 'SIGKILL');
+        }
+        catch {
+            // Process may have exited after TERM.
+        }
+        await waitForProcessExit(state.pid, 1000);
+    }
+    return !processIsAlive(state.pid);
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        if (!processIsAlive(pid))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return !processIsAlive(pid);
+}
 async function copyTemplateProfile(templateDir, userDataDir) {
-    if (!existsSync(templateDir)) {
-        throw new Error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'BROWSER_USE_AUTH_TEMPLATE_MISSING',
-            message: `Browser-use auth template does not exist: ${templateDir}`,
-            suggestion: 'Run `pibo tools browser-use auth-template env`, open the Chat Web App, sign in, then acquire a lease again.',
-        }));
+    if (existsSync(templateDir)) {
+        assertTemplateIsNotRunning(templateDir);
+        await rm(userDataDir, { recursive: true, force: true });
+        await mkdir(userDataDir, { recursive: true });
+        await cp(templateDir, userDataDir, {
+            recursive: true,
+            filter: (source) => {
+                const base = source.split(/[\\/]/).pop() ?? '';
+                return !base.startsWith('Singleton') && base !== 'DevToolsActivePort';
+            },
+        });
+        return;
     }
-    assertTemplateIsNotRunning(templateDir);
+    // Template does not exist yet: create a clean empty profile directory.
+    // Chrome will initialise a fresh profile on first start.
     await rm(userDataDir, { recursive: true, force: true });
     await mkdir(userDataDir, { recursive: true });
-    await cp(templateDir, userDataDir, {
-        recursive: true,
-        filter: (source) => {
-            const base = source.split(/[\\/]/).pop() ?? '';
-            return !base.startsWith('Singleton') && base !== 'DevToolsActivePort';
-        },
-    });
 }
 function assertTemplateIsNotRunning(templateDir) {
     for (const fileName of ['SingletonLock', 'SingletonCookie', 'SingletonSocket']) {
@@ -179,20 +271,25 @@ function nextSlotNumber(leases, app) {
     }
     throw new Error(`No browser-use slots available for ${app}`);
 }
-function createLease(status, app, owner, ttlMinutes, profileName, leases) {
+function createLease(status, app, holder, ttlMinutes, profileName, leases) {
     const slot = nextSlotNumber(leases, app);
     const slotName = `slot-${String(slot).padStart(3, '0')}`;
     const appId = sanitizeIdPart(app);
     const id = `${appId}-${slotName}`;
     const createdAt = nowIso();
+    const sessionName = `pibo-auth-${id}`;
     return {
         id,
         app,
-        owner,
-        sessionName: `pibo-auth-${id}`,
+        holder,
+        sessionName,
         userDataDir: join(appPoolDir(status, app), slotName),
         profileName,
         status: 'active',
+        browserPoolLeaseId: browserPoolLeaseIdForSession(sessionName),
+        browserPoolWorkerId: browserPoolWorkerId(),
+        browserPoolId: browserPoolId(),
+        browserPoolRootDir: browserPoolRootDir(status),
         createdAt,
         updatedAt: createdAt,
         expiresAt: addMinutes(new Date(createdAt), ttlMinutes).toISOString(),
@@ -209,6 +306,8 @@ function printLeaseEnv(status, lease) {
     console.log(`export PIBO_BROWSER_USE_SESSION=${shellQuote(lease.sessionName)}`);
     console.log(`export PIBO_BROWSER_USE_CHROME_USER_DATA_DIR=${shellQuote(lease.userDataDir)}`);
     console.log(`export PIBO_BROWSER_USE_DEFAULT_PROFILE=${shellQuote(lease.profileName)}`);
+    if (lease.browserPoolLeaseId)
+        console.log(`export PIBO_BROWSER_POOL_LEASE_ID=${shellQuote(lease.browserPoolLeaseId)}`);
     console.log(`# browser-use --session "$PIBO_BROWSER_USE_SESSION" state`);
 }
 function printLeaseJson(status, lease) {
@@ -221,23 +320,29 @@ function printLeaseJson(status, lease) {
             PIBO_BROWSER_USE_SESSION: lease.sessionName,
             PIBO_BROWSER_USE_CHROME_USER_DATA_DIR: lease.userDataDir,
             PIBO_BROWSER_USE_DEFAULT_PROFILE: lease.profileName,
+            ...(lease.browserPoolLeaseId ? { PIBO_BROWSER_POOL_LEASE_ID: lease.browserPoolLeaseId } : {}),
         },
     }, null, 2));
 }
 export async function acquireBrowserUseLease(context, options = {}) {
     const app = options.app?.trim() || DEFAULT_APP;
-    const owner = options.owner?.trim() || process.env.PIBO_BROWSER_USE_LEASE_OWNER || process.env.USER || 'unknown';
+    const holder = options.holder?.trim() || process.env.PIBO_BROWSER_USE_LEASE_HOLDER || process.env.USER || 'unknown';
     const ttlMinutes = options.ttlMinutes ?? DEFAULT_TTL_MINUTES;
     const profileName = options.profileName?.trim() || BROWSER_USE_DEFAULT_PROFILE;
     const templateDir = options.templateDir?.trim() || defaultTemplateDir(context.status);
     await withRegistryLock(context.status, async () => {
         const registry = readRegistry(context.status);
+        const reapedCount = await reapStaleLeasesInRegistry(context.status, registry);
         let lease = selectReusableLease(context.status, registry.leases, app);
         if (lease) {
             await copyTemplateProfile(templateDir, lease.userDataDir);
-            lease.owner = owner;
+            lease.holder = holder;
             lease.status = 'active';
             lease.profileName = profileName;
+            lease.browserPoolLeaseId = browserPoolLeaseIdForSession(lease.sessionName);
+            lease.browserPoolWorkerId = browserPoolWorkerId();
+            lease.browserPoolId = browserPoolId();
+            lease.browserPoolRootDir = browserPoolRootDir(context.status);
             lease.updatedAt = nowIso();
             lease.expiresAt = addMinutes(new Date(), ttlMinutes).toISOString();
         }
@@ -254,18 +359,95 @@ export async function acquireBrowserUseLease(context, options = {}) {
                     suggestion: 'Release a lease or rerun with a higher --max-slots value.',
                 }));
             }
-            lease = createLease(context.status, app, owner, ttlMinutes, profileName, registry.leases);
+            lease = createLease(context.status, app, holder, ttlMinutes, profileName, registry.leases);
             await copyTemplateProfile(templateDir, lease.userDataDir);
             registry.leases.push(lease);
         }
         await writeRegistry(context.status, registry);
+        if (reapedCount > 0 && !options.json) {
+            console.log(`Reaped ${reapedCount} stale lease${reapedCount === 1 ? '' : 's'}`);
+        }
         if (options.json)
             printLeaseJson(context.status, lease);
         else
             printLeaseEnv(context.status, lease);
+        if (!options.noWarmup) {
+            const warmup = await warmupBrowserUseLease(context, lease);
+            if (!warmup.success && !options.json) {
+                console.log(`Warning: Browser warm-up failed: ${warmup.error}`);
+            }
+        }
+    });
+}
+async function warmupBrowserUseLease(context, lease, timeoutMs = 15000) {
+    const wrapperPath = join(context.status.homeDir, 'bin', 'browser-use');
+    if (!existsSync(wrapperPath)) {
+        return { success: false, error: 'browser-use wrapper not found' };
+    }
+    const env = {
+        ...process.env,
+        BROWSER_USE_HOME: browserUseHome(context.status),
+        PIBO_BROWSER_USE_SESSION: lease.sessionName,
+        PIBO_BROWSER_USE_CHROME_USER_DATA_DIR: lease.userDataDir,
+        PIBO_BROWSER_USE_DEFAULT_PROFILE: lease.profileName,
+        ...(lease.browserPoolLeaseId ? { PIBO_BROWSER_POOL_LEASE_ID: lease.browserPoolLeaseId } : {}),
+    };
+    return new Promise((resolve) => {
+        const child = spawn(wrapperPath, ['--session', lease.sessionName, '--pibo-ensure-chrome'], {
+            env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => { stdout += chunk; });
+        child.stderr.on('data', (chunk) => { stderr += chunk; });
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            resolve({ success: false, error: `Warm-up timed out after ${timeoutMs}ms` });
+        }, timeoutMs);
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            resolve({ success: false, error: error.message });
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                const cdpUrl = stdout.trim();
+                resolve({ success: true, cdpUrl: cdpUrl || undefined });
+            }
+            else {
+                resolve({ success: false, error: stderr || `Chrome start exited with code ${code}` });
+            }
+        });
     });
 }
+async function reapStaleLeasesInRegistry(status, registry) {
+    let count = 0;
+    for (const lease of registry.leases) {
+        if (lease.status !== 'active' || !isExpired(lease))
+            continue;
+        if (lease.browserPoolLeaseId) {
+            await reapAssociatedBrowserPoolLeaseProcess(status, lease);
+        }
+        else if (leaseProcessIsAlive(status, lease)) {
+            killLeaseProcess(status, lease);
+        }
+        lease.status = 'released';
+        lease.updatedAt = nowIso();
+        count += 1;
+    }
+    return count;
+}
 export async function listBrowserUseLeases(context, json = false) {
+    let reapedCount = 0;
+    // Auto-reap stale leases before listing
+    await withRegistryLock(context.status, async () => {
+        const registry = readRegistry(context.status);
+        reapedCount = await reapStaleLeasesInRegistry(context.status, registry);
+        if (reapedCount > 0) {
+            await writeRegistry(context.status, registry);
+        }
+    });
     const registry = readRegistry(context.status);
     const rows = registry.leases.map((lease) => ({
         ...lease,
@@ -282,7 +464,7 @@ export async function listBrowserUseLeases(context, json = false) {
     }
     for (const row of rows) {
         const state = row.status === 'active' && !row.expired ? 'active' : row.expired ? 'expired' : row.status;
-        console.log(`${row.id}\t${state}\t${row.owner}\t${row.sessionName}\t${row.userDataDir}`);
+        console.log(`${row.id}\t${state}\t${row.holder}\t${row.sessionName}\t${row.userDataDir}`);
     }
 }
 export async function releaseBrowserUseLease(context, id, options = {}) {
@@ -297,7 +479,12 @@ export async function releaseBrowserUseLease(context, id, options = {}) {
                 suggestion: 'Run `pibo tools browser-use lease list`.',
             }));
         }
-        killLeaseProcess(context.status, lease);
+        if (lease.browserPoolLeaseId) {
+            await releaseAssociatedBrowserPoolLease(context.status, lease);
+        }
+        else {
+            killLeaseProcess(context.status, lease);
+        }
         lease.status = 'released';
         lease.updatedAt = nowIso();
         if (options.deleteProfile) {
@@ -310,16 +497,7 @@ export async function releaseBrowserUseLease(context, id, options = {}) {
 export async function reapStaleBrowserUseLeases(context) {
     await withRegistryLock(context.status, async () => {
         const registry = readRegistry(context.status);
-        let count = 0;
-        for (const lease of registry.leases) {
-            if (lease.status !== 'active' || !isExpired(lease))
-                continue;
-            if (leaseProcessIsAlive(context.status, lease))
-                killLeaseProcess(context.status, lease);
-            lease.status = 'released';
-            lease.updatedAt = nowIso();
-            count += 1;
-        }
+        const count = await reapStaleLeasesInRegistry(context.status, registry);
         await writeRegistry(context.status, registry);
         console.log(`Reaped ${count} stale browser-use auth lease${count === 1 ? '' : 's'}`);
     });