@pasko70/pibo 1.1.0 → 1.3.0

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";
+}

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

@@ -0,0 +1,178 @@
+export const PYTHON_RUNTIME_WORKER_SOURCE = String.raw `
+import contextlib
+import inspect
+import io
+import json
+import signal
+import sys
+import traceback
+
+user_globals = {"__name__": "__pibo_runtime__"}
+
+
+def bounded(value, max_bytes=8192):
+    text = str(value)
+    encoded = text.encode("utf-8", "replace")
+    if len(encoded) <= max_bytes:
+        return text
+    return encoded[:max_bytes].decode("utf-8", "replace") + "\n...<truncated>"
+
+
+def safe_repr(value, max_bytes=4096):
+    try:
+        return bounded(repr(value), max_bytes)
+    except Exception as exc:
+        return f"<repr failed: {type(exc).__name__}: {exc}>"
+
+
+def summarize(value, max_bytes=4096):
+    result = {"type": type(value).__name__, "repr": safe_repr(value, max_bytes)}
+    try:
+        if hasattr(value, "shape"):
+            shape = getattr(value, "shape")
+            try:
+                result["shape"] = list(shape)
+            except Exception:
+                pass
+        if hasattr(value, "columns"):
+            try:
+                result["columns"] = [str(c) for c in list(getattr(value, "columns"))[:50]]
+            except Exception:
+                pass
+        if isinstance(value, dict):
+            result["length"] = len(value)
+            result["keys"] = [safe_repr(k, 128) for k in list(value.keys())[:50]]
+        elif isinstance(value, (list, tuple, set, frozenset, str, bytes, bytearray)):
+            result["length"] = len(value)
+        if hasattr(value, "head"):
+            try:
+                result["preview"] = bounded(value.head().to_string(), max_bytes)
+            except Exception:
+                pass
+    except Exception:
+        pass
+    return result
+
+
+def error_summary(exc):
+    tb = traceback.format_exc()
+    line = None
+    try:
+        extracted = traceback.extract_tb(exc.__traceback__)
+        runtime_frames = [frame for frame in extracted if frame.filename == "<pibo-runtime>"]
+        if runtime_frames:
+            line = runtime_frames[-1].lineno
+    except Exception:
+        pass
+    out = {"name": type(exc).__name__, "message": str(exc), "traceback": tb}
+    if line is not None:
+        out["line"] = line
+    return out
+
+
+def execute(req):
+    mode = req.get("mode") or "exec"
+    code = req.get("code") or ""
+    if mode == "auto":
+        mode = "exec"
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+    try:
+        with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
+            if mode == "eval":
+                value = eval(compile(code, "<pibo-runtime>", "eval"), user_globals, user_globals)
+            else:
+                exec(compile(code, "<pibo-runtime>", "exec"), user_globals, user_globals)
+                value = None
+        return {
+            "id": req.get("id"),
+            "status": "ok",
+            "stdout": stdout.getvalue(),
+            "stderr": stderr.getvalue(),
+            "result": summarize(value) if value is not None else None,
+        }
+    except KeyboardInterrupt as exc:
+        return {"id": req.get("id"), "status": "interrupted", "stdout": stdout.getvalue(), "stderr": stderr.getvalue(), "error": error_summary(exc)}
+    except Exception as exc:
+        return {"id": req.get("id"), "status": "error", "stdout": stdout.getvalue(), "stderr": stderr.getvalue(), "error": error_summary(exc)}
+
+
+def inspect_value(req):
+    expression = req.get("expression") or ""
+    what = req.get("what") or "summary"
+    max_bytes = int(req.get("maxBytes") or 8192)
+    try:
+        value = eval(compile(expression, "<pibo-runtime>", "eval"), user_globals, user_globals)
+        result = {"id": req.get("id"), "status": "ok"}
+        if what in ("summary", "all"):
+            result["summary"] = summarize(value, max_bytes)
+        if what in ("signature", "all"):
+            try:
+                result["signature"] = bounded(str(inspect.signature(value)), max_bytes)
+            except Exception as exc:
+                result["signature"] = f"<signature unavailable: {type(exc).__name__}: {exc}>"
+        if what in ("members", "all"):
+            try:
+                result["members"] = [name for name, _ in inspect.getmembers(value)[:200]]
+            except Exception:
+                result["members"] = dir(value)[:200]
+        if what in ("source", "all"):
+            try:
+                result["source"] = bounded(inspect.getsource(value), max_bytes)
+            except Exception as exc:
+                result["source"] = f"<source unavailable: {type(exc).__name__}: {exc}>"
+        if what in ("doc", "all"):
+            result["doc"] = bounded(inspect.getdoc(value) or "", max_bytes)
+        return result
+    except Exception as exc:
+        return {"id": req.get("id"), "status": "error", "error": error_summary(exc)}
+
+
+def list_vars(req):
+    include_private = bool(req.get("includePrivate"))
+    max_items = int(req.get("maxItems") or 100)
+    max_bytes = int(req.get("maxBytes") or 4096)
+    variables = []
+    for name, value in sorted(user_globals.items()):
+        if name == "__builtins__":
+            continue
+        if not include_private and name.startswith("_"):
+            continue
+        if inspect.ismodule(value):
+            continue
+        variables.append({"name": name, "summary": summarize(value, max_bytes)})
+        if len(variables) >= max_items:
+            break
+    return {"id": req.get("id"), "status": "ok", "variables": variables, "truncated": len(variables) >= max_items}
+
+
+def write_response(resp):
+    sys.stdout.write(json.dumps(resp, ensure_ascii=False) + "\n")
+    sys.stdout.flush()
+
+
+def main():
+    write_response({"id": "ready", "status": "ready"})
+    for line in sys.stdin:
+        try:
+            req = json.loads(line)
+            typ = req.get("type")
+            if typ == "exec":
+                resp = execute(req)
+            elif typ == "inspect":
+                resp = inspect_value(req)
+            elif typ == "vars":
+                resp = list_vars(req)
+            elif typ == "shutdown":
+                write_response({"id": req.get("id"), "status": "ok"})
+                return
+            else:
+                resp = {"id": req.get("id"), "status": "error", "error": {"name": "RuntimeProtocolError", "message": f"unknown request type {typ}"}}
+        except Exception as exc:
+            resp = {"id": None, "status": "error", "error": error_summary(exc)}
+        write_response(resp)
+
+
+if __name__ == "__main__":
+    main()
+`;