@pasko70/pibo 3.0.2 → 3.1.0

package/dist/tools/browser-use-leases.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
-import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { cp, mkdir, rm, stat, writeFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { ErrorCode, formatCliError } from '../cli-errors.js';
 import { BROWSER_USE_DEFAULT_PROFILE } from './browser-use-wrapper.js';
@@ -10,6 +11,8 @@ const DEFAULT_APP = 'pibo-chat';
 const DEFAULT_TTL_MINUTES = 8 * 60;
 const DEFAULT_TEMPLATE_PROFILE = 'pibo-auth-template';
 const AUTH_POOL_DIR = 'auth-pool';
+const REGISTRY_LOCK_OWNER_FILE = 'owner.json';
+const LEGACY_REGISTRY_LOCK_STALE_MS = 10 * 60_000;
 function shellQuote(value) {
     return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -32,6 +35,9 @@ function registryPath(status) {
 function lockDir(status) {
     return join(status.homeDir, AUTH_POOL_DIR, '.leases.lock');
 }
+function lockOwnerPath(lock) {
+    return join(lock, REGISTRY_LOCK_OWNER_FILE);
+}
 function appPoolDir(status, app) {
     return join(status.homeDir, AUTH_POOL_DIR, sanitizeIdPart(app));
 }
@@ -110,29 +116,135 @@ async function writeRegistry(status, registry) {
 async function withRegistryLock(status, action) {
     const lock = lockDir(status);
     await mkdir(join(status.homeDir, AUTH_POOL_DIR), { recursive: true });
-    let acquired = false;
+    const token = randomUUID();
     for (let attempt = 0; attempt < 50; attempt += 1) {
         try {
             await mkdir(lock);
-            acquired = true;
+            const processStartId = currentProcessStartId();
+            try {
+                await writeFile(lockOwnerPath(lock), `${JSON.stringify({
+                    pid: process.pid,
+                    token,
+                    acquiredAt: Date.now(),
+                    ...(processStartId ? { processStartId } : {}),
+                })}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+            }
+            catch (error) {
+                await rm(lock, { recursive: true, force: true });
+                throw error;
+            }
             break;
         }
         catch (error) {
             if (error.code !== 'EEXIST')
                 throw error;
+            await recoverStaleRegistryLock(lock);
+            if (!existsSync(lock))
+                continue;
             await new Promise((resolve) => setTimeout(resolve, 50));
         }
     }
-    if (!acquired) {
+    if (!await registryLockOwnedBy(lock, token)) {
         throw new Error('Timed out waiting for browser-use lease registry lock');
     }
     try {
         return await action();
     }
     finally {
+        await releaseRegistryLock(lock, token);
+    }
+}
+function currentProcessStartId() {
+    if (process.platform !== 'linux')
+        return undefined;
+    const identity = linuxProcessIdentity(process.pid);
+    return identity.liveness === 'active' ? identity.startId : undefined;
+}
+function linuxProcessIdentity(pid) {
+    let raw;
+    try {
+        raw = readFileSync(`/proc/${pid}/stat`, 'utf8');
+    }
+    catch (error) {
+        const code = error.code;
+        return code === 'ENOENT' || code === 'ESRCH' ? { liveness: 'dead' } : { liveness: 'ambiguous' };
+    }
+    const commandEnd = raw.lastIndexOf(')');
+    if (commandEnd < 2 || commandEnd + 2 >= raw.length)
+        return { liveness: 'ambiguous' };
+    const fields = raw.slice(commandEnd + 2).trim().split(/\s+/);
+    if (fields[0] === 'Z')
+        return { liveness: 'dead' };
+    const startTicks = fields[19];
+    if (!startTicks || !/^[1-9][0-9]*$/.test(startTicks))
+        return { liveness: 'ambiguous' };
+    return { liveness: 'active', startId: `${pid}:${startTicks}` };
+}
+function validRegistryLockOwner(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const owner = value;
+    if (!Number.isSafeInteger(owner.pid)
+        || (owner.pid ?? 0) <= 0
+        || typeof owner.token !== 'string'
+        || owner.token.length === 0
+        || !Number.isFinite(owner.acquiredAt)
+        || (owner.processStartId !== undefined && typeof owner.processStartId !== 'string'))
+        return undefined;
+    return owner;
+}
+function readRegistryLockOwner(lock) {
+    try {
+        return validRegistryLockOwner(JSON.parse(readFileSync(lockOwnerPath(lock), 'utf8')));
+    }
+    catch {
+        return undefined;
+    }
+}
+function registryLockOwnerLiveness(owner) {
+    if (process.platform === 'linux') {
+        const identity = linuxProcessIdentity(owner.pid);
+        if (identity.liveness !== 'active')
+            return identity.liveness;
+        if (!owner.processStartId || !identity.startId)
+            return 'ambiguous';
+        return owner.processStartId === identity.startId ? 'active' : 'dead';
+    }
+    try {
+        process.kill(owner.pid, 0);
+        return 'active';
+    }
+    catch (error) {
+        return error.code === 'ESRCH' ? 'dead' : 'ambiguous';
+    }
+}
+async function registryLockOwnedBy(lock, token) {
+    return readRegistryLockOwner(lock)?.token === token;
+}
+async function releaseRegistryLock(lock, token) {
+    if (await registryLockOwnedBy(lock, token)) {
         await rm(lock, { recursive: true, force: true });
     }
 }
+async function recoverStaleRegistryLock(lock) {
+    const owner = readRegistryLockOwner(lock);
+    if (owner) {
+        if (registryLockOwnerLiveness(owner) === 'dead' && readRegistryLockOwner(lock)?.token === owner.token) {
+            await rm(lock, { recursive: true, force: true });
+        }
+        return;
+    }
+    try {
+        const lockStat = await stat(lock);
+        if (Date.now() - lockStat.mtimeMs > LEGACY_REGISTRY_LOCK_STALE_MS) {
+            await rm(lock, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
 export function isExpired(lease, now = new Date()) {
     return new Date(lease.expiresAt).getTime() <= now.getTime();
 }
@@ -346,7 +458,7 @@ export async function acquireBrowserUseLease(context, options = {}) {
     const ttlMinutes = options.ttlMinutes ?? DEFAULT_TTL_MINUTES;
     const profileName = options.profileName?.trim() || BROWSER_USE_DEFAULT_PROFILE;
     const templateDir = options.templateDir?.trim() || defaultTemplateDir(context.status);
-    await withRegistryLock(context.status, async () => {
+    const { lease, reapedCount } = await withRegistryLock(context.status, async () => {
         const registry = readRegistry(context.status);
         const reapedCount = await reapStaleLeasesInRegistry(context.status, registry);
         let lease = selectReusableLease(context.status, registry.leases, app);
@@ -380,18 +492,19 @@ export async function acquireBrowserUseLease(context, options = {}) {
             registry.leases.push(lease);
         }
         await writeRegistry(context.status, registry);
-        if (reapedCount > 0 && !options.json) {
-            console.error(`Reaped ${reapedCount} stale lease${reapedCount === 1 ? '' : 's'}`);
-        }
-        if (options.json)
-            printLeaseJson(context.status, lease);
-        else
-            printLeaseEnv(context.status, lease);
-        const warmup = await warmupBrowserUseLease(context, lease, 15000, options.headed);
-        if (!warmup.success && !options.json) {
-            console.error(`Warning: Browser warm-up failed: ${warmup.error?.trim() || 'unknown error'}`);
-        }
+        return { lease, reapedCount };
     });
+    if (reapedCount > 0 && !options.json) {
+        console.error(`Reaped ${reapedCount} stale lease${reapedCount === 1 ? '' : 's'}`);
+    }
+    if (options.json)
+        printLeaseJson(context.status, lease);
+    else
+        printLeaseEnv(context.status, lease);
+    const warmup = await warmupBrowserUseLease(context, lease, 15000, options.headed);
+    if (!warmup.success && !options.json) {
+        console.error(`Warning: Browser warm-up failed: ${warmup.error?.trim() || 'unknown error'}`);
+    }
 }
 async function warmupBrowserUseLease(context, lease, timeoutMs = 15000, headed = false) {
     const wrapperPath = join(context.status.homeDir, 'bin', 'browser-use');

package/dist/tools/browser-use-wrapper.js

@@ -771,7 +771,7 @@ exec "$real_browser_use" "$@"
 `;
 }
 export function ensureBrowserUseWrapper(status) {
-    if (status.entry.name !== 'browser-use')
+    if (!status.installed || status.entry.name !== 'browser-use')
         return undefined;
     const wrapperPath = join(status.homeDir, 'bin', 'browser-use');
     mkdirSync(dirname(wrapperPath), { recursive: true });

package/dist/tools/index.js

@@ -60,17 +60,21 @@ function printShow(name) {
         const wrapperPath = ensureBrowserUseWrapper(status);
         console.log(`  wrapper: ${wrapperPath ?? 'not generated'}`);
         console.log(`  executable: ${status.executablePath}`);
-        console.log('');
-        console.log('  IMPORTANT: Always use the wrapper path above, not the raw executable.');
-        console.log('  The wrapper manages persistent Chrome profiles and CDP automatically.');
+        if (wrapperPath) {
+            console.log('');
+            console.log('  IMPORTANT: Always use the wrapper path above, not the raw executable.');
+            console.log('  The wrapper manages persistent Chrome profiles and CDP automatically.');
+        }
     }
     else if (entry.name === 'agent-browser') {
         const wrapperPath = ensureAgentBrowserWrapper(status);
         console.log(`  wrapper: ${wrapperPath ?? 'not generated'}`);
         console.log(`  executable: ${status.executablePath}`);
-        console.log('');
-        console.log('  IMPORTANT: Always use the wrapper path above, not the raw executable.');
-        console.log('  The wrapper keeps Agent Browser state under the Pibo tool home.');
+        if (wrapperPath) {
+            console.log('');
+            console.log('  IMPORTANT: Always use the wrapper path above, not the raw executable.');
+            console.log('  The wrapper keeps Agent Browser state under the Pibo tool home.');
+        }
     }
     else {
         console.log(`  executable: ${status.executablePath}`);
@@ -88,8 +92,9 @@ function printShow(name) {
     }
     console.log('');
     console.log('Next:');
-    if (entry.kind !== 'internal')
-        console.log(`  pibo tools env ${entry.name}`);
+    if (entry.kind !== 'internal') {
+        console.log(status.installed ? `  pibo tools env ${entry.name}` : `  pibo tools install ${entry.name}`);
+    }
     console.log(`  pibo tools guide ${entry.name} ${entry.guides[0]?.name ?? ''}`.trimEnd());
     if (entry.name === 'browser-use') {
         console.log('  pibo tools browser-use');
@@ -133,9 +138,21 @@ function printGuide(name, guideName) {
     }
     console.log(guide.content);
 }
-function printPath(name) {
+function requireInstalledTool(name) {
     const entry = requireEntry(name);
     const status = getCliToolStatus(entry);
+    if (!status.installed) {
+        throw new Error(formatCliError({
+            code: ErrorCode.CLIENT_ERROR,
+            type: 'CLI_TOOL_NOT_INSTALLED',
+            message: `Tool "${name}" is not installed`,
+            suggestion: `Run pibo tools install ${name}.`,
+        }));
+    }
+    return { entry, status };
+}
+function printPath(name) {
+    const { entry, status } = requireInstalledTool(name);
     if (entry.name === 'browser-use') {
         const wrapperPath = ensureBrowserUseWrapper(status);
         if (wrapperPath) {
@@ -153,8 +170,7 @@ function printPath(name) {
     console.log(status.executablePath);
 }
 function printEnv(name) {
-    const entry = requireEntry(name);
-    const status = getCliToolStatus(entry);
+    const { entry, status } = requireInstalledTool(name);
     const desktop = detectDesktopEnv();
     if (entry.kind === 'internal') {
         console.log(`# ${entry.name} is built into pibo; no extra environment is required.`);

package/dist/tools/python-runtime.js

@@ -52,7 +52,7 @@ function runBuffered(command, args, env = process.env) {
 function isRootUser() {
     return typeof process.getuid === 'function' && process.getuid() === 0;
 }
-async function resolveUvCommand() {
+async function findUvCommand() {
     const uv = await runBuffered('uv', ['--version']);
     if (uv.ok)
         return 'uv';
@@ -62,7 +62,14 @@ async function resolveUvCommand() {
         if (local.ok)
             return localUv;
     }
+    return undefined;
+}
+async function ensureUvCommand() {
+    const uvCommand = await findUvCommand();
+    if (uvCommand)
+        return uvCommand;
     if (process.platform === 'linux' && isRootUser()) {
+        const localUv = join(homedir(), '.local', 'bin', 'uv');
         console.log('uv was not found on PATH. Installing uv automatically.');
         await runInheritedCommand('sh', ['-c', 'curl -LsSf https://astral.sh/uv/install.sh | sh']);
         const installed = await runBuffered(localUv, ['--version'], {
@@ -107,7 +114,7 @@ export function runInheritedCommand(command, args, env = process.env) {
 }
 export async function printToolPythonRuntimeDoctor(name, spec) {
     const paths = getToolPythonRuntimePaths(name, spec);
-    const uvCommand = await resolveUvCommand();
+    const uvCommand = await findUvCommand();
     const uv = uvCommand ? await runBuffered(uvCommand, ['--version']) : { ok: false, output: 'missing' };
     const python = uv.ok
         ? await runBuffered(uvCommand, ['python', 'find', spec.pythonVersion])
@@ -148,7 +155,7 @@ export async function printToolPythonRuntimeDoctor(name, spec) {
     }
 }
 export async function installToolPythonRuntime(name, spec) {
-    const uvCommand = await resolveUvCommand();
+    const uvCommand = await ensureUvCommand();
     if (!uvCommand) {
         throw new Error(formatCliError({
             code: ErrorCode.CLIENT_ERROR,

package/dist/tools/registry.js

@@ -220,7 +220,7 @@ export async function installCliTool(entry, runSetup) {
     if ((entry.name === 'browser-use' || entry.name === 'agent-browser') && process.platform === 'linux' && !hasDesktopDisplay(detectDesktopEnv())) {
         printLinuxVirtualDisplayHint('  ');
     }
-    console.log(`  env: pibo tools env ${entry.name}`);
+    console.log(status.installed ? `  env: pibo tools env ${entry.name}` : `  install: pibo tools install ${entry.name}`);
 }
 export async function removeCliTool(entry) {
     if (entry.kind === 'internal') {

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

@@ -46,13 +46,23 @@ export class NodeRuntimeBackend {
         this.child = spawn(executable, [...args, "-e", NODE_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("Node 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 NodeRuntimeBackend {
         }
     }
     isAlive() {
-        return this.alive && !this.child.killed;
+        return this.alive;
     }
     getRecord() {
         return { pid: this.child.pid, cwd: this.cwd, executable: this.executable };
@@ -146,7 +156,8 @@ export class NodeRuntimeBackend {
     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/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) {