@mastra/factory 0.25.0-alpha.2 → 0.25.0-alpha.4

package/dist/routes/fs.js

@@ -11,16 +11,19 @@ import { detectProject, getResourceIdOverride } from "@mastra/code-sdk/utils/pro
 //#region src/routes/fs.ts
 const MAX_TEXT_FILE_BYTES = 524288;
 const MAX_DIFF_BYTES = 524288;
-const WORKSPACE_NUMSTAT_SCRIPT = `
+const MAX_PATCH_SET_BYTES = 8388608;
+/** Diffs the worktree against `$2`, untracked files as added through a throwaway index so the real one stays untouched. */
+const WORKSPACE_DIFF_SCRIPT = `
 set -e
 workdir=$1
 base=$2
+shift 2
 index_file=$(mktemp)
 untracked_file=$(mktemp)
 object_dir=$(mktemp -d)
 trap 'rm -f "$index_file" "$untracked_file"; rm -rf "$object_dir"' EXIT
 rm -f "$index_file"
-git -C "$workdir" diff --numstat -z --find-renames --no-ext-diff --no-textconv "$base"
+git -C "$workdir" -c core.quotePath=false diff --no-ext-diff --no-textconv --find-renames "$@" "$base"
 git -C "$workdir" ls-files --others --exclude-standard -z >"$untracked_file"
 git_dir=$(git -C "$workdir" rev-parse --absolute-git-dir)
 export GIT_INDEX_FILE="$index_file"
@@ -29,24 +32,30 @@ export GIT_ALTERNATE_OBJECT_DIRECTORIES="$git_dir/objects"
 git -C "$workdir" read-tree --empty
 git -C "$workdir" update-index --add -z --stdin <"$untracked_file"
 empty_tree=$(git -C "$workdir" hash-object -t tree /dev/null)
-git -C "$workdir" diff --cached --numstat -z --no-ext-diff --no-textconv "$empty_tree"
+git -C "$workdir" -c core.quotePath=false diff --cached --no-ext-diff --no-textconv "$@" "$empty_tree"
 `;
-const BOUNDED_GIT_DIFF_SCRIPT = `
-allow_exit_one=$1
+const NUMSTAT_FORMAT = ["--numstat", "-z"];
+const PATCH_FORMAT = [
+	"--patch",
+	"--no-color",
+	"--unified=3",
+	"--src-prefix=a/",
+	"--dst-prefix=b/"
+];
+/** Keeps the first `$1` bytes of the command in the remaining arguments; being cut short is not a failure. */
+const BOUNDED_OUTPUT_SCRIPT = `
+limit=$1
 shift
 status_file=$(mktemp)
-stderr_file=$(mktemp)
-trap 'rm -f "$status_file" "$stderr_file"' EXIT
+trap 'rm -f "$status_file"' EXIT
 (
-  git "$@" 2>"$stderr_file"
+  "$@"
   printf '%s' "$?" >"$status_file"
-) | head -c 524289
+) | head -c "$limit"
 status=$(cat "$status_file")
 case "$status" in
   0|141) exit 0 ;;
-  1) [ "$allow_exit_one" = "1" ] && exit 0 ;;
 esac
-cat "$stderr_file" >&2
 exit "\${status:-1}"
 `;
 const TEXT_DECODER = new TextDecoder("utf-8", { fatal: true });
@@ -318,26 +327,6 @@ function repositoryBaseBranches(session, layout, ownRepo) {
 	}
 	return bases;
 }
