@pasko70/pibo 1.9.7 → 1.9.9

package/dist/tools/linux-virtual-display.js

@@ -1,58 +0,0 @@
-import { existsSync } from 'node:fs';
-import { writeFile } from 'node:fs/promises';
-import { detectDesktopEnv, hasDesktopDisplay, printLinuxVirtualDisplayHint } from './desktop-env.js';
-export const PIBO_XVFB_SERVICE_NAME = 'pibo-xvfb.service';
-export const PIBO_XVFB_SERVICE_PATH = `/etc/systemd/system/${PIBO_XVFB_SERVICE_NAME}`;
-export function createPiboXvfbServiceUnit() {
-    return [
-        '[Unit]',
-        'Description=Virtual X display for Pibo browser automation',
-        'After=network.target',
-        '',
-        '[Service]',
-        'Type=simple',
-        'ExecStart=/usr/bin/Xvfb :0 -screen 0 1920x1080x24 -ac -nolisten tcp',
-        'Restart=always',
-        'RestartSec=2',
-        '',
-        '[Install]',
-        'WantedBy=multi-user.target',
-        '',
-    ].join('\n');
-}
-function isRootUser() {
-    return typeof process.getuid === 'function' && process.getuid() === 0;
-}
-async function waitForDisplaySocket(timeoutMs = 5000) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (existsSync('/tmp/.X11-unix/X0'))
-            return true;
-        await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    return existsSync('/tmp/.X11-unix/X0');
-}
-export async function ensureLinuxVirtualDisplay(options) {
-    if (process.platform !== 'linux')
-        return false;
-    if (hasDesktopDisplay(detectDesktopEnv()))
-        return false;
-    if (!isRootUser()) {
-        console.log('No desktop display detected and automatic virtual display setup requires root.');
-        printLinuxVirtualDisplayHint('  ');
-        return false;
-    }
-    console.log('No desktop display detected. Provisioning virtual X display for browser-use.');
-    await options.runInherited('apt-get', ['update']);
-    await options.runInherited('apt-get', ['install', '-y', 'xvfb', 'xauth', 'x11-xserver-utils']);
-    await writeFile(PIBO_XVFB_SERVICE_PATH, createPiboXvfbServiceUnit(), 'utf8');
-    await options.runInherited('systemctl', ['daemon-reload']);
-    await options.runInherited('systemctl', ['enable', '--now', PIBO_XVFB_SERVICE_NAME]);
-    process.env.DISPLAY = ':0';
-    const ready = await waitForDisplaySocket();
-    if (!ready) {
-        throw new Error('Virtual X display service was installed but DISPLAY :0 did not become ready.');
-    }
-    console.log('Virtual X display ready on DISPLAY=:0');
-    return true;
-}

package/dist/tools/npm-runtime.js

@@ -1,136 +0,0 @@
-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/python-runtime.js

