@pasko70/pibo 3.0.2 → 3.1.0

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

@@ -1,13 +1,151 @@
 export const PYTHON_RUNTIME_WORKER_SOURCE = String.raw `
-import contextlib
+import contextvars
 import inspect
-import io
 import json
+import os
 import signal
+import subprocess
 import sys
+import threading
 import traceback
 
 user_globals = {"__name__": "__pibo_runtime__"}
+protocol_stream = os.fdopen(3, "w", encoding="utf-8", buffering=1, closefd=False)
+output_context = contextvars.ContextVar("pibo_runtime_output", default=None)
+original_stdout = sys.stdout
+original_stderr = sys.stderr
+original_popen = subprocess.Popen
+
+
+def append_output(output, stream, value):
+    text = str(value)
+    if output is None:
+        target = original_stdout if stream == "stdout" else original_stderr
+        target.write(text)
+        target.flush()
+        return
+    with output["lock"]:
+        output[stream].append(text)
+
+
+class BinaryOutputProxy:
+    def __init__(self, stream, fallback):
+        self.stream = stream
+        self.fallback = fallback
+
+    def write(self, value):
+        data = bytes(value)
+        append_output(output_context.get(), self.stream, data.decode("utf-8", "replace"))
+        return len(data)
+
+    def flush(self):
+        self.fallback.flush()
+
+    def __getattr__(self, name):
+        return getattr(self.fallback, name)
+
+
+class OutputProxy:
+    def __init__(self, stream, fallback):
+        self.stream = stream
+        self.fallback = fallback
+        self.encoding = getattr(fallback, "encoding", "utf-8")
+        self.errors = getattr(fallback, "errors", "replace")
+        self.buffer = BinaryOutputProxy(stream, fallback.buffer)
+
+    def write(self, value):
+        append_output(output_context.get(), self.stream, value)
+        return len(str(value))
+
+    def flush(self):
+        self.fallback.flush()
+
+    def __getattr__(self, name):
+        return getattr(self.fallback, name)
+
+
+sys.stdout = OutputProxy("stdout", original_stdout)
+sys.stderr = OutputProxy("stderr", original_stderr)
+
+
+def drain_child_output(read_fd, output, stream):
+    try:
+        with os.fdopen(read_fd, "rb", closefd=True) as source:
+            while True:
+                chunk = source.read(65536)
+                if not chunk:
+                    return
+                append_output(output, stream, chunk.decode("utf-8", "replace"))
+    except Exception:
+        return
+
+
+def join_child_output(threads):
+    for thread in threads:
+        thread.join(0.2)
+
+
+def routed_popen(*args, **kwargs):
+    output = output_context.get()
+    if output is None:
+        return original_popen(*args, **kwargs)
+
+    options = dict(kwargs)
+    routes = []
+    if options.get("stdout") is None:
+        read_fd, write_fd = os.pipe()
+        options["stdout"] = write_fd
+        routes.append((read_fd, write_fd, "stdout"))
+    if options.get("stderr") is None:
+        read_fd, write_fd = os.pipe()
+        options["stderr"] = write_fd
+        routes.append((read_fd, write_fd, "stderr"))
+
+    try:
+        process = original_popen(*args, **options)
+    except Exception:
+        for read_fd, write_fd, _ in routes:
+            os.close(read_fd)
+            os.close(write_fd)
+        raise
+
+    process_threads = []
+    for read_fd, write_fd, stream in routes:
+        os.close(write_fd)
+        thread = threading.Thread(target=drain_child_output, args=(read_fd, output, stream), daemon=True)
+        with output["lock"]:
+            output["threads"].append(thread)
+        process_threads.append(thread)
+        thread.start()
+
+    if process_threads:
+        original_wait = process.wait
+        original_poll = process.poll
+        original_communicate = process.communicate
+
+        def wait_with_output(*wait_args, **wait_kwargs):
+            result = original_wait(*wait_args, **wait_kwargs)
+            join_child_output(process_threads)
+            return result
+
+        def poll_with_output(*poll_args, **poll_kwargs):
+            result = original_poll(*poll_args, **poll_kwargs)
+            if result is not None:
+                join_child_output(process_threads)
+            return result
+
+        def communicate_with_output(*communicate_args, **communicate_kwargs):
+            result = original_communicate(*communicate_args, **communicate_kwargs)
+            join_child_output(process_threads)
+            return result
+
+        process.wait = wait_with_output
+        process.poll = poll_with_output
+        process.communicate = communicate_with_output
+    return process
+
+
+subprocess.Popen = routed_popen
 
 
 def bounded(value, max_bytes=8192):
@@ -70,31 +208,44 @@ def error_summary(exc):
     return out
 
 
+def output_snapshot(output):
+    with output["lock"]:
+        threads = list(output["threads"])
+    for thread in threads:
+        thread.join(0.05)
+    with output["lock"]:
+        return "".join(output["stdout"]), "".join(output["stderr"])
+
+
 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()
+    output = {"stdout": [], "stderr": [], "threads": [], "lock": threading.Lock()}
+    token = output_context.set(output)
     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
+        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
+        stdout, stderr = output_snapshot(output)
         return {
             "id": req.get("id"),
             "status": "ok",
-            "stdout": stdout.getvalue(),
-            "stderr": stderr.getvalue(),
+            "stdout": stdout,
+            "stderr": stderr,
             "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)}
+        stdout, stderr = output_snapshot(output)
+        return {"id": req.get("id"), "status": "interrupted", "stdout": stdout, "stderr": stderr, "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)}
+        stdout, stderr = output_snapshot(output)
+        return {"id": req.get("id"), "status": "error", "stdout": stdout, "stderr": stderr, "error": error_summary(exc)}
+    finally:
+        output_context.reset(token)
 
 
 def inspect_value(req):
@@ -147,8 +298,8 @@ def list_vars(req):
 
 
 def write_response(resp):
-    sys.stdout.write(json.dumps(resp, ensure_ascii=False) + "\n")
-    sys.stdout.flush()
+    protocol_stream.write(json.dumps(resp, ensure_ascii=False) + "\n")
+    protocol_stream.flush()
 
 
 def main():

package/dist/tools/runtime/registry.js

@@ -106,12 +106,7 @@ export class RuntimeSessionRegistry {
         result.executionCount = session.executionCount;
         session.lastExecAt = startedAt;
         session.updatedAt = nowIso();
-        if (result.status === "failed" && !session.backend.isAlive()) {
-            session.status = "failed";
-        }
-        else {
-            session.status = "idle";
-        }
+        session.status = session.backend.isAlive() ? "idle" : "failed";
         this.appendHistory(session, {
             id: randomUUID(),
             startedAt,
@@ -131,6 +126,7 @@ export class RuntimeSessionRegistry {
         if (!session)
             return notFoundInspect(input.sessionId);
         const result = await session.backend.inspect(input);
+        this.reconcileSession(session);
         return { ...result, sessionId: session.sessionId };
     }
     async vars(controllerPiboSessionId, input) {
@@ -138,6 +134,7 @@ export class RuntimeSessionRegistry {
         if (!session)
             return notFoundVars(input.sessionId);
         const result = await session.backend.vars(input);
+        this.reconcileSession(session);
         return { ...result, sessionId: session.sessionId };
     }
     async interrupt(controllerPiboSessionId, input) {
@@ -145,7 +142,12 @@ export class RuntimeSessionRegistry {
         const sessionId = input.sessionId ?? session?.sessionId ?? "auto";
         if (!session)
             return { status: "not_found", sessionId, message: `Runtime session "${sessionId}" was not found.` };
+        if (session.status === "closed" || session.status === "failed")
+            return { status: "failed", sessionId, message: "Runtime worker is not alive" };
+        if (session.status !== "busy")
+            return { status: "ok", sessionId, message: "Runtime session is idle; no active execution to interrupt" };
         const result = await session.backend.interrupt();
+        this.reconcileSession(session);
         return { ...result, sessionId: session.sessionId };
     }
     async close(controllerPiboSessionId, input) {
@@ -176,6 +178,7 @@ export class RuntimeSessionRegistry {
             status: "ok",
             sessions: [...this.sessions.values()]
                 .filter((session) => session.controllerPiboSessionId === controllerPiboSessionId)
+                .map((session) => this.reconcileSession(session))
                 .map(toRecord),
         };
     }
@@ -189,6 +192,7 @@ export class RuntimeSessionRegistry {
     }
     pruneIdle(now = Date.now(), idleTimeoutMs = 30 * 60 * 1000) {
         for (const session of this.sessions.values()) {
+            this.reconcileSession(session);
             if (session.status !== "idle")
                 continue;
             if (now - Date.parse(session.updatedAt) > idleTimeoutMs) {
@@ -208,10 +212,12 @@ export class RuntimeSessionRegistry {
         };
     }
     getDefault(controllerPiboSessionId, runtime) {
-        return [...this.sessions.values()].find((session) => session.controllerPiboSessionId === controllerPiboSessionId &&
-            session.runtime === runtime &&
-            session.status !== "closed" &&
-            session.status !== "failed");
+        return [...this.sessions.values()].find((session) => {
+            if (session.controllerPiboSessionId !== controllerPiboSessionId || session.runtime !== runtime)
+                return false;
+            const status = this.reconcileSession(session).status;
+            return status !== "closed" && status !== "failed";
+        });
     }
     async getOrStartDefault(controllerPiboSessionId, input) {
         const runtime = input.runtime ?? "python";
@@ -230,6 +236,13 @@ export class RuntimeSessionRegistry {
         const session = this.sessions.get(sessionId);
         if (!session || session.controllerPiboSessionId !== controllerPiboSessionId)
             return undefined;
+        return this.reconcileSession(session);
+    }
+    reconcileSession(session) {
+        if (session.status !== "closed" && session.status !== "failed" && !session.backend.isAlive()) {
+            session.status = "failed";
+            session.updatedAt = nowIso();
+        }
         return session;
     }
     appendHistory(session, entry) {

package/dist/user-skills/store.js

@@ -148,7 +148,6 @@ export function updateUserSkill(id, input, cwd = process.cwd()) {
         writeFileSync(skillPath, markdown, "utf-8");
     }
     else if (name !== existing.name || description !== parsed.description) {
-        const currentMarkdown = existsSync(existing.path) ? readFileSync(existing.path, "utf-8") : "";
         const { body } = parseSkillMd(currentMarkdown);
         writeFileSync(skillPath, buildSkillMd(name, description, body), "utf-8");
     }

package/npm-shrinkwrap.json

@@ -1,16 +1,17 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "3.0.2",
+      "version": "3.1.0",
       "workspaces": [
         "packages/workflows"
       ],
       "dependencies": {
+        "@balena/dockerignore": "1.0.2",
         "@earendil-works/pi-agent-core": "0.84.2",
         "@earendil-works/pi-ai": "0.84.2",
         "@earendil-works/pi-coding-agent": "0.84.2",
@@ -968,6 +969,12 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@balena/dockerignore": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@balena/dockerignore/-/dockerignore-1.0.2.tgz",
+      "integrity": "sha512-wMue2Sy4GAVTk6Ic4tJVcnfdau+gx2EnG7S+uAEe+TWJFqE4YoWN4/H8MSLj4eYJKxGg26lZwboEniNiNwZQ6Q==",
+      "license": "Apache-2.0"
+    },
     "node_modules/@better-auth/core": {
       "version": "1.6.30",
       "resolved": "https://registry.npmjs.org/@better-auth/core/-/core-1.6.30.tgz",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "type": "module",
   "workspaces": [
     "packages/workflows"
@@ -14,7 +14,12 @@
     "docs/ops/**",
     "README.md",
     "src/mcp/LICENSE.mcp-cli",
-    "npm-shrinkwrap.json"
+    "npm-shrinkwrap.json",
+    "compute-image/Dockerfile",
+    "compute-image/Dockerfile.dockerignore",
+    "scripts/docker-entrypoint.sh",
+    "scripts/prepare-browser-use-wrapper.sh",
+    "scripts/prepare-agent-browser-wrapper.sh"
   ],
   "bin": {
     "pibo": "dist/bin/pibo.js",
@@ -58,6 +63,7 @@
     "postpack": "node scripts/package-shrinkwrap.mjs clean"
   },
   "dependencies": {
+    "@balena/dockerignore": "1.0.2",
     "@earendil-works/pi-agent-core": "0.84.2",
     "@earendil-works/pi-ai": "0.84.2",
     "@earendil-works/pi-coding-agent": "0.84.2",

package/scripts/docker-entrypoint.sh

@@ -0,0 +1,46 @@
+#!/bin/sh
+set -e
+
+# Xvfb starten (virtueller Display-Server für Browser-Automation)
+if ! pgrep -x Xvfb >/dev/null 2>&1; then
+  echo "[docker-entrypoint] Starting Xvfb on DISPLAY=:99 ..."
+  Xvfb :99 -screen 0 1920x1080x24 -ac -nolisten tcp &
+  sleep 0.5
+fi
+
+export DISPLAY=:99
+
+# Sicherstellen, dass die Browser-Wrapper existieren
+if [ ! -x "$HOME/.pibo/tools/browser-use/home/bin/browser-use" ]; then
+  echo "[docker-entrypoint] Preparing browser-use wrapper ..."
+  /app/scripts/prepare-browser-use-wrapper.sh
+fi
+
+if [ ! -x "$HOME/.pibo/tools/agent-browser/home/bin/agent-browser" ]; then
+  echo "[docker-entrypoint] Preparing agent-browser wrapper ..."
+  /app/scripts/prepare-agent-browser-wrapper.sh
+fi
+
+# PATH erweitern
+export PATH="$HOME/.pibo/tools/agent-browser/home/bin:$HOME/.pibo/tools/agent-browser/node/node_modules/.bin:$HOME/.pibo/tools/browser-use/home/bin:$HOME/.pibo/tools/browser-use/.venv/bin:$PATH"
+export BROWSER_USE_HOME="$HOME/.pibo/tools/browser-use/home"
+export AGENT_BROWSER_HOME="$HOME/.pibo/tools/agent-browser/home"
+
+# Pibo-CLI-Argumente verarbeiten
+case "${1:-gateway}" in
+  gateway)
+    echo "[docker-entrypoint] Starting Pibo gateway on 0.0.0.0:4789 ..."
+    exec node -e "import('./dist/gateway/server.js').then(m => m.runGatewayServer({ host: '0.0.0.0' }))"
+    ;;
+  gateway:web)
+    echo "[docker-entrypoint] Starting Pibo gateway:web with local auth on 0.0.0.0:4789 ..."
+    exec node -e "import('./dist/gateway/web.js').then(m => m.runWebGatewayServer({ authMode: 'local', web: { host: '0.0.0.0' } }))"
+    ;;
+  shell|bash|sh)
+    exec /bin/sh
+    ;;
+  *)
+    # Alles andere direkt an Pibo weiterleiten
+    exec node dist/bin/pibo.js "$@"
+    ;;
+esac

package/scripts/prepare-agent-browser-wrapper.sh

@@ -0,0 +1,70 @@
+#!/bin/sh
+set -e
+
+real_agent_browser="$HOME/.pibo/tools/agent-browser/node/node_modules/.bin/agent-browser"
+wrapper_dir="$HOME/.pibo/tools/agent-browser/home/bin"
+wrapper_path="$wrapper_dir/agent-browser"
+
+mkdir -p "$wrapper_dir" "$HOME/.pibo/tools/agent-browser/home/profiles"
+
+cat > "$wrapper_path" <<'WRAPPER'
+#!/usr/bin/env bash
+set -euo pipefail
+
+real_agent_browser="$HOME/.pibo/tools/agent-browser/node/node_modules/.bin/agent-browser"
+default_home="$HOME/.pibo/tools/agent-browser/home"
+
+if [ -z "${AGENT_BROWSER_HOME:-}" ]; then
+  export AGENT_BROWSER_HOME="$default_home"
+fi
+mkdir -p "$AGENT_BROWSER_HOME" "$AGENT_BROWSER_HOME/profiles"
+
+if [ "${PIBO_AGENT_BROWSER_PRESERVE_HOME:-0}" != "1" ]; then
+  export HOME="$AGENT_BROWSER_HOME"
+fi
+
+explicit_runtime=0
+fresh_profile=0
+show_help=0
+starts_browser=0
+args=()
+
+print_wrapper_help() {
+  cat <<'HELP'
+Pibo agent-browser wrapper
+  - keeps Agent Browser state under AGENT_BROWSER_HOME by default
+  - prepends a persistent Pibo profile for browser-launching commands
+  - pass --fresh-profile to disable Pibo profile injection
+HELP
+}
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --help|-h) show_help=1; args+=("$1") ;;
+    --fresh-profile) fresh_profile=1 ;;
+    --profile|--state|--cdp|--auto-connect|--provider|--engine|--executable-path|--config)
+      explicit_runtime=1; args+=("$1"); if [ "$#" -gt 1 ]; then shift; args+=("$1"); fi ;;
+    --profile=*|--state=*|--cdp=*|--auto-connect=*|--provider=*|--engine=*|--executable-path=*|--config=*)
+      explicit_runtime=1; args+=("$1") ;;
+    open|launch|new|goto) starts_browser=1; args+=("$1") ;;
+    *) args+=("$1") ;;
+  esac
+  shift
+done
+
+if [ "$show_help" -eq 1 ]; then
+  print_wrapper_help
+  exec "$real_agent_browser" "${args[@]}"
+fi
+
+if [ "$starts_browser" -eq 1 ] && [ "$fresh_profile" -eq 0 ] && [ "$explicit_runtime" -eq 0 ]; then
+  profile_dir=${AGENT_BROWSER_PROFILE:-$AGENT_BROWSER_HOME/profiles/PIBo}
+  mkdir -p "$profile_dir"
+  exec "$real_agent_browser" --profile "$profile_dir" "${args[@]}"
+fi
+
+exec "$real_agent_browser" "${args[@]}"
+WRAPPER
+
+chmod +x "$wrapper_path"
+printf '%s\n' "$wrapper_path"