@mastra/daytona 0.10.0 → 0.11.0-alpha.1

package/README.md

@@ -37,6 +37,23 @@ await workspace.destroy();
 - [Daytona integration guide](https://mastra.ai/integrations/sandboxes/daytona)
 - [Workspace documentation](https://mastra.ai/docs/mastra-platform/workspaces)
 
+### R2 integration test
+
+The opt-in S3 mount test creates billable Daytona sandboxes and disposable R2 objects. Use a dedicated test bucket with test-only credentials that can list, read, write, and delete its objects. The lifecycle checks also mount with those long-lived credentials; don't supply production credentials.
+
+Prepare a Daytona snapshot containing Python and `boto3` before running the test. Pin Python dependencies when building the snapshot, and set `DAYTONA_R2_TEST_SNAPSHOT` to its name. You can omit this variable if your default snapshot already contains these dependencies. The test fails with setup instructions if they're missing; it doesn't install Python packages at runtime. Preinstalling `s3fs` also avoids the mount provider's existing runtime system-package installation.
+
+Set `DAYTONA_API_KEY`, `S3_ENDPOINT`, `S3_BUCKET`, `S3_ACCESS_KEY_ID`, and `S3_SECRET_ACCESS_KEY` in the repository-root `.env`, then run from the repository root:
+
+```bash
+DOTENV_CONFIG_PATH="$PWD/.env" \
+RUN_R2_ISOLATION_TEST=1 \
+DAYTONA_R2_TEST_SNAPSHOT=your-prepared-snapshot \
+pnpm --filter @mastra/daytona exec vitest run src/sandbox/mounts/s3-r2.integration.test.ts
+```
+
+The test checks cross-prefix access denial, mount recovery, credential cleanup, sandbox deletion, and removal of its test objects.
+
 ## Changelog
 
 See the [package changelog](https://github.com/mastra-ai/mastra/blob/main/workspaces/daytona/CHANGELOG.md) for version history and release notes.

package/dist/index.cjs

@@ -77,6 +77,51 @@ async function runCommand(sandbox, command, options) {
 	};
 }
 //#endregion
+//#region src/sandbox/mounts/s3-credentials.ts
+function s3CredentialsPrefix(mountPath) {
+	return `/tmp/.mastra-s3-${(0, crypto.createHash)("sha256").update(mountPath.replace(/\/$/, "")).digest("hex")}-`;
+}
+/** Remove credentials only after their s3fs process has exited, including after reconnects. */
+async function cleanupS3Credentials(mountPath, ctx) {
+	const script = `test -r /proc/self/comm || exit 1
+credentials_in_use() {
+  for process in /proc/[0-9]*; do
+    test -d "$process" || continue
+    name=$(cat "$process/comm" 2>/dev/null) || {
+      test -d "$process" && return 0
+      continue
+    }
+    test "$name" = s3fs || continue
+    args=$(tr '\\000' '\\n' < "$process/cmdline") || {
+      test -d "$process" && return 0
+      continue
+    }
+    printf '%s\\n' "$args" | grep -Fxq -- "passwd_file=$directory/credentials" && return 0
+  done
+  return 1
+}
+result=0
+for directory in ${shellQuote(s3CredentialsPrefix(mountPath))}*; do
+  test -d "$directory" && test ! -L "$directory" || continue
+  attempt=0
+  while credentials_in_use && test "$attempt" -lt 20; do
+    sleep 0.25
+    attempt=$((attempt + 1))
+  done
+  if credentials_in_use; then
+    result=1
+    continue
+  fi
+  rm -f -- "$directory/credentials" && rmdir -- "$directory" || result=1
+done
+exit "$result"`;
+	try {
+		if ((await ctx.run(`sh -c ${shellQuote(script)}`, 3e4)).exitCode !== 0) ctx.logger.warn(`${LOG_PREFIX} S3 credentials retained: daemon still active or cleanup could not be verified`);
+	} catch {
+		ctx.logger.warn(`${LOG_PREFIX} Could not clean up S3 credentials`);
+	}
+}
+//#endregion
 //#region src/sandbox/mounts/s3.ts
 /**
 * Mount an S3 bucket using s3fs-fuse.
@@ -90,6 +135,7 @@ async function mountS3(mountPath, config, ctx) {
 	const hasSecretKey = !!config.secretAccessKey;
 	if (hasAccessKey !== hasSecretKey) throw new Error("Both accessKeyId and secretAccessKey must be provided together.");
 	const hasCredentials = hasAccessKey && hasSecretKey;
+	if (config.sessionToken && !hasCredentials) throw new Error("sessionToken requires accessKeyId and secretAccessKey.");
 	if (!hasCredentials && config.endpoint) throw new Error(`S3-compatible storage requires credentials. Detected endpoint: ${config.endpoint}. The public_bucket option only works for AWS S3 public buckets, not R2, MinIO, etc.`);
 	if (config.endpoint) {
 		const endpoint = config.endpoint.replace(/\/$/, "");
@@ -109,43 +155,62 @@ async function mountS3(mountPath, config, ctx) {
 	const [uid, gid] = idResult.stdout.trim().split("\n");
 	const validUidGid = uid && gid && /^\d+$/.test(uid) && /^\d+$/.test(gid);
 	if (!validUidGid) logger.warn(`${LOG_PREFIX} Unexpected uid/gid format: "${idResult.stdout.trim()}" — mounted files will be owned by root`);
-	const credentialsPath = `/tmp/.passwd-s3fs-${(0, crypto.createHash)("md5").update(mountPath).digest("hex").slice(0, 8)}`;
+	const credentialsDirectory = `${s3CredentialsPrefix(mountPath)}${(0, crypto.randomUUID)()}`;
+	const credentialsPath = `${credentialsDirectory}/credentials`;
 	await run("sudo chmod a+rw /dev/fuse 2>/dev/null || true; sudo bash -c 'grep -q \"^user_allow_other\" /etc/fuse.conf 2>/dev/null || echo \"user_allow_other\" >> /etc/fuse.conf' 2>/dev/null || true");
-	if (hasCredentials) {
-		await run(`sudo rm -f ${shellQuote(credentialsPath)}`, 3e4);
-		await writeFile(credentialsPath, `${config.accessKeyId}:${config.secretAccessKey}`);
-		await run(`chmod 600 ${shellQuote(credentialsPath)}`, 3e4);
-	}
-	const mountOptions = [];
-	if (hasCredentials) mountOptions.push(`passwd_file=${credentialsPath}`);
-	else {
-		mountOptions.push("public_bucket=1");
-		logger.debug(`${LOG_PREFIX} No credentials provided, mounting as public bucket (read-only)`);
-	}
-	mountOptions.push("allow_other");
-	if (validUidGid) mountOptions.push(`uid=${uid}`, `gid=${gid}`);
-	if (config.endpoint) {
-		const endpoint = config.endpoint.replace(/\/$/, "");
-		mountOptions.push(`url=${shellQuote(endpoint)}`, "use_path_request_style", "sigv4", "nomultipart");
-	}
-	if (config.readOnly) {
-		mountOptions.push("ro");
-		logger.debug(`${LOG_PREFIX} Mounting as read-only`);
-	}
-	let bucketArg = config.bucket;
-	if (config.prefix) {
-		const normalizedPrefix = validatePrefix(config.prefix);
-		bucketArg = `${config.bucket}:/${normalizedPrefix}`;
+	let credentialsCreated = false;
+	let mountAttempted = false;
+	try {
+		if (config.accessKeyId && config.secretAccessKey) {
+			if ((await run(`mkdir -m 700 ${shellQuote(credentialsDirectory)}`, 3e4)).exitCode !== 0) throw new Error("Failed to create private S3 credentials directory");
+			credentialsCreated = true;
+			await writeFile(credentialsPath, config.sessionToken ? [
+				`export AWS_ACCESS_KEY_ID=${shellQuote(config.accessKeyId)}`,
+				`export AWS_SECRET_ACCESS_KEY=${shellQuote(config.secretAccessKey)}`,
+				`export AWS_SESSION_TOKEN=${shellQuote(config.sessionToken)}`
+			].join("\n") : `${config.accessKeyId}:${config.secretAccessKey}`);
+			if ((await run(`chmod 600 ${shellQuote(credentialsPath)}`, 3e4)).exitCode !== 0) throw new Error("Failed to restrict S3 credentials file permissions");
+		}
+		const mountOptions = [];
+		if (hasCredentials) mountOptions.push(config.sessionToken ? "use_session_token" : `passwd_file=${credentialsPath}`);
+		else {
+			mountOptions.push("public_bucket=1");
+			logger.debug(`${LOG_PREFIX} No credentials provided, mounting as public bucket (read-only)`);
+		}
+		mountOptions.push("allow_other");
+		if (validUidGid) mountOptions.push(`uid=${uid}`, `gid=${gid}`);
+		if (config.endpoint) {
+			const endpoint = config.endpoint.replace(/\/$/, "");
+			mountOptions.push(`url=${shellQuote(endpoint)}`, "use_path_request_style", "sigv4", "nomultipart");
+		}
+		if (config.readOnly) {
+			mountOptions.push("ro");
+			logger.debug(`${LOG_PREFIX} Mounting as read-only`);
+		}
+		let bucketArg = config.bucket;
+		if (config.prefix) {
+			const normalizedPrefix = validatePrefix(config.prefix);
+			bucketArg = `${config.bucket}:/${normalizedPrefix}`;
+		}
+		const mountCmd = `${config.sessionToken ? `. ${shellQuote(credentialsPath)} && ` : ""}s3fs ${shellQuote(bucketArg)} ${quotedMountPath} -o ${mountOptions.join(" -o ")}`;
+		logger.debug(`${LOG_PREFIX} Mounting S3:`, hasCredentials ? mountCmd.replace(credentialsPath, "***") : mountCmd);
+		mountAttempted = true;
+		const result = await run(mountCmd, 6e4);
+		logger.debug(`${LOG_PREFIX} s3fs result:`, {
+			exitCode: result.exitCode,
+			stdout: result.stdout,
+			stderr: result.stderr
+		});
+		if (result.exitCode !== 0) throw new Error(`Failed to mount S3 bucket: ${result.stderr || result.stdout}`);
+		const probe = await run(`timeout -k 5s 15s stat -L -- ${quotedMountPath} > /dev/null`, 3e4);
+		if (probe.exitCode !== 0) throw new Error(`S3 mount is not readable (exit ${probe.exitCode}): ${probe.stderr || probe.stdout}`);
+	} finally {
+		if (credentialsCreated && (config.sessionToken || !mountAttempted)) try {
+			if ((await run(`rm -f ${shellQuote(credentialsPath)} && rmdir ${shellQuote(credentialsDirectory)}`, 3e4)).exitCode !== 0) logger.warn(`${LOG_PREFIX} Failed to remove S3 credentials`);
+		} catch {
+			logger.warn(`${LOG_PREFIX} Failed to remove S3 credentials`);
+		}
 	}
-	const mountCmd = `s3fs ${shellQuote(bucketArg)} ${quotedMountPath} -o ${mountOptions.join(" -o ")}`;
-	logger.debug(`${LOG_PREFIX} Mounting S3:`, hasCredentials ? mountCmd.replace(credentialsPath, "***") : mountCmd);
-	const result = await run(mountCmd, 6e4);
-	logger.debug(`${LOG_PREFIX} s3fs result:`, {
-		exitCode: result.exitCode,
-		stdout: result.stdout,
-		stderr: result.stderr
-	});
-	if (result.exitCode !== 0) throw new Error(`Failed to mount S3 bucket: ${result.stderr || result.stdout}`);
 }
 //#endregion
 //#region src/sandbox/mounts/gcs.ts
@@ -965,8 +1030,12 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 	}
 	/**
 	* Bulk-write files into the sandbox filesystem via the SDK's native upload.
+	*
+	* Per-file permission modes are not supported; an explicit `mode` is
+	* rejected rather than silently discarded.
 	*/
 	async writeFiles(files) {
+		(0, _mastra_core_workspace.assertModesUnsupported)(files, "Daytona");
 		await this.ensureRunning();
 		await this.daytona.fs.uploadFiles(files.map((file) => ({
 			source: Buffer.isBuffer(file.content) ? file.content : Buffer.from(file.content),
@@ -1221,14 +1290,18 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 			}
 		} catch (error) {
 			this.logger.error(`${LOG_PREFIX} Error mounting "${filesystem.provider}" (${filesystem.id}) at "${mountPath}":`, error);
+			if (config.type === "s3") try {
+				await this.unmount(mountPath);
+			} catch (cleanupError) {
+				this.logger.warn(`${LOG_PREFIX} Could not unmount failed S3 mount at ${mountPath}:`, cleanupError);
+			}
 			this.mounts.set(mountPath, {
 				filesystem,
 				state: "error",
 				config,
 				error: errorToString(error)
 			});
-			await runCommand(sandbox, `sudo rmdir ${shellQuote(mountPath)} 2>/dev/null || true`, { timeout: MOUNT_COMMAND_TIMEOUT_MS });
-			this.logger.debug(`${LOG_PREFIX} Cleaned up directory after failed mount: ${mountPath}`);
+			if (config.type !== "s3") await runCommand(sandbox, `sudo rmdir ${shellQuote(mountPath)} 2>/dev/null || true`, { timeout: MOUNT_COMMAND_TIMEOUT_MS });
 			return {
 				success: false,
 				mountPath,
@@ -1255,7 +1328,18 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 		const sandbox = this._sandbox;
 		this.logger.debug(`${LOG_PREFIX} Unmounting "${mountPath}"...`);
 		const quotedPath = shellQuote(mountPath);
-		await runCommand(sandbox, `sudo fusermount -u ${quotedPath} 2>/dev/null; sudo umount -l ${quotedPath} 2>/dev/null; mountpoint -q ${quotedPath} 2>/dev/null && { _p="/tmp/.mastra-defunct-$$"; sudo mkdir -p "$_p" && sudo mount --move ${quotedPath} "$_p" 2>/dev/null; sudo umount -l "$_p" 2>/dev/null; sudo rmdir "$_p" 2>/dev/null; }`, { timeout: MOUNT_COMMAND_TIMEOUT_MS });
+		await runCommand(sandbox, `sudo fusermount -u ${quotedPath} 2>/dev/null; sudo umount -l ${quotedPath} 2>/dev/null; grep -Fq -- ${shellQuote(` ${(mountPath.endsWith("/") ? mountPath.slice(0, -1) : mountPath) || "/"} `)} /proc/mounts && { _p="/tmp/.mastra-defunct-$$"; sudo mkdir -p "$_p" && sudo mount --move ${quotedPath} "$_p" 2>/dev/null; sudo umount -l "$_p" 2>/dev/null; sudo rmdir "$_p" 2>/dev/null; }`, { timeout: MOUNT_COMMAND_TIMEOUT_MS });
+		await cleanupS3Credentials(mountPath, {
+			run: async (cmd, timeout) => {
+				const result = await runCommand(sandbox, cmd, { timeout: timeout ?? MOUNT_COMMAND_TIMEOUT_MS });
+				return {
+					exitCode: result.exitCode,
+					stdout: result.output,
+					stderr: ""
+				};
+			},
+			logger: this.logger
+		});
 		this.mounts.delete(mountPath);
 		const rmdirResult = await runCommand(sandbox, `rm -f ${shellQuote(`/tmp/.mastra-mounts/${this.mounts.markerFilename(mountPath)}`)} 2>/dev/null; sudo rmdir ${quotedPath} 2>&1`, { timeout: MOUNT_COMMAND_TIMEOUT_MS });
 		if (rmdirResult.exitCode === 0) this.logger.debug(`${LOG_PREFIX} Unmounted and removed ${mountPath}`);