@pasko70/pibo 1.9.8 → 1.9.9

package/dist/tools/cdp-client.js

@@ -1,189 +0,0 @@
-export const DEFAULT_CDP_URL = "http://127.0.0.1:56663";
-export const DEFAULT_CDP_TIMEOUT_MS = 2_500;
-export class CdpClient {
-    webSocketUrl;
-    nextId = 0;
-    pending = new Map();
-    socket;
-    constructor(webSocketUrl) {
-        this.webSocketUrl = webSocketUrl;
-    }
-    connect(timeoutMs = 3_000) {
-        return new Promise((resolve, reject) => {
-            const socket = new WebSocket(this.webSocketUrl);
-            this.socket = socket;
-            let settled = false;
-            const timer = setTimeout(() => fail(new Error("Timed out connecting to CDP target")), timeoutMs);
-            const settle = () => {
-                if (settled)
-                    return false;
-                settled = true;
-                clearTimeout(timer);
-                return true;
-            };
-            const succeed = () => {
-                if (settle())
-                    resolve();
-            };
-            const fail = (error) => {
-                if (settle())
-                    reject(error);
-            };
-            socket.addEventListener("open", succeed);
-            socket.addEventListener("message", (event) => this.handleMessage(String(event.data)));
-            socket.addEventListener("error", () => fail(new Error(`CDP WebSocket error connecting to ${this.webSocketUrl}`)));
-            socket.addEventListener("close", () => {
-                for (const [id, pending] of this.pending) {
-                    clearTimeout(pending.timer);
-                    pending.reject(new Error("CDP target closed"));
-                    this.pending.delete(id);
-                }
-            });
-        });
-    }
-    send(method, params, timeoutMs = 10_000) {
-        if (!this.socket || this.socket.readyState !== WebSocket.OPEN)
-            throw new Error("CDP target is not connected");
-        const id = ++this.nextId;
-        const payload = params ? { id, method, params } : { id, method };
-        const promise = new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`Timed out waiting for CDP method ${method}`));
-            }, timeoutMs);
-            this.pending.set(id, { resolve, reject, timer });
-        });
-        this.socket.send(JSON.stringify(payload));
-        return promise;
-    }
-    async evaluate(expression, timeoutMs = 10_000) {
-        const response = await this.send("Runtime.evaluate", {
-            expression,
-            awaitPromise: true,
-            returnByValue: true,
-            userGesture: true,
-        }, timeoutMs);
-        if (response.exceptionDetails)
-            throw new Error(`Browser evaluation failed: ${JSON.stringify(response.exceptionDetails)}`);
-        return response.result?.value;
-    }
-    close() {
-        try {
-            this.socket?.close();
-        }
-        catch {
-            // ignore close races
-        }
-    }
-    handleMessage(raw) {
-        let message;
-        try {
-            message = JSON.parse(raw);
-        }
-        catch {
-            return;
-        }
-        if (typeof message.id !== "number")
-            return;
-        const pending = this.pending.get(message.id);
-        if (!pending)
-            return;
-        clearTimeout(pending.timer);
-        this.pending.delete(message.id);
-        if (message.error) {
-            pending.reject(new Error(message.error.message ?? JSON.stringify(message.error)));
-            return;
-        }
-        pending.resolve(message.result);
-    }
-}
-export function normalizeCdpUrlSync(value) {
-    return value.replace(/\/+$/, "");
-}
-export async function fetchWithTimeout(url, timeoutMs, init = {}) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        return await fetch(url, { ...init, signal: controller.signal });
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to fetch ${url}: ${reason}`);
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-export async function listCdpTargets(options = {}) {
-    const cdpUrl = normalizeCdpUrlSync(options.cdpUrl ?? DEFAULT_CDP_URL);
-    try {
-        const response = await fetchWithTimeout(`${cdpUrl}/json/list`, options.timeoutMs ?? DEFAULT_CDP_TIMEOUT_MS);
-        if (!response.ok) {
-            throw new Error(`Chrome target discovery responded with HTTP ${response.status} ${response.statusText}`);
-        }
-        const payload = await response.json();
-        if (!Array.isArray(payload))
-            throw new Error("Chrome target discovery returned invalid JSON");
-        return payload.map(normalizeCdpTarget);
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.startsWith("Failed to fetch")) {
-            throw new Error(`CDP endpoint ${cdpUrl} is unreachable. Is Chrome running with remote debugging? (${error.message})`);
-        }
-        throw error;
-    }
-}
-export async function openCdpTarget(url, options = {}) {
-    const cdpUrl = normalizeCdpUrlSync(options.cdpUrl ?? DEFAULT_CDP_URL);
-    const timeoutMs = options.timeoutMs ?? DEFAULT_CDP_TIMEOUT_MS;
-    const endpoint = `${cdpUrl}/json/new?${encodeURIComponent(url)}`;
-    try {
-        let response = await fetchWithTimeout(endpoint, timeoutMs, { method: "PUT" });
-        if (response.status === 404 || response.status === 405) {
-            response = await fetchWithTimeout(endpoint, timeoutMs);
-        }
-        if (!response.ok)
-            throw new Error(`Chrome target creation responded with HTTP ${response.status} ${response.statusText}`);
-        const payload = await response.json();
-        return normalizeCdpTarget(payload);
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.startsWith("Failed to fetch")) {
-            throw new Error(`CDP endpoint ${cdpUrl} is unreachable. Is Chrome running with remote debugging? (${error.message})`);
-        }
-        throw error;
-    }
-}
-export function findCdpTarget(targets, targetIdOrUrl) {
-    return targets.find((target) => target.id === targetIdOrUrl || target.url === targetIdOrUrl || target.title === targetIdOrUrl || target.webSocketDebuggerUrl === targetIdOrUrl);
-}
-export async function connectCdpTarget(target, timeoutMs = 3_000) {
-    if (!target.webSocketDebuggerUrl)
-        throw new Error(`CDP target ${target.id || target.url} is not attachable (no webSocketDebuggerUrl)`);
-    const client = new CdpClient(target.webSocketDebuggerUrl);
-    try {
-        await client.connect(timeoutMs);
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to connect to CDP target ${target.id || target.url}: ${reason}`);
-    }
-    return client;
-}
-function normalizeCdpTarget(target) {
-    const record = target && typeof target === "object" && !Array.isArray(target) ? target : {};
-    return {
-        id: stringValue(record.id),
-        type: stringValue(record.type),
-        title: stringValue(record.title),
-        url: stringValue(record.url),
-        webSocketDebuggerUrl: optionalStringValue(record.webSocketDebuggerUrl),
-    };
-}
-function stringValue(value) {
-    return typeof value === "string" ? value : "";
-}
-function optionalStringValue(value) {
-    const text = stringValue(value);
-    return text || undefined;
-}

