@pasko70/pibo 1.13.0 → 1.15.0

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

@@ -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 {
+}

package/dist/tools/codex-browser-node-worker-source.js

@@ -0,0 +1,403 @@
+export const CODEX_BROWSER_NODE_WORKER_SOURCE = String.raw `
+const vm = require("node:vm");
+const util = require("node:util");
+const { Parser } = require(process.argv[1]);
+const walk = require(process.argv[2]);
+
+let context;
+let currentOutput = null;
+let browserRequestCounter = 0;
+let timerCounter = 0;
+const pendingBrowserRequests = new Map();
+const timers = new Map();
+
+function hardenFunction(fn) {
+	Object.setPrototypeOf(fn, null);
+	return Object.freeze(fn);
+}
+
+function nullObject(properties) {
+	return Object.freeze(Object.assign(Object.create(null), properties));
+}
+
+function bounded(value, maxBytes = 8192) {
+	const text = String(value);
+	const bytes = Buffer.byteLength(text, "utf8");
+	if (bytes <= maxBytes) return text;
+	return Buffer.from(text, "utf8").subarray(0, maxBytes).toString("utf8") + "\n...<truncated>";
+}
+
+function safeInspect(value, maxBytes = 4096) {
+	try {
+		return bounded(util.inspect(value, { depth: 4, maxArrayLength: 100, breakLength: 120 }), maxBytes);
+	} catch (error) {
+		return "<inspect failed: " + (error?.name || "Error") + ": " + (error?.message || String(error)) + ">";
+	}
+}
+
+function summarize(value, maxBytes = 4096) {
+	const type = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+	const result = { type, repr: safeInspect(value, maxBytes) };
+	try {
+		if (value != null && typeof value.length === "number") result.length = value.length;
+		if (value && typeof value === "object") {
+			const keys = Object.keys(value).slice(0, 100);
+			if (keys.length > 0) result.keys = keys;
+		}
+	} catch {}
+	return result;
+}
+
+function errorSummary(error) {
+	const stack = error && error.stack ? String(error.stack) : String(error);
+	const out = {
+		name: error && error.name ? String(error.name) : "Error",
+		message: error && error.message ? String(error.message) : String(error),
+		stack,
+	};
+	const match = stack.match(/<node_repl>:(\d+):(\d+)/) || stack.match(/evalmachine\.<anonymous>:(\d+):(\d+)/);
+	if (match) {
+		out.line = Number(match[1]);
+		out.column = Number(match[2]);
+	}
+	return out;
+}
+
+function appendStdout(chunk) {
+	if (currentOutput) currentOutput.stdout += String(chunk);
+}
+
+function appendStderr(chunk) {
+	if (currentOutput) currentOutput.stderr += String(chunk);
+}
+
+function requestBrowser(operation, input = {}) {
+	const id = "browser_" + (++browserRequestCounter);
+	const promise = new Promise((resolve, reject) => {
+		pendingBrowserRequests.set(id, { resolve, reject });
+		writeMessage({ type: "browser_request", id, operation, input });
+	});
+	return nullObject({
+		then: hardenFunction((resolve, reject) => promise.then(resolve, reject)),
+	});
+}
+
+function createTimer(repeat, callback, delay, args) {
+	if (typeof callback !== "function") throw new TypeError("Timer callback must be a function");
+	const id = ++timerCounter;
+	const invoke = () => callback(...args);
+	const timer = repeat ? setInterval(invoke, delay) : setTimeout(() => {
+		timers.delete(id);
+		invoke();
+	}, delay);
+	timers.set(id, { repeat, timer });
+	return id;
+}
+
+function clearTimer(id) {
+	const entry = timers.get(id);
+	if (!entry) return;
+	timers.delete(id);
+	if (entry.repeat) clearInterval(entry.timer);
+	else clearTimeout(entry.timer);
+}
+
+function clearAllTimers() {
+	for (const id of [...timers.keys()]) clearTimer(id);
+}
+
+function createContext() {
+	clearAllTimers();
+	const consoleProxy = nullObject({
+		log: hardenFunction((...args) => appendStdout(util.format(...args) + "\n")),
+		info: hardenFunction((...args) => appendStdout(util.format(...args) + "\n")),
+		debug: hardenFunction((...args) => appendStdout(util.format(...args) + "\n")),
+		warn: hardenFunction((...args) => appendStderr(util.format(...args) + "\n")),
+		error: hardenFunction((...args) => appendStderr(util.format(...args) + "\n")),
+		dir: hardenFunction((value, options) => appendStdout(util.inspect(value, options) + "\n")),
+	});
+	const browser = nullObject({
+		openTabs: hardenFunction(() => requestBrowser("open_tabs")),
+		use: hardenFunction((action, params = {}) => {
+			const input = action && typeof action === "object" ? action : { ...params, action };
+			return requestBrowser("use", input);
+		}),
+	});
+	const sandbox = Object.assign(Object.create(null), {
+		console: consoleProxy,
+		browser,
+		setTimeout: hardenFunction((callback, delay = 0, ...args) => createTimer(false, callback, delay, args)),
+		clearTimeout: hardenFunction((id) => clearTimer(id)),
+		setInterval: hardenFunction((callback, delay = 0, ...args) => createTimer(true, callback, delay, args)),
+		clearInterval: hardenFunction((id) => clearTimer(id)),
+		setImmediate: hardenFunction((callback, ...args) => createTimer(false, callback, 0, args)),
+		clearImmediate: hardenFunction((id) => clearTimer(id)),
+		queueMicrotask: hardenFunction((callback) => { Promise.resolve().then(callback); }),
+	});
+	context = vm.createContext(sandbox, {
+		name: "node_repl",
+		codeGeneration: { strings: false, wasm: false },
+	});
+	context.global = context;
+	context.globalThis = context;
+}
+
+async function withTimeout(value, timeoutMs) {
+	if (!value || typeof value.then !== "function") return value;
+	let timer;
+	try {
+		return await Promise.race([
+			value,
+			new Promise((_, reject) => {
+				timer = setTimeout(() => reject(new Error("JavaScript execution timed out after " + timeoutMs + "ms")), timeoutMs);
+			}),
+		]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
+// Adapt Node REPL's top-level-await rewrite to the restricted vm context.
+function isTopLevelDeclaration(state) {
+	return state.ancestors[state.ancestors.length - 2] === state.body;
+}
+
+const noopVisitor = () => {};
+const topLevelAwaitVisitorsWithoutAncestors = {
+	ClassDeclaration(node, state, c) {
+		if (isTopLevelDeclaration(state)) {
+			state.prepend(node, node.id.name + "=");
+			state.hoistedDeclarationStatements.push("let " + node.id.name + "; ");
+		}
+		walk.base.ClassDeclaration(node, state, c);
+	},
+	ForOfStatement(node, state, c) {
+		if (node.await === true) state.containsAwait = true;
+		walk.base.ForOfStatement(node, state, c);
+	},
+	FunctionDeclaration(node, state) {
+		state.prepend(node, "this." + node.id.name + " = " + node.id.name + "; ");
+		state.hoistedDeclarationStatements.push("var " + node.id.name + "; ");
+	},
+	FunctionExpression: noopVisitor,
+	ArrowFunctionExpression: noopVisitor,
+	MethodDefinition: noopVisitor,
+	AwaitExpression(node, state, c) {
+		state.containsAwait = true;
+		walk.base.AwaitExpression(node, state, c);
+	},
+	ReturnStatement(node, state, c) {
+		state.containsReturn = true;
+		walk.base.ReturnStatement(node, state, c);
+	},
+	VariableDeclaration(node, state, c) {
+		const variableKind = node.kind;
+		const parent = state.ancestors[state.ancestors.length - 2];
+		const isIterableForDeclaration = parent.type === "ForOfStatement" || parent.type === "ForInStatement";
+		if (variableKind === "var" || isTopLevelDeclaration(state)) {
+			state.replace(
+				node.start,
+				node.start + variableKind.length + (isIterableForDeclaration ? 1 : 0),
+				variableKind === "var" && isIterableForDeclaration ? "" : "void" + (node.declarations.length === 1 ? "" : " ("),
+			);
+			if (!isIterableForDeclaration) {
+				for (const declaration of node.declarations) {
+					state.prepend(declaration, "(");
+					state.append(declaration, declaration.init ? ")" : "=undefined)");
+				}
+				if (node.declarations.length !== 1) state.append(node.declarations[node.declarations.length - 1], ")");
+			}
+
+			const variableIdentifiersToHoist = { var: [], let: [] };
+			function registerVariableDeclarationIdentifiers(pattern) {
+				if (!pattern) return;
+				if (pattern.type === "Identifier") {
+					variableIdentifiersToHoist[variableKind === "var" ? "var" : "let"].push(pattern.name);
+					return;
+				}
+				if (pattern.type === "ObjectPattern") {
+					for (const property of pattern.properties) registerVariableDeclarationIdentifiers(property.value || property.argument);
+					return;
+				}
+				if (pattern.type === "ArrayPattern") {
+					for (const element of pattern.elements) registerVariableDeclarationIdentifiers(element);
+				}
+			}
+			for (const declaration of node.declarations) registerVariableDeclarationIdentifiers(declaration.id);
+			for (const kind of ["var", "let"]) {
+				const identifiers = variableIdentifiersToHoist[kind];
+				if (identifiers.length > 0) state.hoistedDeclarationStatements.push(kind + " " + identifiers.join(", ") + "; ");
+			}
+		}
+		walk.base.VariableDeclaration(node, state, c);
+	},
+};
+
+const topLevelAwaitVisitors = {};
+for (const nodeType of Object.keys(walk.base)) {
+	const callback = topLevelAwaitVisitorsWithoutAncestors[nodeType] || walk.base[nodeType];
+	topLevelAwaitVisitors[nodeType] = (node, state, c) => {
+		const isNew = node !== state.ancestors[state.ancestors.length - 1];
+		if (isNew) state.ancestors.push(node);
+		callback(node, state, c);
+		if (isNew) state.ancestors.pop();
+	};
+}
+
+function processTopLevelAwait(source) {
+	const wrapPrefix = "(async () => { ";
+	const wrapped = wrapPrefix + source + " })()";
+	const chars = wrapped.split("");
+	let root;
+	try {
+		root = Parser.parse(wrapped, { ecmaVersion: "latest" });
+	} catch {
+		return null;
+	}
+	const body = root.body[0].expression.callee.body;
+	const state = {
+		body,
+		ancestors: [],
+		hoistedDeclarationStatements: [],
+		containsAwait: false,
+		containsReturn: false,
+		replace(from, to, text) {
+			for (let index = from; index < to; index += 1) chars[index] = "";
+			if (from === to) text += chars[from];
+			chars[from] = text;
+		},
+		prepend(node, text) {
+			chars[node.start] = text + chars[node.start];
+		},
+		append(node, text) {
+			chars[node.end - 1] += text;
+		},
+	};
+	walk.recursive(body, state, topLevelAwaitVisitors);
+	if (!state.containsAwait || state.containsReturn) return null;
+
+	for (let index = body.body.length - 1; index >= 0; index -= 1) {
+		const node = body.body[index];
+		if (node.type === "EmptyStatement") continue;
+		if (node.type === "ExpressionStatement") {
+			state.prepend(node.expression, "{ value: (");
+			state.prepend(node, "return ");
+			state.append(node.expression, ") }");
+		}
+		break;
+	}
+	return state.hoistedDeclarationStatements.join("") + chars.join("");
+}
+
+async function execute(req) {
+	const output = { stdout: "", stderr: "" };
+	currentOutput = output;
+	try {
+		const timeoutMs = Number(req.timeoutMs || 30000);
+		const code = req.code || "";
+		let transformedTopLevelAwait = false;
+		let value;
+		try {
+			value = vm.runInContext(code, context, {
+				filename: "<node_repl>",
+				timeout: timeoutMs,
+			});
+		} catch (error) {
+			const transformed = error && error.name === "SyntaxError" ? processTopLevelAwait(code) : null;
+			if (!transformed) throw error;
+			transformedTopLevelAwait = true;
+			value = vm.runInContext(transformed, context, {
+				filename: "<node_repl>",
+				timeout: timeoutMs,
+			});
+		}
+		const settled = await withTimeout(value, timeoutMs);
+		const result = transformedTopLevelAwait && settled && Object.prototype.hasOwnProperty.call(settled, "value")
+			? settled.value
+			: settled;
+		return {
+			type: "response",
+			id: req.id,
+			status: "ok",
+			stdout: output.stdout,
+			stderr: output.stderr,
+			result: result === undefined ? null : summarize(result),
+		};
+	} catch (error) {
+		return {
+			type: "response",
+			id: req.id,
+			status: "error",
+			stdout: output.stdout,
+			stderr: output.stderr,
+			error: errorSummary(error),
+		};
+	} finally {
+		currentOutput = null;
+	}
+}
+
+function reset(req) {
+	createContext();
+	return { type: "response", id: req.id, status: "ok", reset: true };
+}
+
+function handleBrowserResponse(req) {
+	const pending = pendingBrowserRequests.get(req.id);
+	if (!pending) return;
+	pendingBrowserRequests.delete(req.id);
+	if (req.error) {
+		const error = new Error(req.error.message || String(req.error));
+		error.name = req.error.name || "BrowserUseError";
+		pending.reject(error);
+		return;
+	}
+	const json = JSON.stringify(req.result === undefined ? null : req.result);
+	const contextValue = vm.runInContext("JSON.parse(" + JSON.stringify(json) + ")", context);
+	pending.resolve(contextValue);
+}
+
+function writeMessage(message) {
+	process.stdout.write(JSON.stringify(message) + "\n");
+}
+
+function handleRequest(req) {
+	if (req.type === "browser_response") {
+		handleBrowserResponse(req);
+		return;
+	}
+	if (req.type === "exec") {
+		void execute(req).then(writeMessage);
+		return;
+	}
+	if (req.type === "reset") {
+		writeMessage(reset(req));
+		return;
+	}
+	if (req.type === "shutdown") {
+		writeMessage({ type: "response", id: req.id, status: "ok", shutdown: true });
+		process.exit(0);
+		return;
+	}
+	writeMessage({ type: "response", id: req.id, status: "error", error: { name: "NodeReplProtocolError", message: "Unknown request type " + req.type } });
+}
+
+createContext();
+writeMessage({ type: "ready", id: "ready", status: "ready" });
+let buffer = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+	buffer += chunk;
+	let index;
+	while ((index = buffer.indexOf("\n")) >= 0) {
+		const line = buffer.slice(0, index);
+		buffer = buffer.slice(index + 1);
+		if (!line.trim()) continue;
+		try {
+			handleRequest(JSON.parse(line));
+		} catch (error) {
+			writeMessage({ type: "response", status: "error", error: errorSummary(error) });
+		}
+	}
+});
+`;