npm - @pasko70/pibo - Versions diffs - 1.14.0 → 1.15.0 - Mend

@pasko70/pibo 1.14.0 → 1.15.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/dist/apps/chat-vscode-web/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<meta name="theme-color" content="#101d22" />
 		<title>Pibo</title>
-		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-R_7kgvvD.js"></script>
+		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-V_pKPVAm.js"></script>
 		<link rel="stylesheet" crossorigin href="/apps/chat-vscode/assets/index-Dupu1DzQ.css">
 	</head>
 	<body>

package/dist/apps/vscode-artifacts/latest.vsix CHANGED Viewed

Binary file

package/dist/apps/vscode-artifacts/{pibo-vscode-ext-1.14.0.vsix → pibo-vscode-ext-1.15.0.vsix} RENAMED Viewed

Binary file

package/dist/core/runtime.js CHANGED Viewed

@@ -25,6 +25,7 @@ import { registerOpenAiGpt56Models } from "../providers/openai-gpt56.js";
 import { PIBO_APP_CONTEXT } from "../app-context.js";
 import { createRuntimeToolDefinition } from "../tools/runtime/tool.js";
 import { RuntimeSessionRegistry } from "../tools/runtime/registry.js";
+import { CODEX_BROWSER_TOOL_NAMES, CodexBrowserSessionController, createCodexBrowserToolDefinitions, } from "../tools/codex-browser.js";
 import { compactValidationToolResultForContext } from "./test-output-compaction.js";
 import { installPiboTranscriptIntegrity } from "./transcript-integrity.js";
 function hasOwnRetrySetting(settings, key) {
@@ -102,12 +103,18 @@ function getEnabledSkillPaths(cwd, profile) {
         .filter((skill) => skill.enabled !== false)
         .map((skill) => resolveProfilePath(cwd, skill.path));
 }
-function getEnabledToolDefinitions(profile, options, subagentRunner, runToolController, runtimeToolController) {
+function getEnabledToolDefinitions(profile, options, subagentRunner, runToolController, runtimeToolController, codexBrowserController) {
     const runtimeProfileTool = profile.tools.find(isEnabledRuntimeTool);
     const runtimeTool = runtimeProfileTool && runtimeToolController
         ? createRuntimeToolDefinition(runtimeToolController)
         : undefined;
-    const profileTools = profile.tools.filter((tool) => !isRuntimeTool(tool)).filter(hasEnabledToolDefinition);
+    const selectedCodexBrowserToolNames = profile.tools
+        .filter(isEnabledCodexBrowserTool)
+        .map((tool) => tool.name);
+    const codexBrowserTools = codexBrowserController
+        ? createCodexBrowserToolDefinitions(codexBrowserController, selectedCodexBrowserToolNames)
+        : [];
+    const profileTools = profile.tools.filter((tool) => !isRuntimeTool(tool) && !isCodexBrowserTool(tool)).filter(hasEnabledToolDefinition);
     const profileToolDefinitions = profileTools.map((tool) => getToolDefinition(tool, options.toolContext));
     const codexCompatEnabled = profile.toolPackages.codexCompat === true;
     const runControlEnabled = profile.toolPackages.runControl === true;
@@ -129,6 +136,7 @@ function getEnabledToolDefinitions(profile, options, subagentRunner, runToolCont
         ...(runControlBashTool ? [runControlBashTool] : []),
         ...profileTools.filter((tool) => tool.yieldable !== false).map((tool) => getToolDefinition(tool, options.toolContext)),
         ...(runtimeTool && runtimeProfileTool?.yieldable !== false ? [runtimeTool] : []),
+        ...codexBrowserTools.filter((definition) => profile.tools.find((tool) => tool.name === definition.name)?.yieldable !== false),
         ...subagentTools,
         ...codexCompatTools,
     ];
@@ -139,6 +147,7 @@ function getEnabledToolDefinitions(profile, options, subagentRunner, runToolCont
         ...(runControlBashTool ? [runControlBashTool] : []),
         ...profileToolDefinitions,
         ...(runtimeTool ? [runtimeTool] : []),
+        ...codexBrowserTools,
         ...subagentTools,
         ...codexCompatTools,
         ...goalTools,
@@ -159,6 +168,12 @@ function isRuntimeTool(tool) {
 function isEnabledRuntimeTool(tool) {
     return tool.enabled !== false && isRuntimeTool(tool);
 }
+function isCodexBrowserTool(tool) {
+    return tool.builtInPiboTool === "codex_browser" || CODEX_BROWSER_TOOL_NAMES.includes(tool.name);
+}
+function isEnabledCodexBrowserTool(tool) {
+    return tool.enabled !== false && isCodexBrowserTool(tool);
+}
 function isGeneratedPiboTool(name) {
     return name === "runtime" || name.startsWith("pibo_subagent_") || name.startsWith("pibo_run_") || PIBO_GOAL_TOOL_NAMES.includes(name);
 }
@@ -280,6 +295,12 @@ export async function createPiboRuntime(options = {}) {
         const localRuntimeRegistry = ownsLocalRuntimeRegistry ? new RuntimeSessionRegistry({ cwd: runtimeCwd }) : undefined;
         const runtimeToolController = options.runtimeToolController
             ?? localRuntimeRegistry?.createController(profile.sessionId ?? "local");
+        const codexBrowserController = profile.tools.some(isEnabledCodexBrowserTool)
+            ? new CodexBrowserSessionController({
+                cwd: runtimeCwd,
+                piboSessionId: options.sessionContext?.piboSessionId ?? profile.sessionId ?? runtimeSessionManager.getSessionId(),
+            })
+            : undefined;
         const customTools = getEnabledToolDefinitions(profile, {
             runtimeCwd,
             shellCommandPrefix: services.settingsManager.getShellCommandPrefix(),
@@ -290,7 +311,7 @@ export async function createPiboRuntime(options = {}) {
                 profileName: profile.profileName,
                 getActiveMessage: options.sessionContext?.getActiveMessage,
             },
-        }, options.subagentRunner, options.runToolController, runtimeToolController);
+        }, options.subagentRunner, options.runToolController, runtimeToolController, codexBrowserController);
         const modelDefaults = options.modelDefaults ?? loadPiboModelDefaults(runtimeCwd);
         const created = await createAgentSessionFromServices({
             services,
@@ -324,6 +345,7 @@ export async function createPiboRuntime(options = {}) {
             if (localRuntimeRegistry) {
                 void localRuntimeRegistry.closeControllerSessions(profile.sessionId ?? "local", { force: true });
             }
+            void codexBrowserController?.dispose();
             originalDispose();
         };
         return {
@@ -444,8 +466,8 @@ export async function inspectPiboProfile(options = {}) {
             })),
             tools: profile.tools.map((tool) => ({
                 name: tool.name,
-                hasDefinition: Boolean(tool.definition) || Boolean(tool.createDefinition) || isRuntimeTool(tool),
-                registered: registeredToolNames.has(tool.name) || tool.providerTool !== undefined || isRuntimeTool(tool),
+                hasDefinition: Boolean(tool.definition) || Boolean(tool.createDefinition) || isRuntimeTool(tool) || isCodexBrowserTool(tool),
+                registered: registeredToolNames.has(tool.name) || tool.providerTool !== undefined || isRuntimeTool(tool) || isCodexBrowserTool(tool),
                 active: activeToolNames.has(tool.name) || tool.providerTool !== undefined,
             })).concat(generatedTools),
             subagents: profile.subagents.map((subagent) => {

package/dist/plugins/builtin.js CHANGED Viewed

@@ -4,6 +4,7 @@ import { createPiboGatewayToolProfiles } from "../gateway/tool.js";
 import { InitialSessionContextBuilder } from "../core/profiles.js";
 import { parsePiboThinkingLevel } from "../core/thinking.js";
 import { createWebSearchToolProfile } from "../tools/web-search.js";
+import { CODEX_BROWSER_TOOL_NAMES, createCodexBrowserToolProfiles } from "../tools/codex-browser.js";
 import { createRuntimeToolProfile } from "../tools/runtime/tool.js";
 import { completeLogin, getLoginStatus, removeLogin, setApiKey, startLogin } from "../auth/login-actions.js";
 import { loadModelCatalog } from "../apps/chat/model-catalog.js";
@@ -166,6 +167,12 @@ export const piboCorePlugin = definePiboPlugin({
         });
         api.registerTool(createWebSearchToolProfile());
         api.registerTool(createRuntimeToolProfile());
+        api.registerTools(createCodexBrowserToolProfiles());
+        api.registerCapabilityPackage({
+            name: "codex-browser-interface",
+            description: "Expose Browser Use and its persistent browser-bound Node REPL through a Codex-familiar structured tool surface.",
+            toolNames: [...CODEX_BROWSER_TOOL_NAMES],
+        });
         registerPiboNativeTooling(api);
         api.registerProfile({
             name: DEFAULT_PIBO_PROFILE_NAME,

package/dist/session-ui/terminalRows.js CHANGED Viewed

@@ -2,6 +2,13 @@ import { compareTraceNodes } from "../shared/trace-engine.js";
 import { terminalTextValue } from "./terminalValue.js";
 export const COMPACT_TERMINAL_OUTPUT_PREVIEW_LINES = 5;
 export const COMPACT_TERMINAL_EXPLORING_PREVIEW_LINES = 6;
+const CODEX_COMPATIBLE_TOOL_LABELS = {
+    browser_use_open_tabs: "browser_use.open_tabs",
+    browser_use_take_screenshot: "browser_use.take_screenshot",
+    browser_use_browser_use: "browser_use.browser_use",
+    node_repl_js: "node_repl.js",
+    node_repl_js_reset: "node_repl.js_reset",
+};
 export function buildCompactTerminalRows(traceView, options) {
     if (!traceView)
         return [];
@@ -270,7 +277,7 @@ function createToolRowCandidate(node, turnId) {
                     token(toolVerb(node.status), toneForStatus(node.status), "semibold"),
                     token(" "),
                 ],
-                functionCall: { name: node.title, input: node.input },
+                functionCall: { name: displayToolName(node.title), input: node.input },
             },
             ...preview.lines,
         ],
@@ -359,7 +366,7 @@ function createToolResultRow(node) {
         lines: [
             {
                 prefix: "bullet",
-                tokens: [token(node.status === "error" ? "Tool failed" : "Returned", toneForStatus(node.status), "semibold"), token(` ${node.title}`)],
+                tokens: [token(node.status === "error" ? "Tool failed" : "Returned", toneForStatus(node.status), "semibold"), token(` ${displayToolName(node.title)}`)],
             },
             ...preview.lines,
         ],
@@ -1030,6 +1037,9 @@ function classifyExploringTool(node) {
     }
     return undefined;
 }
+function displayToolName(name) {
+    return CODEX_COMPATIBLE_TOOL_LABELS[name] ?? name;
+}
 function matchesTool(name, terms) {
     return terms.some((term) => name === term || name.startsWith(`${term}_`) || name.endsWith(`_${term}`) || name.includes(term));
 }

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

@@ -73,6 +73,22 @@ function defaultTemplateDir(status) {
     // Create an empty template directory so leases get clean profiles.
     return preferred;
 }
+export function findActiveBrowserUseLeaseForHolder(status, holder, app, now = new Date()) {
+    return readRegistry(status).leases.find((lease) => lease.holder === holder &&
+        lease.status === 'active' &&
+        !isExpired(lease, now) &&
+        (app === undefined || lease.app === app));
+}
+export function browserUseLeaseEnvironment(status, lease) {
+    return {
+        BROWSER_USE_HOME: browserUseHome(status),
+        PIBO_BROWSER_USE_LEASE_ID: lease.id,
+        PIBO_BROWSER_USE_SESSION: lease.sessionName,
+        PIBO_BROWSER_USE_CHROME_USER_DATA_DIR: lease.userDataDir,
+        PIBO_BROWSER_USE_DEFAULT_PROFILE: lease.profileName,
+        ...(lease.browserPoolLeaseId ? { PIBO_BROWSER_POOL_LEASE_ID: lease.browserPoolLeaseId } : {}),
+    };
+}
 export function readRegistry(status) {
     const path = registryPath(status);
     if (!existsSync(path))

package/dist/tools/codex-browser-node-repl.js ADDED Viewed

@@ -0,0 +1,224 @@
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { createInterface } from "node:readline";
+import { CODEX_BROWSER_NODE_WORKER_SOURCE } from "./codex-browser-node-worker-source.js";
+const packageRequire = createRequire(import.meta.url);
+const ACORN_PATH = packageRequire.resolve("acorn");
+const ACORN_WALK_PATH = packageRequire.resolve("acorn-walk");
+function errorSummary(error, name = "NodeReplError") {
+    return error instanceof Error
+        ? { name: error.name || name, message: error.message, stack: error.stack }
+        : { name, message: String(error) };
+}
+export class CodexBrowserNodeRepl {
+    bridge;
+    child;
+    pending = new Map();
+    requestCounter = 0;
+    executionCount = 0;
+    alive = true;
+    busy = false;
+    diagnostics = "";
+    readyPromise;
+    readyResolve;
+    readyReject;
+    constructor(bridge, cwd) {
+        this.bridge = bridge;
+        this.readyPromise = new Promise((resolve, reject) => {
+            this.readyResolve = resolve;
+            this.readyReject = reject;
+        });
+        this.child = spawn("node", ["-e", CODEX_BROWSER_NODE_WORKER_SOURCE, ACORN_PATH, ACORN_WALK_PATH], {
+            cwd,
+            env: minimalWorkerEnvironment(),
+            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_repl worker exited with code ${code ?? "null"}${signal ? ` signal ${signal}` : ""}`);
+            this.readyReject(error);
+            this.rejectAll(error);
+        });
+    }
+    static async start(bridge, cwd, timeoutMs = 10_000) {
+        const repl = new CodexBrowserNodeRepl(bridge, cwd);
+        await repl.waitReady(timeoutMs);
+        return repl;
+    }
+    isAlive() {
+        return this.alive && !this.child.killed;
+    }
+    async exec(code, timeoutMs = 30_000) {
+        const startedAt = Date.now();
+        if (this.busy) {
+            return {
+                status: "failed",
+                stdout: "",
+                stderr: "",
+                durationMs: 0,
+                executionCount: this.executionCount,
+                error: { name: "NodeReplBusy", message: "node_repl.js is already executing code." },
+            };
+        }
+        this.busy = true;
+        try {
+            const response = await this.request("exec", { code, timeoutMs }, timeoutMs + 1_000);
+            this.executionCount += 1;
+            return {
+                status: response.status === "ok" ? "ok" : "error",
+                stdout: response.stdout ?? "",
+                stderr: response.stderr ?? "",
+                result: response.result,
+                error: response.error,
+                durationMs: Date.now() - startedAt,
+                executionCount: this.executionCount,
+            };
+        }
+        catch (error) {
+            return {
+                status: error instanceof NodeReplTimeoutError ? "timeout" : "failed",
+                stdout: "",
+                stderr: this.diagnostics,
+                durationMs: Date.now() - startedAt,
+                executionCount: this.executionCount,
+                error: errorSummary(error),
+            };
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+    async reset(timeoutMs = 10_000) {
+        if (this.busy) {
+            return {
+                status: "failed",
+                reset: false,
+                error: { name: "NodeReplBusy", message: "node_repl.js cannot reset while code is executing." },
+            };
+        }
+        try {
+            const response = await this.request("reset", {}, timeoutMs);
+            this.executionCount = 0;
+            return { status: response.status === "ok" ? "ok" : "failed", reset: response.reset === true, error: response.error };
+        }
+        catch (error) {
+            return { status: "failed", reset: false, error: errorSummary(error) };
+        }
+    }
+    dispose() {
+        if (!this.isAlive())
+            return;
+        this.alive = false;
+        this.child.kill("SIGTERM");
+        this.rejectAll(new Error("node_repl worker was disposed"));
+    }
+    waitReady(timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(`Timed out waiting for node_repl worker. ${this.diagnostics}`)), timeoutMs);
+            this.readyPromise.then(() => {
+                clearTimeout(timer);
+                resolve();
+            }, (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+    request(type, payload, timeoutMs) {
+        if (!this.isAlive())
+            return Promise.reject(new Error("node_repl worker is not alive"));
+        const id = `request_${++this.requestCounter}`;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new NodeReplTimeoutError(`node_repl request ${type} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.write({ type, id, ...payload });
+        });
+    }
+    handleLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            this.alive = false;
+            this.rejectAll(new Error(`Invalid node_repl worker protocol line: ${line}`));
+            this.child.kill("SIGTERM");
+            return;
+        }
+        if (message.type === "ready" && message.status === "ready") {
+            this.readyResolve();
+            return;
+        }
+        if (message.type === "browser_request") {
+            void this.handleBrowserRequest(message);
+            return;
+        }
+        const id = message.id;
+        if (!id)
+            return;
+        const pending = this.pending.get(id);
+        if (!pending)
+            return;
+        this.pending.delete(id);
+        clearTimeout(pending.timer);
+        pending.resolve(message);
+    }
+    async handleBrowserRequest(message) {
+        if (!message.id)
+            return;
+        try {
+            let result;
+            if (message.operation === "open_tabs") {
+                result = await this.bridge.openTabs();
+            }
+            else if (message.operation === "use") {
+                if (!message.input || typeof message.input !== "object" || Array.isArray(message.input)) {
+                    throw new Error("browser.use requires an action object");
+                }
+                result = await this.bridge.use(message.input);
+            }
+            else {
+                throw new Error(`Unknown browser bridge operation ${message.operation ?? ""}`);
+            }
+            this.write({ type: "browser_response", id: message.id, result });
+        }
+        catch (error) {
+            this.write({ type: "browser_response", id: message.id, error: errorSummary(error, "BrowserUseError") });
+        }
+    }
+    write(message) {
+        if (!this.isAlive())
+            return;
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    rejectAll(error) {
+        for (const [id, pending] of this.pending) {
+            this.pending.delete(id);
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+    }
+}
+function minimalWorkerEnvironment() {
+    const env = {};
+    for (const name of ["PATH", "HOME", "TMPDIR", "TEMP", "TMP", "LANG", "LC_ALL", "TZ"]) {
+        if (process.env[name] !== undefined)
+            env[name] = process.env[name];
+    }
+    return env;
+}
+class NodeReplTimeoutError extends Error {
+}