@@ -1,183 +0,0 @@
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { mkdir, rm } 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 getToolPythonRuntimePaths(name, spec) {
-    const rootDir = join(getPiboHome(), 'tools', name);
-    const homeDir = join(rootDir, 'home');
-    const venvDir = join(rootDir, '.venv');
-    const binDir = join(venvDir, process.platform === 'win32' ? 'Scripts' : 'bin');
-    const executable = process.platform === 'win32'
-        ? `${spec.executableName}.exe`
-        : spec.executableName;
-    return {
-        rootDir,
-        homeDir,
-        venvDir,
-        binDir,
-        pythonPath: join(binDir, process.platform === 'win32' ? 'python.exe' : 'python'),
-        executablePath: join(binDir, executable),
-    };
-}
-export function getToolPythonRuntimeEnv(paths, spec) {
-    const env = { ...process.env, ...getDesktopProcessEnv() };
-    env.PATH = `${paths.binDir}:${join(paths.homeDir, 'bin')}:${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 isRootUser() {
-    return typeof process.getuid === 'function' && process.getuid() === 0;
-}
-async function resolveUvCommand() {
-    const uv = await runBuffered('uv', ['--version']);
-    if (uv.ok)
-        return 'uv';
-    const localUv = join(homedir(), '.local', 'bin', 'uv');
-    if (existsSync(localUv)) {
-        const local = await runBuffered(localUv, ['--version']);
-        if (local.ok)
-            return localUv;
-    }
-    if (process.platform === 'linux' && isRootUser()) {
-        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'], {
-            ...process.env,
-            PATH: `${join(homedir(), '.local', 'bin')}:${process.env.PATH ?? ''}`,
-        });
-        if (installed.ok)
-            return localUv;
-    }
-    return undefined;
-}
-export function runInheritedCommand(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 uv 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 setup error above, then rerun the install command.',
-            })));
-        });
-    });
-}
-export async function printToolPythonRuntimeDoctor(name, spec) {
-    const paths = getToolPythonRuntimePaths(name, spec);
-    const uvCommand = await resolveUvCommand();
-    const uv = uvCommand ? await runBuffered(uvCommand, ['--version']) : { ok: false, output: 'missing' };
-    const python = uv.ok
-        ? await runBuffered(uvCommand, ['python', 'find', spec.pythonVersion])
-        : { ok: false, output: 'skipped because uv is missing' };
-    console.log(`${name}`);
-    console.log(`  uv: ${uv.ok ? uv.output || 'ok' : `missing (${uv.output})`}`);
-    console.log(`  python ${spec.pythonVersion}: ${python.ok ? python.output || 'ok' : `missing (${python.output})`}`);
-    console.log(`  runtime: ${paths.rootDir}`);
-    console.log(`  home: ${paths.homeDir}`);
-    console.log(`  venv: ${existsSync(paths.venvDir) ? 'present' : 'missing'}`);
-    console.log(`  executable: ${existsSync(paths.executablePath) ? paths.executablePath : 'missing'}`);
-    printDesktopEnvStatus('  ');
-    if (name === 'browser-use' && process.platform === 'linux' && !hasDesktopDisplay(detectDesktopEnv())) {
-        printLinuxVirtualDisplayHint('  ');
-    }
-    if (existsSync(paths.executablePath) && spec.doctorArgs?.length) {
-        const doctor = await runBuffered(paths.executablePath, spec.doctorArgs, getToolPythonRuntimeEnv(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 (!uv.ok) {
-        console.log('');
-        console.log('Install uv first:');
-        console.log('  macOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh');
-        console.log('  Windows PowerShell: irm https://astral.sh/uv/install.ps1 | iex');
-    }
-    if (uv.ok && !python.ok) {
-        console.log('');
-        console.log(`Install Python ${spec.pythonVersion}+ first:`);
-        console.log('  Ubuntu/Debian: sudo apt update && sudo apt install -y python3 python3-venv');
-        console.log('  macOS: brew install python');
-        console.log('  Windows PowerShell: winget install Python.Python.3.12');
-        console.log('');
-        console.log('Then rerun:');
-        console.log(`  pibo tools doctor ${name}`);
-    }
-}
-export async function installToolPythonRuntime(name, spec) {
-    const uvCommand = await resolveUvCommand();
-    if (!uvCommand) {
-        throw new Error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'CLI_TOOL_UV_MISSING',
-            message: 'uv was not found on PATH',
-            details: 'spawn uv ENOENT',
-            suggestion: 'Install uv first. macOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh. Windows PowerShell: irm https://astral.sh/uv/install.ps1 | iex.',
-        }));
-    }
-    const paths = getToolPythonRuntimePaths(name, spec);
-    await mkdir(paths.rootDir, { recursive: true });
-    await mkdir(paths.homeDir, { recursive: true });
-    if (!existsSync(paths.venvDir)) {
-        await runInheritedCommand(uvCommand, ['venv', paths.venvDir, '--python', spec.pythonVersion]);
-    }
-    await runInheritedCommand(uvCommand, [
-        'pip',
-        'install',
-        '--python',
-        paths.pythonPath,
-        spec.packageName,
-    ]);
-    if (spec.postInstallArgs?.length) {
-        await runInheritedCommand(paths.executablePath, spec.postInstallArgs, getToolPythonRuntimeEnv(paths, spec));
-    }
-    return paths;
-}
-export async function removeToolPythonRuntime(name, spec) {
-    const paths = getToolPythonRuntimePaths(name, spec);
-    await rm(paths.rootDir, { recursive: true, force: true });
-    console.log(`Removed runtime: ${paths.rootDir}`);
-}

package/dist/tools/registry.js

@@ -1,237 +0,0 @@
-import { existsSync } from 'node:fs';
-import { ensureAgentBrowserWrapper } from './agent-browser-wrapper.js';
-import { detectDesktopEnv, hasDesktopDisplay, printDesktopEnvStatus, printLinuxVirtualDisplayHint } from './desktop-env.js';
-import { AGENT_BROWSER_GUIDE, BROWSER_USE_GUIDE, GRAPHIFY_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';
-const REGISTRY = [
-    {
-        name: 'browser-use',
-        description: 'Browser automation CLI for web interaction, screenshots, and extraction.',
-        runtime: {
-            packageName: 'browser-use[cli]==0.12.6',
-            executableName: 'browser-use',
-            pythonVersion: '3.12',
-            homeEnvVar: 'BROWSER_USE_HOME',
-            doctorArgs: ['doctor'],
-        },
-        guides: [BROWSER_USE_GUIDE, REMOTE_BROWSER_GUIDE],
-        notes: [
-            'Installed on demand into an isolated Python virtual environment.',
-            'Pinned to browser-use 0.12.6 so the CLI surface matches the bundled guides.',
-            'The tool uses BROWSER_USE_HOME under the pibo tool runtime directory.',
-            'The pibo tool environment wraps browser-use so new browser sessions default to Pibo-managed persistent PIBo Chrome via CDP; pass --fresh-profile for a temporary profile.',
-            'Use pibo tools browser-use 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 browser-use)"`.',
-            '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: 'graphify',
-        description: 'Codebase visualization CLI that generates interactive knowledge graphs and reports.',
-        runtime: {
-            packageName: 'graphifyy',
-            executableName: 'graphify',
-            pythonVersion: '3.12',
-            postInstallArgs: ['install', '--platform', 'pi'],
-        },
-        guides: [GRAPHIFY_GUIDE],
-        notes: [
-            'Installed on demand into an isolated Python virtual environment from the graphifyy package.',
-            'The installer runs graphify install --platform pi after package installation so Graphify is ready for Pi/Pibo workflows.',
-            'Graphify writes generated graph artifacts under graphify-out/; prefer an ignored room/session artifact directory unless the user explicitly wants repo files.',
-            'Guides are available through pibo tools guide and are not loaded into pibo profiles automatically.',
-        ],
-        agentContextSnippet: [
-            'Codebase visualization CLI for graphify-out/graph.html, graph.json, and GRAPH_REPORT.md.',
-            'Start with `eval "$(npm run --silent dev -- tools env graphify)"`.',
-            'No LLM key: run `graphify .` on code, then `graphify cluster-only . --no-label`.',
-            'Guide: `npm run dev -- tools guide graphify graphify`.',
-        ].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();
-    if (snippet.length === 0) {
-        throw new Error(`CLI tool "${entry.name}" is missing agentContextSnippet`);
-    }
-    if (snippet.length > MAX_AGENT_CONTEXT_SNIPPET_LENGTH) {
-        throw new Error(`CLI tool "${entry.name}" agentContextSnippet exceeds ${MAX_AGENT_CONTEXT_SNIPPET_LENGTH} characters`);
-    }
-}
-export function listCliToolEntries() {
-    return REGISTRY;
-}
-export function findCliToolEntry(name) {
-    return REGISTRY.find((entry) => entry.name === name);
-}
-export function getCliToolStatus(entry) {
-    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),
-        executablePath: paths.executablePath,
-        rootDir: paths.rootDir,
-        homeDir: paths.homeDir,
-    };
-}
-export function findToolGuide(entry, guideName) {
-    return entry.guides.find((guide) => guide.name === guideName);
-}
-export function listInstalledCliToolAgentContexts() {
-    return REGISTRY
-        .filter((entry) => getCliToolStatus(entry).installed)
-        .map((entry) => ({
-        name: entry.name,
-        description: entry.description,
-        snippet: entry.agentContextSnippet,
-    }));
-}
-export function getInstalledCliToolContextFile() {
-    const installedEntries = listInstalledCliToolAgentContexts();
-    if (installedEntries.length === 0)
-        return undefined;
-    const sections = installedEntries.flatMap((entry) => [
-        `## ${entry.name}`,
-        entry.snippet,
-        '',
-    ]);
-    return {
-        path: INSTALLED_TOOLS_CONTEXT_PATH,
-        content: [
-            '# Installed Pibo Tools',
-            '',
-            'These curated CLI tools are installed in this environment. The CLI remains the source of truth; use the referenced commands to discover each workflow step by step.',
-            '',
-            ...sections,
-        ].join('\n').trimEnd(),
-    };
-}
-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' || entry.name === 'agent-browser') {
-            await ensureLinuxVirtualDisplay({ runInherited: runInheritedCommand });
-        }
-        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' || entry.name === 'agent-browser') && process.platform === 'linux' && !hasDesktopDisplay(detectDesktopEnv())) {
-        printLinuxVirtualDisplayHint('  ');
-    }
-    console.log(`  env: pibo tools env ${entry.name}`);
-}
-export async function removeCliTool(entry) {
-    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) {
-    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

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