@librechat/agents 3.2.32 → 3.2.34

package/dist/esm/tools/cloudflare/CloudflareSandboxExecutionEngine.mjs

@@ -1,575 +1,482 @@
-import { PassThrough } from 'stream';
-import { posix } from 'path';
-import { EventEmitter } from 'events';
-import { validateBashCommand, LOCAL_SPAWN_TIMEOUT_MS } from '../local/LocalExecutionEngine.mjs';
-
-const DEFAULT_WORKSPACE_ROOT = '/workspace';
-const DEFAULT_TIMEOUT_MS = 60000;
-const DEFAULT_MAX_OUTPUT_CHARS = 200000;
+import { LOCAL_SPAWN_TIMEOUT_MS, validateBashCommand } from "../local/LocalExecutionEngine.mjs";
+import { posix } from "path";
+import { PassThrough } from "stream";
+import { EventEmitter } from "events";
+//#region src/tools/cloudflare/CloudflareSandboxExecutionEngine.ts
+const DEFAULT_WORKSPACE_ROOT = "/workspace";
+const DEFAULT_TIMEOUT_MS = 6e4;
+const DEFAULT_MAX_OUTPUT_CHARS = 2e5;
 const PROTECTED_TARGET_ARG_RE = /^(?:\/|~|\$\{?HOME\}?|\.)(?:\/?\.?\*|\/)?$/;
 const DESTRUCTIVE_OP_IN_COMMAND_RE = /\b(?:rm\s+-[^\s]*[rf]|chmod\s+-R|chown\s+-R)\b/;
