@pasko70/pibo 1.1.0 → 1.3.0

package/dist/tools/npm-runtime.js

@@ -0,0 +1,136 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { ErrorCode, formatCliError } from '../cli-errors.js';
+import { detectDesktopEnv, getDesktopProcessEnv, hasDesktopDisplay, printDesktopEnvStatus, printLinuxVirtualDisplayHint, } from './desktop-env.js';
+function getPiboHome() {
+    return process.env.PIBO_HOME || join(homedir(), '.pibo');
+}
+export function getToolNpmRuntimePaths(name, spec) {
+    const rootDir = join(getPiboHome(), 'tools', name);
+    const homeDir = join(rootDir, 'home');
+    const nodeDir = join(rootDir, 'node');
+    const binDir = join(nodeDir, 'node_modules', '.bin');
+    const executable = process.platform === 'win32' ? `${spec.executableName}.cmd` : spec.executableName;
+    return {
+        rootDir,
+        homeDir,
+        nodeDir,
+        binDir,
+        executablePath: join(binDir, executable),
+    };
+}
+export function getToolNpmRuntimeEnv(paths, spec) {
+    const env = { ...process.env, ...getDesktopProcessEnv() };
+    env.PATH = `${join(paths.homeDir, 'bin')}:${paths.binDir}:${env.PATH ?? ''}`;
+    if (spec.homeEnvVar)
+        env[spec.homeEnvVar] = paths.homeDir;
+    return env;
+}
+function runBuffered(command, args, env = process.env) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'], env });
+        const chunks = [];
+        child.stdout.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+        child.stderr.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+        child.on('error', (error) => resolve({ ok: false, output: error.message }));
+        child.on('close', (code) => {
+            resolve({ ok: code === 0, output: Buffer.concat(chunks).toString('utf-8').trim() });
+        });
+    });
+}
+function runInheritedNpmCommand(command, args, env = process.env) {
+    return new Promise((resolve, reject) => {
+        console.log(`Running: ${command} ${args.join(' ')}`);
+        const child = spawn(command, args, { stdio: 'inherit', env });
+        child.on('error', (error) => {
+            reject(new Error(formatCliError({
+                code: ErrorCode.CLIENT_ERROR,
+                type: 'CLI_TOOL_COMMAND_FAILED',
+                message: `Failed to run command: ${command}`,
+                details: error.message,
+                suggestion: 'Install Node.js and npm first, then rerun the command.',
+            })));
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(formatCliError({
+                code: ErrorCode.CLIENT_ERROR,
+                type: 'CLI_TOOL_COMMAND_FAILED',
+                message: `Command failed with exit code ${code ?? 'unknown'}`,
+                details: `${command} ${args.join(' ')}`,
+                suggestion: 'Fix the npm setup error above, then rerun the install command.',
+            })));
+        });
+    });
+}
+async function ensureNodeAndNpm() {
+    const node = await runBuffered('node', ['--version']);
+    const npm = await runBuffered('npm', ['--version']);
+    if (!node.ok || !npm.ok) {
+        throw new Error(formatCliError({
+            code: ErrorCode.CLIENT_ERROR,
+            type: 'CLI_TOOL_NPM_MISSING',
+            message: 'node or npm was not found on PATH',
+            details: `node: ${node.output || 'missing'}; npm: ${npm.output || 'missing'}`,
+            suggestion: 'Install Node.js and npm, then rerun the install command.',
+        }));
+    }
+}
+export async function installToolNpmRuntime(name, spec) {
+    await ensureNodeAndNpm();
+    const paths = getToolNpmRuntimePaths(name, spec);
+    await mkdir(paths.rootDir, { recursive: true });
+    await mkdir(paths.homeDir, { recursive: true });
+    await mkdir(paths.nodeDir, { recursive: true });
+    const packageJsonPath = join(paths.nodeDir, 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        await writeFile(packageJsonPath, `${JSON.stringify({ private: true, name: `pibo-tool-${name}` }, null, 2)}\n`);
+    }
+    await runInheritedNpmCommand('npm', ['install', '--prefix', paths.nodeDir, spec.packageName]);
+    if (spec.postInstallArgs?.length) {
+        await runInheritedNpmCommand(paths.executablePath, spec.postInstallArgs, getToolNpmRuntimeEnv(paths, spec));
+    }
+    return paths;
+}
+export async function removeToolNpmRuntime(name, spec) {
+    const paths = getToolNpmRuntimePaths(name, spec);
+    await rm(paths.rootDir, { recursive: true, force: true });
+    console.log(`Removed runtime: ${paths.rootDir}`);
+}
+export async function printToolNpmRuntimeDoctor(name, spec) {
+    const paths = getToolNpmRuntimePaths(name, spec);
+    const node = await runBuffered('node', ['--version']);
+    const npm = await runBuffered('npm', ['--version']);
+    console.log(`${name}`);
+    console.log(`  node: ${node.ok ? node.output || 'ok' : `missing (${node.output})`}`);
+    console.log(`  npm: ${npm.ok ? npm.output || 'ok' : `missing (${npm.output})`}`);
+    console.log(`  package: ${spec.packageName}`);
+    console.log(`  runtime: ${paths.rootDir}`);
+    console.log(`  home: ${paths.homeDir}`);
+    console.log(`  node modules: ${existsSync(join(paths.nodeDir, 'node_modules')) ? 'present' : 'missing'}`);
+    console.log(`  executable: ${existsSync(paths.executablePath) ? paths.executablePath : 'missing'}`);
+    printDesktopEnvStatus('  ');
+    if (name === 'agent-browser' && process.platform === 'linux' && !hasDesktopDisplay(detectDesktopEnv())) {
+        printLinuxVirtualDisplayHint('  ');
+    }
+    if (existsSync(paths.executablePath)) {
+        const doctorExecutablePath = name === 'agent-browser' && existsSync(join(paths.homeDir, 'bin', 'agent-browser'))
+            ? join(paths.homeDir, 'bin', 'agent-browser')
+            : paths.executablePath;
+        const doctor = await runBuffered(doctorExecutablePath, ['doctor', '--offline', '--quick'], getToolNpmRuntimeEnv(paths, spec));
+        console.log(`  tool doctor: ${doctor.ok ? 'ok' : 'failed'}`);
+        if (doctor.output)
+            console.log(doctor.output.split('\n').map((line) => `    ${line}`).join('\n'));
+    }
+    if (!node.ok || !npm.ok) {
+        console.log('');
+        console.log('Install Node.js and npm first, then rerun:');
+        console.log(`  pibo tools doctor ${name}`);
+    }
+}

