@mastra/daytona 0.5.2 → 0.6.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Daytona, DaytonaNotFoundError, SandboxState } from '@daytonaio/sdk';
+import { Daytona, SandboxState, DaytonaNotFoundError } from '@daytonaio/sdk';
 import { SandboxProcessManager, MastraSandbox, SandboxNotReadyError, ProcessHandle } from '@mastra/core/workspace';
 import { createHash } from 'crypto';
 
@@ -738,6 +738,29 @@ var DaytonaSandbox = class _DaytonaSandbox extends MastraSandbox {
   name = "DaytonaSandbox";
   provider = "daytona";
   // Non-optional (initialized by base class when mount() exists)
+  /**
+   * Networking capability: public HTTPS URLs for sandbox ports.
+   * Daytona exposes ports through preview links (`getPreviewLink(port)`) —
+   * if the port is closed it is opened automatically. Private sandboxes
+   * require the preview token; pass `public: true` for tokenless URLs
+   * (required for sandbox deploys).
+   *
+   * When not attached in this process, the sandbox is looked up by identity
+   * (`daytona.get()` does not start it), so other processes can resolve
+   * deployments without waking a stopped sandbox.
+   */
+  networking = {
+    getPortUrl: async (port) => {
+      try {
+        const sandbox = this._sandbox ?? await this.lookupDetachedSandbox();
+        if (!sandbox) return null;
+        const preview = await sandbox.getPreviewLink(port);
+        return preview?.url ?? null;
+      } catch {
+        return null;
+      }
+    }
+  };
   status = "pending";
   _daytona = null;
   _sandbox = null;
@@ -763,6 +786,7 @@ var DaytonaSandbox = class _DaytonaSandbox extends MastraSandbox {
   networkBlockAll;
   networkAllowList;
   connectionOpts;
+  _constructorOptions;
   constructor(options = {}) {
     super({
       ...options,
@@ -795,10 +819,34 @@ var DaytonaSandbox = class _DaytonaSandbox extends MastraSandbox {
       ...options.apiUrl !== void 0 && { apiUrl: options.apiUrl },
       ...options.target !== void 0 && { target: options.target }
     };
+    this._constructorOptions = { ...options };
   }
   generateId() {
     return `daytona-sandbox-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   }
+  /**
+   * Construct a sibling `DaytonaSandbox` that inherits this sandbox's
+   * configuration (credentials, snapshot/image, resources, network policy)
+   * with per-instance overrides.
+   *
+   * Performs no I/O — the sandbox clone provisions (or reconnects to an
+   * existing Daytona sandbox with the same logical `id`) on its own `start()`.
+   * Use it when one configured sandbox acts as the template for a fleet of
+   * independent sandboxes (e.g. one per project).
+   *
+   * `options.idleTimeoutMinutes` maps to Daytona's `autoStopInterval`
+   * (minutes); `options.sandboxId` is ignored because Daytona reconnects by
+   * logical `id`.
+   */
+  clone(options = {}) {
+    const { id: _id, name: _name, ...base } = this._constructorOptions;
+    return new _DaytonaSandbox({
+      ...base,
+      ...options.id !== void 0 && { id: options.id },
+      ...options.env !== void 0 && { env: options.env },
+      ...options.idleTimeoutMinutes !== void 0 && { autoStopInterval: options.idleTimeoutMinutes }
+    });
+  }
   /**
    * Get the underlying Daytona Sandbox instance for direct access to Daytona APIs.
    *
@@ -888,13 +936,23 @@ var DaytonaSandbox = class _DaytonaSandbox extends MastraSandbox {
    * Unmounts all filesystems, then stops the sandbox.
    */
   async stop() {
+    if (!this._sandbox) {
+      try {
+        const existing = await this.lookupDetachedSandbox();
+        if (existing && existing.state === SandboxState.STARTED) {
+          await this._daytona.stop(existing);
+        }
+      } catch {
+      }
+      return;
+    }
     for (const mountPath of [...this.mounts.entries.keys()]) {
       try {
         await this.unmount(mountPath);
       } catch {
       }
     }
-    if (this._sandbox && this._daytona) {
+    if (this._daytona) {
       try {
         await this._daytona.stop(this._sandbox);
       } catch {
@@ -912,14 +970,13 @@ var DaytonaSandbox = class _DaytonaSandbox extends MastraSandbox {
         await this._daytona.delete(this._sandbox);
       } catch {
       }
-    } else if (!this._sandbox && this._daytona) {
-      const lookupKey = this._daytonaSandboxId ?? this.sandboxName;
-      if (lookupKey) {
-        try {
-          const orphan = await this._daytona.get(lookupKey);
+    } else if (!this._sandbox) {
+      try {
+        const orphan = await this.lookupDetachedSandbox();
+        if (orphan) {
           await this._daytona.delete(orphan);
-        } catch {
         }
+      } catch {
       }
     }
     this._sandbox = null;
@@ -998,6 +1055,18 @@ var DaytonaSandbox = class _DaytonaSandbox extends MastraSandbox {
     const result = await handle.wait();
     return { ...result, command, args };
   }
+  /**
+   * Bulk-write files into the sandbox filesystem via the SDK's native upload.
+   */
+  async writeFiles(files) {
+    await this.ensureRunning();
+    await this.daytona.fs.uploadFiles(
+      files.map((file) => ({
+        source: Buffer.isBuffer(file.content) ? file.content : Buffer.from(file.content),
+        destination: file.path
+      }))
+    );
+  }
   // ---------------------------------------------------------------------------
   // Mount Support
   // ---------------------------------------------------------------------------
@@ -1323,6 +1392,28 @@ var DaytonaSandbox = class _DaytonaSandbox extends MastraSandbox {
       this.logger.debug(`${LOG_PREFIX} Could not detect working directory, will omit from instructions`);
     }
   }
+  /**
+   * Look up the existing Daytona sandbox by identity WITHOUT starting it.
+   * Used for detached (cross-process) networking/stop/destroy so those
+   * operations never wake a stopped sandbox. Returns null when not found.
+   */
+  async lookupDetachedSandbox() {
+    const lookupKey = this._daytonaSandboxId ?? this.sandboxName;
+    if (!lookupKey) {
+      return null;
+    }
+    if (!this._daytona) {
+      this._daytona = new Daytona(this.connectionOpts);
+    }
+    try {
+      return await this._daytona.get(lookupKey);
+    } catch (error) {
+      if (error instanceof DaytonaNotFoundError) {
+        return null;
+      }
+      throw error;
+    }
+  }
   async findExistingSandbox() {
     const DEAD_STATES = [
       SandboxState.DESTROYED,