coding-agents-sdk 0.2.0 → 0.3.0

package/dist/diff-De8d3MVb.mjs

@@ -1,333 +0,0 @@
-import { t as formatError } from "./util-B4RQZkKr.mjs";
-import { n as ContainerDiffError, o as ContainerNotRunningError, r as ContainerDisposedError } from "./errors-BAmHDQu8.mjs";
-import { createReadStream } from "node:fs";
-import { copyFile, lstat, mkdir, mkdtemp, readdir, readlink, rm, stat, symlink } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, isAbsolute, join, posix, relative, sep } from "node:path";
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { promisify } from "node:util";
-import { pipeline } from "node:stream/promises";
-//#region src/core/process/errors.ts
-const isExecFileError = (error) => {
-	return error instanceof Error && "code" in error && ("stdout" in error || "stderr" in error);
-};
-//#endregion
-//#region src/core/process/shell.ts
-const shellEscape = (s) => `'${s.replace(/'/g, "'\\''")}'`;
-//#endregion
-//#region src/container/diff.ts
-const execFileAsync = promisify(execFile);
-const isRelativePath = (value) => {
-	return value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value);
-};
-const toPosixRelativePath = (rootDir, absolutePath) => {
-	const relativePath = relative(rootDir, absolutePath);
-	if (!isRelativePath(relativePath)) return;
-	return relativePath.split(sep).join(posix.sep);
-};
-const relativizeGitPath = (absolutePath, beforeDir, afterDir) => {
-	const beforePath = toPosixRelativePath(beforeDir, absolutePath);
-	if (beforePath !== void 0) return beforePath;
-	const afterPath = toPosixRelativePath(afterDir, absolutePath);
-	if (afterPath !== void 0) return afterPath;
-	throw new ContainerDiffError(`Git diff produced a path outside the materialized trees: ${absolutePath}`);
-};
-const sortFileChanges = (changes) => changes.sort((left, right) => {
-	if (left.path === right.path) return (left.previousPath ?? "").localeCompare(right.previousPath ?? "");
-	return left.path.localeCompare(right.path);
-});
-const removeGitMetadataDirs = async (rootDir) => {
-	const entries = await readdir(rootDir, { withFileTypes: true });
-	for (const entry of entries) {
-		const fullPath = join(rootDir, entry.name);
-		if (entry.name === ".git") {
-			await rm(fullPath, {
-				recursive: true,
-				force: true
-			});
-			continue;
-		}
-		if (entry.isDirectory()) await removeGitMetadataDirs(fullPath);
-	}
-};
-const createTempTree = () => mkdtemp(join(tmpdir(), "cw-workdir-diff-"));
-const cleanupTempTree = async (path) => {
-	if (!path) return;
-	await rm(path, {
-		recursive: true,
-		force: true
-	}).catch(() => {});
-};
-const createSnapshot = (meta, snapshotMetadata) => {
-	const snapshot = {
-		cwd: meta.cwd,
-		createdAt: /* @__PURE__ */ new Date()
-	};
-	snapshotMetadata.set(snapshot, meta);
-	return snapshot;
-};
-const getSnapshotMeta = (owner, snapshot, snapshotMetadata) => {
-	if (typeof snapshot !== "object" || snapshot === null) throw new ContainerDiffError("Invalid workdir snapshot.");
-	const meta = snapshotMetadata.get(snapshot);
-	if (!meta) throw new ContainerDiffError("Invalid workdir snapshot.");
-	if (meta.owner !== owner) throw new ContainerDiffError("Workdir snapshot was created by a different container instance.");
-	return meta;
-};
-const assertSnapshotActive = (snapshot, activeSnapshots) => {
-	if (!activeSnapshots.has(snapshot)) throw new ContainerDiffError("Workdir snapshot has been released.");
-};
-const createContentHash = (value) => createHash("sha256").update(value).digest("hex");
-const toBuffer = (value) => Buffer.isBuffer(value) ? value : Buffer.from(value, "utf8");
-const hashFileStream = async (path) => {
-	const hash = createHash("sha256");
-	await pipeline(createReadStream(path), hash);
-	return hash.digest("hex");
-};
-const getFileMetadata = async (rootDir, relativePath, cache) => {
-	const cacheKey = `${rootDir}:${relativePath}`;
-	if (cache.has(cacheKey)) return cache.get(cacheKey);
-	const absolutePath = join(rootDir, ...relativePath.split(posix.sep));
-	try {
-		const entry = await lstat(absolutePath);
-		let hash;
-		let size;
-		if (entry.isSymbolicLink()) {
-			const linkTarget = Buffer.from(await readlink(absolutePath));
-			hash = createContentHash(linkTarget);
-			size = linkTarget.byteLength;
-		} else if (entry.isFile()) {
-			hash = await hashFileStream(absolutePath);
-			size = entry.size;
-		} else throw new ContainerDiffError(`Unsupported filesystem entry in diff metadata: ${absolutePath}`);
-		const metadata = {
-			hash,
-			size
-		};
-		cache.set(cacheKey, metadata);
-		return metadata;
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-			cache.set(cacheKey, void 0);
-			return;
-		}
-		throw error;
-	}
-};
-const parseGitDiffOutput = (stdout, beforeDir, afterDir) => {
-	if (stdout.byteLength === 0) return [];
-	const fields = stdout.toString("utf8").split("\0");
-	if (fields[fields.length - 1] === "") fields.pop();
-	const changes = [];
-	for (let index = 0; index < fields.length;) {
-		const status = fields[index++];
-		if (!status) continue;
-		if (status.startsWith("R")) {
-			const previousPath = fields[index++];
-			const path = fields[index++];
-			if (!previousPath || !path) throw new ContainerDiffError("Failed to parse git rename entry.");
-			changes.push({
-				kind: "renamed",
-				previousPath: relativizeGitPath(previousPath, beforeDir, afterDir),
-				path: relativizeGitPath(path, beforeDir, afterDir)
-			});
-			continue;
-		}
-		const path = fields[index++];
-		if (!path) throw new ContainerDiffError("Failed to parse git diff entry.");
-		switch (status) {
-			case "A":
-				changes.push({
-					kind: "added",
-					path: relativizeGitPath(path, beforeDir, afterDir)
-				});
-				break;
-			case "D":
-				changes.push({
-					kind: "deleted",
-					path: relativizeGitPath(path, beforeDir, afterDir)
-				});
-				break;
-			case "M":
-				changes.push({
-					kind: "modified",
-					path: relativizeGitPath(path, beforeDir, afterDir)
-				});
-				break;
-			case "T":
-				changes.push({
-					kind: "modified",
-					path: relativizeGitPath(path, beforeDir, afterDir)
-				});
-				break;
-			default: throw new ContainerDiffError(`Unsupported git diff change kind: ${status}`);
-		}
-	}
-	return changes;
-};
-const runGitDiff = async (beforeDir, afterDir) => {
-	try {
-		return parseGitDiffOutput(toBuffer((await execFileAsync("git", [
-			"diff",
-			"--no-index",
-			"-z",
-			"--name-status",
-			"-M",
-			"--find-renames=100%",
-			beforeDir,
-			afterDir
-		], {
-			cwd: tmpdir(),
-			encoding: "buffer",
-			maxBuffer: 50 * 1024 * 1024
-		})).stdout), beforeDir, afterDir);
-	} catch (error) {
-		if (!isExecFileError(error)) throw new ContainerDiffError(`Failed to run git diff: ${formatError(error)}`);
-		const code = error.code ?? 1;
-		const stdout = Buffer.isBuffer(error.stdout) ? error.stdout : Buffer.from(String(error.stdout ?? ""), "utf8");
-		const stderr = Buffer.isBuffer(error.stderr) ? error.stderr : Buffer.from(String(error.stderr ?? ""), "utf8");
-		if (code === 0 || code === 1) return parseGitDiffOutput(stdout, beforeDir, afterDir);
-		throw new ContainerDiffError(`Failed to run git diff: ${stderr.toString("utf8").trim() || stdout.toString("utf8").trim() || `exit code ${code}`}`);
-	}
-};
-const enrichFileChanges = async (changes, beforeDir, afterDir) => {
-	const metadataCache = /* @__PURE__ */ new Map();
-	return sortFileChanges(await Promise.all(changes.map(async (change) => {
-		let beforePath;
-		if (change.kind === "added") beforePath = void 0;
-		else if (change.kind === "renamed") beforePath = change.previousPath;
-		else beforePath = change.path;
-		const afterPath = change.kind === "deleted" ? void 0 : change.path;
-		const [beforeMetadata, afterMetadata] = await Promise.all([beforePath === void 0 ? void 0 : getFileMetadata(beforeDir, beforePath, metadataCache), afterPath === void 0 ? void 0 : getFileMetadata(afterDir, afterPath, metadataCache)]);
-		return {
-			path: change.path,
-			previousPath: change.previousPath,
-			kind: change.kind,
-			beforeHash: beforeMetadata?.hash,
-			afterHash: afterMetadata?.hash,
-			beforeSize: beforeMetadata?.size,
-			afterSize: afterMetadata?.size
-		};
-	})));
-};
-const buildChangedFiles = (fileChanges) => {
-	const changedFiles = /* @__PURE__ */ new Set();
-	for (const change of fileChanges) {
-		changedFiles.add(change.path);
-		if (change.kind === "renamed" && change.previousPath) changedFiles.add(change.previousPath);
-	}
-	return [...changedFiles].sort((left, right) => left.localeCompare(right));
-};
-const wrapMaterializeError = (action, error) => {
-	if (error instanceof ContainerDiffError || error instanceof ContainerDisposedError || error instanceof ContainerNotRunningError) throw error;
-	throw new ContainerDiffError(`${action}: ${formatError(error)}`);
-};
-const copyLocalDirectoryContents = async (sourceDir, targetDir) => {
-	if (!(await stat(sourceDir)).isDirectory()) throw new ContainerDiffError(`Target path is not a directory: ${sourceDir}`);
-	await mkdir(targetDir, { recursive: true });
-	const entries = await readdir(sourceDir, { withFileTypes: true });
-	await Promise.all(entries.filter((entry) => entry.name !== ".git").map(async (entry) => {
-		const sourcePath = join(sourceDir, entry.name);
-		const targetPath = join(targetDir, entry.name);
-		if (entry.isDirectory()) {
-			await copyLocalDirectoryContents(sourcePath, targetPath);
-			return;
-		}
-		if (entry.isSymbolicLink()) {
-			await mkdir(dirname(targetPath), { recursive: true });
-			await symlink(await readlink(sourcePath), targetPath);
-			return;
-		}
-		if (entry.isFile()) {
-			await mkdir(dirname(targetPath), { recursive: true });
-			await copyFile(sourcePath, targetPath);
-			return;
-		}
-		throw new ContainerDiffError(`Unsupported filesystem entry in workdir diff: ${sourcePath}`);
-	}));
-};
-const createWorkdirDiffApi = (options) => {
-	const activeSnapshots = /* @__PURE__ */ new Set();
-	const snapshotMetadata = /* @__PURE__ */ new WeakMap();
-	const snapshotWorkdir = async (snapshotOptions = {}) => {
-		const cwd = snapshotOptions.cwd ?? options.workdir;
-		let tempDir;
-		try {
-			tempDir = await createTempTree();
-			await options.materialize(cwd, tempDir);
-			await removeGitMetadataDirs(tempDir);
-			const snapshotMeta = {
-				owner: options.owner,
-				tempDir,
-				cwd,
-				inFlightDiffs: 0,
-				released: false
-			};
-			activeSnapshots.add(snapshotMeta);
-			tempDir = void 0;
-			return createSnapshot(snapshotMeta, snapshotMetadata);
-		} catch (error) {
-			await cleanupTempTree(tempDir);
-			return wrapMaterializeError("Failed to materialize workdir snapshot", error);
-		}
-	};
-	const diffWorkdir = async (snapshot) => {
-		const startedAt = Date.now();
-		const snapshotMeta = getSnapshotMeta(options.owner, snapshot, snapshotMetadata);
-		assertSnapshotActive(snapshotMeta, activeSnapshots);
-		snapshotMeta.inFlightDiffs++;
-		let currentTempDir;
-		try {
-			currentTempDir = await createTempTree();
-			await options.materialize(snapshotMeta.cwd, currentTempDir);
-			await removeGitMetadataDirs(currentTempDir);
-			const fileChanges = await enrichFileChanges(await runGitDiff(snapshotMeta.tempDir, currentTempDir), snapshotMeta.tempDir, currentTempDir);
-			const changedFiles = buildChangedFiles(fileChanges);
-			return {
-				cwd: snapshotMeta.cwd,
-				changedFiles,
-				fileChanges,
-				stats: {
-					durationMs: Date.now() - startedAt,
-					filesCompared: changedFiles.length
-				}
-			};
-		} catch (error) {
-			return wrapMaterializeError("Failed to diff workdir snapshot", error);
-		} finally {
-			snapshotMeta.inFlightDiffs--;
-			if (snapshotMeta.inFlightDiffs === 0) {
-				snapshotMeta.resolveIdle?.();
-				snapshotMeta.resolveIdle = void 0;
-			}
-			await cleanupTempTree(currentTempDir);
-		}
-	};
-	const releaseSnapshot = (snapshotMeta) => {
-		const meta = snapshotMeta;
-		if (meta.releasePromise) return meta.releasePromise;
-		meta.released = true;
-		activeSnapshots.delete(meta);
-		meta.releasePromise = (async () => {
-			if (meta.inFlightDiffs > 0) await new Promise((resolve) => {
-				meta.resolveIdle = resolve;
-			});
-			await cleanupTempTree(meta.tempDir);
-		})();
-		return meta.releasePromise;
-	};
-	const releaseWorkdirSnapshot = async (snapshot) => {
-		await releaseSnapshot(getSnapshotMeta(options.owner, snapshot, snapshotMetadata));
-	};
-	const disposeSnapshots = async () => {
-		await Promise.all(Array.from(activeSnapshots).map(releaseSnapshot));
-	};
-	return {
-		snapshotWorkdir,
-		diffWorkdir,
-		releaseWorkdirSnapshot,
-		disposeSnapshots
-	};
-};
-//#endregion
-export { isExecFileError as i, createWorkdirDiffApi as n, shellEscape as r, copyLocalDirectoryContents as t };