package/dist/tools/codex-compat.js

@@ -1,85 +0,0 @@
-import { spawn } from "node:child_process";
-import { readFile } from "node:fs/promises";
-import { extname, isAbsolute, resolve } from "node:path";
-import { StringEnum, Type } from "@earendil-works/pi-ai";
-import { defineTool } from "@earendil-works/pi-coding-agent";
-function resolveCwd(baseCwd, workdir) {
-    if (!workdir || workdir.trim().length === 0)
-        return baseCwd;
-    return isAbsolute(workdir) ? workdir : resolve(baseCwd, workdir);
-}
-function mimeTypeForPath(path) {
-    switch (extname(path).toLowerCase()) {
-        case ".jpg":
-        case ".jpeg":
-            return "image/jpeg";
-        case ".webp":
-            return "image/webp";
-        case ".gif":
-            return "image/gif";
-        default:
-            return "image/png";
-    }
-}
-export function createCodexCompatToolDefinitions() {
-    const applyPatch = defineTool({
-        name: "apply_patch",
-        label: "Apply Patch",
-        description: "Applies a Codex-style patch to files in the workspace.",
-        promptSnippet: "Use apply_patch for manual file edits by passing the complete patch text.",
-        executionMode: "sequential",
-        parameters: Type.Object({
-            patch: Type.String({ description: "Patch text starting with *** Begin Patch and ending with *** End Patch." }),
-            workdir: Type.Optional(Type.String({ description: "Working directory. Defaults to the runtime cwd." })),
-        }),
-        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-            const cwd = resolveCwd(ctx.cwd, params.workdir);
-            const result = await new Promise((resolveApply, reject) => {
-                const child = spawn("apply_patch", [], { cwd, env: process.env, stdio: "pipe" });
-                let output = "";
-                const abort = () => child.kill("SIGTERM");
-                signal?.addEventListener("abort", abort, { once: true });
-                child.stdout.on("data", (chunk) => {
-                    output += String(chunk);
-                });
-                child.stderr.on("data", (chunk) => {
-                    output += String(chunk);
-                });
-                child.once("error", reject);
-                child.once("close", (exitCode) => {
-                    signal?.removeEventListener("abort", abort);
-                    resolveApply({ exitCode, output });
-                });
-                child.stdin.end(params.patch);
-            });
-            return {
-                content: [{ type: "text", text: result.output }],
-                details: { exitCode: result.exitCode, cwd },
-                isError: result.exitCode !== 0,
-            };
-        },
-    });
-    const viewImage = defineTool({
-        name: "view_image",
-        label: "View Image",
-        description: "Reads a local image file and returns it as an inline image result.",
-        promptSnippet: "Use view_image to inspect a local image path when visual details matter.",
-        executionMode: "parallel",
-        parameters: Type.Object({
-            path: Type.String({ description: "Local filesystem path to an image file." }),
-            detail: Type.Optional(StringEnum(["original"], { description: "Use original resolution when set." })),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-            const path = resolveCwd(ctx.cwd, params.path);
-            const data = await readFile(path);
-            return {
-                content: [{ type: "image", data: data.toString("base64"), mimeType: mimeTypeForPath(path) }],
-                details: { path, detail: params.detail },
-            };
-        },
-    });
-    return [
-        applyPatch,
-        viewImage,
-    ];
-}

