@pasko70/pibo 1.9.8 → 1.9.9

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

@@ -1,178 +0,0 @@
-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

@@ -1,255 +0,0 @@
-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

@@ -1,168 +0,0 @@
-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

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