-const sandboxFactoryCache = new WeakMap();
+const sandboxFactoryCache = /* @__PURE__ */ new WeakMap();
 function normalizeWorkspaceRoot(workspaceRoot) {
-    const normalized = posix.normalize(workspaceRoot);
-    return normalized === '/' ? normalized : normalized.replace(/\/+$/, '');
+	const normalized = posix.normalize(workspaceRoot);
+	return normalized === "/" ? normalized : normalized.replace(/\/+$/, "");
 }
 function getCloudflareWorkspaceRoot(config) {
-    return normalizeWorkspaceRoot(config?.workspaceRoot ?? DEFAULT_WORKSPACE_ROOT);
+	return normalizeWorkspaceRoot(config?.workspaceRoot ?? DEFAULT_WORKSPACE_ROOT);
 }
 async function resolveCloudflareSandbox(config) {
-    const sandbox = config.sandbox;
-    if (typeof sandbox !== 'function') {
-        return sandbox;
-    }
-    let cached = sandboxFactoryCache.get(config);
-    if (cached == null) {
-        cached = Promise.resolve()
-            .then(() => sandbox())
-            .catch((error) => {
-            sandboxFactoryCache.delete(config);
-            throw error;
-        });
-        sandboxFactoryCache.set(config, cached);
-    }
-    return cached;
+	const sandbox = config.sandbox;
+	if (typeof sandbox !== "function") return sandbox;
+	let cached = sandboxFactoryCache.get(config);
+	if (cached == null) {
+		cached = Promise.resolve().then(() => sandbox()).catch((error) => {
+			sandboxFactoryCache.delete(config);
+			throw error;
+		});
+		sandboxFactoryCache.set(config, cached);
+	}
+	return cached;
 }
 async function getRuntimeContext(config) {
-    return {
-        sandbox: await resolveCloudflareSandbox(config),
-        workspaceRoot: getCloudflareWorkspaceRoot(config),
-        env: config.env,
-        timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-        maxOutputChars: config.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS,
-        shell: config.shell ?? 'bash',
-    };
+	return {
+		sandbox: await resolveCloudflareSandbox(config),
+		workspaceRoot: getCloudflareWorkspaceRoot(config),
+		env: config.env,
+		timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+		maxOutputChars: config.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS,
+		shell: config.shell ?? "bash"
+	};
 }
 function toSandboxPath(filePath, workspaceRoot) {
-    const raw = filePath === '' ? '.' : filePath;
-    const root = normalizeWorkspaceRoot(workspaceRoot);
-    const resolved = raw.startsWith('/')
-        ? posix.normalize(raw)
-        : posix.resolve(root, raw);
-    if (root === '/') {
-        return resolved;
-    }
-    if (resolved === root || resolved.startsWith(`${root}/`)) {
-        return resolved;
-    }
-    throw new Error(`Path is outside the Cloudflare sandbox workspace: ${filePath}`);
+	const raw = filePath === "" ? "." : filePath;
+	const root = normalizeWorkspaceRoot(workspaceRoot);
+	const resolved = raw.startsWith("/") ? posix.normalize(raw) : posix.resolve(root, raw);
+	if (root === "/") return resolved;
+	if (resolved === root || resolved.startsWith(`${root}/`)) return resolved;
+	throw new Error(`Path is outside the Cloudflare sandbox workspace: ${filePath}`);
 }
 function quote(value) {
-    if (value === '') {
-        return '\'\'';
-    }
-    if (/^[A-Za-z0-9_/:=.,@%+-]+$/.test(value)) {
-        return value;
-    }
-    return `'${value.replace(/'/g, '\'\\\'\'')}'`;
+	if (value === "") return "''";
+	if (/^[A-Za-z0-9_/:=.,@%+-]+$/.test(value)) return value;
+	return `'${value.replace(/'/g, "'\\''")}'`;
 }
 function withInSandboxTimeout(command, timeoutMs) {
-    const timeoutSeconds = Math.max(1, Math.ceil(timeoutMs / 1000));
-    return `timeout -k 2s ${timeoutSeconds}s ${command}`;
+	return `timeout -k 2s ${Math.max(1, Math.ceil(timeoutMs / 1e3))}s ${command}`;
 }
 function outerTimeoutMs(timeoutMs) {
-    return timeoutMs + 5000;
+	return timeoutMs + 5e3;
 }
 function isInSandboxTimeoutExit(exitCode) {
-    return exitCode === 124 || exitCode === 137;
+	return exitCode === 124 || exitCode === 137;
 }
 function truncateOutput(value, maxChars) {
-    if (maxChars <= 0 || value.length <= maxChars) {
-        return value;
-    }
-    const head = Math.max(Math.floor(maxChars / 2), 0);
-    const tail = Math.max(maxChars - head, 0);
-    return `${value.slice(0, head)}\n...[truncated ${value.length - maxChars} chars]...\n${value.slice(value.length - tail)}`;
+	if (maxChars <= 0 || value.length <= maxChars) return value;
+	const head = Math.max(Math.floor(maxChars / 2), 0);
+	const tail = Math.max(maxChars - head, 0);
+	return `${value.slice(0, head)}\n...[truncated ${value.length - maxChars} chars]...\n${value.slice(value.length - tail)}`;
 }
 async function readStream(stream) {
-    const reader = stream.getReader();
-    const chunks = [];
-    try {
-        for (;;) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            chunks.push(value);
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-    return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
+	const reader = stream.getReader();
+	const chunks = [];
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
 }
 async function normalizeReadFileContent(result) {
-    if (typeof result === 'string') {
-        return Buffer.from(result, 'utf8');
-    }
-    if (Buffer.isBuffer(result)) {
-        return result;
-    }
-    if (result instanceof Uint8Array) {
-        return Buffer.from(result);
-    }
-    const content = result.content;
-    if (typeof content === 'string') {
-        if (result.encoding === 'base64') {
-            return Buffer.from(content, 'base64');
-        }
-        return Buffer.from(content, 'utf8');
-    }
-    if (Buffer.isBuffer(content)) {
-        return content;
-    }
-    if (content instanceof Uint8Array) {
-        return Buffer.from(content);
-    }
-    return readStream(content);
+	if (typeof result === "string") return Buffer.from(result, "utf8");
+	if (Buffer.isBuffer(result)) return result;
+	if (result instanceof Uint8Array) return Buffer.from(result);
+	const content = result.content;
+	if (typeof content === "string") {
+		if (result.encoding === "base64") return Buffer.from(content, "base64");
+		return Buffer.from(content, "utf8");
+	}
+	if (Buffer.isBuffer(content)) return content;
+	if (content instanceof Uint8Array) return Buffer.from(content);
+	return readStream(content);
 }
 function bytesToStream(bytes) {
-    return new ReadableStream({
-        start(controller) {
-            controller.enqueue(bytes);
-            controller.close();
-        },
-    });
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(bytes);
+		controller.close();
+	} });
 }
 function normalizeWriteFileContent(content) {
-    if (typeof content === 'string') {
-        return { content, options: { encoding: 'utf8' } };
-    }
-    return { content: bytesToStream(content) };
+	if (typeof content === "string") return {
+		content,
+		options: { encoding: "utf8" }
+	};
+	return { content: bytesToStream(content) };
 }
 function createStats(info) {
-    const type = info.type ?? 'file';
-    const now = new Date();
-    return {
-        size: info.size ?? 0,
-        isFile: () => type === 'file',
-        isDirectory: () => type === 'directory',
-        isSymbolicLink: () => type === 'symlink',
-        isBlockDevice: () => false,
-        isCharacterDevice: () => false,
-        isFIFO: () => false,
-        isSocket: () => false,
-        dev: 0,
-        ino: 0,
-        mode: 0,
-        nlink: 1,
-        uid: 0,
-        gid: 0,
-        rdev: 0,
-        blksize: 0,
-        blocks: 0,
-        atimeMs: now.getTime(),
-        mtimeMs: now.getTime(),
-        ctimeMs: now.getTime(),
-        birthtimeMs: now.getTime(),
-        atime: now,
-        mtime: now,
-        ctime: now,
-        birthtime: now,
-    };
+	const type = info.type ?? "file";
+	const now = /* @__PURE__ */ new Date();
+	return {
+		size: info.size ?? 0,
+		isFile: () => type === "file",
+		isDirectory: () => type === "directory",
+		isSymbolicLink: () => type === "symlink",
+		isBlockDevice: () => false,
+		isCharacterDevice: () => false,
+		isFIFO: () => false,
+		isSocket: () => false,
+		dev: 0,
+		ino: 0,
+		mode: 0,
+		nlink: 1,
+		uid: 0,
+		gid: 0,
+		rdev: 0,
+		blksize: 0,
+		blocks: 0,
+		atimeMs: now.getTime(),
+		mtimeMs: now.getTime(),
+		ctimeMs: now.getTime(),
+		birthtimeMs: now.getTime(),
+		atime: now,
+		mtime: now,
+		ctime: now,
+		birthtime: now
+	};
 }
 function normalizeFileList(result) {
-    return Array.isArray(result) ? result : result.files;
+	return Array.isArray(result) ? result : result.files;
 }
 function entryNameFor(info, parentPath) {
-    if (info.name !== '') {
-        return info.name.includes('/') ? posix.basename(info.name) : info.name;
-    }
-    if (info.absolutePath != null && info.absolutePath !== '') {
-        return posix.basename(info.absolutePath);
-    }
-    if (info.relativePath != null && info.relativePath !== '') {
-        return posix.basename(info.relativePath);
-    }
-    return posix.basename(parentPath);
+	if (info.name !== "") return info.name.includes("/") ? posix.basename(info.name) : info.name;
+	if (info.absolutePath != null && info.absolutePath !== "") return posix.basename(info.absolutePath);
+	if (info.relativePath != null && info.relativePath !== "") return posix.basename(info.relativePath);
+	return posix.basename(parentPath);
 }
 function entryAbsolutePath(info, parentPath) {
-    if (info.absolutePath != null && info.absolutePath !== '') {
-        return posix.normalize(info.absolutePath);
-    }
-    if (info.relativePath != null && info.relativePath !== '') {
-        return posix.resolve(parentPath, info.relativePath);
-    }
-    return posix.resolve(parentPath, info.name);
+	if (info.absolutePath != null && info.absolutePath !== "") return posix.normalize(info.absolutePath);
+	if (info.relativePath != null && info.relativePath !== "") return posix.resolve(parentPath, info.relativePath);
+	return posix.resolve(parentPath, info.name);
 }
 function createDirent(info) {
-    return {
-        name: entryNameFor(info, ''),
-        isFile: () => (info.type ?? 'file') === 'file',
-        isDirectory: () => info.type === 'directory',
-        isSymbolicLink: () => info.type === 'symlink',
-    };
+	return {
+		name: entryNameFor(info, ""),
+		isFile: () => (info.type ?? "file") === "file",
+		isDirectory: () => info.type === "directory",
+		isSymbolicLink: () => info.type === "symlink"
+	};
 }
 async function findChildInfo(sandbox, filePath) {
-    const parent = posix.dirname(filePath);
-    const basename = posix.basename(filePath);
-    const entries = normalizeFileList(await sandbox.listFiles(parent, { includeHidden: true }));
-    return entries.find((entry) => {
-        const absolute = entryAbsolutePath(entry, parent);
-        return absolute === filePath || entryNameFor(entry, parent) === basename;
-    });
+	const parent = posix.dirname(filePath);
+	const basename = posix.basename(filePath);
+	return normalizeFileList(await sandbox.listFiles(parent, { includeHidden: true })).find((entry) => {
+		return entryAbsolutePath(entry, parent) === filePath || entryNameFor(entry, parent) === basename;
+	});
 }
 function createCloudflareWorkspaceFS(config) {
-    const workspaceRoot = getCloudflareWorkspaceRoot(config);
-    const fs = {
-        readFile: (async (filePath, encoding) => {
-            const sandbox = await resolveCloudflareSandbox(config);
-            const resolved = toSandboxPath(filePath, workspaceRoot);
-            const buffer = await normalizeReadFileContent(await sandbox.readFile(resolved, encoding ? { encoding } : undefined));
-            return encoding != null ? buffer.toString(encoding) : buffer;
-        }),
-        writeFile: async (filePath, content, _options) => {
-            const sandbox = await resolveCloudflareSandbox(config);
-            const resolved = toSandboxPath(filePath, workspaceRoot);
-            const normalized = normalizeWriteFileContent(content);
-            await sandbox.writeFile(resolved, normalized.content, normalized.options);
-        },
-        stat: async (filePath) => {
-            const sandbox = await resolveCloudflareSandbox(config);
-            const resolved = toSandboxPath(filePath, workspaceRoot);
-            if (resolved === workspaceRoot) {
-                const entries = normalizeFileList(await sandbox.listFiles(resolved, { includeHidden: true }));
-                return createStats({ size: entries.length, type: 'directory' });
-            }
-            const info = await findChildInfo(sandbox, resolved);
-            if (info != null) {
-                return createStats({ size: info.size, type: info.type });
-            }
-            try {
-                const entries = normalizeFileList(await sandbox.listFiles(resolved, { includeHidden: true }));
-                return createStats({ size: entries.length, type: 'directory' });
-            }
-            catch {
-                const buffer = await normalizeReadFileContent(await sandbox.readFile(resolved));
-                return createStats({ size: buffer.length, type: 'file' });
-            }
-        },
-        readdir: (async (filePath, options) => {
-            const sandbox = await resolveCloudflareSandbox(config);
-            const resolved = toSandboxPath(filePath, workspaceRoot);
-            const entries = normalizeFileList(await sandbox.listFiles(resolved, { includeHidden: true }));
-            if (options?.withFileTypes === true) {
-                return entries.map(createDirent);
-            }
-            return entries.map((entry) => entryNameFor(entry, resolved));
-        }),
-        mkdir: async (filePath, options) => {
-            const sandbox = await resolveCloudflareSandbox(config);
-            await sandbox.mkdir(toSandboxPath(filePath, workspaceRoot), {
-                recursive: options?.recursive,
-            });
-        },
-        realpath: async (filePath) => toSandboxPath(filePath, workspaceRoot),
-        unlink: async (filePath) => {
-            const sandbox = await resolveCloudflareSandbox(config);
-            await sandbox.deleteFile(toSandboxPath(filePath, workspaceRoot));
-        },
-        open: async (filePath, _flags) => {
-            const sandbox = await resolveCloudflareSandbox(config);
-            const resolved = toSandboxPath(filePath, workspaceRoot);
-            const buffer = await normalizeReadFileContent(await sandbox.readFile(resolved));
-            return {
-                read: async (target, offset, length, position) => {
-                    const start = Math.max(position, 0);
-                    const slice = buffer.subarray(start, start + length);
-                    slice.copy(target, offset);
-                    return { bytesRead: slice.length, buffer: target };
-                },
-                close: async () => undefined,
-            };
-        },
-    };
-    return fs;
+	const workspaceRoot = getCloudflareWorkspaceRoot(config);
+	return {
+		readFile: (async (filePath, encoding) => {
+			const sandbox = await resolveCloudflareSandbox(config);
+			const resolved = toSandboxPath(filePath, workspaceRoot);
+			const buffer = await normalizeReadFileContent(await sandbox.readFile(resolved, encoding ? { encoding } : void 0));
+			return encoding != null ? buffer.toString(encoding) : buffer;
+		}),
+		writeFile: async (filePath, content, _options) => {
+			const sandbox = await resolveCloudflareSandbox(config);
+			const resolved = toSandboxPath(filePath, workspaceRoot);
+			const normalized = normalizeWriteFileContent(content);
+			await sandbox.writeFile(resolved, normalized.content, normalized.options);
+		},
+		stat: async (filePath) => {
+			const sandbox = await resolveCloudflareSandbox(config);
+			const resolved = toSandboxPath(filePath, workspaceRoot);
+			if (resolved === workspaceRoot) return createStats({
+				size: normalizeFileList(await sandbox.listFiles(resolved, { includeHidden: true })).length,
+				type: "directory"
+			});
+			const info = await findChildInfo(sandbox, resolved);
+			if (info != null) return createStats({
+				size: info.size,
+				type: info.type
+			});
+			try {
+				return createStats({
+					size: normalizeFileList(await sandbox.listFiles(resolved, { includeHidden: true })).length,
+					type: "directory"
+				});
+			} catch {
+				return createStats({
+					size: (await normalizeReadFileContent(await sandbox.readFile(resolved))).length,
+					type: "file"
+				});
+			}
+		},
+		readdir: (async (filePath, options) => {
+			const sandbox = await resolveCloudflareSandbox(config);
+			const resolved = toSandboxPath(filePath, workspaceRoot);
+			const entries = normalizeFileList(await sandbox.listFiles(resolved, { includeHidden: true }));
+			if (options?.withFileTypes === true) return entries.map(createDirent);
+			return entries.map((entry) => entryNameFor(entry, resolved));
+		}),
+		mkdir: async (filePath, options) => {
+			await (await resolveCloudflareSandbox(config)).mkdir(toSandboxPath(filePath, workspaceRoot), { recursive: options?.recursive });
+		},
+		realpath: async (filePath) => toSandboxPath(filePath, workspaceRoot),
+		unlink: async (filePath) => {
+			await (await resolveCloudflareSandbox(config)).deleteFile(toSandboxPath(filePath, workspaceRoot));
+		},
+		open: async (filePath, _flags) => {
+			const sandbox = await resolveCloudflareSandbox(config);
+			const resolved = toSandboxPath(filePath, workspaceRoot);
+			const buffer = await normalizeReadFileContent(await sandbox.readFile(resolved));
+			return {
+				read: async (target, offset, length, position) => {
+					const start = Math.max(position, 0);
+					const slice = buffer.subarray(start, start + length);
+					slice.copy(target, offset);
+					return {
+						bytesRead: slice.length,
+						buffer: target
+					};
+				},
+				close: async () => void 0
+			};
+		}
+	};
 }
 function createCloudflareSpawn(config) {
-    return (command, args, options) => {
-        const stdout = new PassThrough();
-        const stderr = new PassThrough();
-        const child = new EventEmitter();
-        const abortController = new AbortController();
-        const state = { closed: false };
-        /** Read through a function so concurrent `closeOnce` mutation (via
-         * `kill()`/abort during an `await`) isn't statically narrowed away. */
-        const isClosed = () => state.closed;
-        const closeOnce = (exitCode, signal) => {
-            if (state.closed) {
-                return;
-            }
-            state.closed = true;
-            stdout.end();
-            stderr.end();
-            Object.assign(child, {
-                exitCode,
-                signalCode: signal,
-            });
-            child.emit('close', exitCode, signal);
-        };
-        Object.assign(child, {
-            stdout,
-            stderr,
-            stdin: new PassThrough(),
-            stdio: [null, stdout, stderr],
-            killed: false,
-            exitCode: null,
-            signalCode: null,
-            pid: undefined,
-            kill: (signal = 'SIGTERM') => {
-                Object.assign(child, { killed: true, signalCode: signal });
-                abortController.abort();
-                closeOnce(null, signal);
-                return true;
-            },
-        });
-        void (async () => {
-            const ctx = await getRuntimeContext(config);
-            const rendered = [command, ...args].map(quote).join(' ');
-            const spawnTimeoutMs = options[LOCAL_SPAWN_TIMEOUT_MS];
-            const timeoutMs = typeof spawnTimeoutMs === 'number' && Number.isFinite(spawnTimeoutMs)
-                ? spawnTimeoutMs
-                : ctx.timeoutMs;
-            const timedCommand = withInSandboxTimeout(rendered, timeoutMs);
-            const cwd = options.cwd == null ? ctx.workspaceRoot : options.cwd.toString();
-            if (isClosed()) {
-                return;
-            }
-            const execOptions = {
-                cwd,
-                env: ctx.env,
-                timeout: outerTimeoutMs(timeoutMs),
-            };
-            if (ctx.sandbox.supportsExecSignal === true) {
-                execOptions.signal = abortController.signal;
-            }
-            try {
-                const result = await ctx.sandbox.exec(timedCommand, execOptions);
-                if (isClosed()) {
-                    return;
-                }
-                if (result.stdout)
-                    stdout.write(result.stdout);
-                if (result.stderr)
-                    stderr.write(result.stderr);
-                closeOnce(result.exitCode, null);
-            }
-            catch (error) {
-                if (isClosed()) {
-                    return;
-                }
-                stderr.write(error.message);
-                closeOnce(1, null);
-            }
-        })();
-        return child;
-    };
+	return (command, args, options) => {
+		const stdout = new PassThrough();
+		const stderr = new PassThrough();
+		const child = new EventEmitter();
+		const abortController = new AbortController();
+		const state = { closed: false };
+		/** Read through a function so concurrent `closeOnce` mutation (via
+		* `kill()`/abort during an `await`) isn't statically narrowed away. */
+		const isClosed = () => state.closed;
+		const closeOnce = (exitCode, signal) => {
+			if (state.closed) return;
+			state.closed = true;
+			stdout.end();
+			stderr.end();
+			Object.assign(child, {
+				exitCode,
+				signalCode: signal
+			});
+			child.emit("close", exitCode, signal);
+		};
+		Object.assign(child, {
+			stdout,
+			stderr,
+			stdin: new PassThrough(),
+			stdio: [
+				null,
+				stdout,
+				stderr
+			],
+			killed: false,
+			exitCode: null,
+			signalCode: null,
+			pid: void 0,
+			kill: (signal = "SIGTERM") => {
+				Object.assign(child, {
+					killed: true,
+					signalCode: signal
+				});
+				abortController.abort();
+				closeOnce(null, signal);
+				return true;
+			}
+		});
+		(async () => {
+			const ctx = await getRuntimeContext(config);
+			const rendered = [command, ...args].map(quote).join(" ");
+			const spawnTimeoutMs = options[LOCAL_SPAWN_TIMEOUT_MS];
+			const timeoutMs = typeof spawnTimeoutMs === "number" && Number.isFinite(spawnTimeoutMs) ? spawnTimeoutMs : ctx.timeoutMs;
+			const timedCommand = withInSandboxTimeout(rendered, timeoutMs);
+			const cwd = options.cwd == null ? ctx.workspaceRoot : options.cwd.toString();
+			if (isClosed()) return;
+			const execOptions = {
+				cwd,
+				env: ctx.env,
+				timeout: outerTimeoutMs(timeoutMs)
+			};
+			if (ctx.sandbox.supportsExecSignal === true) execOptions.signal = abortController.signal;
+			try {
+				const result = await ctx.sandbox.exec(timedCommand, execOptions);
+				if (isClosed()) return;
+				if (result.stdout) stdout.write(result.stdout);
+				if (result.stderr) stderr.write(result.stderr);
+				closeOnce(result.exitCode, null);
+			} catch (error) {
+				if (isClosed()) return;
+				stderr.write(error.message);
+				closeOnce(1, null);
+			}
+		})();
+		return child;
+	};
 }
 function createCloudflareLocalExecutionConfig(config) {
-    const workspaceRoot = getCloudflareWorkspaceRoot(config);
-    return {
-        cwd: workspaceRoot,
-        workspace: { root: workspaceRoot },
-        exec: {
-            spawn: createCloudflareSpawn(config),
-            fs: createCloudflareWorkspaceFS(config),
-            sandboxed: true,
-        },
-        shell: config.shell ?? 'bash',
-        timeoutMs: config.timeoutMs,
-        maxOutputChars: config.maxOutputChars,
-        env: config.env,
-        includeCodingTools: config.includeCodingTools,
-        compileCheck: config.compileCheck,
-        readOnly: config.readOnly,
-        allowDangerousCommands: config.allowDangerousCommands,
-        bashAst: config.bashAst,
-        fileCheckpointing: config.fileCheckpointing,
-        maxReadBytes: config.maxReadBytes,
-        attachReadAttachments: config.attachReadAttachments,
-        maxAttachmentBytes: config.maxAttachmentBytes,
-        postEditSyntaxCheck: config.postEditSyntaxCheck,
-    };
+	const workspaceRoot = getCloudflareWorkspaceRoot(config);
+	return {
+		cwd: workspaceRoot,
+		workspace: { root: workspaceRoot },
+		exec: {
+			spawn: createCloudflareSpawn(config),
+			fs: createCloudflareWorkspaceFS(config),
+			sandboxed: true
+		},
+		shell: config.shell ?? "bash",
+		timeoutMs: config.timeoutMs,
+		maxOutputChars: config.maxOutputChars,
+		env: config.env,
+		includeCodingTools: config.includeCodingTools,
+		compileCheck: config.compileCheck,
+		readOnly: config.readOnly,
+		allowDangerousCommands: config.allowDangerousCommands,
+		bashAst: config.bashAst,
+		fileCheckpointing: config.fileCheckpointing,
+		maxReadBytes: config.maxReadBytes,
+		attachReadAttachments: config.attachReadAttachments,
+		maxAttachmentBytes: config.maxAttachmentBytes,
+		postEditSyntaxCheck: config.postEditSyntaxCheck
+	};
 }
 async function validateCloudflareBashCommand(command, args, config) {
-    const localConfig = createCloudflareLocalExecutionConfig(config);
-    const validation = await validateBashCommand(command, localConfig);
-    if (!validation.valid) {
-        throw new Error(validation.errors.join('\n'));
-    }
-    if (args.length > 0 &&
-        config.allowDangerousCommands !== true &&
-        DESTRUCTIVE_OP_IN_COMMAND_RE.test(command)) {
-        const offending = args.find((arg) => PROTECTED_TARGET_ARG_RE.test(arg));
-        if (offending !== undefined) {
-            throw new Error(`Command matches a destructive command pattern (protected target "${offending}" passed via positional arg).`);
-        }
-    }
+	const validation = await validateBashCommand(command, createCloudflareLocalExecutionConfig(config));
+	if (!validation.valid) throw new Error(validation.errors.join("\n"));
+	if (args.length > 0 && config.allowDangerousCommands !== true && DESTRUCTIVE_OP_IN_COMMAND_RE.test(command)) {
+		const offending = args.find((arg) => PROTECTED_TARGET_ARG_RE.test(arg));
+		if (offending !== void 0) throw new Error(`Command matches a destructive command pattern (protected target "${offending}" passed via positional arg).`);
+	}
 }
 async function executeCloudflareBash(command, config, args = []) {
-    await validateCloudflareBashCommand(command, args, config);
-    const ctx = await getRuntimeContext(config);
-    const shellCommand = args.length > 0
-        ? `${ctx.shell} -lc ${quote(command)} -- ${args.map(quote).join(' ')}`
-        : `${ctx.shell} -lc ${quote(command)}`;
-    const result = await ctx.sandbox.exec(withInSandboxTimeout(shellCommand, ctx.timeoutMs), {
-        cwd: ctx.workspaceRoot,
-        env: ctx.env,
-        timeout: outerTimeoutMs(ctx.timeoutMs),
-    });
-    return {
-        stdout: truncateOutput(result.stdout, ctx.maxOutputChars),
-        stderr: truncateOutput(result.stderr, ctx.maxOutputChars),
-        exitCode: result.exitCode,
-        timedOut: isInSandboxTimeoutExit(result.exitCode),
-    };
+	await validateCloudflareBashCommand(command, args, config);
+	const ctx = await getRuntimeContext(config);
+	const shellCommand = args.length > 0 ? `${ctx.shell} -lc ${quote(command)} -- ${args.map(quote).join(" ")}` : `${ctx.shell} -lc ${quote(command)}`;
+	const result = await ctx.sandbox.exec(withInSandboxTimeout(shellCommand, ctx.timeoutMs), {
+		cwd: ctx.workspaceRoot,
+		env: ctx.env,
+		timeout: outerTimeoutMs(ctx.timeoutMs)
+	});
+	return {
+		stdout: truncateOutput(result.stdout, ctx.maxOutputChars),
+		stderr: truncateOutput(result.stderr, ctx.maxOutputChars),
+		exitCode: result.exitCode,
+		timedOut: isInSandboxTimeoutExit(result.exitCode)
+	};
 }
