@mastra/code-sdk 0.0.0-client-tool-results-20260912062135

package/dist/agents/sandbox-filesystem.d.ts

@@ -0,0 +1,117 @@
+/**
+ * SandboxFilesystem
+ *
+ * A `WorkspaceFilesystem` that stores files inside a remote `MastraSandbox`
+ * (e.g. a Railway VM) rather than on the server host. File operations are
+ * implemented by shelling out through the sandbox's `executeCommand`, so the
+ * agent's file tools and command tools share one VM and one view of the repo.
+ *
+ * Paths are workspace-relative (`/src/foo.ts`) and resolve under the sandbox
+ * working directory (`basePath`). A traversal guard rejects any path that
+ * escapes the workdir, mirroring `LocalFilesystem`'s contained mode.
+ *
+ * Reads/writes use base64 over the wire so binary content survives the shell.
+ */
+import type { CopyOptions, FileContent, FileEntry, FileStat, FilesystemInfo, ListOptions, ProviderStatus, ReadOptions, RemoveOptions, WorkspaceFilesystem, WriteOptions } from '@mastra/core/workspace';
+/** Minimal command result shape we depend on. */
+export interface SandboxCommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+/** Minimal sandbox surface the filesystem needs. */
+export interface SandboxExec {
+    readonly id: string;
+    executeCommand(command: string, args?: string[], options?: {
+        timeout?: number;
+    }): Promise<SandboxCommandResult>;
+}
+export interface SandboxFilesystemOptions {
+    /** Live sandbox to run commands in. */
+    sandbox: SandboxExec;
+    /**
+     * Absolute path inside the sandbox that is the workspace root — or a lazy
+     * resolver for it. The resolver form exists for sandboxes whose workspace
+     * root is only knowable once the VM is running (e.g. `$HOME/<repo>` under
+     * a provider-chosen home dir): it is awaited on the first file operation
+     * (which itself may lazily start the VM) and the result is memoized.
+     */
+    workdir: string | (() => Promise<string> | string);
+    /** Optional stable id; defaults to a sandbox-derived id. */
+    id?: string;
+}
+export declare class SandboxFilesystem implements WorkspaceFilesystem {
+    readonly id: string;
+    readonly name = "SandboxFilesystem";
+    readonly provider = "sandbox";
+    status: ProviderStatus;
+    private readonly sandbox;
+    private readonly workdirSource;
+    private resolvedBase?;
+    private resolvingBase?;
+    constructor(options: SandboxFilesystemOptions);
+    /** The resolved workspace root; empty until a lazy workdir first resolves. */
+    get basePath(): string;
+    /** Await (and memoize) the workspace root, resolving a lazy workdir once. */
+    private base;
+    /**
+     * Resolve a workspace path to an absolute path inside the sandbox, enforcing
+     * that it stays within the workdir. Awaits the workspace root first, which
+     * for a lazy workdir may start the VM.
+     */
+    private resolveAsync;
+    /**
+     * Resolve a workspace path against a known base, enforcing that it stays
+     * within the workdir.
+     *
+     * Accepts both workspace-relative paths (`src/foo.ts`, `/src/foo.ts`) and
+     * absolute sandbox paths that already live under the workdir — the agent's
+     * prompt advertises the workdir as its working directory, so tools are
+     * routinely called with fully-qualified paths like `<workdir>/src/foo.ts`.
+     */
+    private resolveAgainst;
+    resolveAbsolutePath(inputPath: string): string | undefined;
+    private exec;
+    /**
+     * Lexical guard catches `..` traversal, but a symlink inside the workdir can
+     * still point outside it. After resolving a path that refers to an existing
+     * entry, verify its realpath is still contained in the workdir.
+     *
+     * Canonicalization tries `realpath`, then `readlink -f` (GNU/busybox), then
+     * `cd && pwd -P` for directories — covering GNU hosts, macOS/BSD, and
+     * busybox. If the path exists but cannot be canonicalized we fail CLOSED:
+     * returning without a check would let a symlink bypass containment.
+     */
+    private assertContainedRealpath;
+    /**
+     * Guard for write destinations. The lexical guard catches `..`, but a symlink
+     * inside the workdir can redirect a write outside it. For an existing target
+     * we check its realpath; for a not-yet-existing target we check the realpath
+     * of its nearest existing ancestor directory, since a symlinked parent is the
+     * escape vector (e.g. `link -> /etc` then writing `link/passwd`).
+     */
+    private assertContainedDest;
+    private execOk;
+    readFile(path: string, options?: ReadOptions): Promise<string | Buffer>;
+    writeFile(path: string, content: FileContent, options?: WriteOptions): Promise<void>;
+    appendFile(path: string, content: FileContent): Promise<void>;
+    deleteFile(path: string, options?: RemoveOptions): Promise<void>;
+    copyFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
+    moveFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(path: string, options?: RemoveOptions): Promise<void>;
+    readdir(path: string, options?: ListOptions): Promise<FileEntry[]>;
+    private parseListOutput;
+    private parseFindOutput;
+    private matchesExtension;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FileStat>;
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    isReady(): Promise<boolean>;
+    getInfo(): FilesystemInfo;
+    getInstructions(): string;
+}
+//# sourceMappingURL=sandbox-filesystem.d.ts.map

package/dist/agents/sandbox-filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox-filesystem.d.ts","sourceRoot":"","sources":["../../src/agents/sandbox-filesystem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,SAAS,EACT,QAAQ,EACR,cAAc,EACd,WAAW,EACX,cAAc,EACd,WAAW,EACX,aAAa,EACb,mBAAmB,EACnB,YAAY,EACb,MAAM,wBAAwB,CAAC;AAWhC,iDAAiD;AACjD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,oDAAoD;AACpD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACjH;AAED,MAAM,WAAW,wBAAwB;IACvC,uCAAuC;IACvC,OAAO,EAAE,WAAW,CAAC;IACrB;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;IACnD,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAmBD,qBAAa,iBAAkB,YAAW,mBAAmB;IAC3D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,uBAAuB;IACpC,QAAQ,CAAC,QAAQ,aAAa;IAC9B,MAAM,EAAE,cAAc,CAAW;IAEjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA4C;IAC1E,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,aAAa,CAAC,CAAkB;gBAE5B,OAAO,EAAE,wBAAwB;IAc7C,8EAA8E;IAC9E,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,6EAA6E;YAC/D,IAAI;IAkBlB;;;;OAIG;YACW,YAAY;IAI1B;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;IAkBtB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;YAS5C,IAAI;IAIlB;;;;;;;;;OASG;YACW,uBAAuB;IA0BrC;;;;;;OAMG;YACW,mBAAmB;YAWnB,MAAM;IAUd,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC;IAoBvE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBpF,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAU7D,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBhE,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA2CzE,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAqCzE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAOrE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB3D,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAuBxE,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,eAAe;IAgBvB,OAAO,CAAC,gBAAgB;IAQlB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMtC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IA+BrC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAKjC,OAAO,IAAI,cAAc;IAUzB,eAAe,IAAI,MAAM;CAG1B"}

package/dist/agents/sandbox-filesystem.js