package/dist/tools/registry.js

@@ -1,7 +1,9 @@
 import { existsSync } from 'node:fs';
+import { ensureAgentBrowserWrapper } from './agent-browser-wrapper.js';
 import { detectDesktopEnv, hasDesktopDisplay, printDesktopEnvStatus, printLinuxVirtualDisplayHint } from './desktop-env.js';
-import { BROWSER_USE_GUIDE, REMOTE_BROWSER_GUIDE } from './guides.js';
+import { AGENT_BROWSER_GUIDE, BROWSER_USE_GUIDE, RALPH_GUIDE, REMOTE_BROWSER_GUIDE } from './guides.js';
 import { ensureLinuxVirtualDisplay } from './linux-virtual-display.js';
+import { getToolNpmRuntimePaths, installToolNpmRuntime, printToolNpmRuntimeDoctor, removeToolNpmRuntime, } from './npm-runtime.js';
 import { getToolPythonRuntimePaths, installToolPythonRuntime, runInheritedCommand, printToolPythonRuntimeDoctor, removeToolPythonRuntime, } from './python-runtime.js';
 const MAX_AGENT_CONTEXT_SNIPPET_LENGTH = 480;
 const INSTALLED_TOOLS_CONTEXT_PATH = '.pibo/context/installed-pibo-tools.md';
@@ -27,10 +29,53 @@ const REGISTRY = [
         agentContextSnippet: [
             'Browser automation CLI for frontend development and web testing.',
             'Start in one persistent shell with `eval "$(npm run --silent dev -- tools env browser-use)"`.',
-            'For authenticated Pibo Chat Web App testing, prefer `eval "$(npm run --silent dev -- tools browser-use lease acquire --app pibo-chat --owner "$USER")"`.',
+            'For authenticated Pibo Chat Web App testing, prefer `eval "$(npm run --silent dev -- tools browser-use lease acquire --app pibo-chat --holder "$USER")"`.',
             'Discover details with `npm run dev -- tools show browser-use` and `npm run dev -- tools guide browser-use browser-use`.',
         ].join('\n'),
     },
