@pasko70/pibo 1.9.9 → 1.9.11

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

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

package/dist/tools/runtime/node-worker-source.js

@@ -0,0 +1,206 @@
+export const NODE_RUNTIME_WORKER_SOURCE = String.raw `
+const vm = require("node:vm");
+const util = require("node:util");
+
+let currentOutput = null;
+
+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: 3, maxArrayLength: 50, 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 (Array.isArray(value)) result.length = value.length;
+		if (value && typeof value === "object") {
+			const keys = Object.keys(value).slice(0, 50);
+			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(/<pibo-runtime>:(\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);
+}
+
+const processProxy = new Proxy(process, {
+	get(target, prop, receiver) {
+		if (prop === "stdout") return { write: (chunk) => { appendStdout(chunk); return true; } };
+		if (prop === "stderr") return { write: (chunk) => { appendStderr(chunk); return true; } };
+		return Reflect.get(target, prop, receiver);
+	},
+});
+
+const consoleProxy = {
+	log: (...args) => appendStdout(util.format(...args) + "\n"),
+	info: (...args) => appendStdout(util.format(...args) + "\n"),
+	debug: (...args) => appendStdout(util.format(...args) + "\n"),
+	warn: (...args) => appendStderr(util.format(...args) + "\n"),
+	error: (...args) => appendStderr(util.format(...args) + "\n"),
+	dir: (value, options) => appendStdout(util.inspect(value, options) + "\n"),
+};
+
+const context = vm.createContext({
+	console: consoleProxy,
+	require,
+	process: processProxy,
+	Buffer,
+	URL,
+	URLSearchParams,
+	TextEncoder,
+	TextDecoder,
+	setTimeout,
+	clearTimeout,
+	setInterval,
+	clearInterval,
+	setImmediate,
+	clearImmediate,
+	queueMicrotask,
+});
+context.global = context;
+context.globalThis = context;
+
+async function execute(req) {
+	const mode = req.mode || "exec";
+	const code = req.code || "";
+	const output = { stdout: "", stderr: "" };
+	currentOutput = output;
+	try {
+		const value = await (async () => {
+			if (mode === "eval") {
+				return await vm.runInContext(code, context, { filename: "<pibo-runtime>", timeout: Number(req.timeoutMs || 30000) });
+			}
+			const result = vm.runInContext(code, context, { filename: "<pibo-runtime>", timeout: Number(req.timeoutMs || 30000) });
+			if (result && typeof result.then === "function") await result;
+			return undefined;
+		})();
+		return {
+			id: req.id,
+			status: "ok",
+			stdout: output.stdout,
+			stderr: output.stderr,
+			result: value === undefined ? null : summarize(value),
+		};
+	} catch (error) {
+		return {
+			id: req.id,
+			status: "error",
+			stdout: output.stdout,
+			stderr: output.stderr,
+			error: errorSummary(error),
+		};
+	} finally {
+		currentOutput = null;
+	}
+}
+
+async function inspectValue(req) {
+	const expression = req.expression || "";
+	const what = req.what || "summary";
+	const maxBytes = Number(req.maxBytes || 8192);
+	try {
+		const value = await vm.runInContext(expression, context, { filename: "<pibo-runtime>", timeout: 15000 });
+		const result = { id: req.id, status: "ok" };
+		if (what === "summary" || what === "all") result.summary = summarize(value, maxBytes);
+		if (what === "signature" || what === "all") result.signature = typeof value === "function" ? bounded(value.toString().split("{")[0].trim(), maxBytes) : "<signature unavailable>";
+		if (what === "members" || what === "all") {
+			const members = new Set();
+			for (const key of Reflect.ownKeys(Object(value))) members.add(String(key));
+			const proto = value == null ? undefined : Object.getPrototypeOf(value);
+			if (proto) for (const key of Reflect.ownKeys(proto)) members.add(String(key));
+			result.members = [...members].slice(0, 200);
+		}
+		if (what === "source" || what === "all") result.source = typeof value === "function" ? bounded(value.toString(), maxBytes) : "<source unavailable>";
+		if (what === "doc" || what === "all") result.doc = "";
+		return result;
+	} catch (error) {
+		return { id: req.id, status: "error", error: errorSummary(error) };
+	}
+}
+
+function listVars(req) {
+	const includePrivate = Boolean(req.includePrivate);
+	const maxItems = Number(req.maxItems || 100);
+	const maxBytes = Number(req.maxBytes || 4096);
+	const hidden = new Set(["console", "require", "process", "Buffer", "URL", "URLSearchParams", "TextEncoder", "TextDecoder", "global", "globalThis"]);
+	const variables = [];
+	for (const name of Object.keys(context).sort()) {
+		if (hidden.has(name)) continue;
+		if (!includePrivate && name.startsWith("_")) continue;
+		variables.push({ name, summary: summarize(context[name], maxBytes) });
+		if (variables.length >= maxItems) break;
+	}
+	return { id: req.id, status: "ok", variables, truncated: variables.length >= maxItems };
+}
+
+function writeResponse(resp) {
+	process.stdout.write(JSON.stringify(resp) + "\n");
+}
+
+async function handle(req) {
+	if (req.type === "exec") return await execute(req);
+	if (req.type === "inspect") return await inspectValue(req);
+	if (req.type === "vars") return listVars(req);
+	if (req.type === "shutdown") return { id: req.id, status: "ok", shutdown: true };
+	return { id: req.id, status: "error", error: { name: "RuntimeProtocolError", message: "unknown request type " + req.type } };
+}
+
+async function main() {
+	writeResponse({ id: "ready", status: "ready" });
+	let buffer = "";
+	process.stdin.setEncoding("utf8");
+	process.stdin.on("data", async (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;
+			let req;
+			try {
+				req = JSON.parse(line);
+				const resp = await handle(req);
+				writeResponse(resp);
+				if (resp.shutdown) process.exit(0);
+			} catch (error) {
+				writeResponse({ id: req?.id, status: "error", error: errorSummary(error) });
+			}
+		}
+	});
+}
+
+main();
+`;

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

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