@mastra/factory 0.24.0-alpha.8 → 0.24.0

package/dist/routes/fs.js

@@ -1,7 +1,7 @@
 import { requireExec } from "../sandbox/materialization.js";
+import { SETUP_MARKER_DIR } from "../packages/_internals/workspace/dist/index.js";
 import { peekSessionSandbox, sessionLayout } from "../sandbox/session-sandbox.js";
 import { peekSessionEnvironment } from "../session/environment-state-processor.js";
-import { waitForPendingFilesystemCapture } from "../session/filesystem-capture.js";
 import { registerApiRoute } from "@mastra/core/server";
 import { isAbsolute, join, posix, resolve, sep } from "path";
 import { SandboxFilesystem } from "@mastra/code-sdk/agents/sandbox-filesystem";
@@ -9,8 +9,8 @@ import { lstat, open, readdir, realpath, stat } from "fs/promises";
 import { homedir } from "os";
 import { detectProject, getResourceIdOverride } from "@mastra/code-sdk/utils/project";
 //#region src/routes/fs.ts
-const MAX_TEXT_FILE_BYTES = 512 * 1024;
-const MAX_DIFF_BYTES = 512 * 1024;
+const MAX_TEXT_FILE_BYTES = 524288;
+const MAX_DIFF_BYTES = 524288;
 const WORKSPACE_NUMSTAT_SCRIPT = `
 set -e
 workdir=$1
@@ -87,11 +87,10 @@ async function realPathWithinRoot(candidate, root) {
 	}
 }
 function assertRelativePath(path, label) {
-	const trimmed = path.trim();
-	if (!trimmed) throw new Error(`Missing required query param: ${label}`);
-	if (isAbsolute(trimmed)) throw new Error(`${label} must be relative`);
-	if (trimmed.split(/[\\/]+/).includes("..")) throw new Error(`${label} escapes workspace`);
-	const normalized = resolve("/", trimmed).slice(1);
+	if (!path.trim()) throw new Error(`Missing required query param: ${label}`);
+	if (isAbsolute(path)) throw new Error(`${label} must be relative`);
+	if (path.split(/[\\/]+/).includes("..")) throw new Error(`${label} escapes workspace`);
+	const normalized = resolve("/", path).slice(1);
 	if (!normalized || normalized === ".." || normalized.startsWith(`..${sep}`)) throw new Error(`${label} escapes workspace`);
 	return normalized;
 }
@@ -275,24 +274,6 @@ async function resolveAuthorizedSession(c, deps, workspacePath) {
 	}
 	return session;
 }
-async function listSessionFilesystemFiles(filesystem, session, threadId) {
-	const safeThreadId = threadId.trim();
-	if (!safeThreadId) throw new Error("Missing required query param: threadId");
-	await waitForPendingFilesystemCapture(session.sessionId);
-	const layout = sessionLayout(peekSessionSandbox(session.id));
-	return {
-		workspacePath: session.sessionId,
-		threadId: safeThreadId,
-		files: await filesystem.listFiles({
-			resourceId: session.sessionId,
-			threadId: safeThreadId
-		}),
-		...layout && layout.repos.length > 1 ? { repositories: layout.repos.map((repo) => ({
-			slug: repo.slug,
-			prefix: repo.prefix
-		})) } : {}
-	};
-}
 /**
 * Resolve the session's sandbox from the per-process memo and wrap the
 * session layout's root in a `SandboxFilesystem`: the checkout for a
@@ -311,7 +292,8 @@ async function sessionSandbox(session) {
 		sandbox,
 		filesystem: new SandboxFilesystem({
 			sandbox,
-			workdir: layout.root
+			workdir: layout.root,
+			verifySymlinks: true
 		}),
 		layout,
 		baseBranches: repositoryBaseBranches(session, layout, entry.ownRepo)
@@ -397,26 +379,211 @@ async function listSessionRenderedPath(session, renderedRoot) {
 		entries
 	};
 }
-/** Read a file inside a session's sandbox. Paths outside rendered roots require a persisted-file allowlist check in the route. */
-async function readSessionWorkspaceFile(session, path, options = {}) {
+/**
+* Directory entries the file tree never shows or serves: git internals and the
+* sandbox's own setup markers.
+*/
+const HIDDEN_TREE_ENTRIES = /* @__PURE__ */ new Set([".git", SETUP_MARKER_DIR]);
+/**
+* Where a tree path lives. Inside a checkout: that checkout and the path within
+* it (a bare repository directory resolves to its root). Elsewhere in the
+* working directory (a multi-repository session's root, `.artifacts`): no
+* checkout, so no ignore rules apply.
+*/
+function treeLocation(layout, path) {
+	const safePath = path ? assertRelativePath(path, "path") : "";
+	if (safePath.split("/").some((segment) => HIDDEN_TREE_ENTRIES.has(segment))) throw new Error("Path is not available in this session");
+	if (layout.repos.length === 1) return {
+		repo: layout.repos[0],
+		relative: safePath
+	};
+	const repo = layout.repos.filter((candidate) => `${safePath}/`.startsWith(candidate.prefix)).toSorted((a, b) => b.prefix.length - a.prefix.length)[0];
+	return repo ? {
+		repo,
+		relative: safePath.slice(repo.prefix.length)
+	} : {
+		repo: void 0,
+		relative: safePath
+	};
+}
+/**
+* The checkout-relative paths git ignores, in one `git check-ignore` call.
+* Ignored files (`.env`, build output, `node_modules`) are neither listed nor
+* served: viewers of a session shouldn't read its local secrets. Fails closed
+* when git can't answer.
+*/
+async function ignoredPaths(sandbox, repoDir, paths) {
+	if (paths.length === 0) return /* @__PURE__ */ new Set();
+	const result = await sandbox.executeCommand("sh", [
+		"-c",
+		"cd \"$1\" && shift && printf '%s\\0' \"$@\" | git check-ignore -z --stdin",
+		"sh",
+		repoDir,
+		...paths
+	], {
+		timeout: 3e4,
+		maxRetainedBytes: Infinity
+	});
+	if (result.exitCode === 1) return /* @__PURE__ */ new Set();
+	if (result.exitCode !== 0) throw new Error(`Unable to check ignored files: ${result.stderr.trim() || "git failed"}`);
+	return new Set(result.stdout.split("\0").filter(Boolean));
+}
+/**
+* The real absolute location of each path (relative to `root`), following
+* every symlink, or `''` when it doesn't exist; plus `root`'s own. Paths go in
+* as positional arguments and come back NUL-separated.
+*/
+async function realPaths(sandbox, root, paths) {
+	const result = await sandbox.executeCommand("sh", [
+		"-c",
+		"cd \"$1\" && shift && printf '%s\\0' \"$(pwd -P)\" && for p; do printf '%s\\0' \"$([ -e \"$p\" ] && readlink -f -- \"$p\")\"; done",
+		"sh",
+		root,
+		...paths
+	], {
+		timeout: 3e4,
+		maxRetainedBytes: Infinity
+	});
+	if (result.exitCode !== 0) throw new Error(`Unable to resolve symlinks: ${result.stderr.trim() || "failed"}`);
+	const [physicalRoot = "", ...resolved] = result.stdout.split("\0");
+	return {
+		root: physicalRoot,
+		paths: resolved.slice(0, paths.length)
+	};
+}
+/** The first `bytes` bytes of a file, base64-encoded in the sandbox so binary content survives. */
+async function readFilePrefix(sandbox, path, bytes) {
+	const result = await sandbox.executeCommand("sh", [
+		"-c",
+		"t=$(mktemp) && trap 'rm -f \"$t\"' EXIT && head -c \"$1\" -- \"$2\" >\"$t\" && base64 <\"$t\"",
+		"sh",
+		String(bytes),
+		path
+	], {
+		timeout: 3e4,
+		maxRetainedBytes: Infinity
+	});
+	if (result.exitCode !== 0) throw new Error(`Unable to read file: ${result.stderr.trim() || "failed"}`);
+	return Buffer.from(result.stdout, "base64");
+}
+/**
+* Where a real absolute path sits in the tree, or `undefined` when the tree
+* can't show it: missing, outside the working directory, or inside git
+* internals or setup markers.
+*/
+function treePathOf(layout, physicalRoot, real) {
+	if (!real) return void 0;
+	const relative = posix.relative(physicalRoot, real);
+	if (relative === ".." || relative.startsWith("../") || posix.isAbsolute(relative)) return void 0;
+	try {
+		treeLocation(layout, relative);
+	} catch {
+		return;
+	}
+	return relative;
+}
+/** Which tree paths their checkout ignores: one `git check-ignore` per checkout involved. */
+async function ignoredTreePaths(sandbox, layout, paths) {
+	const byRepo = /* @__PURE__ */ new Map();
+	for (const path of paths) {
+		const { repo, relative } = treeLocation(layout, path);
+		if (!repo || !relative) continue;
+		const inRepo = byRepo.get(repo) ?? /* @__PURE__ */ new Map();
+		inRepo.set(relative, path);
+		byRepo.set(repo, inRepo);
+	}
+	const ignored = /* @__PURE__ */ new Set();
+	for (const [repo, inRepo] of byRepo) for (const relative of await ignoredPaths(sandbox, repo.dir, [...inRepo.keys()])) ignored.add(inRepo.get(relative));
+	return ignored;
+}
+/**
+* List one directory of a session's working directory from its sandbox,
+* without git internals or entries a checkout ignores. Passive like every
+* session read: a session with no sandbox in this process comes back
+* `available: false` instead of starting one.
+*/
+async function listSessionWorkspaceTree(session, path = "") {
+	const requested = path.trim() ? path : "";
+	const handle = await sessionSandbox(session);
+	const listing = {
+		workspacePath: session.sessionId,
+		path: requested
+	};
+	if (!handle) return {
+		...listing,
+		available: false,
+		entries: []
+	};
+	const { layout, sandbox, filesystem } = handle;
+	const location = treeLocation(layout, requested);
+	const dir = (location.repo ? location.repo.prefix + location.relative : location.relative).replace(/\/$/, "");
+	const children = (await filesystem.readdir(dir || ".")).filter((entry) => !HIDDEN_TREE_ENTRIES.has(entry.name));
+	const childPath = (name) => dir ? `${dir}/${name}` : name;
+	const links = children.filter((entry) => entry.isSymlink);
+	const resolve = [...dir ? [dir] : [], ...links.map((entry) => childPath(entry.name))];
+	const real = resolve.length > 0 ? await realPaths(sandbox, layout.root, resolve) : void 0;
+	const linkTargets = real ? real.paths.slice(dir ? 1 : 0) : [];
+	if (dir && real.paths[0] !== posix.join(real.root, dir)) throw new Error("Path is not available in this session");
+	const targets = new Map(links.map((entry, i) => [entry.name, treePathOf(layout, real.root, linkTargets[i])]));
+	const ignored = await ignoredTreePaths(sandbox, layout, [
+		...dir ? [dir] : [],
+		...children.map((entry) => childPath(entry.name)),
+		...[...targets.values()].filter((target) => target !== void 0)
+	]);
+	if (dir && ignored.has(dir)) throw new Error("Path is not available in this session");
+	const entries = children.filter((entry) => {
+		if (ignored.has(childPath(entry.name))) return false;
+		if (!entry.isSymlink) return true;
+		const target = targets.get(entry.name);
+		return target !== void 0 && !ignored.has(target);
+	}).map((entry) => ({
+		name: entry.name,
+		path: childPath(entry.name),
+		type: entry.type,
+		...entry.type === "file" && entry.size !== void 0 && { size: entry.size },
+		...entry.isSymlink && {
+			symlinkTarget: entry.symlinkTarget ?? targets.get(entry.name),
+			linkedPath: targets.get(entry.name)
+		}
+	})).toSorted((a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "directory" ? -1 : 1);
+	return {
+		...listing,
+		available: true,
+		entries
+	};
+}
+/**
+* Read a file inside a session's sandbox: anything under an approved rendered
+* root, or anything the tree would list (not git internals, not ignored by its
+* checkout).
+*/
+async function readSessionWorkspaceFile(session, path) {
 	const safePath = assertRelativePath(path, "path");
-	if (!options.allowUnapprovedPath) assertApprovedRenderedRoot(safePath.split("/")[0] ?? "");
 	const handle = await sessionSandbox(session);
 	if (!handle) throw new Error("Session workspace is not available");
+	const { layout, sandbox } = handle;
+	treeLocation(layout, safePath);
+	const parent = posix.dirname(safePath);
+	const real = await realPaths(sandbox, layout.root, parent === "." ? [safePath] : [safePath, parent]);
+	const target = treePathOf(layout, real.root, real.paths[0]);
+	const throughLink = parent !== "." && real.paths[1] !== posix.join(real.root, parent);
+	if (target === void 0 || throughLink) throw new Error("Path is not available in this session");
+	const trusted = APPROVED_RENDERED_ROOTS.has(safePath.split("/")[0] ?? "");
+	if ((await ignoredTreePaths(sandbox, layout, [.../* @__PURE__ */ new Set([...trusted ? [] : [safePath], ...target === safePath ? [] : [target]])])).size > 0) throw new Error("Path is not available in this session");
 	const { filesystem } = handle;
 	const info = await filesystem.stat(safePath);
 	if (info.type === "directory") throw new Error("Path is a directory");
-	const buffer = await filesystem.readFile(safePath);
-	const truncated = buffer.length > MAX_TEXT_FILE_BYTES;
+	const truncated = info.size > MAX_TEXT_FILE_BYTES;
+	const buffer = truncated ? await readFilePrefix(sandbox, real.paths[0], MAX_TEXT_FILE_BYTES) : await filesystem.readFile(safePath);
 	const base = {
 		workspacePath: session.sessionId,
 		path: safePath,
 		name: posix.basename(safePath),
-		size: buffer.length,
+		size: info.size,
 		updatedAt: info.modifiedAt.toISOString()
 	};
 	try {
-		const content = TEXT_DECODER.decode(truncated ? buffer.subarray(0, MAX_TEXT_FILE_BYTES) : buffer);
+		const content = TEXT_DECODER.decode(buffer);
 		return {
 			...base,
 			contentType: "text",
@@ -807,57 +974,55 @@ function buildFsRoutes(options = {}) {
 				}
 			}
 		}),
-		registerApiRoute("/web/workspace/files", {
+		registerApiRoute("/web/workspace/changes", {
 			method: "GET",
 			requiresAuth: false,
 			handler: async (c) => {
 				const workspacePath = c.req.query("workspacePath");
-				const threadId = c.req.query("threadId")?.trim();
 				if (!workspacePath) return c.json({ error: "Missing required query param: workspacePath" }, 400);
-				if (!threadId) return c.json({ error: "Missing required query param: threadId" }, 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 listSessionFilesystemFiles(sessionFs.filesystem, session, threadId));
+					if (!session || !sessionFs) return c.json(unavailableWorkspaceChanges(workspacePath));
+					return c.json(await listSessionWorkspaceChanges(session));
 				} catch (error) {
 					const message = error instanceof Error ? error.message : String(error);
-					const status = message.includes("not available") ? 403 : 500;
-					return c.json({ error: message }, status);
+					return c.json({ error: message }, message.includes("not available") ? 403 : 500);
 				}
 			}
 		}),
-		registerApiRoute("/web/workspace/changes", {
+		registerApiRoute("/web/workspace/changes/diff", {
 			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");
 				if (!workspacePath) return c.json({ error: "Missing required query param: workspacePath" }, 400);
+				if (!path) return c.json({ error: "Missing required query param: path" }, 400);
 				try {
 					const session = await resolveAuthorizedSession(loose(c), sessionFs, workspacePath);
-					if (!session || !sessionFs) return c.json(unavailableWorkspaceChanges(workspacePath));
-					return c.json(await listSessionWorkspaceChanges(session));
+					if (!session || !sessionFs) return c.json({ error: "Session workspace is not available" }, 403);
+					return c.json(await readSessionWorkspaceDiff(session, path, previousPath));
 				} catch (error) {
 					const message = error instanceof Error ? error.message : String(error);
-					return c.json({ error: message }, message.includes("not available") ? 403 : 500);
+					const status = message.includes("relative") || message.includes("escapes") || message.includes("not available") ? 403 : 500;
+					return c.json({ error: message }, status);
 				}
 			}
 		}),
-		registerApiRoute("/web/workspace/changes/diff", {
+		registerApiRoute("/web/workspace/tree", {
 			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");
 				if (!workspacePath) return c.json({ error: "Missing required query param: workspacePath" }, 400);
-				if (!path) return c.json({ error: "Missing required query param: path" }, 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));
+					return c.json(await listSessionWorkspaceTree(session, c.req.query("path") ?? ""));
 				} 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;
+					const status = message.includes("relative") || message.includes("escapes") || message.includes("not available") ? 403 : message.includes("not found") ? 404 : 500;
 					return c.json({ error: message }, status);
 				}
 			}
@@ -868,22 +1033,11 @@ function buildFsRoutes(options = {}) {
 			handler: async (c) => {
 				const workspacePath = c.req.query("workspacePath");
 				const path = c.req.query("path");
-				const requestedThreadId = c.req.query("threadId");
-				const threadId = requestedThreadId?.trim();
 				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 (requestedThreadId !== void 0 && !threadId) return c.json({ error: "Missing required query param: threadId" }, 400);
 				try {
 					const session = await resolveAuthorizedSession(loose(c), sessionFs, workspacePath);
-					if (session && sessionFs) {
-						if (threadId) {
-							const safePath = assertRelativePath(path, "path");
-							if (!(await listSessionFilesystemFiles(sessionFs.filesystem, session, threadId)).files.some((file) => file.path === safePath)) return c.json({ error: "Path is not available for this thread" }, 404);
-							return c.json(await readSessionWorkspaceFile(session, safePath, { allowUnapprovedPath: true }));
-						}
-						return c.json(await readSessionWorkspaceFile(session, path));
-					}
-					if (threadId) return c.json({ error: "Session workspace is not available" }, 403);
+					if (session && sessionFs) return c.json(await readSessionWorkspaceFile(session, path));
 					return c.json(await readWorkspaceFile(root, workspacePath, path));
 				} catch (error) {
 					const message = error instanceof Error ? error.message : String(error);
@@ -911,6 +1065,6 @@ function buildFsRoutes(options = {}) {
 	];
 }
 //#endregion
-export { buildFsRoutes, listArtifacts, listDirectory, listSessionFilesystemFiles, listSessionRenderedPath, listSessionWorkspaceChanges, listWorkspaceRenderedPath, parseWorkspaceChangeStats, parseWorkspaceChanges, parseWorkspaceTrackedChanges, readSessionWorkspaceDiff, readSessionWorkspaceFile, readWorkspaceFile, resolveCodebase, resolveFsRoot };
+export { buildFsRoutes, listArtifacts, listDirectory, listSessionRenderedPath, listSessionWorkspaceChanges, listSessionWorkspaceTree, listWorkspaceRenderedPath, parseWorkspaceChangeStats, parseWorkspaceChanges, parseWorkspaceTrackedChanges, readSessionWorkspaceDiff, readSessionWorkspaceFile, readWorkspaceFile, resolveCodebase, resolveFsRoot };
 
 //# sourceMappingURL=fs.js.map