-/**
-* Split a client path into the layout repository it belongs to and the path
-* inside that checkout. Longest prefix wins; the inside path is validated
-* again so a prefix cannot smuggle a traversal. A path matching no repository
-* (including a bare prefix) is not available: the file routes only serve the
-* checkouts, never the workspace root itself.
-*/
-function resolveLayoutPath(layout, path, label) {
-	const safePath = assertRelativePath(path, label);
-	if (layout.repos.length === 1) return {
-		repo: layout.repos[0],
-		relative: safePath
-	};
-	const repo = layout.repos.filter((candidate) => safePath.startsWith(candidate.prefix) && safePath.length > candidate.prefix.length).toSorted((a, b) => b.prefix.length - a.prefix.length)[0];
-	if (!repo) throw new Error(`${label} is not available in this session's repositories`);
-	return {
-		repo,
-		relative: assertRelativePath(safePath.slice(repo.prefix.length), label)
-	};
-}
 /** List an approved rendered root inside a Factory session's sandbox workdir. */
 async function listSessionRenderedPath(session, renderedRoot) {
 	const safeRoot = assertApprovedRenderedRoot(renderedRoot);
@@ -696,7 +685,11 @@ function unavailableWorkspaceChanges(workspacePath) {
 		changes: []
 	};
 }