-function runtimeForCode(lang, tempDir, code, args = [], shell = 'bash') {
-    const fileFor = (name) => posix.join(tempDir, name);
-    const argText = args.map(quote).join(' ');
-    switch (lang) {
-        case 'py':
-        case 'python':
-            return {
-                fileName: 'main.py',
-                source: code,
-                command: `python3 ${quote(fileFor('main.py'))} ${argText}`,
-            };
-        case 'js':
-        case 'javascript':
-            return {
-                fileName: 'main.js',
-                source: code,
-                command: `node ${quote(fileFor('main.js'))} ${argText}`,
-            };
-        case 'ts':
-        case 'typescript':
-            return {
-                fileName: 'main.ts',
-                source: code,
-                command: `npx --no-install tsx ${quote(fileFor('main.ts'))} ${argText}`,
-            };
-        case 'php':
-            return {
-                fileName: 'main.php',
-                source: code,
-                command: `php ${quote(fileFor('main.php'))} ${argText}`,
-            };
-        case 'go':
-            return {
-                fileName: 'main.go',
-                source: code,
-                command: `go run ${quote(fileFor('main.go'))} ${argText}`,
-            };
-        case 'rs':
-            return {
-                fileName: 'main.rs',
-                source: code,
-                command: `${shell} -lc ${quote(`rustc ${quote(fileFor('main.rs'))} -o ${quote(fileFor('main-rs'))} && ${quote(fileFor('main-rs'))} ${argText}`)}`,
-            };
-        case 'c':
-            return {
-                fileName: 'main.c',
-                source: code,
-                command: `${shell} -lc ${quote(`cc ${quote(fileFor('main.c'))} -o ${quote(fileFor('main-c'))} && ${quote(fileFor('main-c'))} ${argText}`)}`,
-            };
-        case 'cpp':
-            return {
-                fileName: 'main.cpp',
-                source: code,
-                command: `${shell} -lc ${quote(`c++ ${quote(fileFor('main.cpp'))} -o ${quote(fileFor('main-cpp'))} && ${quote(fileFor('main-cpp'))} ${argText}`)}`,
-            };
-        case 'java':
-            return {
-                fileName: 'Main.java',
-                source: code,
-                command: `${shell} -lc ${quote(`javac ${quote(fileFor('Main.java'))} && java -cp ${quote(tempDir)} Main ${argText}`)}`,
-            };
-        case 'r':
-            return {
-                fileName: 'main.R',
-                source: code,
-                command: `Rscript ${quote(fileFor('main.R'))} ${argText}`,
-            };
-        case 'd':
-            return {
-                fileName: 'main.d',
-                source: code,
-                command: `${shell} -lc ${quote(`dmd ${quote(fileFor('main.d'))} -of=${quote(fileFor('main-d'))} && ${quote(fileFor('main-d'))} ${argText}`)}`,
-            };
-        case 'f90':
-            return {
-                fileName: 'main.f90',
-                source: code,
-                command: `${shell} -lc ${quote(`gfortran ${quote(fileFor('main.f90'))} -o ${quote(fileFor('main-f90'))} && ${quote(fileFor('main-f90'))} ${argText}`)}`,
-            };
-        case 'bash':
-        case 'sh':
-            return {
-                fileName: 'main.sh',
-                source: code,
-                command: `${shell} -lc ${quote(code)} -- ${argText}`,
-            };
-        default:
-            throw new Error(`Unsupported Cloudflare sandbox runtime: ${lang}`);
-    }
+function runtimeForCode(lang, tempDir, code, args = [], shell = "bash") {
+	const fileFor = (name) => posix.join(tempDir, name);
+	const argText = args.map(quote).join(" ");
+	switch (lang) {
+		case "py":
+		case "python": return {
+			fileName: "main.py",
+			source: code,
+			command: `python3 ${quote(fileFor("main.py"))} ${argText}`
+		};
+		case "js":
+		case "javascript": return {
+			fileName: "main.js",
+			source: code,
+			command: `node ${quote(fileFor("main.js"))} ${argText}`
+		};
+		case "ts":
+		case "typescript": return {
+			fileName: "main.ts",
+			source: code,
+			command: `npx --no-install tsx ${quote(fileFor("main.ts"))} ${argText}`
+		};
+		case "php": return {
+			fileName: "main.php",
+			source: code,
+			command: `php ${quote(fileFor("main.php"))} ${argText}`
+		};
+		case "go": return {
+			fileName: "main.go",
+			source: code,
+			command: `go run ${quote(fileFor("main.go"))} ${argText}`
+		};
+		case "rs": return {
+			fileName: "main.rs",
+			source: code,
+			command: `${shell} -lc ${quote(`rustc ${quote(fileFor("main.rs"))} -o ${quote(fileFor("main-rs"))} && ${quote(fileFor("main-rs"))} ${argText}`)}`
+		};
+		case "c": return {
+			fileName: "main.c",
+			source: code,
+			command: `${shell} -lc ${quote(`cc ${quote(fileFor("main.c"))} -o ${quote(fileFor("main-c"))} && ${quote(fileFor("main-c"))} ${argText}`)}`
+		};
+		case "cpp": return {
+			fileName: "main.cpp",
+			source: code,
+			command: `${shell} -lc ${quote(`c++ ${quote(fileFor("main.cpp"))} -o ${quote(fileFor("main-cpp"))} && ${quote(fileFor("main-cpp"))} ${argText}`)}`
+		};
+		case "java": return {
+			fileName: "Main.java",
+			source: code,
+			command: `${shell} -lc ${quote(`javac ${quote(fileFor("Main.java"))} && java -cp ${quote(tempDir)} Main ${argText}`)}`
+		};
+		case "r": return {
+			fileName: "main.R",
+			source: code,
+			command: `Rscript ${quote(fileFor("main.R"))} ${argText}`
+		};
+		case "d": return {
+			fileName: "main.d",
+			source: code,
+			command: `${shell} -lc ${quote(`dmd ${quote(fileFor("main.d"))} -of=${quote(fileFor("main-d"))} && ${quote(fileFor("main-d"))} ${argText}`)}`
+		};
+		case "f90": return {
+			fileName: "main.f90",
+			source: code,
+			command: `${shell} -lc ${quote(`gfortran ${quote(fileFor("main.f90"))} -o ${quote(fileFor("main-f90"))} && ${quote(fileFor("main-f90"))} ${argText}`)}`
+		};
+		case "bash":
+		case "sh": return {
+			fileName: "main.sh",
+			source: code,
+			command: `${shell} -lc ${quote(code)} -- ${argText}`
+		};
+		default: throw new Error(`Unsupported Cloudflare sandbox runtime: ${lang}`);
+	}
 }
 async function executeCloudflareCode(input, config) {
-    if (input.lang === 'bash' || input.lang === 'sh') {
-        return executeCloudflareBash(input.code, config, input.args ?? []);
-    }
-    const ctx = await getRuntimeContext(config);
-    const id = globalThis.crypto.randomUUID();
-    const tempDir = posix.join(ctx.workspaceRoot, '.lc-exec', id);
-    const runtime = runtimeForCode(input.lang, tempDir, input.code, input.args, ctx.shell);
-    await ctx.sandbox.mkdir(tempDir, { recursive: true });
-    if (runtime.source != null) {
-        await ctx.sandbox.writeFile(posix.join(tempDir, runtime.fileName), runtime.source, {
-            encoding: 'utf8',
-        });
-    }
-    try {
-        const result = await ctx.sandbox.exec(withInSandboxTimeout(runtime.command, ctx.timeoutMs), {
-            cwd: ctx.workspaceRoot,
-            env: ctx.env,
-            timeout: outerTimeoutMs(ctx.timeoutMs),
-        });
-        return {
-            stdout: truncateOutput(result.stdout, ctx.maxOutputChars),
-            stderr: truncateOutput(result.stderr, ctx.maxOutputChars),
-            exitCode: result.exitCode,
-            timedOut: isInSandboxTimeoutExit(result.exitCode),
-        };
-    }
-    finally {
-        await ctx.sandbox
-            .exec(`rm -rf ${quote(tempDir)}`, {
-            cwd: ctx.workspaceRoot,
-            env: ctx.env,
-            timeout: 10000,
-        })
-            .catch(() => undefined);
-    }
+	if (input.lang === "bash" || input.lang === "sh") return executeCloudflareBash(input.code, config, input.args ?? []);
+	const ctx = await getRuntimeContext(config);
+	const id = globalThis.crypto.randomUUID();
+	const tempDir = posix.join(ctx.workspaceRoot, ".lc-exec", id);
+	const runtime = runtimeForCode(input.lang, tempDir, input.code, input.args, ctx.shell);
+	await ctx.sandbox.mkdir(tempDir, { recursive: true });
+	if (runtime.source != null) await ctx.sandbox.writeFile(posix.join(tempDir, runtime.fileName), runtime.source, { encoding: "utf8" });
+	try {
+		const result = await ctx.sandbox.exec(withInSandboxTimeout(runtime.command, ctx.timeoutMs), {
+			cwd: ctx.workspaceRoot,
+			env: ctx.env,
+			timeout: outerTimeoutMs(ctx.timeoutMs)
+		});
+		return {
+			stdout: truncateOutput(result.stdout, ctx.maxOutputChars),
+			stderr: truncateOutput(result.stderr, ctx.maxOutputChars),
+			exitCode: result.exitCode,
+			timedOut: isInSandboxTimeoutExit(result.exitCode)
+		};
+	} finally {
+		await ctx.sandbox.exec(`rm -rf ${quote(tempDir)}`, {
+			cwd: ctx.workspaceRoot,
+			env: ctx.env,
+			timeout: 1e4
+		}).catch(() => void 0);
+	}
 }
 function formatCloudflareOutput(result, cwd) {
-    let formatted = '';
-    if (result.stdout !== '') {
-        formatted += `stdout:\n${result.stdout}\n`;
-    }
-    else {
-        formatted += 'stdout: Empty. Ensure you\'re writing output explicitly.\n';
-    }
-    if (result.stderr !== '') {
-        formatted += `stderr:\n${result.stderr}\n`;
-    }
-    if (result.exitCode != null && result.exitCode !== 0) {
-        formatted += `exit_code: ${result.exitCode}\n`;
-    }
-    if (result.timedOut) {
-        formatted += 'timed_out: true\n';
-    }
-    formatted += `working_directory: ${cwd}`;
-    return formatted.trim();
+	let formatted = "";
+	if (result.stdout !== "") formatted += `stdout:\n${result.stdout}\n`;
+	else formatted += "stdout: Empty. Ensure you're writing output explicitly.\n";
+	if (result.stderr !== "") formatted += `stderr:\n${result.stderr}\n`;
+	if (result.exitCode != null && result.exitCode !== 0) formatted += `exit_code: ${result.exitCode}\n`;
+	if (result.timedOut) formatted += "timed_out: true\n";
+	formatted += `working_directory: ${cwd}`;
+	return formatted.trim();
 }
-
+//#endregion
 export { createCloudflareLocalExecutionConfig, createCloudflareWorkspaceFS, executeCloudflareBash, executeCloudflareCode, formatCloudflareOutput, getCloudflareWorkspaceRoot, resolveCloudflareSandbox, validateCloudflareBashCommand };
-//# sourceMappingURL=CloudflareSandboxExecutionEngine.mjs.map
+
+//# sourceMappingURL=CloudflareSandboxExecutionEngine.mjs.map