@pasko70/pibo 3.0.1 → 3.1.0

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

@@ -68,6 +68,28 @@ async function withRegistryLock(status, action) {
 function isExpired(lease, now = new Date()) {
     return new Date(lease.expiresAt).getTime() <= now.getTime();
 }
+function leaseTimestamp(lease) {
+    const updatedAt = Date.parse(lease.updatedAt);
+    if (Number.isFinite(updatedAt))
+        return updatedAt;
+    const createdAt = Date.parse(lease.createdAt);
+    return Number.isFinite(createdAt) ? createdAt : 0;
+}
+function deduplicateLeaseIdentities(registry) {
+    const leasesById = new Map();
+    for (const lease of registry.leases) {
+        const existing = leasesById.get(lease.id);
+        if (!existing) {
+            leasesById.set(lease.id, lease);
+            continue;
+        }
+        const preferLease = lease.status === 'active' && existing.status !== 'active'
+            || lease.status === existing.status && leaseTimestamp(lease) > leaseTimestamp(existing);
+        if (preferLease)
+            leasesById.set(lease.id, lease);
+    }
+    registry.leases = [...leasesById.values()];
+}
 function copyFilter(source) {
     const base = source.split(/[\\/]/).pop() || '';
     return ![
@@ -114,6 +136,7 @@ export async function acquireAgentBrowserLease(status, options) {
     const maxSlots = options.maxSlots ?? 4;
     const result = await withRegistryLock(status, async () => {
         const registry = readRegistry(status);
+        deduplicateLeaseIdentities(registry);
         const now = new Date();
         for (const lease of registry.leases) {
             if (lease.status === 'active' && isExpired(lease, now)) {
@@ -131,34 +154,44 @@ export async function acquireAgentBrowserLease(status, options) {
                 suggestion: 'Release a lease or rerun with a higher --max-slots value.',
             }));
         }
-        const used = new Set(active.map((lease) => lease.slot));
-        let slotNumber = 1;
-        while (used.has(`slot-${String(slotNumber).padStart(3, '0')}`))
-            slotNumber += 1;
-        const slot = `slot-${String(slotNumber).padStart(3, '0')}`;
-        const sessionName = `pibo-auth-${app}-${slot}`;
-        const profileDir = leaseProfileDir(status, app, slot);
-        const lease = {
-            id: `${app}-${slot}`,
-            app,
-            holder,
-            slot,
-            sessionName,
-            profileDir,
-            status: 'active',
-            createdAt: nowIso(),
-            updatedAt: nowIso(),
-            expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
-        };
-        await rm(profileDir, { recursive: true, force: true });
+        let lease = registry.leases.find((item) => item.app === app && item.status === 'released');
+        if (lease) {
+            lease.holder = holder;
+            lease.status = 'active';
+            lease.updatedAt = nowIso();
+            lease.expiresAt = new Date(now.getTime() + ttlMs).toISOString();
+        }
+        else {
+            const used = new Set(active.map((item) => item.slot));
+            let slotNumber = 1;
+            while (used.has(`slot-${String(slotNumber).padStart(3, '0')}`))
+                slotNumber += 1;
+            const slot = `slot-${String(slotNumber).padStart(3, '0')}`;
+            const sessionName = `pibo-auth-${app}-${slot}`;
+            const profileDir = leaseProfileDir(status, app, slot);
+            const createdAt = nowIso();
+            lease = {
+                id: `${app}-${slot}`,
+                app,
+                holder,
+                slot,
+                sessionName,
+                profileDir,
+                status: 'active',
+                createdAt,
+                updatedAt: createdAt,
+                expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+            };
+            registry.leases.push(lease);
+        }
+        await rm(lease.profileDir, { recursive: true, force: true });
         const sourceTemplate = templateDir(status, app);
         if (existsSync(sourceTemplate)) {
-            await cp(sourceTemplate, profileDir, { recursive: true, force: true, filter: copyFilter });
+            await cp(sourceTemplate, lease.profileDir, { recursive: true, force: true, filter: copyFilter });
         }
         else {
-            await mkdir(profileDir, { recursive: true });
+            await mkdir(lease.profileDir, { recursive: true });
         }
-        registry.leases.push(lease);
         await writeRegistry(status, registry);
         return lease;
     });
@@ -187,6 +220,7 @@ export async function listAgentBrowserLeases(status, json = false) {
 export async function releaseAgentBrowserLease(status, id, options) {
     await withRegistryLock(status, async () => {
         const registry = readRegistry(status);
+        deduplicateLeaseIdentities(registry);
         const lease = registry.leases.find((item) => item.id === id);
         if (!lease)
             throw new Error(`Agent Browser lease not found: ${id}`);
@@ -202,6 +236,7 @@ export async function reapStaleAgentBrowserLeases(status, json = false) {
     let released = 0;
     await withRegistryLock(status, async () => {
         const registry = readRegistry(status);
+        deduplicateLeaseIdentities(registry);
         const now = new Date();
         for (const lease of registry.leases) {
             if (lease.status === 'active' && isExpired(lease, now)) {

package/dist/tools/agent-browser-wrapper.js

@@ -89,7 +89,7 @@ exec "$real_agent_browser" "\${args[@]}"
 `;
 }
 export function ensureAgentBrowserWrapper(status) {
-    if (!status.homeDir || !status.executablePath)
+    if (!status.installed || !status.homeDir || !status.executablePath)
         return undefined;
     const wrapperPath = join(status.homeDir, 'bin', 'agent-browser');
     mkdirSync(dirname(wrapperPath), { recursive: true });

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

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
-import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { cp, mkdir, rm, stat, writeFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { ErrorCode, formatCliError } from '../cli-errors.js';
 import { BROWSER_USE_DEFAULT_PROFILE } from './browser-use-wrapper.js';
@@ -10,6 +11,8 @@ const DEFAULT_APP = 'pibo-chat';
 const DEFAULT_TTL_MINUTES = 8 * 60;
 const DEFAULT_TEMPLATE_PROFILE = 'pibo-auth-template';
 const AUTH_POOL_DIR = 'auth-pool';
+const REGISTRY_LOCK_OWNER_FILE = 'owner.json';
+const LEGACY_REGISTRY_LOCK_STALE_MS = 10 * 60_000;
 function shellQuote(value) {
     return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -32,6 +35,9 @@ function registryPath(status) {
 function lockDir(status) {
     return join(status.homeDir, AUTH_POOL_DIR, '.leases.lock');
 }
+function lockOwnerPath(lock) {
+    return join(lock, REGISTRY_LOCK_OWNER_FILE);
+}
 function appPoolDir(status, app) {
     return join(status.homeDir, AUTH_POOL_DIR, sanitizeIdPart(app));
 }
@@ -110,29 +116,135 @@ async function writeRegistry(status, registry) {
 async function withRegistryLock(status, action) {
     const lock = lockDir(status);
     await mkdir(join(status.homeDir, AUTH_POOL_DIR), { recursive: true });
-    let acquired = false;
+    const token = randomUUID();
     for (let attempt = 0; attempt < 50; attempt += 1) {
         try {
             await mkdir(lock);
-            acquired = true;
+            const processStartId = currentProcessStartId();
+            try {
+                await writeFile(lockOwnerPath(lock), `${JSON.stringify({
+                    pid: process.pid,
+                    token,
+                    acquiredAt: Date.now(),
+                    ...(processStartId ? { processStartId } : {}),
+                })}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+            }
+            catch (error) {
+                await rm(lock, { recursive: true, force: true });
+                throw error;
+            }
             break;
         }
         catch (error) {
             if (error.code !== 'EEXIST')
                 throw error;
+            await recoverStaleRegistryLock(lock);
+            if (!existsSync(lock))
+                continue;
             await new Promise((resolve) => setTimeout(resolve, 50));
         }
     }
-    if (!acquired) {
+    if (!await registryLockOwnedBy(lock, token)) {
         throw new Error('Timed out waiting for browser-use lease registry lock');
     }
     try {
         return await action();
     }
     finally {
+        await releaseRegistryLock(lock, token);
+    }
+}
+function currentProcessStartId() {
+    if (process.platform !== 'linux')
+        return undefined;
+    const identity = linuxProcessIdentity(process.pid);
+    return identity.liveness === 'active' ? identity.startId : undefined;
+}
+function linuxProcessIdentity(pid) {
+    let raw;
+    try {
+        raw = readFileSync(`/proc/${pid}/stat`, 'utf8');
+    }
+    catch (error) {
+        const code = error.code;
+        return code === 'ENOENT' || code === 'ESRCH' ? { liveness: 'dead' } : { liveness: 'ambiguous' };
+    }
+    const commandEnd = raw.lastIndexOf(')');
+    if (commandEnd < 2 || commandEnd + 2 >= raw.length)
+        return { liveness: 'ambiguous' };
+    const fields = raw.slice(commandEnd + 2).trim().split(/\s+/);
+    if (fields[0] === 'Z')
+        return { liveness: 'dead' };
+    const startTicks = fields[19];
+    if (!startTicks || !/^[1-9][0-9]*$/.test(startTicks))
+        return { liveness: 'ambiguous' };
+    return { liveness: 'active', startId: `${pid}:${startTicks}` };
+}
+function validRegistryLockOwner(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const owner = value;
+    if (!Number.isSafeInteger(owner.pid)
+        || (owner.pid ?? 0) <= 0
+        || typeof owner.token !== 'string'
+        || owner.token.length === 0
+        || !Number.isFinite(owner.acquiredAt)
+        || (owner.processStartId !== undefined && typeof owner.processStartId !== 'string'))
+        return undefined;
+    return owner;
+}
+function readRegistryLockOwner(lock) {
+    try {
+        return validRegistryLockOwner(JSON.parse(readFileSync(lockOwnerPath(lock), 'utf8')));
+    }
+    catch {
+        return undefined;
+    }
+}
+function registryLockOwnerLiveness(owner) {
+    if (process.platform === 'linux') {
+        const identity = linuxProcessIdentity(owner.pid);
+        if (identity.liveness !== 'active')
+            return identity.liveness;
+        if (!owner.processStartId || !identity.startId)
+            return 'ambiguous';
+        return owner.processStartId === identity.startId ? 'active' : 'dead';
+    }
+    try {
+        process.kill(owner.pid, 0);
+        return 'active';
+    }
+    catch (error) {
+        return error.code === 'ESRCH' ? 'dead' : 'ambiguous';
+    }
+}
+async function registryLockOwnedBy(lock, token) {
+    return readRegistryLockOwner(lock)?.token === token;
+}
+async function releaseRegistryLock(lock, token) {
+    if (await registryLockOwnedBy(lock, token)) {
         await rm(lock, { recursive: true, force: true });
     }
 }
+async function recoverStaleRegistryLock(lock) {
+    const owner = readRegistryLockOwner(lock);
+    if (owner) {
+        if (registryLockOwnerLiveness(owner) === 'dead' && readRegistryLockOwner(lock)?.token === owner.token) {
+            await rm(lock, { recursive: true, force: true });
+        }
+        return;
+    }
+    try {
+        const lockStat = await stat(lock);
+        if (Date.now() - lockStat.mtimeMs > LEGACY_REGISTRY_LOCK_STALE_MS) {
+            await rm(lock, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
 export function isExpired(lease, now = new Date()) {
     return new Date(lease.expiresAt).getTime() <= now.getTime();
 }
@@ -346,7 +458,7 @@ export async function acquireBrowserUseLease(context, options = {}) {
     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 { lease, reapedCount } = 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);
@@ -380,18 +492,19 @@ export async function acquireBrowserUseLease(context, options = {}) {
             registry.leases.push(lease);
         }
         await writeRegistry(context.status, registry);
-        if (reapedCount > 0 && !options.json) {
-            console.error(`Reaped ${reapedCount} stale lease${reapedCount === 1 ? '' : 's'}`);
-        }
-        if (options.json)
-            printLeaseJson(context.status, lease);
-        else
-            printLeaseEnv(context.status, lease);
-        const warmup = await warmupBrowserUseLease(context, lease, 15000, options.headed);
-        if (!warmup.success && !options.json) {
-            console.error(`Warning: Browser warm-up failed: ${warmup.error?.trim() || 'unknown error'}`);
-        }
+        return { lease, reapedCount };
     });
+    if (reapedCount > 0 && !options.json) {
+        console.error(`Reaped ${reapedCount} stale lease${reapedCount === 1 ? '' : 's'}`);
+    }
+    if (options.json)
+        printLeaseJson(context.status, lease);
+    else
+        printLeaseEnv(context.status, lease);
+    const warmup = await warmupBrowserUseLease(context, lease, 15000, options.headed);
+    if (!warmup.success && !options.json) {
+        console.error(`Warning: Browser warm-up failed: ${warmup.error?.trim() || 'unknown error'}`);
+    }
 }
 async function warmupBrowserUseLease(context, lease, timeoutMs = 15000, headed = false) {
     const wrapperPath = join(context.status.homeDir, 'bin', 'browser-use');

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

@@ -771,7 +771,7 @@ exec "$real_browser_use" "$@"
 `;
 }
 export function ensureBrowserUseWrapper(status) {
-    if (status.entry.name !== 'browser-use')
+    if (!status.installed || status.entry.name !== 'browser-use')
         return undefined;
     const wrapperPath = join(status.homeDir, 'bin', 'browser-use');
     mkdirSync(dirname(wrapperPath), { recursive: true });

package/dist/tools/index.js

@@ -60,17 +60,21 @@ function printShow(name) {
         const wrapperPath = ensureBrowserUseWrapper(status);
         console.log(`  wrapper: ${wrapperPath ?? 'not generated'}`);
         console.log(`  executable: ${status.executablePath}`);
-        console.log('');
-        console.log('  IMPORTANT: Always use the wrapper path above, not the raw executable.');
-        console.log('  The wrapper manages persistent Chrome profiles and CDP automatically.');
+        if (wrapperPath) {
+            console.log('');
+            console.log('  IMPORTANT: Always use the wrapper path above, not the raw executable.');
+            console.log('  The wrapper manages persistent Chrome profiles and CDP automatically.');
+        }
     }
     else if (entry.name === 'agent-browser') {
         const wrapperPath = ensureAgentBrowserWrapper(status);
         console.log(`  wrapper: ${wrapperPath ?? 'not generated'}`);
         console.log(`  executable: ${status.executablePath}`);
-        console.log('');
-        console.log('  IMPORTANT: Always use the wrapper path above, not the raw executable.');
-        console.log('  The wrapper keeps Agent Browser state under the Pibo tool home.');
+        if (wrapperPath) {
+            console.log('');
+            console.log('  IMPORTANT: Always use the wrapper path above, not the raw executable.');
+            console.log('  The wrapper keeps Agent Browser state under the Pibo tool home.');
+        }
     }
     else {
         console.log(`  executable: ${status.executablePath}`);
@@ -88,8 +92,9 @@ function printShow(name) {
     }
     console.log('');
     console.log('Next:');
-    if (entry.kind !== 'internal')
-        console.log(`  pibo tools env ${entry.name}`);
+    if (entry.kind !== 'internal') {
+        console.log(status.installed ? `  pibo tools env ${entry.name}` : `  pibo tools install ${entry.name}`);
+    }
     console.log(`  pibo tools guide ${entry.name} ${entry.guides[0]?.name ?? ''}`.trimEnd());
     if (entry.name === 'browser-use') {
         console.log('  pibo tools browser-use');
@@ -133,9 +138,21 @@ function printGuide(name, guideName) {
     }
     console.log(guide.content);
 }
-function printPath(name) {
+function requireInstalledTool(name) {
     const entry = requireEntry(name);
     const status = getCliToolStatus(entry);
+    if (!status.installed) {
+        throw new Error(formatCliError({
+            code: ErrorCode.CLIENT_ERROR,
+            type: 'CLI_TOOL_NOT_INSTALLED',
+            message: `Tool "${name}" is not installed`,
+            suggestion: `Run pibo tools install ${name}.`,
+        }));
+    }
+    return { entry, status };
+}
+function printPath(name) {
+    const { entry, status } = requireInstalledTool(name);
     if (entry.name === 'browser-use') {
         const wrapperPath = ensureBrowserUseWrapper(status);
         if (wrapperPath) {
@@ -153,8 +170,7 @@ function printPath(name) {
     console.log(status.executablePath);
 }
 function printEnv(name) {
-    const entry = requireEntry(name);
-    const status = getCliToolStatus(entry);
+    const { entry, status } = requireInstalledTool(name);
     const desktop = detectDesktopEnv();
     if (entry.kind === 'internal') {
         console.log(`# ${entry.name} is built into pibo; no extra environment is required.`);

package/dist/tools/python-runtime.js

@@ -52,7 +52,7 @@ function runBuffered(command, args, env = process.env) {
 function isRootUser() {
     return typeof process.getuid === 'function' && process.getuid() === 0;
 }
-async function resolveUvCommand() {
+async function findUvCommand() {
     const uv = await runBuffered('uv', ['--version']);
     if (uv.ok)
         return 'uv';
@@ -62,7 +62,14 @@ async function resolveUvCommand() {
         if (local.ok)
             return localUv;
     }
+    return undefined;
+}
+async function ensureUvCommand() {
+    const uvCommand = await findUvCommand();
+    if (uvCommand)
+        return uvCommand;
     if (process.platform === 'linux' && isRootUser()) {
+        const localUv = join(homedir(), '.local', 'bin', 'uv');
         console.log('uv was not found on PATH. Installing uv automatically.');
         await runInheritedCommand('sh', ['-c', 'curl -LsSf https://astral.sh/uv/install.sh | sh']);
         const installed = await runBuffered(localUv, ['--version'], {
@@ -107,7 +114,7 @@ export function runInheritedCommand(command, args, env = process.env) {
 }
 export async function printToolPythonRuntimeDoctor(name, spec) {
     const paths = getToolPythonRuntimePaths(name, spec);
-    const uvCommand = await resolveUvCommand();
+    const uvCommand = await findUvCommand();
     const uv = uvCommand ? await runBuffered(uvCommand, ['--version']) : { ok: false, output: 'missing' };
     const python = uv.ok
         ? await runBuffered(uvCommand, ['python', 'find', spec.pythonVersion])
@@ -148,7 +155,7 @@ export async function printToolPythonRuntimeDoctor(name, spec) {
     }
 }
 export async function installToolPythonRuntime(name, spec) {
-    const uvCommand = await resolveUvCommand();
+    const uvCommand = await ensureUvCommand();
     if (!uvCommand) {
         throw new Error(formatCliError({
             code: ErrorCode.CLIENT_ERROR,

package/dist/tools/registry.js

@@ -220,7 +220,7 @@ export async function installCliTool(entry, runSetup) {
     if ((entry.name === 'browser-use' || entry.name === 'agent-browser') && process.platform === 'linux' && !hasDesktopDisplay(detectDesktopEnv())) {
         printLinuxVirtualDisplayHint('  ');
     }
-    console.log(`  env: pibo tools env ${entry.name}`);
+    console.log(status.installed ? `  env: pibo tools env ${entry.name}` : `  install: pibo tools install ${entry.name}`);
 }
 export async function removeCliTool(entry) {
     if (entry.kind === 'internal') {

package/dist/tools/runtime/node-backend.js

@@ -46,13 +46,23 @@ export class NodeRuntimeBackend {
         this.child = spawn(executable, [...args, "-e", NODE_RUNTIME_WORKER_SOURCE], {
             cwd,
             env: { ...process.env, ...(env ?? {}) },
-            stdio: "pipe",
+            stdio: ["pipe", "pipe", "pipe", "pipe"],
+        });
+        const protocol = this.child.stdio[3];
+        if (!protocol)
+            throw new Error("Node runtime protocol pipe was not created");
+        const responses = createInterface({ input: protocol });
+        responses.on("line", (line) => this.handleLine(line));
+        this.child.stdout.on("data", (chunk) => {
+            this.diagnostics += String(chunk);
         });
-        const stdout = createInterface({ input: this.child.stdout });
-        stdout.on("line", (line) => this.handleLine(line));
         this.child.stderr.on("data", (chunk) => {
             this.diagnostics += String(chunk);
         });
+        this.child.stdin.on("error", (error) => {
+            this.alive = false;
+            this.rejectAll(error);
+        });
         this.child.once("error", (error) => {
             this.alive = false;
             this.readyReject(error);
@@ -78,7 +88,7 @@ export class NodeRuntimeBackend {
         }
     }
     isAlive() {
-        return this.alive && !this.child.killed;
+        return this.alive;
     }
     getRecord() {
         return { pid: this.child.pid, cwd: this.cwd, executable: this.executable };
@@ -146,7 +156,8 @@ export class NodeRuntimeBackend {
     async interrupt() {
         if (!this.isAlive())
             return { status: "failed", sessionId: "", message: "Runtime worker is not alive" };
-        this.child.kill("SIGINT");
+        if (!this.child.kill("SIGINT"))
+            return { status: "failed", sessionId: "", message: "Runtime worker is not alive" };
         return { status: "ok", sessionId: "", message: "Sent SIGINT to runtime worker" };
     }
     async close(force = false) {