-async function resolveSessionComparisonBase(sandbox, workdir, baseBranch) {
+function isWorkspaceChangesScope(value) {
+	return value === "branch" || value === "uncommitted";
+}
+async function resolveSessionComparisonBase(sandbox, workdir, baseBranch, scope) {
+	if (scope === "uncommitted") return "HEAD";
 	const result = await sandbox.executeCommand("git", [
 		"-C",
 		workdir,
@@ -708,8 +701,7 @@ async function resolveSessionComparisonBase(sandbox, workdir, baseBranch) {
 	return result.exitCode === 0 && /^[0-9a-f]{40,64}$/i.test(sha) ? sha : "HEAD";
 }
 /** The changes of one checkout against its comparison base; `available: false` when git cannot inspect it. */
-async function listRepositoryChanges(sandbox, workdir, baseBranch) {
-	const comparisonBase = await resolveSessionComparisonBase(sandbox, workdir, baseBranch);
+async function listRepositoryChanges(sandbox, workdir, comparisonBase) {
 	const [statusResult, trackedResult, statsResult] = await Promise.all([
 		sandbox.executeCommand("git", [
 			"-C",
@@ -736,10 +728,11 @@ async function listRepositoryChanges(sandbox, workdir, baseBranch) {
 		}),
 		sandbox.executeCommand("sh", [
 			"-c",
-			WORKSPACE_NUMSTAT_SCRIPT,
+			WORKSPACE_DIFF_SCRIPT,
 			"mastracode-numstat",
 			workdir,
-			comparisonBase
+			comparisonBase,
+			...NUMSTAT_FORMAT
 		], {
 			timeout: 3e4,
 			maxRetainedBytes: Infinity
@@ -784,27 +777,20 @@ function prefixChange(change, prefix) {
 		...change.previousPath ? { previousPath: `${prefix}${change.previousPath}` } : {}
 	};
 }
-async function listSessionWorkspaceChanges(session) {
-	const handle = await sessionSandbox(session);
-	if (!handle) return unavailableWorkspaceChanges(session.sessionId);
-	const { layout, baseBranches: bases } = handle;
-	if (layout.repos.length === 1) {
-		const repo = layout.repos[0];
-		const result = await listRepositoryChanges(handle.sandbox, repo.dir, bases.get(repo.slug) ?? session.baseBranch);
-		if (!result.available) return unavailableWorkspaceChanges(session.sessionId);
+function assembleWorkspaceChanges(workspacePath, inspected) {
+	if (inspected.length === 1) {
+		const { changes } = inspected[0];
+		if (!changes.available) return unavailableWorkspaceChanges(workspacePath);
 		return {
-			workspacePath: session.sessionId,
-			...result
+			workspacePath,
+			...changes
 		};
 	}
-	const groups = await Promise.all(layout.repos.map(async (repo) => {
-		const result = await listRepositoryChanges(handle.sandbox, repo.dir, bases.get(repo.slug));
-		return {
-			slug: repo.slug,
-			prefix: repo.prefix,
-			...result,
-			changes: result.changes.map((change) => prefixChange(change, repo.prefix))
-		};
+	const groups = inspected.map(({ repo, changes }) => ({
+		slug: repo.slug,
+		prefix: repo.prefix,
+		...changes,
+		changes: changes.changes.map((change) => prefixChange(change, repo.prefix))
 	}));
 	const available = groups.filter((group) => group.available);
 	const changes = available.flatMap((group) => group.changes).toSorted((a, b) => a.path.localeCompare(b.path));
@@ -814,90 +800,134 @@ async function listSessionWorkspaceChanges(session) {
 		deletions: counted.reduce((sum, group) => sum + (group.deletions ?? 0), 0)
 	} : {};
 	return {
-		workspacePath: session.sessionId,
+		workspacePath,
 		available: available.length > 0,
 		changes,
 		...totals,
 		repositories: groups
 	};
 }
-async function executeBoundedGitDiff(sandbox, args, allowExitOne = false) {
-	return sandbox.executeCommand("sh", [
-		"-c",
-		BOUNDED_GIT_DIFF_SCRIPT,
-		"mastracode-diff",
-		allowExitOne ? "1" : "0",
-		...args
-	], { timeout: 3e4 });
+async function listSessionWorkspaceChanges(session) {
+	const handle = await sessionSandbox(session);
+	if (!handle) return unavailableWorkspaceChanges(session.sessionId);
+	const { sandbox, layout, baseBranches } = handle;
+	const inspected = await Promise.all(layout.repos.map(async (repo) => {
+		const comparisonBase = await resolveSessionComparisonBase(sandbox, repo.dir, baseBranches.get(repo.slug) ?? session.baseBranch, "branch");
+		return {
+			repo,
+			changes: await listRepositoryChanges(sandbox, repo.dir, comparisonBase)
+		};
+	}));
+	return assembleWorkspaceChanges(session.sessionId, inspected);
 }
-function truncatePatch(patchBuffer) {
-	const patch = patchBuffer.subarray(0, MAX_DIFF_BYTES).toString("utf8");
-	const lastNewline = patch.lastIndexOf("\n");
-	if (lastNewline >= 0) return patch.slice(0, lastNewline + 1);
-	return patch.replace(/\uFFFD+$/, "");
+const GIT_C_ESCAPES = {
+	"\"": "\\\"",
+	"\\": "\\\\",
+	"\x07": "\\a",
+	"\b": "\\b",
+	"	": "\\t",
+	"\n": "\\n",
+	"\v": "\\v",
+	"\f": "\\f",
+	"\r": "\\r"
+};
+/** A path as git writes it in a diff header: `core.quotePath=false` quotes only for quotes, backslashes and control characters. */
+function gitHeaderPath(path) {
+	let escaped = "";
+	let quoted = false;
+	for (const char of path) {
+		const code = char.charCodeAt(0);
+		const escape = GIT_C_ESCAPES[char] ?? (code < 32 || code === 127 ? `\\${code.toString(8).padStart(3, "0")}` : "");
+		quoted ||= escape !== "";
+		escaped += escape || char;
+	}
+	return quoted ? `"${escaped}"` : path;
 }
-async function readSessionWorkspaceDiff(session, path, previousPath) {
-	const safePath = assertRelativePath(path, "path");
-	if (previousPath) assertRelativePath(previousPath, "previousPath");
+function keyWorkspacePatches(patch, changes) {
+	const sections = patch.split(/^(?=diff --git )/m);
+	const budgetSpent = Buffer.byteLength(patch) > MAX_PATCH_SET_BYTES;
+	if (budgetSpent) sections.pop();
+	const sectionsByHeader = /* @__PURE__ */ new Map();
+	for (const section of sections) {
+		const headerEnd = section.indexOf("\n");
+		if (headerEnd >= 0) sectionsByHeader.set(section.slice(0, headerEnd), section);
+	}
+	const keyed = {
+		patches: /* @__PURE__ */ new Map(),
+		omitted: /* @__PURE__ */ new Map()
+	};
+	for (const change of changes) {
+		const header = `diff --git ${gitHeaderPath(`a/${change.previousPath ?? change.path}`)} ${gitHeaderPath(`b/${change.path}`)}`;
+		const section = sectionsByHeader.get(header);
+		if (section === void 0) {
+			if (budgetSpent) keyed.omitted.set(change.path, "total-too-large");
+		} else if (Buffer.byteLength(section) > MAX_DIFF_BYTES) keyed.omitted.set(change.path, "file-too-large");
+		else keyed.patches.set(change.path, section);
+	}
+	return keyed;
+}
+function prefixedEntries(prefix, entries) {
+	return Array.from(entries, ([path, value]) => [`${prefix}${path}`, value]);
+}
+function unavailableWorkspacePatches(workspacePath, scope) {
+	return {
+		...unavailableWorkspaceChanges(workspacePath),
+		scope,
+		patches: {},
+		omittedPatches: {}
+	};
+}
+async function listSessionWorkspacePatches(session, scope) {
 	const handle = await sessionSandbox(session);
-	if (!handle) throw new Error("Session workspace is not available");
-	const target = resolveLayoutPath(handle.layout, safePath, "path");
-	const previous = previousPath ? resolveLayoutPath(handle.layout, previousPath, "previousPath") : void 0;
-	if (previous && previous.repo !== target.repo) throw new Error("previousPath is not available in the repository of path");
-	const workdir = target.repo.dir;
-	const comparisonBase = await resolveSessionComparisonBase(handle.sandbox, workdir, handle.baseBranches.get(target.repo.slug));
-	const pathspecs = previous ? [previous.relative, target.relative] : [target.relative];
-	let result = await executeBoundedGitDiff(handle.sandbox, [
-		"--literal-pathspecs",
-		"-C",
-		workdir,
-		"diff",
-		"--find-renames",
-		"--no-ext-diff",
-		"--no-color",
-		"--unified=3",
-		comparisonBase,
-		"--",
-		...pathspecs
-	]);
-	if (result.exitCode !== 0) throw new Error(result.stderr || "Unable to read workspace diff");
-	if (!result.stdout) {
-		const untracked = await handle.sandbox.executeCommand("git", [
-			"--literal-pathspecs",
-			"-C",
-			workdir,
-			"ls-files",
-			"--others",
-			"--exclude-standard",
-			"--",
-			target.relative
+	if (!handle) return unavailableWorkspacePatches(session.sessionId, scope);
+	const { sandbox, layout, baseBranches } = handle;
+	const inspected = await Promise.all(layout.repos.map(async (repo) => {
+		const comparisonBase = await resolveSessionComparisonBase(sandbox, repo.dir, baseBranches.get(repo.slug) ?? session.baseBranch, scope);
+		const [changes, patch] = await Promise.all([listRepositoryChanges(sandbox, repo.dir, comparisonBase), sandbox.executeCommand("sh", [
+			"-c",
+			BOUNDED_OUTPUT_SCRIPT,
+			"mastracode-bounded",
+			String(8388609),
+			"sh",
+			"-c",
+			WORKSPACE_DIFF_SCRIPT,
+			"mastracode-patch",
+			repo.dir,
+			comparisonBase,
+			...PATCH_FORMAT
 		], {
 			timeout: 3e4,
 			maxRetainedBytes: Infinity
-		});
-		if (untracked.exitCode === 0 && untracked.stdout.trim()) {
-			result = await executeBoundedGitDiff(handle.sandbox, [
-				"-C",
-				workdir,
-				"diff",
-				"--no-index",
-				"--no-ext-diff",
-				"--no-color",
-				"--unified=3",
-				"--",
-				"/dev/null",
-				target.relative
-			], true);
-			if (result.exitCode !== 0 && result.exitCode !== 1) throw new Error(result.stderr || "Unable to read workspace diff");
+		})]);
+		if (patch.exitCode !== 0 && changes.changes.length > 0) {
+			const diffError = patch.stderr.trim().split("\n")[0] || `git diff exited with code ${patch.exitCode}`;
+			return {
+				repo,
+				changes,
+				keyed: {
+					patches: /* @__PURE__ */ new Map(),
+					omitted: /* @__PURE__ */ new Map()
+				},
+				diffError
+			};
 		}
-	}
-	const patchBuffer = Buffer.from(result.stdout);
-	const truncated = patchBuffer.length > MAX_DIFF_BYTES;
+		return {
+			repo,
+			changes,
+			keyed: keyWorkspacePatches(patch.stdout, changes.changes),
+			diffError: void 0
+		};
+	}));
+	const diffErrors = inspected.flatMap(({ repo, diffError }) => {
+		if (!diffError) return [];
+		return [layout.repos.length > 1 ? `${repo.slug}: ${diffError}` : diffError];
+	});
 	return {
-		workspacePath: session.sessionId,
-		path: safePath,
-		patch: truncated ? truncatePatch(patchBuffer) : result.stdout,
-		truncated
+		...assembleWorkspaceChanges(session.sessionId, inspected),
+		scope,
+		patches: Object.fromEntries(inspected.flatMap(({ repo, keyed }) => prefixedEntries(repo.prefix, keyed.patches))),
+		omittedPatches: Object.fromEntries(inspected.flatMap(({ repo, keyed }) => prefixedEntries(repo.prefix, keyed.omitted))),
+		...diffErrors.length > 0 ? { diffError: diffErrors.join("\n") } : {}
 	};
 }
 /**
@@ -990,23 +1020,21 @@ function buildFsRoutes(options = {}) {
 				}
 			}
 		}),
-		registerApiRoute("/web/workspace/changes/diff", {
+		registerApiRoute("/web/workspace/changes/patches", {
 			method: "GET",
 			requiresAuth: false,
 			handler: async (c) => {
 				const workspacePath = c.req.query("workspacePath");
-				const path = c.req.query("path");
-				const previousPath = c.req.query("previousPath");
+				const scope = c.req.query("scope") ?? "branch";
 				if (!workspacePath) return c.json({ error: "Missing required query param: workspacePath" }, 400);
-				if (!path) return c.json({ error: "Missing required query param: path" }, 400);
+				if (!isWorkspaceChangesScope(scope)) return c.json({ error: "scope must be branch or uncommitted" }, 400);
 				try {
 					const session = await resolveAuthorizedSession(loose(c), sessionFs, workspacePath);
-					if (!session || !sessionFs) return c.json({ error: "Session workspace is not available" }, 403);
-					return c.json(await readSessionWorkspaceDiff(session, path, previousPath));
+					if (!session || !sessionFs) return c.json(unavailableWorkspacePatches(workspacePath, scope));
+					return c.json(await listSessionWorkspacePatches(session, scope));
 				} catch (error) {
 					const message = error instanceof Error ? error.message : String(error);
-					const status = message.includes("relative") || message.includes("escapes") || message.includes("not available") ? 403 : 500;
-					return c.json({ error: message }, status);
+					return c.json({ error: message }, message.includes("not available") ? 403 : 500);
 				}
 			}
 		}),
@@ -1065,6 +1093,6 @@ function buildFsRoutes(options = {}) {
 	];
 }
 //#endregion
-export { buildFsRoutes, listArtifacts, listDirectory, listSessionRenderedPath, listSessionWorkspaceChanges, listSessionWorkspaceTree, listWorkspaceRenderedPath, parseWorkspaceChangeStats, parseWorkspaceChanges, parseWorkspaceTrackedChanges, readSessionWorkspaceDiff, readSessionWorkspaceFile, readWorkspaceFile, resolveCodebase, resolveFsRoot };
+export { buildFsRoutes, listArtifacts, listDirectory, listSessionRenderedPath, listSessionWorkspaceChanges, listSessionWorkspacePatches, listSessionWorkspaceTree, listWorkspaceRenderedPath, parseWorkspaceChangeStats, parseWorkspaceChanges, parseWorkspaceTrackedChanges, readSessionWorkspaceFile, readWorkspaceFile, resolveCodebase, resolveFsRoot };
 
 //# sourceMappingURL=fs.js.map