@pasko70/pibo 1.9.9 → 1.9.10

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()
+`;

package/dist/tools/runtime/registry.js

@@ -0,0 +1,255 @@
+import { randomUUID } from "node:crypto";
+import { PythonRuntimeBackend } from "./python-backend.js";
+import { NodeRuntimeBackend } from "./node-backend.js";
+function nowIso() {
+    return new Date().toISOString();
+}
+function notFoundExec(sessionId = "auto") {
+    return {
+        status: "not_found",
+        sessionId,
+        durationMs: 0,
+        error: { name: "RuntimeNotFound", message: `Runtime session "${sessionId}" was not found.` },
+    };
+}
+function notFoundInspect(sessionId = "auto") {
+    return {
+        status: "not_found",
+        sessionId,
+        error: { name: "RuntimeNotFound", message: `Runtime session "${sessionId}" was not found.` },
+    };
+}
+function notFoundVars(sessionId = "auto") {
+    return {
+        status: "not_found",
+        sessionId,
+        variables: [],
+        error: { name: "RuntimeNotFound", message: `Runtime session "${sessionId}" was not found.` },
+    };
+}
+export class RuntimeSessionRegistry {
+    options;
+    sessions = new Map();
+    maxHistoryEntries;
+    constructor(options) {
+        this.options = options;
+        this.maxHistoryEntries = options.maxHistoryEntries ?? 100;
+    }
+    async start(controllerPiboSessionId, input) {
+        if (input.target?.type && input.target.type !== "local") {
+            return {
+                status: "error",
+                error: { name: "UnsupportedRuntimeTarget", message: `Runtime target "${input.target.type}" is not implemented yet.` },
+            };
+        }
+        const sessionId = `rt_${input.runtime}_${randomUUID().slice(0, 8)}`;
+        try {
+            const backend = input.runtime === "python"
+                ? await PythonRuntimeBackend.start(this.options.cwd, input)
+                : await NodeRuntimeBackend.start(this.options.cwd, input);
+            const startedAt = nowIso();
+            const record = backend.getRecord();
+            const session = {
+                sessionId,
+                runtime: input.runtime,
+                name: input.name,
+                cwd: record.cwd,
+                status: "idle",
+                startedAt,
+                updatedAt: startedAt,
+                executionCount: 0,
+                pid: record.pid,
+                executable: record.executable,
+                controllerPiboSessionId,
+                backend,
+                history: [],
+            };
+            this.sessions.set(sessionId, session);
+            return { status: "ok", sessionId, runtime: input.runtime, name: input.name, ...record, startedAt };
+        }
+        catch (error) {
+            return {
+                status: "failed",
+                sessionId,
+                runtime: input.runtime,
+                error: error instanceof Error
+                    ? { name: error.name, message: error.message, stack: error.stack }
+                    : { name: "RuntimeStartError", message: String(error) },
+            };
+        }
+    }
+    async exec(controllerPiboSessionId, input) {
+        const session = input.sessionId
+            ? this.getSessionForController(controllerPiboSessionId, input.sessionId)
+            : await this.getOrStartDefault(controllerPiboSessionId, input);
+        const sessionId = input.sessionId ?? session?.sessionId ?? "auto";
+        if (!session)
+            return notFoundExec(sessionId);
+        if (session.status === "closed" || session.status === "failed")
+            return notFoundExec(sessionId);
+        if (session.status === "busy") {
+            return {
+                status: "failed",
+                sessionId,
+                runtime: session.runtime,
+                durationMs: 0,
+                error: { name: "RuntimeBusy", message: `Runtime session "${sessionId}" is already busy.` },
+            };
+        }
+        const startedAt = nowIso();
+        session.status = "busy";
+        session.updatedAt = startedAt;
+        const result = await session.backend.exec(input);
+        result.sessionId = session.sessionId;
+        result.runtime = session.runtime;
+        session.executionCount += 1;
+        result.executionCount = session.executionCount;
+        session.lastExecAt = startedAt;
+        session.updatedAt = nowIso();
+        if (result.status === "failed" && !session.backend.isAlive()) {
+            session.status = "failed";
+        }
+        else {
+            session.status = "idle";
+        }
+        this.appendHistory(session, {
+            id: randomUUID(),
+            startedAt,
+            durationMs: result.durationMs,
+            code: input.code,
+            status: result.status,
+            error: result.error,
+        });
+        if (input.closeOnSuccess === true && result.status === "ok") {
+            await this.close(controllerPiboSessionId, { sessionId: session.sessionId });
+            result.autoClosed = true;
+        }
+        return result;
+    }
+    async inspect(controllerPiboSessionId, input) {
+        const session = input.sessionId ? this.getSessionForController(controllerPiboSessionId, input.sessionId) : this.getDefault(controllerPiboSessionId, input.runtime ?? "python");
+        if (!session)
+            return notFoundInspect(input.sessionId);
+        const result = await session.backend.inspect(input);
+        return { ...result, sessionId: session.sessionId };
+    }
+    async vars(controllerPiboSessionId, input) {
+        const session = input.sessionId ? this.getSessionForController(controllerPiboSessionId, input.sessionId) : this.getDefault(controllerPiboSessionId, input.runtime ?? "python");
+        if (!session)
+            return notFoundVars(input.sessionId);
+        const result = await session.backend.vars(input);
+        return { ...result, sessionId: session.sessionId };
+    }
+    async interrupt(controllerPiboSessionId, input) {
+        const session = input.sessionId ? this.getSessionForController(controllerPiboSessionId, input.sessionId) : this.getDefault(controllerPiboSessionId, input.runtime ?? "python");
+        const sessionId = input.sessionId ?? session?.sessionId ?? "auto";
+        if (!session)
+            return { status: "not_found", sessionId, message: `Runtime session "${sessionId}" was not found.` };
+        const result = await session.backend.interrupt();
+        return { ...result, sessionId: session.sessionId };
+    }
+    async close(controllerPiboSessionId, input) {
+        const session = this.getSessionForController(controllerPiboSessionId, input.sessionId);
+        if (!session)
+            return { status: "not_found", sessionId: input.sessionId, closed: false, message: `Runtime session "${input.sessionId}" was not found.` };
+        try {
+            await session.backend.close(input.force);
+            session.status = "closed";
+            session.updatedAt = nowIso();
+            this.sessions.delete(session.sessionId);
+            return { status: "ok", sessionId: input.sessionId, closed: true };
+        }
+        catch (error) {
+            session.status = "failed";
+            return {
+                status: "failed",
+                sessionId: input.sessionId,
+                closed: false,
+                error: error instanceof Error
+                    ? { name: error.name, message: error.message, stack: error.stack }
+                    : { name: "RuntimeCloseError", message: String(error) },
+            };
+        }
+    }
+    list(controllerPiboSessionId) {
+        return {
+            status: "ok",
+            sessions: [...this.sessions.values()]
+                .filter((session) => session.controllerPiboSessionId === controllerPiboSessionId)
+                .map(toRecord),
+        };
+    }
+    async closeControllerSessions(controllerPiboSessionId, options = {}) {
+        const sessions = [...this.sessions.values()].filter((session) => session.controllerPiboSessionId === controllerPiboSessionId);
+        await Promise.all(sessions.map((session) => this.close(controllerPiboSessionId, { sessionId: session.sessionId, force: options.force })));
+    }
+    async closeAll(options = {}) {
+        const sessions = [...this.sessions.values()];
+        await Promise.all(sessions.map((session) => this.close(session.controllerPiboSessionId, { sessionId: session.sessionId, force: options.force })));
+    }
+    pruneIdle(now = Date.now(), idleTimeoutMs = 30 * 60 * 1000) {
+        for (const session of this.sessions.values()) {
+            if (session.status !== "idle")
+                continue;
+            if (now - Date.parse(session.updatedAt) > idleTimeoutMs) {
+                void this.close(session.controllerPiboSessionId, { sessionId: session.sessionId, force: true });
+            }
+        }
+    }
+    createController(controllerPiboSessionId) {
+        return {
+            start: (input) => this.start(controllerPiboSessionId, input),
+            exec: (input) => this.exec(controllerPiboSessionId, input),
+            inspect: (input) => this.inspect(controllerPiboSessionId, input),
+            vars: (input) => this.vars(controllerPiboSessionId, input),
+            interrupt: (input) => this.interrupt(controllerPiboSessionId, input),
+            close: (input) => this.close(controllerPiboSessionId, input),
+            list: () => this.list(controllerPiboSessionId),
+        };
+    }
+    getDefault(controllerPiboSessionId, runtime) {
+        return [...this.sessions.values()].find((session) => session.controllerPiboSessionId === controllerPiboSessionId &&
+            session.runtime === runtime &&
+            session.status !== "closed" &&
+            session.status !== "failed");
+    }
+    async getOrStartDefault(controllerPiboSessionId, input) {
+        const runtime = input.runtime ?? "python";
+        const existing = this.getDefault(controllerPiboSessionId, runtime);
+        if (existing)
+            return existing;
+        const started = await this.start(controllerPiboSessionId, {
+            runtime,
+            name: input.name,
+            target: input.target,
+            timeoutMs: input.timeoutMs,
+        });
+        return started.sessionId ? this.getSessionForController(controllerPiboSessionId, started.sessionId) : undefined;
+    }
+    getSessionForController(controllerPiboSessionId, sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session || session.controllerPiboSessionId !== controllerPiboSessionId)
+            return undefined;
+        return session;
+    }
+    appendHistory(session, entry) {
+        session.history.push(entry);
+        if (session.history.length > this.maxHistoryEntries)
+            session.history.splice(0, session.history.length - this.maxHistoryEntries);
+    }
+}
+function toRecord(session) {
+    return {
+        sessionId: session.sessionId,
+        runtime: session.runtime,
+        name: session.name,
+        cwd: session.cwd,
+        status: session.status,
+        startedAt: session.startedAt,
+        updatedAt: session.updatedAt,
+        lastExecAt: session.lastExecAt,
+        executionCount: session.executionCount,
+        pid: session.pid,
+        executable: session.executable,
+    };
+}

package/dist/tools/runtime/tool.js

@@ -0,0 +1,168 @@
+import { StringEnum, Type } from "@earendil-works/pi-ai";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+export function createRuntimeToolProfile() {
+    return {
+        name: "runtime",
+        description: "Run Python/Node code in persistent runtime sessions; exec runs normal scripts.",
+        yieldable: true,
+        builtInPiboTool: "runtime",
+    };
+}
+function requireString(value, field) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`runtime.${field} must be a non-empty string`);
+    return value;
+}
+function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function validateTarget(value) {
+    const object = asObject(value);
+    if (!object)
+        return undefined;
+    const target = {};
+    if (object.type !== undefined) {
+        if (object.type !== "local" && object.type !== "docker" && object.type !== "ssh")
+            throw new Error("runtime.target.type must be local, docker, or ssh");
+        target.type = object.type;
+    }
+    if (object.cwd !== undefined)
+        target.cwd = requireString(object.cwd, "target.cwd");
+    if (object.executable !== undefined)
+        target.executable = requireString(object.executable, "target.executable");
+    if (object.args !== undefined) {
+        if (!Array.isArray(object.args) || object.args.some((arg) => typeof arg !== "string"))
+            throw new Error("runtime.target.args must be an array of strings");
+        target.args = [...object.args];
+    }
+    if (object.env !== undefined) {
+        const env = asObject(object.env);
+        if (!env)
+            throw new Error("runtime.target.env must be an object");
+        target.env = Object.fromEntries(Object.entries(env).map(([key, value]) => [key, requireString(value, `target.env.${key}`)]));
+    }
+    return target;
+}
+function resultStatus(result) {
+    return asObject(result)?.status;
+}
+function isErrorStatus(status) {
+    return status !== undefined && status !== "ok";
+}
+function formatRuntimeResult(result) {
+    const object = asObject(result) ?? {};
+    const lines = [
+        `status: ${object.status ?? "unknown"}`,
+    ];
+    if (object.sessionId)
+        lines.push(`sessionId: ${object.sessionId}`);
+    if (object.runtime)
+        lines.push(`runtime: ${object.runtime}`);
+    if (object.autoClosed !== undefined)
+        lines.push(`autoClosed: ${object.autoClosed}`);
+    if (object.executionCount !== undefined)
+        lines.push(`executionCount: ${object.executionCount}`);
+    if (object.durationMs !== undefined)
+        lines.push(`durationMs: ${object.durationMs}`);
+    if (typeof object.stdout === "string" && object.stdout.length > 0)
+        lines.push("", "stdout:", object.stdout);
+    if (typeof object.stderr === "string" && object.stderr.length > 0)
+        lines.push("", "stderr:", object.stderr);
+    if (object.result !== undefined && object.result !== null)
+        lines.push("", "result:", JSON.stringify(object.result, null, 2));
+    if (object.error !== undefined)
+        lines.push("", "error:", JSON.stringify(object.error, null, 2));
+    if (object.sessions !== undefined)
+        lines.push("", "sessions:", JSON.stringify(object.sessions, null, 2));
+    if (object.variables !== undefined)
+        lines.push("", "variables:", JSON.stringify(object.variables, null, 2));
+    if (object.summary !== undefined)
+        lines.push("", "summary:", JSON.stringify(object.summary, null, 2));
+    if (object.signature !== undefined)
+        lines.push("", "signature:", String(object.signature));
+    if (object.members !== undefined)
+        lines.push("", "members:", JSON.stringify(object.members, null, 2));
+    if (object.source !== undefined)
+        lines.push("", "source:", String(object.source));
+    if (object.doc !== undefined)
+        lines.push("", "doc:", String(object.doc));
+    if (object.closed !== undefined)
+        lines.push(`closed: ${object.closed}`);
+    if (object.message !== undefined)
+        lines.push(`message: ${object.message}`);
+    return lines.join("\n");
+}
+export function createRuntimeToolDefinition(controller) {
+    return defineTool({
+        name: "runtime",
+        label: "Runtime",
+        description: "Run Python/Node code in persistent sessions. Use this instead of bash for Python/Node execution except trivial one-line shell checks.",
+        promptSnippet: "Use runtime for Python/Node execution, especially longer snippets (~20+ lines), uncertain code, or objects/state to inspect. Prefer runtime over bash for Python/Node except trivial one-line shell checks. Auto-starts on exec; print values you need. Runtime keeps variables and processes alive between calls; reuse sessionId to inspect or continue from that state after partial failures. This saves output tokens and keeps your mental model tied to live state. Use read for file contents; use bash for shell commands and package installs.",
+        executionMode: "parallel",
+        parameters: Type.Object({
+            action: StringEnum(["exec", "inspect", "vars", "interrupt", "list"], { description: "Runtime action to perform." }),
+            runtime: Type.Optional(StringEnum(["python", "node"], { description: "Runtime kind; default python." })),
+            name: Type.Optional(Type.String({ description: "Optional human-readable runtime name." })),
+            target: Type.Optional(Type.Any({ description: "Auto-start target options such as { type: 'local', cwd, executable, args, env }." })),
+            sessionId: Type.Optional(Type.String({ description: "Existing runtime session id; omit to use auto runtime." })),
+            code: Type.Optional(Type.String({ description: "Code to execute for exec." })),
+            timeoutMs: Type.Optional(Type.Number({ description: "Action timeout in milliseconds." })),
+            mode: Type.Optional(StringEnum(["exec", "eval", "auto"], { description: "For exec: execution mode. Use eval when you need an expression result." })),
+            closeOnSuccess: Type.Optional(Type.Boolean({ description: "For exec: close the runtime only if execution succeeds." })),
+            expression: Type.Optional(Type.String({ description: "Expression to inspect." })),
+            what: Type.Optional(StringEnum(["summary", "signature", "members", "source", "doc", "all"], { description: "Inspection detail to return." })),
+            maxBytes: Type.Optional(Type.Number({ description: "Maximum bytes for summaries or inspect fields." })),
+            includePrivate: Type.Optional(Type.Boolean({ description: "For vars: include private names." })),
+            maxItems: Type.Optional(Type.Number({ description: "For vars: maximum variables to return." })),
+        }),
+        async execute(_toolCallId, params) {
+            let result;
+            try {
+                switch (params.action) {
+                    case "exec":
+                        result = await controller.exec({
+                            sessionId: params.sessionId,
+                            runtime: params.runtime,
+                            name: params.name,
+                            target: validateTarget(params.target),
+                            code: requireString(params.code, "code"),
+                            timeoutMs: params.timeoutMs,
+                            mode: params.mode,
+                            closeOnSuccess: params.closeOnSuccess,
+                        });
+                        break;
+                    case "inspect":
+                        result = await controller.inspect({
+                            sessionId: params.sessionId,
+                            runtime: params.runtime,
+                            expression: requireString(params.expression, "expression"),
+                            what: params.what,
+                            maxBytes: params.maxBytes,
+                        });
+                        break;
+                    case "vars":
+                        result = await controller.vars({ sessionId: params.sessionId, runtime: params.runtime, includePrivate: params.includePrivate, maxItems: params.maxItems, maxBytes: params.maxBytes });
+                        break;
+                    case "interrupt":
+                        result = await controller.interrupt({ sessionId: params.sessionId, runtime: params.runtime });
+                        break;
+                    case "list":
+                        result = await controller.list({});
+                        break;
+                }
+            }
+            catch (error) {
+                result = {
+                    status: "failed",
+                    error: error instanceof Error ? { name: error.name, message: error.message, stack: error.stack } : { name: "RuntimeToolError", message: String(error) },
+                };
+            }
+            const status = resultStatus(result);
+            return {
+                content: [{ type: "text", text: formatRuntimeResult(result) }],
+                details: result,
+                isError: isErrorStatus(status),
+            };
+        },
+    });
+}

package/dist/tools/runtime/types.js

@@ -0,0 +1 @@
+export {};