package/dist/tools/codex-image-generation.js

@@ -1,272 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { platform, release, arch } from "node:os";
-import { dirname, extname, isAbsolute, join, resolve } from "node:path";
-import { AuthStorage } from "@earendil-works/pi-coding-agent";
-import { Type } from "@earendil-works/pi-ai";
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { getPiboHome } from "../core/pibo-home.js";
-const OPENAI_CODEX_PROVIDER = "openai-codex";
-const DEFAULT_CODEX_BACKEND_BASE_URL = "https://chatgpt.com/backend-api";
-const CODEX_IMAGE_MODEL = "gpt-image-2";
-const MAX_EDIT_IMAGES = 5;
-const OPENAI_JWT_CLAIM_PATH = "https://api.openai.com/auth";
-function trimTrailingSlashes(value) {
-    return value.replace(/\/+$/, "");
-}
-export function resolveCodexImageUrl(operation, baseUrl) {
-    const raw = baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BACKEND_BASE_URL;
-    let normalized = trimTrailingSlashes(raw.trim());
-    if (normalized.endsWith("/codex/responses"))
-        normalized = normalized.slice(0, -"/responses".length);
-    if (!normalized.endsWith("/codex"))
-        normalized = `${normalized}/codex`;
-    return `${normalized}/images/${operation}`;
-}
-function decodeJwtPayload(token) {
-    try {
-        const payload = token.split(".")[1];
-        if (!payload)
-            return undefined;
-        const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
-        const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
-        const parsed = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function getOpenAiAccountId(accessToken, storedAccountId) {
-    if (typeof storedAccountId === "string" && storedAccountId.trim().length > 0)
-        return storedAccountId;
-    const payload = decodeJwtPayload(accessToken);
-    const auth = payload?.[OPENAI_JWT_CLAIM_PATH];
-    if (!auth || typeof auth !== "object" || Array.isArray(auth))
-        return undefined;
-    const accountId = auth.chatgpt_account_id;
-    return typeof accountId === "string" && accountId.trim().length > 0 ? accountId : undefined;
-}
-async function getCodexImageAuth() {
-    const authStorage = AuthStorage.create();
-    const credential = authStorage.get(OPENAI_CODEX_PROVIDER);
-    if (credential?.type !== "oauth") {
-        throw new Error("codex_image_generation requires ChatGPT/Codex OAuth login for provider openai-codex. Use the existing OpenAI Codex login flow; API keys are not supported for this tool.");
-    }
-    const accessToken = await authStorage.getApiKey(OPENAI_CODEX_PROVIDER, { includeFallback: false });
-    if (!accessToken) {
-        throw new Error("codex_image_generation could not load a ChatGPT/Codex OAuth access token for provider openai-codex. Please log in again with the OpenAI Codex login flow.");
-    }
-    const accountId = getOpenAiAccountId(accessToken, credential.accountId);
-    if (!accountId) {
-        throw new Error("codex_image_generation could not resolve the ChatGPT account id from the openai-codex OAuth credential. Please log in again with the OpenAI Codex login flow.");
-    }
-    return { accessToken, accountId };
-}
-function mimeTypeForPath(path) {
-    switch (extname(path).toLowerCase()) {
-        case ".jpg":
-        case ".jpeg":
-            return "image/jpeg";
-        case ".webp":
-            return "image/webp";
-        case ".gif":
-            return "image/gif";
-        default:
-            return "image/png";
-    }
-}
-function resolveCwd(baseCwd, path) {
-    return isAbsolute(path) ? path : resolve(baseCwd, path);
-}
-function isImageContent(value) {
-    return Boolean(value)
-        && typeof value === "object"
-        && value.type === "image"
-        && typeof value.data === "string"
-        && typeof value.mimeType === "string";
-}
-function imageContentToDataUrl(image) {
-    if (image.data.startsWith("data:"))
-        return image.data;
-    return `data:${image.mimeType};base64,${image.data}`;
-}
-async function imageFileToDataUrl(cwd, path) {
-    const resolved = resolveCwd(cwd, path);
-    const data = await readFile(resolved);
-    return `data:${mimeTypeForPath(resolved)};base64,${data.toString("base64")}`;
-}
-function contentFromSessionEntry(entry) {
-    if (!entry || typeof entry !== "object")
-        return undefined;
-    const record = entry;
-    if (record.type === "message") {
-        const message = record.message;
-        return message && typeof message === "object" ? message.content : undefined;
-    }
-    if (record.type === "custom_message")
-        return record.content;
-    return undefined;
-}
-function recentImagesFromSessionEntries(entries, count) {
-    const images = [];
-    for (const entry of [...entries].reverse()) {
-        const content = contentFromSessionEntry(entry);
-        if (!Array.isArray(content))
-            continue;
-        for (const item of [...content].reverse()) {
-            if (!isImageContent(item))
-                continue;
-            images.push(imageContentToDataUrl(item));
-            if (images.length === count)
-                break;
-        }
-        if (images.length === count)
-            break;
-    }
-    images.reverse();
-    return images.map((image_url) => ({ image_url }));
-}
-function validateImageArgs(params) {
-    if (params.prompt.trim().length === 0)
-        throw new Error("`prompt` must not be empty.");
-    const pathCount = params.referenced_image_paths?.length ?? 0;
-    if (pathCount > MAX_EDIT_IMAGES)
-        throw new Error(`\`referenced_image_paths\` must contain at most ${MAX_EDIT_IMAGES} paths.`);
-    if (pathCount > 0 && params.num_last_images_to_include !== undefined) {
-        throw new Error("Provide only one of `referenced_image_paths` or `num_last_images_to_include`.");
-    }
-    if (params.num_last_images_to_include !== undefined) {
-        if (!Number.isInteger(params.num_last_images_to_include) || params.num_last_images_to_include < 1 || params.num_last_images_to_include > MAX_EDIT_IMAGES) {
-            throw new Error(`\`num_last_images_to_include\` must be an integer between 1 and ${MAX_EDIT_IMAGES}.`);
-        }
-    }
-}
-function sanitizePathPart(value) {
-    return value.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 120) || "unknown";
-}
-function artifactPath(sessionId, toolCallId) {
-    const safeSessionId = sanitizePathPart(sessionId?.trim() || "local");
-    const safeToolCallId = sanitizePathPart(toolCallId || `image_${Date.now()}`);
-    const artifactId = `${safeSessionId}/${safeToolCallId}.png`;
-    return {
-        artifactId,
-        savedPath: join(getPiboHome(), "generated_images", safeSessionId, `${safeToolCallId}.png`),
-    };
-}
-async function saveGeneratedImage(sessionId, toolCallId, b64Json) {
-    const target = artifactPath(sessionId, toolCallId);
-    await mkdir(dirname(target.savedPath), { recursive: true });
-    await writeFile(target.savedPath, Buffer.from(b64Json.trim(), "base64"));
-    return target;
-}
-function truncateErrorBody(text) {
-    const compact = text.replace(/\s+/g, " ").trim();
-    return compact.length > 1000 ? `${compact.slice(0, 1000)}…` : compact;
-}
-async function postCodexImageRequest(operation, body, auth, signal, baseUrl) {
-    const url = resolveCodexImageUrl(operation, baseUrl);
-    const response = await fetch(url, {
-        method: "POST",
-        signal,
-        headers: {
-            Authorization: `Bearer ${auth.accessToken}`,
-            "chatgpt-account-id": auth.accountId,
-            originator: "pi",
-            "User-Agent": `pibo (${platform()} ${release()}; ${arch()})`,
-            Accept: "application/json",
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify(body),
-    });
-    if (!response.ok) {
-        const text = await response.text().catch(() => "");
-        throw new Error(`Codex image ${operation} request failed: ${response.status}${text ? ` ${truncateErrorBody(text)}` : ""}`);
-    }
-    return await response.json();
-}
-function firstImageB64(response) {
-    const b64 = response.data?.[0]?.b64_json;
-    if (!b64 || typeof b64 !== "string")
-        throw new Error("Codex image generation returned no image data.");
-    return b64;
-}
-function createRequest(prompt, images) {
-    return {
-        ...(images && images.length > 0 ? { images } : {}),
-        prompt,
-        background: "auto",
-        model: CODEX_IMAGE_MODEL,
-        quality: "auto",
-        size: "auto",
-    };
-}
-async function collectEditImages(params, cwd, sessionEntries) {
-    const paths = params.referenced_image_paths ?? [];
-    if (paths.length > 0) {
-        return await Promise.all(paths.map(async (path) => ({ image_url: await imageFileToDataUrl(cwd, path) })));
-    }
-    if (params.num_last_images_to_include !== undefined) {
-        const images = recentImagesFromSessionEntries(sessionEntries, params.num_last_images_to_include);
-        if (images.length !== params.num_last_images_to_include) {
-            throw new Error(`Requested the last ${params.num_last_images_to_include} conversation images, but only ${images.length} were available.`);
-        }
-        return images;
-    }
-    return [];
-}
-export function createCodexImageGenerationToolDefinition(context = {}, options = {}) {
-    return defineTool({
-        name: "codex_image_generation",
-        label: "Codex Image Generation",
-        description: "Generates or edits images through the ChatGPT/Codex backend API using openai-codex OAuth entitlement. Does not use the public OpenAI Images API.",
-        promptSnippet: "Use codex_image_generation to create an image from a prompt, or to edit referenced/recent images with the Codex/ChatGPT image backend.",
-        promptGuidelines: [
-            "Use codex_image_generation for image generation and image edits when the user asks for pictures, visual variants, or edits to existing images.",
-            "For edits, pass either referenced_image_paths for local image files or num_last_images_to_include for recent conversation images, but not both.",
-        ],
-        executionMode: "sequential",
-        parameters: Type.Object({
-            prompt: Type.String({ description: "Image generation/editing prompt. Be specific about the desired final image." }),
-            referenced_image_paths: Type.Optional(Type.Array(Type.String({ description: "Local filesystem image path to edit." }), { description: `Optional local image paths to edit. At most ${MAX_EDIT_IMAGES}.` })),
-            num_last_images_to_include: Type.Optional(Type.Number({ description: `Use the last N conversation images as edit references. Must be between 1 and ${MAX_EDIT_IMAGES}.` })),
-        }),
-        async execute(toolCallId, params, signal, _onUpdate, ctx) {
-            validateImageArgs(params);
-            const images = await collectEditImages(params, ctx.cwd, ctx.sessionManager.getBranch());
-            const operation = images.length > 0 ? "edit" : "generate";
-            const endpoint = operation === "edit" ? "edits" : "generations";
-            const auth = await getCodexImageAuth();
-            const response = await postCodexImageRequest(endpoint, createRequest(params.prompt, images), auth, signal, options.baseUrl);
-            const result = firstImageB64(response);
-            const saved = await saveGeneratedImage(context.piboSessionId, toolCallId, result);
-            const details = {
-                provider: OPENAI_CODEX_PROVIDER,
-                api: "codex-chatgpt-images",
-                operation,
-                model: CODEX_IMAGE_MODEL,
-                savedPath: saved.savedPath,
-                artifactId: saved.artifactId,
-                referencedImageCount: images.length,
-                endpoint,
-                created: response.created,
-                background: response.background,
-                quality: response.quality,
-                size: response.size,
-            };
-            return {
-                content: [
-                    { type: "image", data: result, mimeType: "image/png" },
-                    { type: "text", text: `Generated image saved to ${saved.savedPath}` },
-                ],
-                details,
-            };
-        },
-    });
-}
-export function createCodexImageGenerationToolProfile() {
-    return {
-        name: "codex_image_generation",
-        description: "Generate and edit images through the ChatGPT/Codex backend API using openai-codex OAuth.",
-        createDefinition: createCodexImageGenerationToolDefinition,
-    };
-}

package/dist/tools/desktop-env.js

@@ -1,99 +0,0 @@
-import { existsSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-export function hasDesktopDisplay(desktop) {
-    return Boolean(desktop.display || desktop.waylandDisplay);
-}
-function getRuntimeDir() {
-    if (process.env.XDG_RUNTIME_DIR)
-        return process.env.XDG_RUNTIME_DIR;
-    if (typeof process.getuid !== 'function')
-        return undefined;
-    return `/run/user/${process.getuid()}`;
-}
-function findXDisplay() {
-    if (process.env.DISPLAY)
-        return process.env.DISPLAY;
-    if (!existsSync('/tmp/.X11-unix/X0'))
-        return undefined;
-    return ':0';
-}
-function findWaylandDisplay(runtimeDir) {
-    if (process.env.WAYLAND_DISPLAY)
-        return process.env.WAYLAND_DISPLAY;
-    if (!runtimeDir)
-        return undefined;
-    if (existsSync(join(runtimeDir, 'wayland-0')))
-        return 'wayland-0';
-    return undefined;
-}
-function findXauthority(runtimeDir) {
-    if (process.env.XAUTHORITY)
-        return process.env.XAUTHORITY;
-    if (!runtimeDir || !existsSync(runtimeDir))
-        return undefined;
-    let authFile;
-    try {
-        authFile = readdirSync(runtimeDir).find((name) => name.startsWith('.mutter-Xwaylandauth.'));
-    }
-    catch {
-        return undefined;
-    }
-    return authFile ? join(runtimeDir, authFile) : undefined;
-}
-export function detectDesktopEnv() {
-    if (process.platform !== 'linux')
-        return {};
-    const xdgRuntimeDir = getRuntimeDir();
-    const display = findXDisplay();
-    const waylandDisplay = findWaylandDisplay(xdgRuntimeDir);
-    const xauthority = findXauthority(xdgRuntimeDir);
-    const dbusPath = xdgRuntimeDir ? join(xdgRuntimeDir, 'bus') : undefined;
-    const dbusSessionBusAddress = process.env.DBUS_SESSION_BUS_ADDRESS ??
-        (dbusPath && existsSync(dbusPath) ? `unix:path=${dbusPath}` : undefined);
-    return {
-        display,
-        waylandDisplay,
-        xauthority,
-        xdgRuntimeDir,
-        dbusSessionBusAddress,
-    };
-}
-export function getDesktopProcessEnv() {
-    const desktop = detectDesktopEnv();
-    const env = {};
-    if (desktop.display)
-        env.DISPLAY = desktop.display;
-    if (desktop.waylandDisplay)
-        env.WAYLAND_DISPLAY = desktop.waylandDisplay;
-    if (desktop.xauthority)
-        env.XAUTHORITY = desktop.xauthority;
-    if (desktop.xdgRuntimeDir)
-        env.XDG_RUNTIME_DIR = desktop.xdgRuntimeDir;
-    if (desktop.dbusSessionBusAddress)
-        env.DBUS_SESSION_BUS_ADDRESS = desktop.dbusSessionBusAddress;
-    return env;
-}
-export function printDesktopEnvStatus(indent = '  ') {
-    const desktop = detectDesktopEnv();
-    if (hasDesktopDisplay(desktop)) {
-        const parts = [
-            desktop.display ? `DISPLAY=${desktop.display}` : undefined,
-            desktop.waylandDisplay ? `WAYLAND_DISPLAY=${desktop.waylandDisplay}` : undefined,
-            desktop.xauthority ? `XAUTHORITY=${desktop.xauthority}` : undefined,
-        ].filter(Boolean);
-        console.log(`${indent}desktop: detected (${parts.join(', ')})`);
-        console.log(`${indent}headed browser: available after applying pibo tools env`);
-        return;
-    }
-    console.log(`${indent}desktop: not detected`);
-    console.log(`${indent}warning: headed browser mode is unavailable; use headless mode or start a desktop display first.`);
-}
-export function printLinuxVirtualDisplayHint(indent = '  ') {
-    if (process.platform !== 'linux')
-        return;
-    console.log(`${indent}linux headed browser hint:`);
-    console.log(`${indent}  Install a virtual X display if this host has no desktop session.`);
-    console.log(`${indent}  Ubuntu/Debian: sudo apt update && sudo apt install -y xvfb xauth x11-xserver-utils`);
-    console.log(`${indent}  Start one display: Xvfb :0 -screen 0 1920x1080x24 -ac -nolisten tcp`);
-    console.log(`${indent}  Then export DISPLAY=:0 before running browser-use.`);
-}