package/dist/errors-BAmHDQu8.mjs

@@ -1,45 +0,0 @@
-//#region src/container/errors.ts
-var ContainerError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "ContainerError";
-	}
-};
-var ContainerCreateError = class extends ContainerError {
-	constructor(message) {
-		super(message);
-		this.name = "ContainerCreateError";
-	}
-};
-var ContainerStartError = class extends ContainerError {
-	constructor(message) {
-		super(message);
-		this.name = "ContainerStartError";
-	}
-};
-var ContainerExecError = class extends ContainerError {
-	constructor(message) {
-		super(message);
-		this.name = "ContainerExecError";
-	}
-};
-var ContainerNotRunningError = class extends ContainerError {
-	constructor(message = "Container is not running.") {
-		super(message);
-		this.name = "ContainerNotRunningError";
-	}
-};
-var ContainerDisposedError = class extends ContainerError {
-	constructor(message = "Container has been disposed.") {
-		super(message);
-		this.name = "ContainerDisposedError";
-	}
-};
-var ContainerDiffError = class extends ContainerError {
-	constructor(message) {
-		super(message);
-		this.name = "ContainerDiffError";
-	}
-};
-//#endregion
-export { ContainerExecError as a, ContainerError as i, ContainerDiffError as n, ContainerNotRunningError as o, ContainerDisposedError as r, ContainerStartError as s, ContainerCreateError as t };