coding-agents-sdk 0.0.1 → 0.2.0

package/dist/container-CHxKIonn.mjs

@@ -0,0 +1,440 @@
+import { t as formatError } from "./util-B4RQZkKr.mjs";
+import { n as ContainerDiffError, o as ContainerNotRunningError, r as ContainerDisposedError, s as ContainerStartError, t as ContainerCreateError } from "./errors-BAmHDQu8.mjs";
+import { n as createWorkdirDiffApi, r as shellEscape } from "./diff-De8d3MVb.mjs";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join, posix } from "node:path";
+import { CommandExitError, FileType, Sandbox } from "e2b";
+//#region src/container/e2b/helpers.ts
+const buildCommandLine = (command, args) => [command, ...args].map(shellEscape).join(" ");
+const resolveRuntimeUser = (config) => config.user;
+const resolveRuntimeEnv = (config, env) => {
+	const merged = {
+		...config.env,
+		...env
+	};
+	return Object.keys(merged).length > 0 ? merged : void 0;
+};
+const resolveRuntimeCwd = (config, cwd) => cwd ?? config.workdir;
+//#endregion
+//#region src/container/e2b/spawner.ts
+const encoder = new TextEncoder();
+const toError = (error) => error instanceof Error ? error : new Error(String(error));
+const normalizeSignal = (signal) => typeof signal === "string" ? signal : "SIGKILL";
+const normalizeStdio = (options, index) => {
+	const value = options?.stdio?.[index];
+	if (value === "ignore" || value === "inherit" || value === "pipe") return value;
+	return value === void 0 ? "pipe" : "ignore";
+};
+const createByteQueue = () => {
+	const chunks = [];
+	const waiters = [];
+	let ended = false;
+	let error;
+	const flush = () => {
+		while (waiters.length > 0 && chunks.length > 0) waiters.shift().resolve({
+			done: false,
+			value: chunks.shift()
+		});
+		if (error) {
+			while (waiters.length > 0) waiters.shift().reject(error);
+			return;
+		}
+		if (ended) while (waiters.length > 0) waiters.shift().resolve({
+			done: true,
+			value: void 0
+		});
+	};
+	return {
+		iterable: { async *[Symbol.asyncIterator]() {
+			while (true) {
+				if (chunks.length > 0) {
+					yield chunks.shift();
+					continue;
+				}
+				if (error) throw toError(error);
+				if (ended) return;
+				const result = await new Promise((resolve, reject) => {
+					waiters.push({
+						resolve,
+						reject
+					});
+				});
+				if (result.done) return;
+				yield result.value;
+			}
+		} },
+		push(text) {
+			if (text.length === 0 || ended || error) return;
+			chunks.push(encoder.encode(text));
+			flush();
+		},
+		end() {
+			if (ended || error) return;
+			ended = true;
+			flush();
+		},
+		fail(reason) {
+			if (ended || error) return;
+			error = reason;
+			flush();
+		}
+	};
+};
+const createE2BSpawner = (sandbox, config) => ({ spawn: (command, args, options = {}) => {
+	const stdinMode = normalizeStdio(options, 0);
+	const stdoutMode = normalizeStdio(options, 1);
+	const stderrMode = normalizeStdio(options, 2);
+	const stdoutQueue = stdoutMode === "pipe" ? createByteQueue() : void 0;
+	const stderrQueue = stderrMode === "pipe" ? createByteQueue() : void 0;
+	let waitSignal = null;
+	const commandOptions = {
+		background: true,
+		stdin: stdinMode === "pipe",
+		cwd: resolveRuntimeCwd(config, options.cwd),
+		envs: resolveRuntimeEnv(config, options.env),
+		user: resolveRuntimeUser(config),
+		requestTimeoutMs: config.requestTimeoutMs,
+		onStdout: (data) => {
+			if (stdoutMode === "inherit") {
+				process.stdout.write(data);
+				return;
+			}
+			stdoutQueue?.push(data);
+		},
+		onStderr: (data) => {
+			if (stderrMode === "inherit") {
+				process.stderr.write(data);
+				return;
+			}
+			stderrQueue?.push(data);
+		}
+	};
+	const commandHandlePromise = sandbox.commands.run(buildCommandLine(command, args), commandOptions);
+	commandHandlePromise.catch((error) => {
+		stdoutQueue?.fail(error);
+		stderrQueue?.fail(error);
+	});
+	const wait = async () => {
+		try {
+			const result = await (await commandHandlePromise).wait();
+			stdoutQueue?.end();
+			stderrQueue?.end();
+			if (waitSignal) return {
+				exitCode: null,
+				signal: waitSignal
+			};
+			return {
+				exitCode: result.exitCode,
+				signal: null
+			};
+		} catch (error) {
+			stdoutQueue?.end();
+			stderrQueue?.end();
+			if (error instanceof CommandExitError) {
+				if (waitSignal) return {
+					exitCode: null,
+					signal: waitSignal
+				};
+				return {
+					exitCode: error.exitCode,
+					signal: null
+				};
+			}
+			throw error;
+		}
+	};
+	return {
+		stdout: stdoutQueue?.iterable ?? null,
+		stderr: stderrQueue?.iterable ?? null,
+		stdin: stdinMode === "pipe" ? {
+			write: (chunk) => {
+				commandHandlePromise.then((handle) => {
+					sandbox.commands.sendStdin(handle.pid, chunk, { requestTimeoutMs: config.requestTimeoutMs });
+				}).catch(() => {});
+			},
+			end: () => {
+				commandHandlePromise.then((handle) => {
+					sandbox.commands.closeStdin(handle.pid, { requestTimeoutMs: config.requestTimeoutMs });
+				}).catch(() => {});
+			}
+		} : null,
+		kill: (signal) => {
+			waitSignal = normalizeSignal(signal);
+			commandHandlePromise.then((handle) => handle.kill()).catch(() => {});
+		},
+		wait
+	};
+} });
+//#endregion
+//#region src/container/e2b/container.ts
+const resolveConnectionOptions = (config) => ({
+	apiKey: config.apiKey,
+	accessToken: config.accessToken,
+	domain: config.domain,
+	requestTimeoutMs: config.requestTimeoutMs,
+	headers: config.headers
+});
+const isConnectConfig = (config) => {
+	return "sandboxId" in config && typeof config.sandboxId === "string";
+};
+const resolveCreateOptions = (config) => {
+	const connection = resolveConnectionOptions(config);
+	if (isConnectConfig(config)) return connection;
+	return {
+		...connection,
+		envs: config.env,
+		timeoutMs: config.timeoutMs,
+		metadata: config.metadata,
+		secure: config.secure,
+		allowInternetAccess: config.allowInternetAccess,
+		network: config.network,
+		lifecycle: config.lifecycle
+	};
+};
+const ensureWorkdir = async (sandbox, config) => {
+	await sandbox.files.makeDir(config.workdir, { user: resolveRuntimeUser(config) });
+};
+const isAbortError = (error) => {
+	return error instanceof Error && error.name === "AbortError";
+};
+const toArrayBuffer = (value) => Uint8Array.from(value).buffer;
+const sandboxBasename = (path) => {
+	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+	return posix.basename(normalized);
+};
+const getLocalEntry = async (path) => {
+	try {
+		return await stat(path);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
+		throw error;
+	}
+};
+const getSandboxEntry = async (sandbox, path, user) => {
+	if (!await sandbox.files.exists(path, { user })) return;
+	return sandbox.files.getInfo(path, { user });
+};
+const resolveSandboxCopyTarget = async (sandbox, sourcePath, requestedTarget, user) => {
+	if ((await getSandboxEntry(sandbox, requestedTarget, user))?.type === FileType.DIR) return posix.join(requestedTarget, basename(sourcePath));
+	return requestedTarget;
+};
+const resolveLocalCopyTarget = async (sourcePath, requestedTarget) => {
+	if ((await getLocalEntry(requestedTarget))?.isDirectory()) return join(requestedTarget, sandboxBasename(sourcePath));
+	return requestedTarget;
+};
+const copyLocalPathToSandbox = async (sandbox, sourcePath, targetPath, user) => {
+	const entry = await stat(sourcePath);
+	if (entry.isDirectory()) {
+		await sandbox.files.makeDir(targetPath, { user });
+		const children = await readdir(sourcePath);
+		await Promise.all(children.map((child) => copyLocalPathToSandbox(sandbox, join(sourcePath, child), posix.join(targetPath, child), user)));
+		return;
+	}
+	if (!entry.isFile()) throw new Error(`Unsupported local filesystem entry at ${sourcePath}.`);
+	const data = await readFile(sourcePath);
+	await sandbox.files.write(targetPath, toArrayBuffer(data), { user });
+};
+const copySandboxPathToLocal = async (sandbox, sourcePath, targetPath, user) => {
+	if ((await sandbox.files.getInfo(sourcePath, { user })).type === FileType.DIR) {
+		await mkdir(targetPath, { recursive: true });
+		const children = await sandbox.files.list(sourcePath, { user });
+		await Promise.all(children.map((child) => copySandboxPathToLocal(sandbox, child.path, join(targetPath, child.name), user)));
+		return;
+	}
+	const data = await sandbox.files.read(sourcePath, {
+		format: "bytes",
+		user
+	});
+	await mkdir(dirname(targetPath), { recursive: true });
+	await writeFile(targetPath, data);
+};
+const createSandbox = async (config) => {
+	if (isConnectConfig(config)) return Sandbox.connect(config.sandboxId, resolveConnectionOptions(config));
+	const createOptions = resolveCreateOptions(config);
+	if (config.template) return Sandbox.create(config.template, createOptions);
+	return Sandbox.create(createOptions);
+};
+const reconnectSandbox = async (sandbox, config) => sandbox.connect(resolveConnectionOptions(config));
+const waitForExec = async (handle, options) => {
+	const abortSignal = options.signal;
+	if (abortSignal?.aborted) {
+		const reason = abortSignal.reason;
+		throw reason instanceof Error ? reason : new DOMException("The operation was aborted.", "AbortError");
+	}
+	let aborted = false;
+	const abortHandler = () => {
+		aborted = true;
+		handle.kill();
+	};
+	abortSignal?.addEventListener("abort", abortHandler, { once: true });
+	try {
+		const result = await handle.wait();
+		if (aborted) throw new DOMException("The operation was aborted.", "AbortError");
+		return {
+			exitCode: result.exitCode,
+			stdout: result.stdout,
+			stderr: result.stderr
+		};
+	} catch (error) {
+		if (aborted || isAbortError(error)) throw new DOMException("The operation was aborted.", "AbortError");
+		if (error instanceof CommandExitError) return {
+			exitCode: error.exitCode,
+			stdout: error.stdout,
+			stderr: error.stderr
+		};
+		throw error;
+	} finally {
+		abortSignal?.removeEventListener("abort", abortHandler);
+	}
+};
+const createE2BContainer = async (config) => {
+	let sandbox;
+	try {
+		sandbox = await createSandbox(config);
+		await ensureWorkdir(sandbox, config);
+	} catch (error) {
+		throw new ContainerCreateError(`E2B create failed: ${formatError(error)}`);
+	}
+	const runtimeName = config.name ?? sandbox.sandboxId;
+	let status = "running";
+	let spawner = createE2BSpawner(sandbox, config);
+	const diffOwner = {};
+	const assertNotDisposed = () => {
+		if (status === "disposed") throw new ContainerDisposedError();
+	};
+	const assertRunning = () => {
+		assertNotDisposed();
+		if (status !== "running") throw new ContainerNotRunningError();
+	};
+	const diffApi = createWorkdirDiffApi({
+		owner: diffOwner,
+		workdir: config.workdir,
+		materialize: async (cwd, targetDir) => {
+			assertRunning();
+			const user = resolveRuntimeUser(config);
+			const entry = await getSandboxEntry(sandbox, cwd, user);
+			if (!entry) throw new ContainerDiffError(`Target path does not exist: ${cwd}`);
+			if (entry.type !== FileType.DIR) throw new ContainerDiffError(`Target path is not a directory: ${cwd}`);
+			await mkdir(targetDir, { recursive: true });
+			for (const child of await sandbox.files.list(cwd, { user })) await copySandboxPathToLocal(sandbox, child.path, join(targetDir, child.name), user);
+		}
+	});
+	const container = {
+		get type() {
+			return "e2b";
+		},
+		get id() {
+			return sandbox.sandboxId;
+		},
+		get name() {
+			return runtimeName;
+		},
+		get config() {
+			return config;
+		},
+		get status() {
+			return status;
+		},
+		get workdir() {
+			return config.workdir;
+		},
+		get spawner() {
+			return spawner;
+		},
+		async start() {
+			assertNotDisposed();
+			if (status === "running") return;
+			try {
+				sandbox = await reconnectSandbox(sandbox, config);
+				await ensureWorkdir(sandbox, config);
+				spawner = createE2BSpawner(sandbox, config);
+				status = "running";
+			} catch (error) {
+				throw new ContainerStartError(`E2B start failed: ${formatError(error)}`);
+			}
+		},
+		async stop() {
+			assertNotDisposed();
+			if (status !== "running") return;
+			await sandbox.pause({ requestTimeoutMs: config.requestTimeoutMs });
+			status = "stopped";
+		},
+		async dispose() {
+			if (status === "disposed") return;
+			try {
+				await sandbox.kill({ requestTimeoutMs: config.requestTimeoutMs });
+			} catch {}
+			await diffApi.disposeSnapshots().catch(() => {});
+			status = "disposed";
+		},
+		async exec(command, args, options = {}) {
+			assertRunning();
+			const commandOptions = {
+				background: true,
+				cwd: resolveRuntimeCwd(config, options.cwd),
+				envs: resolveRuntimeEnv(config, options.env),
+				user: resolveRuntimeUser(config),
+				timeoutMs: options.timeoutMs,
+				requestTimeoutMs: config.requestTimeoutMs
+			};
+			return waitForExec(await sandbox.commands.run(buildCommandLine(command, args), commandOptions), options);
+		},
+		async copyTo(hostPath, containerPath) {
+			assertRunning();
+			const targetPath = await resolveSandboxCopyTarget(sandbox, hostPath, containerPath, resolveRuntimeUser(config));
+			await copyLocalPathToSandbox(sandbox, hostPath, targetPath, resolveRuntimeUser(config));
+		},
+		async copyFrom(containerPath, hostPath) {
+			assertRunning();
+			const targetPath = await resolveLocalCopyTarget(containerPath, hostPath);
+			await copySandboxPathToLocal(sandbox, containerPath, targetPath, resolveRuntimeUser(config));
+		},
+		async writeFile(path, content) {
+			assertRunning();
+			await sandbox.files.write(path, typeof content === "string" ? content : toArrayBuffer(content), { user: resolveRuntimeUser(config) });
+		},
+		async readFile(path) {
+			assertRunning();
+			return sandbox.files.read(path, {
+				format: "text",
+				user: resolveRuntimeUser(config)
+			});
+		},
+		async fileExists(path) {
+			assertRunning();
+			return sandbox.files.exists(path, { user: resolveRuntimeUser(config) });
+		},
+		async mkdir(path) {
+			assertRunning();
+			await sandbox.files.makeDir(path, { user: resolveRuntimeUser(config) });
+		},
+		async execShell(script, options = {}) {
+			return container.exec("sh", ["-c", script], options);
+		},
+		async logs() {
+			return "";
+		},
+		async syncStatus() {
+			return status;
+		},
+		async snapshotWorkdir(options = {}) {
+			return diffApi.snapshotWorkdir(options);
+		},
+		async diffWorkdir(snapshot) {
+			return diffApi.diffWorkdir(snapshot);
+		},
+		async releaseWorkdirSnapshot(snapshot) {
+			return diffApi.releaseWorkdirSnapshot(snapshot);
+		},
+		getHost(port) {
+			assertRunning();
+			return sandbox.getHost(port);
+		},
+		[Symbol.asyncDispose]() {
+			return container.dispose();
+		}
+	};
+	return container;
+};
+//#endregion
+export { createE2BContainer };

package/dist/container-D2Z0ITDJ.mjs

@@ -0,0 +1,22 @@
+import { n as resolveOciImage, t as createOciContainer } from "./oci-DMZZQZ47.mjs";
+//#region src/container/podman/container.ts
+const createPodmanContainer = async (config) => {
+	const binary = config.binary ?? "podman";
+	const image = await resolveOciImage(binary, config);
+	return createOciContainer("podman", {
+		binary,
+		containerName: config.name,
+		workdir: config.workdir,
+		user: config.user,
+		network: config.network,
+		platform: config.platform,
+		env: config.env,
+		ports: config.ports,
+		mounts: config.mounts,
+		extraArgs: config.extraArgs,
+		image,
+		builtImage: config.build !== void 0 && !config.build.tag
+	}, config);
+};
+//#endregion
+export { createPodmanContainer };