@pasko70/pibo 3.0.2 → 3.1.1

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

@@ -1,8 +1,11 @@
 export const NODE_RUNTIME_WORKER_SOURCE = String.raw `
 const vm = require("node:vm");
 const util = require("node:util");
+const fs = require("node:fs");
+const childProcess = require("node:child_process");
+const { AsyncLocalStorage } = require("node:async_hooks");
 
-let currentOutput = null;
+const outputStorage = new AsyncLocalStorage();
 
 function bounded(value, maxBytes = 8192) {
 	const text = String(value);
@@ -48,14 +51,91 @@ function errorSummary(error) {
 	return out;
 }
 
+function appendOutput(output, stream, chunk) {
+	if (output) output[stream] += String(chunk);
+	else if (stream === "stdout") process.stdout.write(String(chunk));
+	else process.stderr.write(String(chunk));
+}
+
 function appendStdout(chunk) {
-	if (currentOutput) currentOutput.stdout += String(chunk);
+	appendOutput(outputStorage.getStore(), "stdout", chunk);
 }
 
 function appendStderr(chunk) {
-	if (currentOutput) currentOutput.stderr += String(chunk);
+	appendOutput(outputStorage.getStore(), "stderr", chunk);
+}
+
+function routedStdio(stdio) {
+	if (stdio === "inherit") {
+		return { stdio: ["inherit", "pipe", "pipe"], stdout: true, stderr: true };
+	}
+	if (!Array.isArray(stdio)) return undefined;
+	const next = [...stdio];
+	const stdout = next[1] === "inherit" || next[1] === 1;
+	const stderr = next[2] === "inherit" || next[2] === 2;
+	if (!stdout && !stderr) return undefined;
+	if (stdout) next[1] = "pipe";
+	if (stderr) next[2] = "pipe";
+	return { stdio: next, stdout, stderr };
+}
+
+function captureSpawnedOutput(child, output, route) {
+	if (route.stdout && child.stdout) child.stdout.on("data", (chunk) => appendOutput(output, "stdout", chunk));
+	if (route.stderr && child.stderr) child.stderr.on("data", (chunk) => appendOutput(output, "stderr", chunk));
+	if (child.spawnargs && child.spawnargs.length > 0 && child.stdout && typeof child.stdout.unref === "function") child.stdout.unref();
+	if (child.spawnargs && child.spawnargs.length > 0 && child.stderr && typeof child.stderr.unref === "function") child.stderr.unref();
+}
+
+function routedSpawn(command, args, options) {
+	const hasArgs = Array.isArray(args);
+	const actualArgs = hasArgs ? args : [];
+	const actualOptions = (hasArgs ? options : args) || {};
+	const output = outputStorage.getStore();
+	const route = output ? routedStdio(actualOptions.stdio) : undefined;
+	if (!route) return hasArgs ? childProcess.spawn(command, actualArgs, actualOptions) : childProcess.spawn(command, actualOptions);
+	const child = childProcess.spawn(command, actualArgs, { ...actualOptions, stdio: route.stdio });
+	captureSpawnedOutput(child, output, route);
+	return child;
+}
+
+function routedSpawnSync(command, args, options) {
+	const hasArgs = Array.isArray(args);
+	const actualArgs = hasArgs ? args : [];
+	const actualOptions = (hasArgs ? options : args) || {};
+	const output = outputStorage.getStore();
+	const route = output ? routedStdio(actualOptions.stdio) : undefined;
+	if (!route) return hasArgs ? childProcess.spawnSync(command, actualArgs, actualOptions) : childProcess.spawnSync(command, actualOptions);
+	const result = childProcess.spawnSync(command, actualArgs, { ...actualOptions, stdio: route.stdio });
+	if (route.stdout && result.stdout != null) appendOutput(output, "stdout", result.stdout);
+	if (route.stderr && result.stderr != null) appendOutput(output, "stderr", result.stderr);
+	if (route.stdout) {
+		result.stdout = null;
+		if (result.output) result.output[1] = null;
+	}
+	if (route.stderr) {
+		result.stderr = null;
+		if (result.output) result.output[2] = null;
+	}
+	return result;
 }
 
+const childProcessProxy = new Proxy(childProcess, {
+	get(target, prop, receiver) {
+		if (prop === "spawn") return routedSpawn;
+		if (prop === "spawnSync") return routedSpawnSync;
+		return Reflect.get(target, prop, receiver);
+	},
+});
+
+function runtimeRequire(specifier) {
+	if (specifier === "child_process" || specifier === "node:child_process") return childProcessProxy;
+	return require(specifier);
+}
+runtimeRequire.resolve = require.resolve;
+runtimeRequire.cache = require.cache;
+runtimeRequire.extensions = require.extensions;
+runtimeRequire.main = require.main;
+
 const processProxy = new Proxy(process, {
 	get(target, prop, receiver) {
 		if (prop === "stdout") return { write: (chunk) => { appendStdout(chunk); return true; } };
@@ -75,7 +155,7 @@ const consoleProxy = {
 
 const context = vm.createContext({
 	console: consoleProxy,
-	require,
+	require: runtimeRequire,
 	process: processProxy,
 	Buffer,
 	URL,
@@ -97,34 +177,33 @@ 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;
-	}
+	return await outputStorage.run(output, async () => {
+		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),
+			};
+		}
+	});
 }
 
 async function inspectValue(req) {
@@ -167,7 +246,7 @@ function listVars(req) {
 }
 
 function writeResponse(resp) {
-	process.stdout.write(JSON.stringify(resp) + "\n");
+	fs.writeSync(3, JSON.stringify(resp) + "\n");
 }
 
 async function handle(req) {

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

@@ -46,13 +46,23 @@ export class PythonRuntimeBackend {
         this.child = spawn(executable, [...args, "-u", "-c", PYTHON_RUNTIME_WORKER_SOURCE], {
             cwd,
             env: { ...process.env, ...(env ?? {}) },
-            stdio: "pipe",
+            stdio: ["pipe", "pipe", "pipe", "pipe"],
+        });
+        const protocol = this.child.stdio[3];
+        if (!protocol)
+            throw new Error("Python runtime protocol pipe was not created");
+        const responses = createInterface({ input: protocol });
+        responses.on("line", (line) => this.handleLine(line));
+        this.child.stdout.on("data", (chunk) => {
+            this.diagnostics += String(chunk);
         });
-        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.stdin.on("error", (error) => {
+            this.alive = false;
+            this.rejectAll(error);
+        });
         this.child.once("error", (error) => {
             this.alive = false;
             this.readyReject(error);
@@ -78,7 +88,7 @@ export class PythonRuntimeBackend {
         }
     }
     isAlive() {
-        return this.alive && !this.child.killed;
+        return this.alive;
     }
     getRecord() {
         return { pid: this.child.pid, cwd: this.cwd, executable: this.executable };
@@ -145,7 +155,8 @@ export class PythonRuntimeBackend {
     async interrupt() {
         if (!this.isAlive())
             return { status: "failed", sessionId: "", message: "Runtime worker is not alive" };
-        this.child.kill("SIGINT");
+        if (!this.child.kill("SIGINT"))
+            return { status: "failed", sessionId: "", message: "Runtime worker is not alive" };
         return { status: "ok", sessionId: "", message: "Sent SIGINT to runtime worker" };
     }
     async close(force = false) {

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.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "3.0.2",
+      "version": "3.1.1",
       "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.1",
   "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