@@ -0,0 +1,356 @@
+import { posix } from "path";
+import { FileExistsError, FileNotFoundError, IsDirectoryError } from "@mastra/core/workspace";
+//#region src/agents/sandbox-filesystem.ts
+/**
+* SandboxFilesystem
+*
+* A `WorkspaceFilesystem` that stores files inside a remote `MastraSandbox`
+* (e.g. a Railway VM) rather than on the server host. File operations are
+* implemented by shelling out through the sandbox's `executeCommand`, so the
+* agent's file tools and command tools share one VM and one view of the repo.
+*
+* Paths are workspace-relative (`/src/foo.ts`) and resolve under the sandbox
+* working directory (`basePath`). A traversal guard rejects any path that
+* escapes the workdir, mirroring `LocalFilesystem`'s contained mode.
+*
+* Reads/writes use base64 over the wire so binary content survives the shell.
+*/
+/**
+* Sentinel exit codes used by guard clauses that run before the real command,
+* so shell failures can be mapped to typed filesystem errors.
+*/
+const EXIT_NOT_FOUND = 20;
+const EXIT_IS_DIRECTORY = 21;
+const EXIT_EXISTS = 22;
+/** Default per-command deadline so a hung sandbox can't block file tools forever. */
+const COMMAND_TIMEOUT_MS = 3e4;
+/** Single-quote a string for safe POSIX shell interpolation. */
+function shellQuote(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function isFileContentString(content) {
+	return typeof content === "string";
+}
+function toBuffer(content) {
+	if (isFileContentString(content)) return Buffer.from(content, "utf8");
+	return Buffer.from(content);
+}
+var SandboxFilesystem = class {
+	id;
+	name = "SandboxFilesystem";
+	provider = "sandbox";
+	status = "ready";
+	sandbox;
+	workdirSource;
+	resolvedBase;
+	resolvingBase;
+	constructor(options) {
+		this.sandbox = options.sandbox;
+		this.workdirSource = options.workdir;
+		if (typeof options.workdir === "string") this.resolvedBase = options.workdir;
+		this.id = options.id ?? (typeof options.workdir === "string" ? `sandbox-fs:${options.sandbox.id}:${options.workdir}` : `sandbox-fs:${options.sandbox.id}`);
+	}
+	/** The resolved workspace root; empty until a lazy workdir first resolves. */
+	get basePath() {
+		return this.resolvedBase ?? "";
+	}
+	/** Await (and memoize) the workspace root, resolving a lazy workdir once. */
+	async base() {
+		if (this.resolvedBase) return this.resolvedBase;
+		const source = this.workdirSource;
+		if (typeof source === "string") return this.resolvedBase = source;
+		this.resolvingBase ??= Promise.resolve().then(source).then((resolved) => {
+			if (!resolved) throw new Error("Sandbox workspace root resolution returned an empty path");
+			return this.resolvedBase = resolved;
+		}).finally(() => {
+			this.resolvingBase = void 0;
+		});
+		return this.resolvingBase;
+	}
+	/**
+	* Resolve a workspace path to an absolute path inside the sandbox, enforcing
+	* that it stays within the workdir. Awaits the workspace root first, which
+	* for a lazy workdir may start the VM.
+	*/
+	async resolveAsync(inputPath) {
+		return this.resolveAgainst(await this.base(), inputPath);
+	}
+	/**
+	* Resolve a workspace path against a known base, enforcing that it stays
+	* within the workdir.
+	*
+	* Accepts both workspace-relative paths (`src/foo.ts`, `/src/foo.ts`) and
+	* absolute sandbox paths that already live under the workdir — the agent's
+	* prompt advertises the workdir as its working directory, so tools are
+	* routinely called with fully-qualified paths like `<workdir>/src/foo.ts`.
+	*/
+	resolveAgainst(basePath, inputPath) {
+		const base = posix.normalize(basePath);
+		const normalizedInput = posix.normalize(inputPath);
+		const rel = normalizedInput === base ? "" : normalizedInput.startsWith(`${base}/`) ? normalizedInput.slice(base.length + 1) : inputPath.startsWith("/") ? inputPath.slice(1) : inputPath;
+		const resolved = posix.normalize(posix.join(base, rel));
+		if (resolved !== base && !resolved.startsWith(`${base}/`)) throw new Error(`Path escapes workspace root: ${inputPath}`);
+		return resolved;
+	}
+	resolveAbsolutePath(inputPath) {
+		if (!this.resolvedBase) return void 0;
+		return this.resolveAgainst(this.resolvedBase, inputPath);
+	}
+	async exec(script) {
+		return this.sandbox.executeCommand("sh", ["-c", script], { timeout: COMMAND_TIMEOUT_MS });
+	}
+	/**
+	* Lexical guard catches `..` traversal, but a symlink inside the workdir can
+	* still point outside it. After resolving a path that refers to an existing
+	* entry, verify its realpath is still contained in the workdir.
+	*
+	* Canonicalization tries `realpath`, then `readlink -f` (GNU/busybox), then
+	* `cd && pwd -P` for directories — covering GNU hosts, macOS/BSD, and
+	* busybox. If the path exists but cannot be canonicalized we fail CLOSED:
+	* returning without a check would let a symlink bypass containment.
+	*/
+	async assertContainedRealpath(abs, inputPath) {
+		const result = await this.exec([
+			`p=${shellQuote(abs)}`,
+			`if [ ! -e "$p" ] && [ ! -L "$p" ]; then exit ${EXIT_NOT_FOUND}; fi`,
+			`root=$(cd ${shellQuote(this.basePath)} 2>/dev/null && pwd -P)`,
+			`[ -n "$root" ] || exit 1`,
+			`rp=$(realpath "$p" 2>/dev/null) || rp=$(readlink -f "$p" 2>/dev/null) || { [ -d "$p" ] && rp=$(cd "$p" 2>/dev/null && pwd -P); }`,
+			`[ -n "$rp" ] || exit 1`,
+			`printf '%s\\n%s' "$root" "$rp"`
+		].join("\n"));
+		if (result.exitCode === EXIT_NOT_FOUND) return;
+		const [root, real] = result.stdout.split("\n").map((s) => s.trim());
+		if (result.exitCode !== 0 || !root || !real) throw new Error(`Unable to verify path stays within workspace root: ${inputPath}`);
+		if (real !== root && !real.startsWith(`${root}/`)) throw new Error(`Path escapes workspace root (symlink): ${inputPath}`);
+	}
+	/**
+	* Guard for write destinations. The lexical guard catches `..`, but a symlink
+	* inside the workdir can redirect a write outside it. For an existing target
+	* we check its realpath; for a not-yet-existing target we check the realpath
+	* of its nearest existing ancestor directory, since a symlinked parent is the
+	* escape vector (e.g. `link -> /etc` then writing `link/passwd`).
+	*/
+	async assertContainedDest(abs, inputPath) {
+		await this.assertContainedRealpath(abs, inputPath);
+		const parent = posix.dirname(abs);
+		if (parent && parent !== abs) await this.assertContainedRealpath(parent, inputPath);
+	}
+	async execOk(script, context) {
+		const result = await this.exec(script);
+		if (result.exitCode !== 0) throw new Error(`${context} failed (exit ${result.exitCode}): ${result.stderr.trim() || result.stdout.trim()}`);
+		return result;
+	}
+	async readFile(path, options) {
+		const abs = await this.resolveAsync(path);
+		await this.assertContainedRealpath(abs, path);
+		const result = await this.exec(`if [ -d ${shellQuote(abs)} ]; then exit ${EXIT_IS_DIRECTORY}; elif [ ! -e ${shellQuote(abs)} ]; then exit ${EXIT_NOT_FOUND}; fi; base64 < ${shellQuote(abs)}`);
+		if (result.exitCode === EXIT_IS_DIRECTORY) throw new IsDirectoryError(path);
+		if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(path);
+		if (result.exitCode !== 0) throw new Error(`readFile ${path} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
+		const buffer = Buffer.from(result.stdout.replace(/\s/g, ""), "base64");
+		if (options?.encoding) return buffer.toString(options.encoding);
+		return buffer;
+	}
+	async writeFile(path, content, options) {
+		const abs = await this.resolveAsync(path);
+		await this.assertContainedDest(abs, path);
+		const b64 = toBuffer(content).toString("base64");
+		const dir = posix.dirname(abs);
+		const mkdir = options?.recursive === false ? "" : `mkdir -p ${shellQuote(dir)} && `;
+		if (options?.overwrite === false) {
+			const result = await this.exec(`${mkdir}{ (set -C; printf %s ${shellQuote(b64)} | base64 -d > ${shellQuote(abs)}) 2>/dev/null || { [ -e ${shellQuote(abs)} ] && exit ${EXIT_EXISTS} || exit 1; }; }`);
+			if (result.exitCode === EXIT_EXISTS) throw new FileExistsError(path);
+			if (result.exitCode !== 0) throw new Error(`writeFile ${path} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
+			return;
+		}
+		await this.execOk(`${mkdir}printf %s ${shellQuote(b64)} | base64 -d > ${shellQuote(abs)}`, `writeFile ${path}`);
+	}
+	async appendFile(path, content) {
+		const abs = await this.resolveAsync(path);
+		await this.assertContainedDest(abs, path);
+		const b64 = toBuffer(content).toString("base64");
+		await this.execOk(`mkdir -p ${shellQuote(posix.dirname(abs))} && printf %s ${shellQuote(b64)} | base64 -d >> ${shellQuote(abs)}`, `appendFile ${path}`);
+	}
+	async deleteFile(path, options) {
+		const abs = await this.resolveAsync(path);
+		await this.assertContainedRealpath(posix.dirname(abs), path);
+		if (options?.force) {
+			await this.execOk(`rm -f ${shellQuote(abs)}`, `deleteFile ${path}`);
+			return;
+		}
+		const result = await this.exec(`if [ ! -e ${shellQuote(abs)} ]; then exit ${EXIT_NOT_FOUND}; fi; rm ${shellQuote(abs)}`);
+		if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(path);
+		if (result.exitCode !== 0) throw new Error(`deleteFile ${path} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
+	}
+	async copyFile(src, dest, options) {
+		const srcAbs = await this.resolveAsync(src);
+		const destAbs = await this.resolveAsync(dest);
+		await this.assertContainedRealpath(srcAbs, src);
+		await this.assertContainedDest(destAbs, dest);
+		const recursive = options?.recursive ? "-r " : "";
+		if (options?.overwrite === false) {
+			const result = await this.exec([
+				`src=${shellQuote(srcAbs)}`,
+				`dest=${shellQuote(destAbs)}`,
+				`if [ ! -e "$src" ] && [ ! -L "$src" ]; then exit ${EXIT_NOT_FOUND}; fi`,
+				`mkdir -p ${shellQuote(posix.dirname(destAbs))} || exit 1`,
+				`if [ -d "$src" ]; then`,
+				`  mkdir "$dest" 2>/dev/null || exit ${EXIT_EXISTS}`,
+				`  cp -R "$src"/. "$dest"/`,
+				`else`,
+				`  tmp="$dest.__cptmp$$"`,
+				`  cp "$src" "$tmp" || exit 1`,
+				`  ln "$tmp" "$dest" 2>/dev/null || { rm -f "$tmp"; [ -e "$dest" ] && exit ${EXIT_EXISTS} || exit 1; }`,
+				`  rm -f "$tmp"`,
+				`fi`
+			].join("\n"));
+			if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(src);
+			if (result.exitCode === EXIT_EXISTS) throw new FileExistsError(dest);
+			if (result.exitCode !== 0) throw new Error(`copyFile ${src} -> ${dest} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
+			return;
+		}
+		const result = await this.exec(`if [ ! -e ${shellQuote(srcAbs)} ]; then exit ${EXIT_NOT_FOUND}; fi; mkdir -p ${shellQuote(posix.dirname(destAbs))} && cp ${recursive}${shellQuote(srcAbs)} ${shellQuote(destAbs)}`);
+		if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(src);
+		if (result.exitCode !== 0) throw new Error(`copyFile ${src} -> ${dest} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
+	}
+	async moveFile(src, dest, options) {
+		const srcAbs = await this.resolveAsync(src);
+		const destAbs = await this.resolveAsync(dest);
+		await this.assertContainedRealpath(srcAbs, src);
+		await this.assertContainedDest(destAbs, dest);
+		if (options?.overwrite === false) {
+			const result = await this.exec([
+				`src=${shellQuote(srcAbs)}`,
+				`dest=${shellQuote(destAbs)}`,
+				`if [ ! -e "$src" ] && [ ! -L "$src" ]; then exit ${EXIT_NOT_FOUND}; fi`,
+				`mkdir -p ${shellQuote(posix.dirname(destAbs))} || exit 1`,
+				`mv -n "$src" "$dest" 2>/dev/null || exit 1`,
+				`if [ -e "$src" ] || [ -L "$src" ]; then exit ${EXIT_EXISTS}; fi`
+			].join("\n"));
+			if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(src);
+			if (result.exitCode === EXIT_EXISTS) throw new FileExistsError(dest);
+			if (result.exitCode !== 0) throw new Error(`moveFile ${src} -> ${dest} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
+			return;
+		}
+		const result = await this.exec(`if [ ! -e ${shellQuote(srcAbs)} ]; then exit ${EXIT_NOT_FOUND}; fi; mkdir -p ${shellQuote(posix.dirname(destAbs))} && mv ${shellQuote(srcAbs)} ${shellQuote(destAbs)}`);
+		if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(src);
+		if (result.exitCode !== 0) throw new Error(`moveFile ${src} -> ${dest} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
+	}
+	async mkdir(path, options) {
+		const abs = await this.resolveAsync(path);
+		await this.assertContainedDest(abs, path);
+		const flag = options?.recursive === false ? "" : "-p ";
+		await this.execOk(`mkdir ${flag}${shellQuote(abs)}`, `mkdir ${path}`);
+	}
+	async rmdir(path, options) {
+		const abs = await this.resolveAsync(path);
+		await this.assertContainedRealpath(posix.dirname(abs), path);
+		if (options?.recursive) {
+			const force = options?.force ? "-f " : "";
+			await this.execOk(`rm -r ${force}${shellQuote(abs)}`, `rmdir ${path}`);
+			return;
+		}
+		if ((await this.exec(`rmdir ${shellQuote(abs)}`)).exitCode !== 0 && !options?.force) throw new Error(`Directory not empty or not found: ${path}`);
+	}
+	async readdir(path, options) {
+		const abs = await this.resolveAsync(path);
+		await this.assertContainedRealpath(abs, path);
+		if (options?.recursive) {
+			const result = await this.exec(`test -d ${shellQuote(abs)} && find ${shellQuote(abs)} -mindepth 1 ${options.maxDepth ? `-maxdepth ${Number(options.maxDepth)} ` : ""}2>/dev/null | while IFS= read -r f; do if [ -d "$f" ]; then printf 'd\\t%s\\n' "$f"; else printf 'f\\t%s\\n' "$f"; fi; done`);
+			if (result.exitCode !== 0) throw new Error(`Directory not found: ${path}`);
+			return this.parseFindOutput(result.stdout, abs, options);
+		}
+		const result = await this.exec(`cd ${shellQuote(abs)} 2>/dev/null && for f in * .[!.]*; do [ -e "$f" ] || continue; if [ -d "$f" ]; then printf 'd\\t%s\\n' "$f"; else printf 'f\\t%s\\n' "$f"; fi; done`);
+		if (result.exitCode !== 0) throw new Error(`Directory not found: ${path}`);
+		return this.parseListOutput(result.stdout, options);
+	}
+	parseListOutput(stdout, options) {
+		const entries = [];
+		for (const line of stdout.split("\n")) {
+			if (!line) continue;
+			const tab = line.indexOf("	");
+			if (tab < 0) continue;
+			const type = line.slice(0, tab) === "d" ? "directory" : "file";
+			const name = line.slice(tab + 1);
+			if (!name || name === "." || name === "..") continue;
+			if (type === "file" && !this.matchesExtension(name, options?.extension)) continue;
+			entries.push({
+				name,
+				type
+			});
+		}
+		return entries;
+	}
+	parseFindOutput(stdout, base, options) {
+		const entries = [];
+		for (const line of stdout.split("\n")) {
+			if (!line) continue;
+			const tab = line.indexOf("	");
+			if (tab < 0) continue;
+			const type = line.slice(0, tab) === "d" ? "directory" : "file";
+			const fullPath = line.slice(tab + 1);
+			const name = posix.relative(base, fullPath);
+			if (!name) continue;
+			if (type === "file" && !this.matchesExtension(name, options?.extension)) continue;
+			entries.push({
+				name,
+				type
+			});
+		}
+		return entries;
+	}
+	matchesExtension(name, extension) {
+		if (!extension) return true;
+		return (Array.isArray(extension) ? extension : [extension]).some((ext) => name.endsWith(ext));
+	}
+	async exists(path) {
+		const abs = await this.resolveAsync(path);
+		return (await this.exec(`test -e ${shellQuote(abs)}`)).exitCode === 0;
+	}
+	async stat(path) {
+		const abs = await this.resolveAsync(path);
+		await this.assertContainedRealpath(abs, path);
+		const result = await this.exec(`stat -c '%F|%s|%Y|%W' ${shellQuote(abs)} 2>/dev/null || stat -f '%HT|%z|%m|%B' ${shellQuote(abs)}`);
+		if (result.exitCode !== 0) throw new FileNotFoundError(path);
+		const [kind, sizeStr, mtimeStr, ctimeStr] = result.stdout.trim().split("|");
+		const type = kind && kind.toLowerCase().includes("directory") ? "directory" : "file";
+		const size = Number(sizeStr) || 0;
+		const mtime = Number(mtimeStr) || 0;
+		const ctime = Number(ctimeStr);
+		return {
+			name: posix.basename(abs),
+			path: `/${posix.relative(this.basePath, abs)}`,
+			type,
+			size: type === "directory" ? 0 : size,
+			modifiedAt: /* @__PURE__ */ new Date(mtime * 1e3),
+			createdAt: /* @__PURE__ */ new Date((ctime > 0 ? ctime : mtime) * 1e3)
+		};
+	}
+	async init() {
+		await this.execOk(`mkdir -p ${shellQuote(await this.base())}`, "init workdir");
+	}
+	async destroy() {}
+	async isReady() {
+		return (await this.exec(`test -d ${shellQuote(await this.base())}`)).exitCode === 0;
+	}
+	getInfo() {
+		return {
+			id: this.id,
+			name: this.name,
+			provider: this.provider,
+			status: this.status,
+			metadata: {
+				basePath: this.basePath,
+				sandboxId: this.sandbox.id
+			}
+		};
+	}
+	getInstructions() {
+		return `Files are stored in a remote sandbox at ${this.basePath}. Use absolute workspace paths like /src/index.ts. All reads, writes and commands run inside the same sandbox.`;
+	}
+};
+//#endregion
+export { SandboxFilesystem };
+
+//# sourceMappingURL=sandbox-filesystem.js.map

package/dist/agents/sandbox-filesystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox-filesystem.js","names":["posixPath"],"sources":["../../src/agents/sandbox-filesystem.ts"],"sourcesContent":["/**\n * SandboxFilesystem\n *\n * A `WorkspaceFilesystem` that stores files inside a remote `MastraSandbox`\n * (e.g. a Railway VM) rather than on the server host. File operations are\n * implemented by shelling out through the sandbox's `executeCommand`, so the\n * agent's file tools and command tools share one VM and one view of the repo.\n *\n * Paths are workspace-relative (`/src/foo.ts`) and resolve under the sandbox\n * working directory (`basePath`). A traversal guard rejects any path that\n * escapes the workdir, mirroring `LocalFilesystem`'s contained mode.\n *\n * Reads/writes use base64 over the wire so binary content survives the shell.\n */\n\nimport { posix as posixPath } from 'node:path';\nimport type {\n  CopyOptions,\n  FileContent,\n  FileEntry,\n  FileStat,\n  FilesystemInfo,\n  ListOptions,\n  ProviderStatus,\n  ReadOptions,\n  RemoveOptions,\n  WorkspaceFilesystem,\n  WriteOptions,\n} from '@mastra/core/workspace';\nimport { FileExistsError, FileNotFoundError, IsDirectoryError } from '@mastra/core/workspace';\n\n/**\n * Sentinel exit codes used by guard clauses that run before the real command,\n * so shell failures can be mapped to typed filesystem errors.\n */\nconst EXIT_NOT_FOUND = 20;\nconst EXIT_IS_DIRECTORY = 21;\nconst EXIT_EXISTS = 22;\n\n/** Minimal command result shape we depend on. */\nexport interface SandboxCommandResult {\n  exitCode: number;\n  stdout: string;\n  stderr: string;\n}\n\n/** Minimal sandbox surface the filesystem needs. */\nexport interface SandboxExec {\n  readonly id: string;\n  executeCommand(command: string, args?: string[], options?: { timeout?: number }): Promise<SandboxCommandResult>;\n}\n\nexport interface SandboxFilesystemOptions {\n  /** Live sandbox to run commands in. */\n  sandbox: SandboxExec;\n  /**\n   * Absolute path inside the sandbox that is the workspace root — or a lazy\n   * resolver for it. The resolver form exists for sandboxes whose workspace\n   * root is only knowable once the VM is running (e.g. `$HOME/<repo>` under\n   * a provider-chosen home dir): it is awaited on the first file operation\n   * (which itself may lazily start the VM) and the result is memoized.\n   */\n  workdir: string | (() => Promise<string> | string);\n  /** Optional stable id; defaults to a sandbox-derived id. */\n  id?: string;\n}\n\n/** Default per-command deadline so a hung sandbox can't block file tools forever. */\nconst COMMAND_TIMEOUT_MS = 30_000;\n\n/** Single-quote a string for safe POSIX shell interpolation. */\nfunction shellQuote(value: string): string {\n  return `'${value.replace(/'/g, `'\\\\''`)}'`;\n}\n\nfunction isFileContentString(content: FileContent): content is string {\n  return typeof content === 'string';\n}\n\nfunction toBuffer(content: FileContent): Buffer {\n  if (isFileContentString(content)) return Buffer.from(content, 'utf8');\n  return Buffer.from(content);\n}\n\nexport class SandboxFilesystem implements WorkspaceFilesystem {\n  readonly id: string;\n  readonly name = 'SandboxFilesystem';\n  readonly provider = 'sandbox';\n  status: ProviderStatus = 'ready';\n\n  private readonly sandbox: SandboxExec;\n  private readonly workdirSource: string | (() => Promise<string> | string);\n  private resolvedBase?: string;\n  private resolvingBase?: Promise<string>;\n\n  constructor(options: SandboxFilesystemOptions) {\n    this.sandbox = options.sandbox;\n    this.workdirSource = options.workdir;\n    if (typeof options.workdir === 'string') this.resolvedBase = options.workdir;\n    // Include the workdir when known: one sandbox can back several\n    // filesystems rooted at different checkouts, and each needs a distinct\n    // id. Lazy-workdir callers pass an explicit id.\n    this.id =\n      options.id ??\n      (typeof options.workdir === 'string'\n        ? `sandbox-fs:${options.sandbox.id}:${options.workdir}`\n        : `sandbox-fs:${options.sandbox.id}`);\n  }\n\n  /** The resolved workspace root; empty until a lazy workdir first resolves. */\n  get basePath(): string {\n    return this.resolvedBase ?? '';\n  }\n\n  /** Await (and memoize) the workspace root, resolving a lazy workdir once. */\n  private async base(): Promise<string> {\n    if (this.resolvedBase) return this.resolvedBase;\n    const source = this.workdirSource;\n    if (typeof source === 'string') return (this.resolvedBase = source);\n    this.resolvingBase ??= Promise.resolve()\n      .then(source)\n      .then(resolved => {\n        if (!resolved) throw new Error('Sandbox workspace root resolution returned an empty path');\n        return (this.resolvedBase = resolved);\n      })\n      .finally(() => {\n        this.resolvingBase = undefined;\n      });\n    return this.resolvingBase;\n  }\n\n  // ── Path handling ──────────────────────────────────────────────────────\n\n  /**\n   * Resolve a workspace path to an absolute path inside the sandbox, enforcing\n   * that it stays within the workdir. Awaits the workspace root first, which\n   * for a lazy workdir may start the VM.\n   */\n  private async resolveAsync(inputPath: string): Promise<string> {\n    return this.resolveAgainst(await this.base(), inputPath);\n  }\n\n  /**\n   * Resolve a workspace path against a known base, enforcing that it stays\n   * within the workdir.\n   *\n   * Accepts both workspace-relative paths (`src/foo.ts`, `/src/foo.ts`) and\n   * absolute sandbox paths that already live under the workdir — the agent's\n   * prompt advertises the workdir as its working directory, so tools are\n   * routinely called with fully-qualified paths like `<workdir>/src/foo.ts`.\n   */\n  private resolveAgainst(basePath: string, inputPath: string): string {\n    const base = posixPath.normalize(basePath);\n    const normalizedInput = posixPath.normalize(inputPath);\n    const rel =\n      normalizedInput === base\n        ? ''\n        : normalizedInput.startsWith(`${base}/`)\n          ? normalizedInput.slice(base.length + 1)\n          : inputPath.startsWith('/')\n            ? inputPath.slice(1)\n            : inputPath;\n    const resolved = posixPath.normalize(posixPath.join(base, rel));\n    if (resolved !== base && !resolved.startsWith(`${base}/`)) {\n      throw new Error(`Path escapes workspace root: ${inputPath}`);\n    }\n    return resolved;\n  }\n\n  resolveAbsolutePath(inputPath: string): string | undefined {\n    // Sync interface: a lazy workdir that has not resolved yet has no\n    // absolute form to offer.\n    if (!this.resolvedBase) return undefined;\n    return this.resolveAgainst(this.resolvedBase, inputPath);\n  }\n\n  // ── Command helper ─────────────────────────────────────────────────────\n\n  private async exec(script: string): Promise<SandboxCommandResult> {\n    return this.sandbox.executeCommand('sh', ['-c', script], { timeout: COMMAND_TIMEOUT_MS });\n  }\n\n  /**\n   * Lexical guard catches `..` traversal, but a symlink inside the workdir can\n   * still point outside it. After resolving a path that refers to an existing\n   * entry, verify its realpath is still contained in the workdir.\n   *\n   * Canonicalization tries `realpath`, then `readlink -f` (GNU/busybox), then\n   * `cd && pwd -P` for directories — covering GNU hosts, macOS/BSD, and\n   * busybox. If the path exists but cannot be canonicalized we fail CLOSED:\n   * returning without a check would let a symlink bypass containment.\n   */\n  private async assertContainedRealpath(abs: string, inputPath: string): Promise<void> {\n    const result = await this.exec(\n      [\n        `p=${shellQuote(abs)}`,\n        `if [ ! -e \"$p\" ] && [ ! -L \"$p\" ]; then exit ${EXIT_NOT_FOUND}; fi`,\n        // The workdir itself may contain symlinked components (/tmp on macOS),\n        // so canonicalize it as the comparison root.\n        `root=$(cd ${shellQuote(this.basePath)} 2>/dev/null && pwd -P)`,\n        `[ -n \"$root\" ] || exit 1`,\n        `rp=$(realpath \"$p\" 2>/dev/null) || rp=$(readlink -f \"$p\" 2>/dev/null) || { [ -d \"$p\" ] && rp=$(cd \"$p\" 2>/dev/null && pwd -P); }`,\n        `[ -n \"$rp\" ] || exit 1`,\n        `printf '%s\\\\n%s' \"$root\" \"$rp\"`,\n      ].join('\\n'),\n    );\n    // Path doesn't exist yet: nothing to canonicalize (writes to a fresh leaf\n    // are covered by assertContainedDest checking the parent directory).\n    if (result.exitCode === EXIT_NOT_FOUND) return;\n    const [root, real] = result.stdout.split('\\n').map(s => s.trim());\n    if (result.exitCode !== 0 || !root || !real) {\n      throw new Error(`Unable to verify path stays within workspace root: ${inputPath}`);\n    }\n    if (real !== root && !real.startsWith(`${root}/`)) {\n      throw new Error(`Path escapes workspace root (symlink): ${inputPath}`);\n    }\n  }\n\n  /**\n   * Guard for write destinations. The lexical guard catches `..`, but a symlink\n   * inside the workdir can redirect a write outside it. For an existing target\n   * we check its realpath; for a not-yet-existing target we check the realpath\n   * of its nearest existing ancestor directory, since a symlinked parent is the\n   * escape vector (e.g. `link -> /etc` then writing `link/passwd`).\n   */\n  private async assertContainedDest(abs: string, inputPath: string): Promise<void> {\n    // First check the target itself (covers overwriting an existing symlink).\n    await this.assertContainedRealpath(abs, inputPath);\n    // Then check the parent directory's realpath; readlink -f resolves the\n    // nearest existing ancestor when the leaf doesn't exist yet.\n    const parent = posixPath.dirname(abs);\n    if (parent && parent !== abs) {\n      await this.assertContainedRealpath(parent, inputPath);\n    }\n  }\n\n  private async execOk(script: string, context: string): Promise<SandboxCommandResult> {\n    const result = await this.exec(script);\n    if (result.exitCode !== 0) {\n      throw new Error(`${context} failed (exit ${result.exitCode}): ${result.stderr.trim() || result.stdout.trim()}`);\n    }\n    return result;\n  }\n\n  // ── File operations ────────────────────────────────────────────────────\n\n  async readFile(path: string, options?: ReadOptions): Promise<string | Buffer> {\n    const abs = await this.resolveAsync(path);\n    await this.assertContainedRealpath(abs, path);\n    // Guard clauses first: redirecting from a directory \"succeeds\" with empty\n    // output on some shells, so classify before reading.\n    const result = await this.exec(\n      `if [ -d ${shellQuote(abs)} ]; then exit ${EXIT_IS_DIRECTORY}; elif [ ! -e ${shellQuote(abs)} ]; then exit ${EXIT_NOT_FOUND}; fi; base64 < ${shellQuote(abs)}`,\n    );\n    if (result.exitCode === EXIT_IS_DIRECTORY) throw new IsDirectoryError(path);\n    if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(path);\n    if (result.exitCode !== 0) {\n      throw new Error(`readFile ${path} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);\n    }\n    const buffer = Buffer.from(result.stdout.replace(/\\s/g, ''), 'base64');\n    if (options?.encoding) {\n      return buffer.toString(options.encoding);\n    }\n    return buffer;\n  }\n\n  async writeFile(path: string, content: FileContent, options?: WriteOptions): Promise<void> {\n    const abs = await this.resolveAsync(path);\n    await this.assertContainedDest(abs, path);\n    const b64 = toBuffer(content).toString('base64');\n    const dir = posixPath.dirname(abs);\n    const mkdir = options?.recursive === false ? '' : `mkdir -p ${shellQuote(dir)} && `;\n    if (options?.overwrite === false) {\n      // `set -C` (noclobber) makes the redirect itself the exclusivity check —\n      // no exists() pre-check that could race with a concurrent writer.\n      const result = await this.exec(\n        `${mkdir}{ (set -C; printf %s ${shellQuote(b64)} | base64 -d > ${shellQuote(abs)}) 2>/dev/null || { [ -e ${shellQuote(abs)} ] && exit ${EXIT_EXISTS} || exit 1; }; }`,\n      );\n      if (result.exitCode === EXIT_EXISTS) throw new FileExistsError(path);\n      if (result.exitCode !== 0) {\n        throw new Error(`writeFile ${path} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);\n      }\n      return;\n    }\n    await this.execOk(`${mkdir}printf %s ${shellQuote(b64)} | base64 -d > ${shellQuote(abs)}`, `writeFile ${path}`);\n  }\n\n  async appendFile(path: string, content: FileContent): Promise<void> {\n    const abs = await this.resolveAsync(path);\n    await this.assertContainedDest(abs, path);\n    const b64 = toBuffer(content).toString('base64');\n    await this.execOk(\n      `mkdir -p ${shellQuote(posixPath.dirname(abs))} && printf %s ${shellQuote(b64)} | base64 -d >> ${shellQuote(abs)}`,\n      `appendFile ${path}`,\n    );\n  }\n\n  async deleteFile(path: string, options?: RemoveOptions): Promise<void> {\n    const abs = await this.resolveAsync(path);\n    // Contain the parent's realpath: deleting `link/file` where `link` points\n    // outside the workdir must fail, while deleting a symlink entry itself\n    // (which lives inside the workdir) stays allowed.\n    await this.assertContainedRealpath(posixPath.dirname(abs), path);\n    if (options?.force) {\n      // `rm -f` already succeeds for a missing file, but still fails for\n      // directories and permission errors — surface those.\n      await this.execOk(`rm -f ${shellQuote(abs)}`, `deleteFile ${path}`);\n      return;\n    }\n    const result = await this.exec(\n      `if [ ! -e ${shellQuote(abs)} ]; then exit ${EXIT_NOT_FOUND}; fi; rm ${shellQuote(abs)}`,\n    );\n    if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(path);\n    if (result.exitCode !== 0) {\n      throw new Error(`deleteFile ${path} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);\n    }\n  }\n\n  async copyFile(src: string, dest: string, options?: CopyOptions): Promise<void> {\n    const srcAbs = await this.resolveAsync(src);\n    const destAbs = await this.resolveAsync(dest);\n    await this.assertContainedRealpath(srcAbs, src);\n    await this.assertContainedDest(destAbs, dest);\n    const recursive = options?.recursive ? '-r ' : '';\n    if (options?.overwrite === false) {\n      // Atomic no-clobber: directories claim the destination with an exclusive\n      // mkdir; files copy to a temp name then hardlink into place (link(2)\n      // fails if the destination exists). No racy exists() pre-check.\n      const result = await this.exec(\n        [\n          `src=${shellQuote(srcAbs)}`,\n          `dest=${shellQuote(destAbs)}`,\n          `if [ ! -e \"$src\" ] && [ ! -L \"$src\" ]; then exit ${EXIT_NOT_FOUND}; fi`,\n          `mkdir -p ${shellQuote(posixPath.dirname(destAbs))} || exit 1`,\n          `if [ -d \"$src\" ]; then`,\n          `  mkdir \"$dest\" 2>/dev/null || exit ${EXIT_EXISTS}`,\n          `  cp -R \"$src\"/. \"$dest\"/`,\n          `else`,\n          `  tmp=\"$dest.__cptmp$$\"`,\n          `  cp \"$src\" \"$tmp\" || exit 1`,\n          `  ln \"$tmp\" \"$dest\" 2>/dev/null || { rm -f \"$tmp\"; [ -e \"$dest\" ] && exit ${EXIT_EXISTS} || exit 1; }`,\n          `  rm -f \"$tmp\"`,\n          `fi`,\n        ].join('\\n'),\n      );\n      if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(src);\n      if (result.exitCode === EXIT_EXISTS) throw new FileExistsError(dest);\n      if (result.exitCode !== 0) {\n        throw new Error(`copyFile ${src} -> ${dest} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);\n      }\n      return;\n    }\n    const result = await this.exec(\n      `if [ ! -e ${shellQuote(srcAbs)} ]; then exit ${EXIT_NOT_FOUND}; fi; mkdir -p ${shellQuote(posixPath.dirname(destAbs))} && cp ${recursive}${shellQuote(srcAbs)} ${shellQuote(destAbs)}`,\n    );\n    if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(src);\n    if (result.exitCode !== 0) {\n      throw new Error(`copyFile ${src} -> ${dest} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);\n    }\n  }\n\n  async moveFile(src: string, dest: string, options?: CopyOptions): Promise<void> {\n    const srcAbs = await this.resolveAsync(src);\n    const destAbs = await this.resolveAsync(dest);\n    await this.assertContainedRealpath(srcAbs, src);\n    await this.assertContainedDest(destAbs, dest);\n    if (options?.overwrite === false) {\n      // `mv -n` exits 0 even when it skips, so detect a skipped move by the\n      // source surviving. The no-clobber rename itself is atomic; no racy\n      // exists() pre-check.\n      const result = await this.exec(\n        [\n          `src=${shellQuote(srcAbs)}`,\n          `dest=${shellQuote(destAbs)}`,\n          `if [ ! -e \"$src\" ] && [ ! -L \"$src\" ]; then exit ${EXIT_NOT_FOUND}; fi`,\n          `mkdir -p ${shellQuote(posixPath.dirname(destAbs))} || exit 1`,\n          `mv -n \"$src\" \"$dest\" 2>/dev/null || exit 1`,\n          `if [ -e \"$src\" ] || [ -L \"$src\" ]; then exit ${EXIT_EXISTS}; fi`,\n        ].join('\\n'),\n      );\n      if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(src);\n      if (result.exitCode === EXIT_EXISTS) throw new FileExistsError(dest);\n      if (result.exitCode !== 0) {\n        throw new Error(`moveFile ${src} -> ${dest} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);\n      }\n      return;\n    }\n    const result = await this.exec(\n      `if [ ! -e ${shellQuote(srcAbs)} ]; then exit ${EXIT_NOT_FOUND}; fi; mkdir -p ${shellQuote(posixPath.dirname(destAbs))} && mv ${shellQuote(srcAbs)} ${shellQuote(destAbs)}`,\n    );\n    if (result.exitCode === EXIT_NOT_FOUND) throw new FileNotFoundError(src);\n    if (result.exitCode !== 0) {\n      throw new Error(`moveFile ${src} -> ${dest} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);\n    }\n  }\n\n  // ── Directory operations ───────────────────────────────────────────────\n\n  async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {\n    const abs = await this.resolveAsync(path);\n    await this.assertContainedDest(abs, path);\n    const flag = options?.recursive === false ? '' : '-p ';\n    await this.execOk(`mkdir ${flag}${shellQuote(abs)}`, `mkdir ${path}`);\n  }\n\n  async rmdir(path: string, options?: RemoveOptions): Promise<void> {\n    const abs = await this.resolveAsync(path);\n    // Same parent containment as deleteFile — `rm -r` through a symlinked\n    // parent would otherwise delete outside the workspace.\n    await this.assertContainedRealpath(posixPath.dirname(abs), path);\n    if (options?.recursive) {\n      const force = options?.force ? '-f ' : '';\n      await this.execOk(`rm -r ${force}${shellQuote(abs)}`, `rmdir ${path}`);\n      return;\n    }\n    const result = await this.exec(`rmdir ${shellQuote(abs)}`);\n    if (result.exitCode !== 0 && !options?.force) {\n      throw new Error(`Directory not empty or not found: ${path}`);\n    }\n  }\n\n  async readdir(path: string, options?: ListOptions): Promise<FileEntry[]> {\n    const abs = await this.resolveAsync(path);\n    await this.assertContainedRealpath(abs, path);\n    if (options?.recursive) {\n      // Recursive listing emitting \"type\\tpath\". `find -printf` is GNU-only\n      // (fails on macOS/BSD hosts backing a local sandbox), so classify each\n      // entry with a portable shell loop instead.\n      const result = await this.exec(\n        `test -d ${shellQuote(abs)} && find ${shellQuote(abs)} -mindepth 1 ${options.maxDepth ? `-maxdepth ${Number(options.maxDepth)} ` : ''}2>/dev/null | while IFS= read -r f; do if [ -d \"$f\" ]; then printf 'd\\\\t%s\\\\n' \"$f\"; else printf 'f\\\\t%s\\\\n' \"$f\"; fi; done`,\n      );\n      if (result.exitCode !== 0) throw new Error(`Directory not found: ${path}`);\n      return this.parseFindOutput(result.stdout, abs, options);\n    }\n    // Non-recursive: list with name + type via a portable loop. Use printf,\n    // not echo — bash-as-/bin/sh (macOS local sandboxes) does not expand \\t\n    // in echo arguments.\n    const result = await this.exec(\n      `cd ${shellQuote(abs)} 2>/dev/null && for f in * .[!.]*; do [ -e \"$f\" ] || continue; if [ -d \"$f\" ]; then printf 'd\\\\t%s\\\\n' \"$f\"; else printf 'f\\\\t%s\\\\n' \"$f\"; fi; done`,\n    );\n    if (result.exitCode !== 0) throw new Error(`Directory not found: ${path}`);\n    return this.parseListOutput(result.stdout, options);\n  }\n\n  private parseListOutput(stdout: string, options?: ListOptions): FileEntry[] {\n    const entries: FileEntry[] = [];\n    for (const line of stdout.split('\\n')) {\n      if (!line) continue;\n      const tab = line.indexOf('\\t');\n      if (tab < 0) continue;\n      const type = line.slice(0, tab) === 'd' ? 'directory' : 'file';\n      const name = line.slice(tab + 1);\n      if (!name || name === '.' || name === '..') continue;\n      if (type === 'file' && !this.matchesExtension(name, options?.extension)) continue;\n      entries.push({ name, type });\n    }\n    return entries;\n  }\n\n  private parseFindOutput(stdout: string, base: string, options?: ListOptions): FileEntry[] {\n    const entries: FileEntry[] = [];\n    for (const line of stdout.split('\\n')) {\n      if (!line) continue;\n      const tab = line.indexOf('\\t');\n      if (tab < 0) continue;\n      const type = line.slice(0, tab) === 'd' ? 'directory' : 'file';\n      const fullPath = line.slice(tab + 1);\n      const name = posixPath.relative(base, fullPath);\n      if (!name) continue;\n      if (type === 'file' && !this.matchesExtension(name, options?.extension)) continue;\n      entries.push({ name, type });\n    }\n    return entries;\n  }\n\n  private matchesExtension(name: string, extension?: string | string[]): boolean {\n    if (!extension) return true;\n    const exts = Array.isArray(extension) ? extension : [extension];\n    return exts.some(ext => name.endsWith(ext));\n  }\n\n  // ── Path / metadata ────────────────────────────────────────────────────\n\n  async exists(path: string): Promise<boolean> {\n    const abs = await this.resolveAsync(path);\n    const result = await this.exec(`test -e ${shellQuote(abs)}`);\n    return result.exitCode === 0;\n  }\n\n  async stat(path: string): Promise<FileStat> {\n    const abs = await this.resolveAsync(path);\n    await this.assertContainedRealpath(abs, path);\n    // GNU stat: %F=type, %s=size, %Y=mtime (epoch seconds), %W=birth (or -1).\n    // BSD/macOS stat (local sandbox hosts) rejects `-c`; fall back to its\n    // `-f` format with the same field order (%HT=type, %z=size, %m=mtime,\n    // %B=birth). Delimit with `|` — neither stat interprets `\\t` escapes in\n    // its format string.\n    const result = await this.exec(\n      `stat -c '%F|%s|%Y|%W' ${shellQuote(abs)} 2>/dev/null || stat -f '%HT|%z|%m|%B' ${shellQuote(abs)}`,\n    );\n    if (result.exitCode !== 0) {\n      throw new FileNotFoundError(path);\n    }\n    const [kind, sizeStr, mtimeStr, ctimeStr] = result.stdout.trim().split('|');\n    const type = kind && kind.toLowerCase().includes('directory') ? 'directory' : 'file';\n    const size = Number(sizeStr) || 0;\n    const mtime = Number(mtimeStr) || 0;\n    const ctime = Number(ctimeStr);\n    return {\n      name: posixPath.basename(abs),\n      path: `/${posixPath.relative(this.basePath, abs)}`,\n      type,\n      size: type === 'directory' ? 0 : size,\n      modifiedAt: new Date(mtime * 1000),\n      createdAt: new Date((ctime > 0 ? ctime : mtime) * 1000),\n    };\n  }\n\n  // ── Lifecycle ──────────────────────────────────────────────────────────\n\n  async init(): Promise<void> {\n    await this.execOk(`mkdir -p ${shellQuote(await this.base())}`, 'init workdir');\n  }\n\n  async destroy(): Promise<void> {\n    // The sandbox lifecycle is owned by the caller; nothing to tear down here.\n  }\n\n  async isReady(): Promise<boolean> {\n    const result = await this.exec(`test -d ${shellQuote(await this.base())}`);\n    return result.exitCode === 0;\n  }\n\n  getInfo(): FilesystemInfo {\n    return {\n      id: this.id,\n      name: this.name,\n      provider: this.provider,\n      status: this.status,\n      metadata: { basePath: this.basePath, sandboxId: this.sandbox.id },\n    };\n  }\n\n  getInstructions(): string {\n    return `Files are stored in a remote sandbox at ${this.basePath}. Use absolute workspace paths like /src/index.ts. All reads, writes and commands run inside the same sandbox.`;\n  }\n}\n"],"mappings":"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"}

package/dist/agents/subagents/execute.d.ts

@@ -0,0 +1,3 @@
+import type { AgentControllerSubagent } from '@mastra/core/agent-controller';
+export declare const executeSubagent: AgentControllerSubagent;
+//# sourceMappingURL=execute.d.ts.map

package/dist/agents/subagents/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../../src/agents/subagents/execute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAG7E,eAAO,MAAM,eAAe,EAAE,uBAoB7B,CAAC"}

package/dist/agents/subagents/execute.js

@@ -0,0 +1,27 @@
+import { MC_TOOLS } from "../../tool-names.js";
+//#region src/agents/subagents/execute.ts
+const executeSubagent = {
+	id: "execute",
+	name: "Execute",
+	description: "Implement a focused task, run relevant checks, and report the result.",
+	instructions: `You are a focused execution agent. Read relevant files before editing them and follow existing conventions. Stay within the assigned task; do not make unrelated changes. Use workspace tools to edit files and execute commands to verify your changes. Do not delegate work or modify the parent task list. Return a concise summary of changed files, verification results, and any blockers. Never claim checks passed unless you ran them successfully.`,
+	allowedWorkspaceTools: [
+		MC_TOOLS.VIEW,
+		MC_TOOLS.FIND_FILES,
+		MC_TOOLS.SEARCH_CONTENT,
+		MC_TOOLS.FILE_STAT,
+		MC_TOOLS.WRITE_FILE,
+		MC_TOOLS.STRING_REPLACE_LSP,
+		MC_TOOLS.DELETE_FILE,
+		MC_TOOLS.MKDIR,
+		MC_TOOLS.AST_SMART_EDIT,
+		MC_TOOLS.EXECUTE_COMMAND,
+		MC_TOOLS.GET_PROCESS_OUTPUT,
+		MC_TOOLS.KILL_PROCESS,
+		MC_TOOLS.LSP_INSPECT
+	]
+};
+//#endregion
+export { executeSubagent };
+
+//# sourceMappingURL=execute.js.map

package/dist/agents/subagents/execute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.js","names":[],"sources":["../../../src/agents/subagents/execute.ts"],"sourcesContent":["import type { AgentControllerSubagent } from '@mastra/core/agent-controller';\nimport { MC_TOOLS } from '../../tool-names.js';\n\nexport const executeSubagent: AgentControllerSubagent = {\n  id: 'execute',\n  name: 'Execute',\n  description: 'Implement a focused task, run relevant checks, and report the result.',\n  instructions: `You are a focused execution agent. Read relevant files before editing them and follow existing conventions. Stay within the assigned task; do not make unrelated changes. Use workspace tools to edit files and execute commands to verify your changes. Do not delegate work or modify the parent task list. Return a concise summary of changed files, verification results, and any blockers. Never claim checks passed unless you ran them successfully.`,\n  allowedWorkspaceTools: [\n    MC_TOOLS.VIEW,\n    MC_TOOLS.FIND_FILES,\n    MC_TOOLS.SEARCH_CONTENT,\n    MC_TOOLS.FILE_STAT,\n    MC_TOOLS.WRITE_FILE,\n    MC_TOOLS.STRING_REPLACE_LSP,\n    MC_TOOLS.DELETE_FILE,\n    MC_TOOLS.MKDIR,\n    MC_TOOLS.AST_SMART_EDIT,\n    MC_TOOLS.EXECUTE_COMMAND,\n    MC_TOOLS.GET_PROCESS_OUTPUT,\n    MC_TOOLS.KILL_PROCESS,\n    MC_TOOLS.LSP_INSPECT,\n  ],\n};\n"],"mappings":";;AAGA,MAAa,kBAA2C;CACtD,IAAI;CACJ,MAAM;CACN,aAAa;CACb,cAAc;CACd,uBAAuB;EACrB,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;EACT,SAAS;CACX;AACF"}

package/dist/agents/subagents/explore.d.ts

@@ -0,0 +1,3 @@
+import type { AgentControllerSubagent } from '@mastra/core/agent-controller';
+export declare const exploreSubagent: AgentControllerSubagent;
+//# sourceMappingURL=explore.d.ts.map

package/dist/agents/subagents/explore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explore.d.ts","sourceRoot":"","sources":["../../../src/agents/subagents/explore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAG7E,eAAO,MAAM,eAAe,EAAE,uBAM7B,CAAC"}

package/dist/agents/subagents/explore.js

@@ -0,0 +1,18 @@
+import { MC_TOOLS } from "../../tool-names.js";
+//#region src/agents/subagents/explore.ts
+const exploreSubagent = {
+	id: "explore",
+	name: "Explore",
+	description: "Explore the codebase and answer focused questions without modifying files.",
+	instructions: `You are a read-only codebase exploration agent. Read relevant files before drawing conclusions. Use view, find_files, search_content, and file_stat to investigate. Do not modify files or run shell commands. Return concise findings with file paths and line numbers, and clearly distinguish verified facts from assumptions.`,
+	allowedWorkspaceTools: [
+		MC_TOOLS.VIEW,
+		MC_TOOLS.FIND_FILES,
+		MC_TOOLS.SEARCH_CONTENT,
+		MC_TOOLS.FILE_STAT
+	]
+};
+//#endregion
+export { exploreSubagent };
+
+//# sourceMappingURL=explore.js.map

package/dist/agents/subagents/explore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"explore.js","names":[],"sources":["../../../src/agents/subagents/explore.ts"],"sourcesContent":["import type { AgentControllerSubagent } from '@mastra/core/agent-controller';\nimport { MC_TOOLS } from '../../tool-names.js';\n\nexport const exploreSubagent: AgentControllerSubagent = {\n  id: 'explore',\n  name: 'Explore',\n  description: 'Explore the codebase and answer focused questions without modifying files.',\n  instructions: `You are a read-only codebase exploration agent. Read relevant files before drawing conclusions. Use view, find_files, search_content, and file_stat to investigate. Do not modify files or run shell commands. Return concise findings with file paths and line numbers, and clearly distinguish verified facts from assumptions.`,\n  allowedWorkspaceTools: [MC_TOOLS.VIEW, MC_TOOLS.FIND_FILES, MC_TOOLS.SEARCH_CONTENT, MC_TOOLS.FILE_STAT],\n};\n"],"mappings":";;AAGA,MAAa,kBAA2C;CACtD,IAAI;CACJ,MAAM;CACN,aAAa;CACb,cAAc;CACd,uBAAuB;EAAC,SAAS;EAAM,SAAS;EAAY,SAAS;EAAgB,SAAS;CAAS;AACzG"}

package/dist/agents/subagents/plan.d.ts

@@ -0,0 +1,3 @@
+import type { AgentControllerSubagent } from '@mastra/core/agent-controller';
+export declare const planSubagent: AgentControllerSubagent;
+//# sourceMappingURL=plan.d.ts.map

package/dist/agents/subagents/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/agents/subagents/plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAG7E,eAAO,MAAM,YAAY,EAAE,uBAM1B,CAAC"}