@librechat/agents 3.2.31 → 3.2.33

package/dist/cjs/tools/cloudflare/CloudflareBridgeRuntime.cjs

@@ -1,381 +1,289 @@
-'use strict';
-
-var path = require('path');
-
-const DEFAULT_API_PREFIX = '/v1';
-const DEFAULT_WORKSPACE_ROOT = '/workspace';
-const DEFAULT_SHELL = 'bash';
+let path = require("path");
+//#region src/tools/cloudflare/CloudflareBridgeRuntime.ts
+const DEFAULT_API_PREFIX = "/v1";
+const DEFAULT_WORKSPACE_ROOT = "/workspace";
+const DEFAULT_SHELL = "bash";
 function normalizeBaseURL(baseURL) {
-    return baseURL.replace(/\/+$/, '');
+	return baseURL.replace(/\/+$/, "");
 }
 function normalizePrefix(prefix) {
-    const raw = prefix ?? DEFAULT_API_PREFIX;
-    const withLeadingSlash = raw.startsWith('/') ? raw : `/${raw}`;
-    return withLeadingSlash.replace(/\/+$/, '');
+	const raw = prefix ?? DEFAULT_API_PREFIX;
+	return (raw.startsWith("/") ? raw : `/${raw}`).replace(/\/+$/, "");
 }
 function normalizeWorkspaceRoot(workspaceRoot) {
-    const normalized = path.posix.normalize(workspaceRoot);
-    return normalized === '/' ? normalized : normalized.replace(/\/+$/, '');
+	const normalized = path.posix.normalize(workspaceRoot);
+	return normalized === "/" ? normalized : normalized.replace(/\/+$/, "");
 }
 function getFetch(config) {
-    const fetchImpl = config.fetch ?? globalThis.fetch;
-    return fetchImpl.bind(globalThis);
+	return (config.fetch ?? globalThis.fetch).bind(globalThis);
 }
 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 encodeBridgePath(filePath) {
-    return filePath
-        .replace(/^\/+/, '')
-        .split('/')
-        .map((part) => encodeURIComponent(part))
-        .join('/');
+	return filePath.replace(/^\/+/, "").split("/").map((part) => encodeURIComponent(part)).join("/");
 }
 function toSandboxPath(filePath, workspaceRoot) {
-    const raw = filePath === '' ? '.' : filePath;
-    const root = normalizeWorkspaceRoot(workspaceRoot);
-    const resolved = raw.startsWith('/')
-        ? path.posix.normalize(raw)
-        : path.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("/") ? path.posix.normalize(raw) : path.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 typeFromFind(value) {
-    switch (value) {
-        case 'd':
-            return 'directory';
-        case 'l':
-            return 'symlink';
-        case 'f':
-            return 'file';
-        default:
-            return 'other';
-    }
+	switch (value) {
+		case "d": return "directory";
+		case "l": return "symlink";
+		case "f": return "file";
+		default: return "other";
+	}
 }
 function decodeBase64(value) {
-    return Buffer.from(value, 'base64').toString('utf8');
+	return Buffer.from(value, "base64").toString("utf8");
 }
 async function readResponseText(response) {
-    try {
-        return await response.text();
-    }
-    catch {
-        return '';
-    }
+	try {
+		return await response.text();
+	} catch {
+		return "";
+	}
 }
 async function assertOk(response, operation) {
-    if (response.ok) {
-        return;
-    }
-    const text = await readResponseText(response);
-    throw new Error(`Cloudflare sandbox bridge ${operation} failed (${response.status}): ${text}`);
+	if (response.ok) return;
+	const text = await readResponseText(response);
+	throw new Error(`Cloudflare sandbox bridge ${operation} failed (${response.status}): ${text}`);
 }
 function createHeaders(config, extra) {
-    const headers = new Headers(extra);
-    if (config.apiKey != null && config.apiKey !== '') {
-        headers.set('Authorization', `Bearer ${config.apiKey}`);
-    }
-    if (config.sessionId != null && config.sessionId !== '') {
-        headers.set('Session-Id', config.sessionId);
-    }
-    return headers;
+	const headers = new Headers(extra);
+	if (config.apiKey != null && config.apiKey !== "") headers.set("Authorization", `Bearer ${config.apiKey}`);
+	if (config.sessionId != null && config.sessionId !== "") headers.set("Session-Id", config.sessionId);
+	return headers;
 }
 function envScript(env) {
-    if (env == null) {
-        return '';
-    }
-    return Object.entries(env)
-        .filter((entry) => entry[1] != null)
-        .map(([key, value]) => `export ${key}=${quote(value)}`)
-        .join('\n');
+	if (env == null) return "";
+	return Object.entries(env).filter((entry) => entry[1] != null).map(([key, value]) => `export ${key}=${quote(value)}`).join("\n");
 }
 function commandWithEnv(command, env) {
-    const exports$1 = envScript(env);
-    return exports$1 === '' ? command : `${exports$1}\n${command}`;
+	const exports = envScript(env);
+	return exports === "" ? command : `${exports}\n${command}`;
 }
 async function collectReadableStream(stream) {
-    const reader = stream.getReader();
-    const chunks = [];
-    let total = 0;
-    try {
-        for (;;) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            chunks.push(value);
-            total += value.byteLength;
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-    const bytes = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        bytes.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    return bytes;
+	const reader = stream.getReader();
+	const chunks = [];
+	let total = 0;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			chunks.push(value);
+			total += value.byteLength;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return bytes;
 }
 async function normalizeWriteBody(content, options) {
-    if (typeof content !== 'string') {
-        return collectReadableStream(content);
-    }
-    if (options?.encoding === 'base64') {
-        return Buffer.from(content, 'base64');
-    }
-    return Buffer.from(content, options?.encoding === 'utf8' ? 'utf8' : 'utf8');
+	if (typeof content !== "string") return collectReadableStream(content);
+	if (options?.encoding === "base64") return Buffer.from(content, "base64");
+	return Buffer.from(content, options?.encoding === "utf8" ? "utf8" : "utf8");
 }
 function parseSSEChunk(buffer) {
-    const normalized = buffer.replace(/\r\n/g, '\n');
-    const parts = normalized.split('\n\n');
-    const remainder = parts.pop() ?? '';
-    const events = parts
-        .map((part) => {
-        let event = 'message';
-        const dataLines = [];
-        for (const line of part.split('\n')) {
-            if (line.startsWith('event:')) {
-                event = line.slice('event:'.length).trim();
-            }
-            else if (line.startsWith('data:')) {
-                dataLines.push(line.slice('data:'.length).trimStart());
-            }
-        }
-        return { event, data: dataLines.join('\n') };
-    })
-        .filter((event) => event.data !== '' || event.event !== 'message');
-    return { events, remainder };
+	const parts = buffer.replace(/\r\n/g, "\n").split("\n\n");
+	const remainder = parts.pop() ?? "";
+	return {
+		events: parts.map((part) => {
+			let event = "message";
+			const dataLines = [];
+			for (const line of part.split("\n")) if (line.startsWith("event:")) event = line.slice(6).trim();
+			else if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+			return {
+				event,
+				data: dataLines.join("\n")
+			};
+		}).filter((event) => event.data !== "" || event.event !== "message"),
+		remainder
+	};
 }
 function parseExitCode(data) {
-    try {
-        const parsed = JSON.parse(data);
-        return typeof parsed.exit_code === 'number' ? parsed.exit_code : 1;
-    }
-    catch {
-        return 1;
-    }
+	try {
+		const parsed = JSON.parse(data);
+		return typeof parsed.exit_code === "number" ? parsed.exit_code : 1;
+	} catch {
+		return 1;
+	}
 }
 function parseBridgeError(data) {
-    try {
-        const parsed = JSON.parse(data);
-        return parsed.error ?? data;
-    }
-    catch {
-        return data;
-    }
+	try {
+		return JSON.parse(data).error ?? data;
+	} catch {
+		return data;
+	}
 }
 function createCloudflareBridgeRuntime(config) {
-    const baseURL = normalizeBaseURL(config.baseURL);
-    const apiPrefix = normalizePrefix(config.apiRoutePrefix);
-    const workspaceRoot = normalizeWorkspaceRoot(config.workspaceRoot ?? DEFAULT_WORKSPACE_ROOT);
-    const shell = config.shell ?? DEFAULT_SHELL;
-    const fetchImpl = getFetch(config);
-    let sandboxIdPromise = config.sandboxId != null ? Promise.resolve(config.sandboxId) : undefined;
-    function bridgeURL(suffix) {
-        return `${baseURL}${apiPrefix}${suffix}`;
-    }
-    async function getSandboxId() {
-        if (sandboxIdPromise == null) {
-            sandboxIdPromise = (async () => {
-                const response = await fetchImpl(bridgeURL('/sandbox'), {
-                    method: 'POST',
-                    headers: createHeaders(config),
-                });
-                await assertOk(response, 'sandbox create');
-                const payload = (await response.json());
-                if (typeof payload.id !== 'string' || payload.id === '') {
-                    throw new Error('Cloudflare sandbox bridge create did not return an id.');
-                }
-                return payload.id;
-            })().catch((error) => {
-                sandboxIdPromise = undefined;
-                throw error;
-            });
-        }
-        return sandboxIdPromise;
-    }
-    async function exec(command, options = {}) {
-        const sandboxId = await getSandboxId();
-        const sandboxPathId = encodeURIComponent(sandboxId);
-        const response = await fetchImpl(bridgeURL(`/sandbox/${sandboxPathId}/exec`), {
-            method: 'POST',
-            headers: createHeaders(config, {
-                'Content-Type': 'application/json',
-            }),
-            body: JSON.stringify({
-                argv: [shell, '-lc', commandWithEnv(command, options.env)],
-                cwd: toSandboxPath(options.cwd ?? workspaceRoot, workspaceRoot),
-                timeout_ms: options.timeout,
-            }),
-            signal: options.signal,
-        });
-        await assertOk(response, 'exec');
-        if (response.body == null) {
-            throw new Error('Cloudflare sandbox bridge exec response did not include a body.');
-        }
-        const decoder = new TextDecoder();
-        const reader = response.body.getReader();
-        let buffer = '';
-        let stdout = '';
-        let stderr = '';
-        let exitCode;
-        try {
-            for (;;) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                const parsed = parseSSEChunk(buffer);
-                buffer = parsed.remainder;
-                for (const event of parsed.events) {
-                    if (event.event === 'stdout') {
-                        const decoded = decodeBase64(event.data);
-                        stdout += decoded;
-                        options.onOutput?.('stdout', decoded);
-                    }
-                    else if (event.event === 'stderr') {
-                        const decoded = decodeBase64(event.data);
-                        stderr += decoded;
-                        options.onOutput?.('stderr', decoded);
-                    }
-                    else if (event.event === 'exit') {
-                        exitCode = parseExitCode(event.data);
-                    }
-                    else if (event.event === 'error') {
-                        throw new Error(parseBridgeError(event.data));
-                    }
-                }
-            }
-            buffer += decoder.decode();
-            const parsed = parseSSEChunk(buffer);
-            buffer = parsed.remainder;
-            for (const event of parsed.events) {
-                if (event.event === 'stdout') {
-                    const decoded = decodeBase64(event.data);
-                    stdout += decoded;
-                    options.onOutput?.('stdout', decoded);
-                }
-                else if (event.event === 'stderr') {
-                    const decoded = decodeBase64(event.data);
-                    stderr += decoded;
-                    options.onOutput?.('stderr', decoded);
-                }
-                else if (event.event === 'exit') {
-                    exitCode = parseExitCode(event.data);
-                }
-                else if (event.event === 'error') {
-                    throw new Error(parseBridgeError(event.data));
-                }
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-        if (exitCode == null) {
-            throw new Error('Cloudflare sandbox bridge exec stream closed before an exit event.');
-        }
-        return {
-            success: exitCode === 0,
-            exitCode,
-            stdout,
-            stderr,
-            command,
-        };
-    }
-    async function readFile(filePath) {
-        const sandboxId = await getSandboxId();
-        const sandboxPathId = encodeURIComponent(sandboxId);
-        const resolvedPath = toSandboxPath(filePath, workspaceRoot);
-        const response = await fetchImpl(bridgeURL(`/sandbox/${sandboxPathId}/file/${encodeBridgePath(resolvedPath)}`), {
-            headers: createHeaders(config),
-        });
-        await assertOk(response, 'readFile');
-        return Buffer.from(await response.arrayBuffer());
-    }
-    async function writeFile(filePath, content, options) {
-        const sandboxId = await getSandboxId();
-        const sandboxPathId = encodeURIComponent(sandboxId);
-        const resolvedPath = toSandboxPath(filePath, workspaceRoot);
-        const body = await normalizeWriteBody(content, options);
-        const response = await fetchImpl(bridgeURL(`/sandbox/${sandboxPathId}/file/${encodeBridgePath(resolvedPath)}`), {
-            method: 'PUT',
-            headers: createHeaders(config, {
-                'Content-Type': 'application/octet-stream',
-            }),
-            body,
-        });
-        await assertOk(response, 'writeFile');
-        return response.json().catch(() => ({ ok: true }));
-    }
-    async function mkdir(filePath, options) {
-        const resolvedPath = toSandboxPath(filePath, workspaceRoot);
-        const command = `${options?.recursive === true ? 'mkdir -p' : 'mkdir'} -- ${quote(resolvedPath)}`;
-        const result = await exec(command, { cwd: workspaceRoot });
-        if (result.exitCode !== 0) {
-            throw new Error(result.stderr || `mkdir failed for ${resolvedPath}`);
-        }
-        return { ok: true };
-    }
-    async function listFiles(filePath, options) {
-        const resolvedPath = toSandboxPath(filePath, workspaceRoot);
-        const maxDepth = options?.recursive === true ? '' : '-maxdepth 1';
-        const hiddenFilter = options?.includeHidden === true ? '' : ' \\( -name \'.*\' -prune \\) -o';
-        const quotedPath = quote(resolvedPath);
-        const command = `[ -d ${quotedPath} ] || { printf '%s is not a directory\\n' ${quotedPath} >&2; exit 20; }; ` +
-            `find ${quotedPath} -mindepth 1 ${maxDepth}${hiddenFilter} ` +
-            '-printf \'%y\\t%s\\t%p\\n\'';
-        const result = await exec(command, { cwd: workspaceRoot });
-        if (result.exitCode !== 0) {
-            throw new Error(result.stderr || `listFiles failed for ${resolvedPath}`);
-        }
-        return result.stdout
-            .split('\n')
-            .filter(Boolean)
-            .map((line) => {
-            const [rawType, rawSize, ...pathParts] = line.split('\t');
-            const absolutePath = pathParts.join('\t');
-            return {
-                name: path.posix.basename(absolutePath),
-                absolutePath,
-                relativePath: path.posix.relative(resolvedPath, absolutePath),
-                type: typeFromFind(rawType),
-                size: Number.parseInt(rawSize, 10) || 0,
-            };
-        });
-    }
-    async function deleteFile(filePath) {
-        const resolvedPath = toSandboxPath(filePath, workspaceRoot);
-        const result = await exec(`rm -rf -- ${quote(resolvedPath)}`, {
-            cwd: workspaceRoot,
-        });
-        if (result.exitCode !== 0) {
-            throw new Error(result.stderr || `deleteFile failed for ${resolvedPath}`);
-        }
-        return { ok: true };
-    }
-    return {
-        supportsExecSignal: true,
-        getSandboxId,
-        exec,
-        readFile,
-        writeFile,
-        mkdir,
-        listFiles,
-        deleteFile,
-    };
+	const baseURL = normalizeBaseURL(config.baseURL);
+	const apiPrefix = normalizePrefix(config.apiRoutePrefix);
+	const workspaceRoot = normalizeWorkspaceRoot(config.workspaceRoot ?? DEFAULT_WORKSPACE_ROOT);
+	const shell = config.shell ?? DEFAULT_SHELL;
+	const fetchImpl = getFetch(config);
+	let sandboxIdPromise = config.sandboxId != null ? Promise.resolve(config.sandboxId) : void 0;
+	function bridgeURL(suffix) {
+		return `${baseURL}${apiPrefix}${suffix}`;
+	}
+	async function getSandboxId() {
+		if (sandboxIdPromise == null) sandboxIdPromise = (async () => {
+			const response = await fetchImpl(bridgeURL("/sandbox"), {
+				method: "POST",
+				headers: createHeaders(config)
+			});
+			await assertOk(response, "sandbox create");
+			const payload = await response.json();
+			if (typeof payload.id !== "string" || payload.id === "") throw new Error("Cloudflare sandbox bridge create did not return an id.");
+			return payload.id;
+		})().catch((error) => {
+			sandboxIdPromise = void 0;
+			throw error;
+		});
+		return sandboxIdPromise;
+	}
+	async function exec(command, options = {}) {
+		const sandboxId = await getSandboxId();
+		const response = await fetchImpl(bridgeURL(`/sandbox/${encodeURIComponent(sandboxId)}/exec`), {
+			method: "POST",
+			headers: createHeaders(config, { "Content-Type": "application/json" }),
+			body: JSON.stringify({
+				argv: [
+					shell,
+					"-lc",
+					commandWithEnv(command, options.env)
+				],
+				cwd: toSandboxPath(options.cwd ?? workspaceRoot, workspaceRoot),
+				timeout_ms: options.timeout
+			}),
+			signal: options.signal
+		});
+		await assertOk(response, "exec");
+		if (response.body == null) throw new Error("Cloudflare sandbox bridge exec response did not include a body.");
+		const decoder = new TextDecoder();
+		const reader = response.body.getReader();
+		let buffer = "";
+		let stdout = "";
+		let stderr = "";
+		let exitCode;
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buffer += decoder.decode(value, { stream: true });
+				const parsed = parseSSEChunk(buffer);
+				buffer = parsed.remainder;
+				for (const event of parsed.events) if (event.event === "stdout") {
+					const decoded = decodeBase64(event.data);
+					stdout += decoded;
+					options.onOutput?.("stdout", decoded);
+				} else if (event.event === "stderr") {
+					const decoded = decodeBase64(event.data);
+					stderr += decoded;
+					options.onOutput?.("stderr", decoded);
+				} else if (event.event === "exit") exitCode = parseExitCode(event.data);
+				else if (event.event === "error") throw new Error(parseBridgeError(event.data));
+			}
+			buffer += decoder.decode();
+			const parsed = parseSSEChunk(buffer);
+			buffer = parsed.remainder;
+			for (const event of parsed.events) if (event.event === "stdout") {
+				const decoded = decodeBase64(event.data);
+				stdout += decoded;
+				options.onOutput?.("stdout", decoded);
+			} else if (event.event === "stderr") {
+				const decoded = decodeBase64(event.data);
+				stderr += decoded;
+				options.onOutput?.("stderr", decoded);
+			} else if (event.event === "exit") exitCode = parseExitCode(event.data);
+			else if (event.event === "error") throw new Error(parseBridgeError(event.data));
+		} finally {
+			reader.releaseLock();
+		}
+		if (exitCode == null) throw new Error("Cloudflare sandbox bridge exec stream closed before an exit event.");
+		return {
+			success: exitCode === 0,
+			exitCode,
+			stdout,
+			stderr,
+			command
+		};
+	}
+	async function readFile(filePath) {
+		const sandboxId = await getSandboxId();
+		const response = await fetchImpl(bridgeURL(`/sandbox/${encodeURIComponent(sandboxId)}/file/${encodeBridgePath(toSandboxPath(filePath, workspaceRoot))}`), { headers: createHeaders(config) });
+		await assertOk(response, "readFile");
+		return Buffer.from(await response.arrayBuffer());
+	}
+	async function writeFile(filePath, content, options) {
+		const sandboxId = await getSandboxId();
+		const sandboxPathId = encodeURIComponent(sandboxId);
+		const resolvedPath = toSandboxPath(filePath, workspaceRoot);
+		const body = await normalizeWriteBody(content, options);
+		const response = await fetchImpl(bridgeURL(`/sandbox/${sandboxPathId}/file/${encodeBridgePath(resolvedPath)}`), {
+			method: "PUT",
+			headers: createHeaders(config, { "Content-Type": "application/octet-stream" }),
+			body
+		});
+		await assertOk(response, "writeFile");
+		return response.json().catch(() => ({ ok: true }));
+	}
+	async function mkdir(filePath, options) {
+		const resolvedPath = toSandboxPath(filePath, workspaceRoot);
+		const result = await exec(`${options?.recursive === true ? "mkdir -p" : "mkdir"} -- ${quote(resolvedPath)}`, { cwd: workspaceRoot });
+		if (result.exitCode !== 0) throw new Error(result.stderr || `mkdir failed for ${resolvedPath}`);
+		return { ok: true };
+	}
+	async function listFiles(filePath, options) {
+		const resolvedPath = toSandboxPath(filePath, workspaceRoot);
+		const maxDepth = options?.recursive === true ? "" : "-maxdepth 1";
+		const hiddenFilter = options?.includeHidden === true ? "" : " \\( -name '.*' -prune \\) -o";
+		const quotedPath = quote(resolvedPath);
+		const result = await exec(`[ -d ${quotedPath} ] || { printf '%s is not a directory\\n' ${quotedPath} >&2; exit 20; }; find ${quotedPath} -mindepth 1 ${maxDepth}${hiddenFilter} -printf '%y\\t%s\\t%p\\n'`, { cwd: workspaceRoot });
+		if (result.exitCode !== 0) throw new Error(result.stderr || `listFiles failed for ${resolvedPath}`);
+		return result.stdout.split("\n").filter(Boolean).map((line) => {
+			const [rawType, rawSize, ...pathParts] = line.split("	");
+			const absolutePath = pathParts.join("	");
+			return {
+				name: path.posix.basename(absolutePath),
+				absolutePath,
+				relativePath: path.posix.relative(resolvedPath, absolutePath),
+				type: typeFromFind(rawType),
+				size: Number.parseInt(rawSize, 10) || 0
+			};
+		});
+	}
+	async function deleteFile(filePath) {
+		const resolvedPath = toSandboxPath(filePath, workspaceRoot);
+		const result = await exec(`rm -rf -- ${quote(resolvedPath)}`, { cwd: workspaceRoot });
+		if (result.exitCode !== 0) throw new Error(result.stderr || `deleteFile failed for ${resolvedPath}`);
+		return { ok: true };
+	}
+	return {
+		supportsExecSignal: true,
+		getSandboxId,
+		exec,
+		readFile,
+		writeFile,
+		mkdir,
+		listFiles,
+		deleteFile
+	};
 }
-
+//#endregion
 exports.createCloudflareBridgeRuntime = createCloudflareBridgeRuntime;
-//# sourceMappingURL=CloudflareBridgeRuntime.cjs.map
+
+//# sourceMappingURL=CloudflareBridgeRuntime.cjs.map