+    {
+        name: 'agent-browser',
+        description: 'Fast native browser automation CLI for AI agents.',
+        kind: 'npm',
+        runtime: {
+            type: 'npm',
+            packageName: 'agent-browser@0.27.0',
+            executableName: 'agent-browser',
+            homeEnvVar: 'AGENT_BROWSER_HOME',
+        },
+        guides: [AGENT_BROWSER_GUIDE],
+        notes: [
+            'Installed on demand into an isolated npm runtime.',
+            'Pinned to agent-browser 0.27.0 so the CLI surface matches the bundled guide.',
+            'The Pibo wrapper redirects HOME to AGENT_BROWSER_HOME by default so Agent Browser state stays in the tool home.',
+            'The wrapper uses home/profiles/PIBo as the default browser profile for launch commands; pass --fresh-profile or explicit upstream flags to opt out.',
+            'Use pibo tools agent-browser lease acquire for isolated authenticated browser slots when multiple agents need Chat Web App access.',
+            'Guides are available through pibo tools guide and are not loaded into pibo profiles automatically.',
+        ],
+        agentContextSnippet: [
+            'Browser automation CLI for frontend development and web testing.',
+            'Start in one persistent shell with `eval "$(npm run --silent dev -- tools env agent-browser)"`.',
+            'For authenticated Pibo Chat Web App testing, prefer `eval "$(npm run --silent dev -- tools agent-browser lease acquire --app pibo-chat --holder "$USER")"`.',
+            'Discover details with `npm run dev -- tools show agent-browser` and `npm run dev -- tools guide agent-browser agent-browser`.',
+        ].join('\n'),
+    },
+    {
+        name: 'ralph',
+        description: 'Pibo-native continuous agent job runner for implementation and debugging loops.',
+        kind: 'internal',
+        guides: [RALPH_GUIDE],
+        notes: [
+            'Ralph is built into the pibo CLI; no external runtime installation is required.',
+            'Ralph jobs are app-global; use room targets or the shared default target when creating jobs.',
+            'Prefer templates for repeatable jobs, and use --json for automation-safe inspection.',
+        ],
+        agentContextSnippet: [
+            'Continuous Pibo agent job runner for implementation/debug loops.',
+            'Use `pibo ralph templates`, then create with `pibo ralph add --template <id> --room <room-id> --start`.',
+            'Inspect/control with `pibo ralph list --json`, `runs --job <id> --json`, `stop <id>`, `cancel <id>`.',
+            'Guide: `pibo tools guide ralph ralph`.',
+        ].join('\n'),
+    },
 ];
 for (const entry of REGISTRY) {
     const snippet = entry.agentContextSnippet.trim();
@@ -48,7 +93,20 @@ export function findCliToolEntry(name) {
     return REGISTRY.find((entry) => entry.name === name);
 }
 export function getCliToolStatus(entry) {
-    const paths = getToolPythonRuntimePaths(entry.name, entry.runtime);
+    if (entry.kind === 'internal') {
+        return {
+            entry,
+            installed: true,
+            executablePath: `pibo ${entry.name}`,
+            rootDir: '',
+            homeDir: '',
+        };
+    }
+    if (!entry.runtime)
+        throw new Error(`CLI tool "${entry.name}" is missing runtime`);
+    const paths = entry.runtime.type === 'npm'
+        ? getToolNpmRuntimePaths(entry.name, entry.runtime)
+        : getToolPythonRuntimePaths(entry.name, entry.runtime);
     return {
         entry,
         installed: existsSync(paths.executablePath),
@@ -90,25 +148,66 @@ export function getInstalledCliToolContextFile() {
     };
 }
 export async function installCliTool(entry, runSetup) {
+    if (entry.kind === 'internal') {
+        const status = getCliToolStatus(entry);
+        console.log(`Built-in ${entry.name}`);
+        console.log(`  executable: ${status.executablePath}`);
+        console.log(`  env: no extra environment required`);
+        return;
+    }
+    if (!entry.runtime)
+        throw new Error(`CLI tool "${entry.name}" is missing runtime`);
     if (runSetup) {
-        if (entry.name === 'browser-use') {
+        if (entry.name === 'browser-use' || entry.name === 'agent-browser') {
             await ensureLinuxVirtualDisplay({ runInherited: runInheritedCommand });
         }
-        await installToolPythonRuntime(entry.name, entry.runtime);
+        if (entry.runtime.type === 'npm') {
+            await installToolNpmRuntime(entry.name, entry.runtime);
+        }
+        else {
+            await installToolPythonRuntime(entry.name, entry.runtime);
+        }
     }
     const status = getCliToolStatus(entry);
+    if (entry.name === 'agent-browser')
+        ensureAgentBrowserWrapper(status);
     console.log(`${runSetup ? 'Installed' : 'Install target'} ${entry.name}`);
     console.log(`  executable: ${status.executablePath}`);
     console.log(`  home: ${status.homeDir}`);
     printDesktopEnvStatus('  ');
-    if (entry.name === 'browser-use' && process.platform === 'linux' && !hasDesktopDisplay(detectDesktopEnv())) {
+    if ((entry.name === 'browser-use' || entry.name === 'agent-browser') && process.platform === 'linux' && !hasDesktopDisplay(detectDesktopEnv())) {
         printLinuxVirtualDisplayHint('  ');
     }
     console.log(`  env: pibo tools env ${entry.name}`);
 }
 export async function removeCliTool(entry) {
-    await removeToolPythonRuntime(entry.name, entry.runtime);
+    if (entry.kind === 'internal') {
+        console.log(`${entry.name} is built into pibo and cannot be removed separately.`);
+        return;
+    }
+    if (!entry.runtime)
+        throw new Error(`CLI tool "${entry.name}" is missing runtime`);
+    if (entry.runtime.type === 'npm') {
+        await removeToolNpmRuntime(entry.name, entry.runtime);
+    }
+    else {
+        await removeToolPythonRuntime(entry.name, entry.runtime);
+    }
 }
 export async function doctorCliTool(entry) {
-    await printToolPythonRuntimeDoctor(entry.name, entry.runtime);
+    if (entry.kind === 'internal') {
+        console.log(`${entry.name}: ok`);
+        console.log(`  executable: pibo ${entry.name}`);
+        return;
+    }
+    if (!entry.runtime)
+        throw new Error(`CLI tool "${entry.name}" is missing runtime`);
+    if (entry.name === 'agent-browser')
+        ensureAgentBrowserWrapper(getCliToolStatus(entry));
+    if (entry.runtime.type === 'npm') {
+        await printToolNpmRuntimeDoctor(entry.name, entry.runtime);
+    }
+    else {
+        await printToolPythonRuntimeDoctor(entry.name, entry.runtime);
+    }
 }

package/dist/tools/runtime/index.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./tool.js";
+export * from "./registry.js";

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

@@ -0,0 +1,225 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { isAbsolute, resolve } from "node:path";
+import { NODE_RUNTIME_WORKER_SOURCE } from "./node-worker-source.js";
+function resolveCwd(baseCwd, cwd) {
+    if (!cwd || cwd.trim().length === 0)
+        return baseCwd;
+    return isAbsolute(cwd) ? cwd : resolve(baseCwd, cwd);
+}
+function errorSummary(error, name = "RuntimeWorkerError") {
+    return error instanceof Error
+        ? { name: error.name || name, message: error.message, stack: error.stack }
+        : { name, message: String(error) };
+}
+function asErrorSummary(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const error = value;
+    return {
+        name: typeof error.name === "string" ? error.name : "RuntimeError",
+        message: typeof error.message === "string" ? error.message : "Runtime error",
+        line: typeof error.line === "number" ? error.line : undefined,
+        column: typeof error.column === "number" ? error.column : undefined,
+        traceback: typeof error.traceback === "string" ? error.traceback : undefined,
+        stack: typeof error.stack === "string" ? error.stack : undefined,
+    };
+}
+export class NodeRuntimeBackend {
+    cwd;
+    executable;
+    child;
+    pending = new Map();
+    requestCounter = 0;
+    alive = true;
+    diagnostics = "";
+    readyPromise;
+    readyResolve;
+    readyReject;
+    constructor(cwd, executable, args, env) {
+        this.cwd = cwd;
+        this.executable = executable;
+        this.readyPromise = new Promise((resolveReady, rejectReady) => {
+            this.readyResolve = resolveReady;
+            this.readyReject = rejectReady;
+        });
+        this.child = spawn(executable, [...args, "-e", NODE_RUNTIME_WORKER_SOURCE], {
+            cwd,
+            env: { ...process.env, ...(env ?? {}) },
+            stdio: "pipe",
+        });
+        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.once("error", (error) => {
+            this.alive = false;
+            this.readyReject(error);
+            this.rejectAll(error);
+        });
+        this.child.once("close", (code, signal) => {
+            this.alive = false;
+            const error = new Error(`Node runtime worker exited with code ${code ?? "null"}${signal ? ` signal ${signal}` : ""}`);
+            this.readyReject(error);
+            this.rejectAll(error);
+        });
+    }
+    static async start(baseCwd, input) {
+        const target = input.target ?? {};
+        const backend = new NodeRuntimeBackend(resolveCwd(baseCwd, target.cwd), target.executable ?? "node", target.args ?? [], target.env);
+        await backend.waitReady(input.timeoutMs ?? 10000);
+        return backend;
+    }
+    isAlive() {
+        return this.alive && !this.child.killed;
+    }
+    getRecord() {
+        return { pid: this.child.pid, cwd: this.cwd, executable: this.executable };
+    }
+    async exec(input) {
+        const started = Date.now();
+        try {
+            const response = await this.request("exec", {
+                code: input.code,
+                mode: input.mode ?? "exec",
+                timeoutMs: input.timeoutMs ?? 30000,
+            }, input.timeoutMs ?? 30000);
+            return {
+                status: normalizeExecStatus(response),
+                sessionId: "",
+                stdout: response.stdout ?? "",
+                stderr: response.stderr ?? "",
+                result: response.result,
+                error: asErrorSummary(response.error),
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                status: error instanceof TimeoutError ? "timeout" : "failed",
+                sessionId: "",
+                durationMs: Date.now() - started,
+                error: errorSummary(error),
+            };
+        }
+    }
+    async inspect(input) {
+        try {
+            const response = await this.request("inspect", input, 15000);
+            return {
+                status: response.status === "ok" ? "ok" : "error",
+                sessionId: "",
+                summary: response.summary,
+                signature: response.signature,
+                members: response.members,
+                source: response.source,
+                doc: response.doc,
+                error: asErrorSummary(response.error),
+            };
+        }
+        catch (error) {
+            return { status: "failed", sessionId: "", error: errorSummary(error) };
+        }
+    }
+    async vars(input) {
+        try {
+            const response = await this.request("vars", input, 15000);
+            return {
+                status: response.status === "ok" ? "ok" : "failed",
+                sessionId: "",
+                variables: Array.isArray(response.variables) ? response.variables : [],
+                truncated: response.truncated,
+                error: asErrorSummary(response.error),
+            };
+        }
+        catch (error) {
+            return { status: "failed", sessionId: "", variables: [], error: errorSummary(error) };
+        }
+    }
+    async interrupt() {
+        if (!this.isAlive())
+            return { status: "failed", sessionId: "", message: "Runtime worker is not alive" };
+        this.child.kill("SIGINT");
+        return { status: "ok", sessionId: "", message: "Sent SIGINT to runtime worker" };
+    }
+    async close(force = false) {
+        if (!this.isAlive())
+            return;
+        if (force) {
+            this.child.kill("SIGKILL");
+            return;
+        }
+        try {
+            await this.request("shutdown", {}, 1000);
+        }
+        catch {
+            this.child.kill("SIGTERM");
+        }
+    }
+    waitReady(timeoutMs) {
+        return new Promise((resolveWait, rejectWait) => {
+            const timer = setTimeout(() => rejectWait(new Error(`Timed out waiting for Node runtime worker. ${this.diagnostics}`)), timeoutMs);
+            this.readyPromise.then(() => {
+                clearTimeout(timer);
+                resolveWait();
+            }, (error) => {
+                clearTimeout(timer);
+                rejectWait(error);
+            });
+        });
+    }
+    request(type, payload, timeoutMs) {
+        if (!this.isAlive())
+            return Promise.reject(new Error("Runtime worker is not alive"));
+        const id = `req_${++this.requestCounter}`;
+        return new Promise((resolveRequest, rejectRequest) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                rejectRequest(new TimeoutError(`Runtime request ${type} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve: resolveRequest, reject: rejectRequest, timer });
+            this.child.stdin.write(`${JSON.stringify({ id, type, ...payload })}\n`);
+        });
+    }
+    handleLine(line) {
+        let response;
+        try {
+            response = JSON.parse(line);
+        }
+        catch {
+            this.alive = false;
+            this.rejectAll(new Error(`Invalid runtime worker protocol line: ${line}`));
+            this.child.kill("SIGTERM");
+            return;
+        }
+        if (response.id === "ready" && response.status === "ready") {
+            this.readyResolve();
+            return;
+        }
+        const id = typeof response.id === "string" ? response.id : undefined;
+        if (!id)
+            return;
+        const pending = this.pending.get(id);
+        if (!pending)
+            return;
+        this.pending.delete(id);
+        clearTimeout(pending.timer);
+        pending.resolve(response);
+    }
+    rejectAll(error) {
+        for (const [id, pending] of this.pending.entries()) {
+            this.pending.delete(id);
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+    }
+}
+function normalizeExecStatus(response) {
+    if (response.status === "ok")
+        return "ok";
+    const message = response.error?.message ?? "";
+    return message.includes("Script execution timed out") ? "timeout" : "error";
+}
+class TimeoutError extends Error {
+}