@mastra/daytona 0.8.1-alpha.0 → 0.9.0-alpha.2

package/CHANGELOG.md

@@ -1,5 +1,68 @@
 # @mastra/daytona
 
+## 0.9.0-alpha.2
+
+### Minor Changes
+
+- Added computer-use support to `DaytonaSandbox`. Workspaces backed by Daytona can now take screenshots, control the mouse and keyboard, inspect the display, and open a noVNC viewer through the standard computer tools. ([#21701](https://github.com/mastra-ai/mastra/pull/21701))
+
+  ```typescript
+  const sandbox = new DaytonaSandbox();
+  await sandbox.start();
+
+  await sandbox.computer.leftClick(100, 200);
+  const screenshot = await sandbox.computer.screenshot();
+  ```
+
+  Desktop services start lazily on the first computer operation. Set `computerUse: false` to disable the capability or `computerUse: { autoStart: false }` to manage those services directly.
+
+### Patch Changes
+
+- Updated dependencies [[`48ef1f1`](https://github.com/mastra-ai/mastra/commit/48ef1f1d24eedafbb07f64e659a81b52b67b8bf6), [`63796ba`](https://github.com/mastra-ai/mastra/commit/63796ba0fda60253be17535e68f6bbbf1e6ffa09), [`3c19dce`](https://github.com/mastra-ai/mastra/commit/3c19dcef8e73062a80627a4927eae3ec11145afd)]:
+  - @mastra/core@1.62.0-alpha.12
+
+## 0.9.0-alpha.1
+
+### Minor Changes
+
+- Added a `secrets` option to `DaytonaSandbox` for injecting Daytona Secrets into sandboxes. Map environment variable names to Daytona Secret names and the real value is substituted into HTTPS request headers at egress — the raw credential never enters the sandbox. ([#22322](https://github.com/mastra-ai/mastra/pull/22322))
+
+  ```typescript
+  const sandbox = new DaytonaSandbox({
+    secrets: {
+      GITHUB_TOKEN: 'github-token',
+    },
+  });
+  ```
+
+  Closes https://github.com/mastra-ai/mastra/issues/22314
+
+### Patch Changes
+
+- Fixed a leak where every command left its process handle behind, by removing Daytona's own `executeCommand` in favour of the shared one, which releases them. ([#21984](https://github.com/mastra-ai/mastra/pull/21984))
+
+  Command results now match every other provider: `command` holds the full command string, and the separate `args` array is gone.
+
+  ```typescript
+  const result = await sandbox.executeCommand('echo', ['hello']);
+  // before: result.command === 'echo',       result.args === ['hello']
+  // after:  result.command === 'echo hello', result.args === undefined
+  ```
+
+- Starting a sandbox now reports whether it created a fresh sandbox or reconnected to an existing one, so an `onStart` handler can run first-time setup only when it's actually needed: ([#21984](https://github.com/mastra-ai/mastra/pull/21984))
+
+  ```typescript
+  new E2BSandbox({
+    id: 'session-1',
+    onStart: async ({ outcome }) => {
+      if (outcome === 'created') await cloneRepo();
+    },
+  });
+  ```
+
+- Updated dependencies [[`4ff3ee2`](https://github.com/mastra-ai/mastra/commit/4ff3ee2bff7ed07528b4817f8f49639031c72a4d), [`c24754c`](https://github.com/mastra-ai/mastra/commit/c24754c1fb6fe144e5051e536e98c8a18b0214ac), [`45dd6ee`](https://github.com/mastra-ai/mastra/commit/45dd6ee089bd7df0d0c98a10098e483fd388e04a), [`32d3583`](https://github.com/mastra-ai/mastra/commit/32d358332cb8ac2306b83b73cf3536e74dbd435e), [`aca2869`](https://github.com/mastra-ai/mastra/commit/aca2869b2031982f3c4a2f52525c9be7cf123ef8)]:
+  - @mastra/core@1.62.0-alpha.11
+
 ## 0.8.1-alpha.0
 
 ### Patch Changes

package/dist/index.cjs

@@ -618,6 +618,8 @@ function validateMountPath(mountPath) {
 }
 /** Allowlist for marker filenames from ls output — e.g. "mount-abc123" */
 const SAFE_MARKER_NAME = /^mount-[a-z0-9]+$/;
+/** Default port of the noVNC web viewer started by Daytona computer use. */
+const DEFAULT_NOVNC_PORT = 6080;
 /** Patterns indicating the sandbox is dead/gone (@daytonaio/sdk@0.143.0). */
 const SANDBOX_DEAD_PATTERNS = [
 	/sandbox is not running/i,
@@ -690,6 +692,9 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 	_createdAt = null;
 	_workingDir = null;
 	_isRetrying = false;
+	_computerUseStarted = null;
+	computerUseAutoStart;
+	noVncPort;
 	timeout;
 	language;
 	resources;
@@ -708,6 +713,7 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 	networkBlockAll;
 	networkAllowList;
 	domainAllowList;
+	secrets;
 	connectionOpts;
 	_constructorOptions;
 	constructor(options = {}) {
@@ -734,12 +740,17 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 		this.networkBlockAll = options.networkBlockAll;
 		this.networkAllowList = options.networkAllowList;
 		this.domainAllowList = options.domainAllowList;
+		this.secrets = options.secrets;
 		this.connectionOpts = {
 			...options.apiKey !== void 0 && { apiKey: options.apiKey },
 			...options.apiUrl !== void 0 && { apiUrl: options.apiUrl },
 			...options.target !== void 0 && { target: options.target }
 		};
 		this._constructorOptions = { ...options };
+		const computerUseOption = options.computerUse ?? true;
+		this.computerUseAutoStart = typeof computerUseOption === "object" ? computerUseOption.autoStart ?? true : true;
+		this.noVncPort = typeof computerUseOption === "object" ? computerUseOption.noVncPort ?? DEFAULT_NOVNC_PORT : DEFAULT_NOVNC_PORT;
+		if (computerUseOption !== false) this.computer = this.createComputer();
 	}
 	generateId() {
 		return `daytona-sandbox-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -791,26 +802,35 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 		return this.daytona;
 	}
 	/**
-	* Start the Daytona sandbox.
-	* Reconnects to an existing sandbox with the same logical ID if one exists,
-	* otherwise creates a new sandbox instance.
+	* Acquisition primitives (base-orchestrated start): the base derives
+	* `created` structurally from whether an existing sandbox was found, so
+	* reconnecting to one with the same logical ID reports `connected`.
+	* Lookup errors other than not-found propagate deliberately — creating a
+	* duplicate sandbox on a transient/auth error would be worse than failing.
 	*/
-	async start() {
-		if (this._sandbox) return;
+	async find() {
+		if (this._sandbox) return this._sandbox;
 		if (!this._daytona) this._daytona = new _daytonaio_sdk.Daytona(this.connectionOpts);
-		const existing = await this.findExistingSandbox();
-		if (existing) {
-			this._sandbox = existing;
-			this._daytonaSandboxId = existing.id;
-			this._createdAt = existing.createdAt ? new Date(existing.createdAt) : /* @__PURE__ */ new Date();
-			this.logger.debug(`${LOG_PREFIX} Reconnected to existing sandbox ${existing.id} for: ${this.id}`);
-			const expectedPaths = Array.from(this.mounts.entries.keys());
-			this.logger.debug(`${LOG_PREFIX} Running mount reconciliation...`);
-			await this.reconcileMounts(expectedPaths);
-			this.logger.debug(`${LOG_PREFIX} Mount reconciliation complete`);
-			await this.detectWorkingDir();
-			return;
+		return await this.findExistingSandbox() ?? void 0;
+	}
+	async connect(existing) {
+		if (existing === this._sandbox) return;
+		if (existing.state !== _daytonaio_sdk.SandboxState.STARTED) {
+			this.logger.debug(`${LOG_PREFIX} Restarting sandbox ${existing.id} (state: ${existing.state})`);
+			await this.waitForStableStateAndStart(existing);
 		}
+		this._sandbox = existing;
+		this._daytonaSandboxId = existing.id;
+		this._createdAt = existing.createdAt ? new Date(existing.createdAt) : /* @__PURE__ */ new Date();
+		this.logger.debug(`${LOG_PREFIX} Reconnected to existing sandbox ${existing.id} for: ${this.id}`);
+		const expectedPaths = Array.from(this.mounts.entries.keys());
+		this.logger.debug(`${LOG_PREFIX} Running mount reconciliation...`);
+		await this.reconcileMounts(expectedPaths);
+		this.logger.debug(`${LOG_PREFIX} Mount reconciliation complete`);
+		await this.detectWorkingDir();
+	}
+	async create() {
+		if (!this._daytona) this._daytona = new _daytonaio_sdk.Daytona(this.connectionOpts);
 		this.logger.debug(`${LOG_PREFIX} Creating sandbox for: ${this.id}`);
 		const baseParams = compact({
 			language: this.language,
@@ -828,7 +848,8 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 			public: this.sandboxPublic,
 			networkBlockAll: this.networkBlockAll,
 			networkAllowList: this.networkAllowList,
-			domainAllowList: this.domainAllowList
+			domainAllowList: this.domainAllowList,
+			secrets: this.secrets
 		});
 		if (this.resources && !this.image) this.logger.warn(`${LOG_PREFIX} 'resources' option requires 'image' to take effect — falling back to snapshot-based creation without custom resources`);
 		const createParams = this.image && !this.snapshotId ? compact({
@@ -864,6 +885,7 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 			await this._daytona.stop(this._sandbox);
 		} catch {}
 		this._sandbox = null;
+		this._computerUseStarted = null;
 	}
 	/**
 	* Destroy the Daytona sandbox and clean up all resources.
@@ -880,6 +902,7 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 		this._sandbox = null;
 		this._daytonaSandboxId = void 0;
 		this._daytona = null;
+		this._computerUseStarted = null;
 		this.mounts?.clear();
 	}
 	/**
@@ -933,18 +956,6 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 		return parts.join(" ");
 	}
 	/**
-	* Execute a command in the sandbox and return the result.
-	*/
-	async executeCommand(command, args = [], options = {}) {
-		await this.ensureRunning();
-		const fullCommand = args.length > 0 ? `${command} ${args.map(shellQuote).join(" ")}` : command;
-		return {
-			...await (await this.processes.spawn(fullCommand, options)).wait(),
-			command,
-			args
-		};
-	}
-	/**
 	* Bulk-write files into the sandbox filesystem via the SDK's native upload.
 	*/
 	async writeFiles(files) {
@@ -955,6 +966,96 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 		})));
 	}
 	/**
+	* Ensure the Daytona computer use processes (Xvfb, xfce4, x11vnc, noVNC)
+	* are running. Memoized per attached sandbox; the memo is reset when the
+	* sandbox stops, dies, or is destroyed so a fresh sandbox restarts them.
+	*/
+	async ensureComputerUseStarted() {
+		if (!this.computerUseAutoStart) return;
+		if (!this._computerUseStarted) this._computerUseStarted = this.daytona.computerUse.start().then(() => void 0).catch((error) => {
+			this._computerUseStarted = null;
+			throw error;
+		});
+		return this._computerUseStarted;
+	}
+	/**
+	* Build the {@link SandboxComputer} capability backed by Daytona's
+	* computer use API (`sandbox.computerUse`).
+	*
+	* Every operation ensures the sandbox is running and the desktop processes
+	* are started, and retries once if the sandbox died (mirroring command
+	* execution behavior).
+	*/
+	createComputer() {
+		const run = async (fn) => {
+			await this.ensureRunning();
+			return this.retryOnDead(async () => {
+				await this.ensureComputerUseStarted();
+				return fn(this.daytona.computerUse);
+			});
+		};
+		return {
+			screenshot: async () => {
+				const response = await run((computerUse) => computerUse.screenshot.takeFullScreen());
+				if (!response.screenshot) throw new Error(`${LOG_PREFIX} Daytona returned an empty screenshot response`);
+				return {
+					data: new Uint8Array(Buffer.from(response.screenshot, "base64")),
+					mediaType: "image/png"
+				};
+			},
+			leftClick: async (x, y) => {
+				await run((computerUse) => computerUse.mouse.click(x, y, "left"));
+			},
+			rightClick: async (x, y) => {
+				await run((computerUse) => computerUse.mouse.click(x, y, "right"));
+			},
+			doubleClick: async (x, y) => {
+				await run((computerUse) => computerUse.mouse.click(x, y, "left", true));
+			},
+			moveMouse: async (x, y) => {
+				await run((computerUse) => computerUse.mouse.move(x, y));
+			},
+			drag: async (from, to) => {
+				await run((computerUse) => computerUse.mouse.drag(from.x, from.y, to.x, to.y));
+			},
+			scroll: async (direction, amount) => {
+				await run(async (computerUse) => {
+					const position = await computerUse.mouse.getPosition();
+					return computerUse.mouse.scroll(position.x ?? 0, position.y ?? 0, direction, amount);
+				});
+			},
+			type: async (text) => {
+				await run((computerUse) => computerUse.keyboard.type(text));
+			},
+			press: async (key) => {
+				await run((computerUse) => Array.isArray(key) ? computerUse.keyboard.hotkey(key.join("+")) : computerUse.keyboard.press(key));
+			},
+			getScreenSize: async () => {
+				const info = await run((computerUse) => computerUse.display.getInfo());
+				const display = info.displays?.find((d) => d.isActive) ?? info.displays?.[0];
+				if (!display || display.width === void 0 || display.height === void 0) throw new Error(`${LOG_PREFIX} Daytona did not return display information`);
+				return {
+					width: display.width,
+					height: display.height
+				};
+			},
+			getCursorPosition: async () => {
+				const position = await run((computerUse) => computerUse.mouse.getPosition());
+				return {
+					x: position.x ?? 0,
+					y: position.y ?? 0
+				};
+			},
+			streamUrl: async () => {
+				try {
+					return (await run(() => this.daytona.getPreviewLink(this.noVncPort)))?.url ?? null;
+				} catch {
+					return null;
+				}
+			}
+		};
+	}
+	/**
 	* Mount a filesystem at a path in the sandbox.
 	* Uses FUSE tools (s3fs, gcsfuse) to mount cloud storage.
 	*/
@@ -1315,10 +1416,6 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 			} catch {}
 			return null;
 		}
-		if (state !== _daytonaio_sdk.SandboxState.STARTED) {
-			this.logger.debug(`${LOG_PREFIX} Restarting sandbox ${sandbox.id} (state: ${state})`);
-			await this.waitForStableStateAndStart(sandbox);
-		}
 		return sandbox;
 	}
 	/**
@@ -1393,6 +1490,7 @@ var DaytonaSandbox = class DaytonaSandbox extends _mastra_core_workspace.MastraS
 	*/
 	handleSandboxTimeout() {
 		this._sandbox = null;
+		this._computerUseStarted = null;
 		if (this.mounts) {
 			for (const [path, entry] of this.mounts.entries) if (entry.state === "mounted" || entry.state === "mounting") this.mounts.set(path, { state: "pending" });
 		}