@daytona/sdk 0.199.0-alpha.1 → 0.200.0

package/esm/Sandbox.js

@@ -4,8 +4,9 @@
  */
 import { __esDecorate, __runInitializers } from "tslib";
 import { SandboxState } from '@daytona/api-client';
+import { TelemetryApi as AnalyticsTelemetryApi, Configuration as AnalyticsConfiguration, } from '@daytona/analytics-api-client';
 import { Daytona } from './Daytona.js';
-import { FileSystemApi, GitApi, ProcessApi, LspApi, InfoApi, ComputerUseApi, InterpreterApi, ServerApi, } from '@daytona/toolbox-api-client';
+import { FileSystemApi, GitApi, ProcessApi, LspApi, InfoApi, SystemApi, ComputerUseApi, InterpreterApi, ServerApi, } from '@daytona/toolbox-api-client';
 import { FileSystem } from './FileSystem.js';
 import { Git } from './Git.js';
 import { Process } from './Process.js';
@@ -15,35 +16,12 @@ import { CODE_TOOLBOX_LANGUAGE_LABEL } from './Daytona.js';
 import { ComputerUse } from './ComputerUse.js';
 import { CodeInterpreter } from './CodeInterpreter.js';
 import { WithInstrumentation } from './utils/otel.decorator.js';
-import { VolumeType } from '@daytona/api-client';
-/**
- * Builds the shell command that bootstraps the hotmount agent and mounts the volume inside a
- * Sandbox. It exports the SEAWEED_* environment contract and runs the region's `init.sh`, using
- * passwordless sudo when not already root (sudo strips env, so the vars are passed via `env`).
- */
-function buildHotmountMountCommand(mountToken, mountPath) {
-    const envVars = {
-        SEAWEED_TOKEN: mountToken.token,
-        SEAWEED_GATEWAY_GRPC: mountToken.gatewayGrpc,
-        SEAWEED_GATEWAY_HTTP: mountToken.gatewayHttp,
-        SEAWEED_BINARIES_URL: mountToken.binariesUrl,
-        SEAWEED_MOUNT_DIR: mountPath,
-        SEAWEED_VERSION: mountToken.version,
+function withEvents(target, _context) {
+    return function (...args) {
+        ;
+        this.ensureSubscribed();
+        return target.apply(this, args);
     };
-    const envAssignments = Object.entries(envVars)
-        .filter(([, value]) => value !== undefined && value !== '')
-        .map(([key, value]) => `${key}='${value}'`)
-        .join(' ');
-    // The bootstrap (and init.sh itself) requires curl. Fail loudly if it is missing or the
-    // download fails, rather than letting a broken `curl … | bash` pipe exit 0 and mount nothing.
-    const inner = [
-        'set -e',
-        'if ! command -v curl >/dev/null 2>&1; then echo "hotmount: curl is required to bootstrap the agent but was not found in the sandbox" >&2; exit 1; fi',
-        'mkdir -p "$SEAWEED_MOUNT_DIR"',
-        'init_script="$(curl -fsSL "$SEAWEED_BINARIES_URL/init.sh")"',
-        'printf %s "$init_script" | bash',
-    ].join('; ');
-    return (`if [ "$(id -u)" != 0 ]; then SUDO="sudo -n"; else SUDO=""; fi; ` + `$SUDO env ${envAssignments} bash -c '${inner}'`);
 }
 /**
  * Represents a Daytona Sandbox.
@@ -74,8 +52,10 @@ function buildHotmountMountCommand(mountToken, mountPath) {
  * @property {string} [backupCreatedAt] - When the backup was created (not returned by list results;
  * call `refreshData()` on each item to populate)
  * @property {number} [autoStopInterval] - Auto-stop interval in minutes
+ * @property {number} [autoPauseInterval] - Auto-pause interval in minutes
  * @property {number} [autoArchiveInterval] - Auto-archive interval in minutes
  * @property {number} [autoDeleteInterval] - Auto-delete interval in minutes
+ * @property {string} [autoDestroyAt] - When the Sandbox will be automatically destroyed (only set when a TTL is configured)
  * @property {Array<SandboxVolume>} [volumes] - Volumes attached to the Sandbox (not returned by
  * list results; call `refreshData()` on each item to populate)
  * @property {BuildInfo} [buildInfo] - Build information for the Sandbox if it was created from dynamic build
@@ -97,13 +77,14 @@ function buildHotmountMountCommand(mountToken, mountPath) {
 let Sandbox = (() => {
     let _instanceExtraInitializers = [];
     let _getUserHomeDir_decorators;
+    let _getMetricsLatest_decorators;
+    let _getMetrics_decorators;
     let _getUserRootDir_decorators;
     let _getWorkDir_decorators;
-    let _mountVolume_decorators;
-    let _pullVolumes_decorators;
     let _createLspServer_decorators;
     let _setLabels_decorators;
     let _start_decorators;
+    let _recover_decorators;
     let _stop_decorators;
     let __experimental_fork_decorators;
     let __experimental_createSnapshot_decorators;
@@ -112,13 +93,18 @@ let Sandbox = (() => {
     let _waitUntilStarted_decorators;
     let _waitUntilStopped_decorators;
     let _refreshData_decorators;
+    let _refreshActivity_decorators;
     let _setAutostopInterval_decorators;
+    let _setAutoPauseInterval_decorators;
+    let _setTtl_decorators;
     let _setAutoArchiveInterval_decorators;
     let _setAutoDeleteInterval_decorators;
     let _updateNetworkSettings_decorators;
     let _updateSecrets_decorators;
     let _updateEnv_decorators;
     let _getPreviewLink_decorators;
+    let _getSignedPreviewUrl_decorators;
+    let _expireSignedPreviewUrl_decorators;
     let _archive_decorators;
     let _resize_decorators;
     let _waitForResizeComplete_decorators;
@@ -128,43 +114,50 @@ let Sandbox = (() => {
     return class Sandbox {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _getUserHomeDir_decorators = [WithInstrumentation()];
-            _getUserRootDir_decorators = [WithInstrumentation()];
-            _getWorkDir_decorators = [WithInstrumentation()];
-            _mountVolume_decorators = [WithInstrumentation()];
-            _pullVolumes_decorators = [WithInstrumentation()];
-            _createLspServer_decorators = [WithInstrumentation()];
-            _setLabels_decorators = [WithInstrumentation()];
-            _start_decorators = [WithInstrumentation()];
-            _stop_decorators = [WithInstrumentation()];
-            __experimental_fork_decorators = [WithInstrumentation()];
-            __experimental_createSnapshot_decorators = [WithInstrumentation()];
-            _pause_decorators = [WithInstrumentation()];
-            _delete_decorators = [WithInstrumentation()];
-            _waitUntilStarted_decorators = [WithInstrumentation()];
-            _waitUntilStopped_decorators = [WithInstrumentation()];
-            _refreshData_decorators = [WithInstrumentation()];
-            _setAutostopInterval_decorators = [WithInstrumentation()];
-            _setAutoArchiveInterval_decorators = [WithInstrumentation()];
-            _setAutoDeleteInterval_decorators = [WithInstrumentation()];
+            _getUserHomeDir_decorators = [WithInstrumentation(), withEvents];
+            _getMetricsLatest_decorators = [WithInstrumentation()];
+            _getMetrics_decorators = [WithInstrumentation()];
+            _getUserRootDir_decorators = [WithInstrumentation(), withEvents];
+            _getWorkDir_decorators = [WithInstrumentation(), withEvents];
+            _createLspServer_decorators = [WithInstrumentation(), withEvents];
+            _setLabels_decorators = [WithInstrumentation(), withEvents];
+            _start_decorators = [WithInstrumentation(), withEvents];
+            _recover_decorators = [withEvents];
+            _stop_decorators = [WithInstrumentation(), withEvents];
+            __experimental_fork_decorators = [WithInstrumentation(), withEvents];
+            __experimental_createSnapshot_decorators = [WithInstrumentation(), withEvents];
+            _pause_decorators = [WithInstrumentation(), withEvents];
+            _delete_decorators = [WithInstrumentation(), withEvents];
+            _waitUntilStarted_decorators = [WithInstrumentation(), withEvents];
+            _waitUntilStopped_decorators = [WithInstrumentation(), withEvents];
+            _refreshData_decorators = [WithInstrumentation(), withEvents];
+            _refreshActivity_decorators = [withEvents];
+            _setAutostopInterval_decorators = [WithInstrumentation(), withEvents];
+            _setAutoPauseInterval_decorators = [WithInstrumentation()];
+            _setTtl_decorators = [WithInstrumentation()];
+            _setAutoArchiveInterval_decorators = [WithInstrumentation(), withEvents];
+            _setAutoDeleteInterval_decorators = [WithInstrumentation(), withEvents];
             _updateNetworkSettings_decorators = [WithInstrumentation()];
             _updateSecrets_decorators = [WithInstrumentation()];
             _updateEnv_decorators = [WithInstrumentation()];
-            _getPreviewLink_decorators = [WithInstrumentation()];
-            _archive_decorators = [WithInstrumentation()];
-            _resize_decorators = [WithInstrumentation()];
-            _waitForResizeComplete_decorators = [WithInstrumentation()];
-            _createSshAccess_decorators = [WithInstrumentation()];
-            _revokeSshAccess_decorators = [WithInstrumentation()];
-            _validateSshAccess_decorators = [WithInstrumentation()];
+            _getPreviewLink_decorators = [WithInstrumentation(), withEvents];
+            _getSignedPreviewUrl_decorators = [withEvents];
+            _expireSignedPreviewUrl_decorators = [withEvents];
+            _archive_decorators = [WithInstrumentation(), withEvents];
+            _resize_decorators = [WithInstrumentation(), withEvents];
+            _waitForResizeComplete_decorators = [WithInstrumentation(), withEvents];
+            _createSshAccess_decorators = [WithInstrumentation(), withEvents];
+            _revokeSshAccess_decorators = [WithInstrumentation(), withEvents];
+            _validateSshAccess_decorators = [WithInstrumentation(), withEvents];
             __esDecorate(this, null, _getUserHomeDir_decorators, { kind: "method", name: "getUserHomeDir", static: false, private: false, access: { has: obj => "getUserHomeDir" in obj, get: obj => obj.getUserHomeDir }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getMetricsLatest_decorators, { kind: "method", name: "getMetricsLatest", static: false, private: false, access: { has: obj => "getMetricsLatest" in obj, get: obj => obj.getMetricsLatest }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getMetrics_decorators, { kind: "method", name: "getMetrics", static: false, private: false, access: { has: obj => "getMetrics" in obj, get: obj => obj.getMetrics }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getUserRootDir_decorators, { kind: "method", name: "getUserRootDir", static: false, private: false, access: { has: obj => "getUserRootDir" in obj, get: obj => obj.getUserRootDir }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getWorkDir_decorators, { kind: "method", name: "getWorkDir", static: false, private: false, access: { has: obj => "getWorkDir" in obj, get: obj => obj.getWorkDir }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _mountVolume_decorators, { kind: "method", name: "mountVolume", static: false, private: false, access: { has: obj => "mountVolume" in obj, get: obj => obj.mountVolume }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _pullVolumes_decorators, { kind: "method", name: "pullVolumes", static: false, private: false, access: { has: obj => "pullVolumes" in obj, get: obj => obj.pullVolumes }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _createLspServer_decorators, { kind: "method", name: "createLspServer", static: false, private: false, access: { has: obj => "createLspServer" in obj, get: obj => obj.createLspServer }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _setLabels_decorators, { kind: "method", name: "setLabels", static: false, private: false, access: { has: obj => "setLabels" in obj, get: obj => obj.setLabels }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _start_decorators, { kind: "method", name: "start", static: false, private: false, access: { has: obj => "start" in obj, get: obj => obj.start }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _recover_decorators, { kind: "method", name: "recover", static: false, private: false, access: { has: obj => "recover" in obj, get: obj => obj.recover }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _stop_decorators, { kind: "method", name: "stop", static: false, private: false, access: { has: obj => "stop" in obj, get: obj => obj.stop }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, __experimental_fork_decorators, { kind: "method", name: "_experimental_fork", static: false, private: false, access: { has: obj => "_experimental_fork" in obj, get: obj => obj._experimental_fork }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, __experimental_createSnapshot_decorators, { kind: "method", name: "_experimental_createSnapshot", static: false, private: false, access: { has: obj => "_experimental_createSnapshot" in obj, get: obj => obj._experimental_createSnapshot }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -173,13 +166,18 @@ let Sandbox = (() => {
             __esDecorate(this, null, _waitUntilStarted_decorators, { kind: "method", name: "waitUntilStarted", static: false, private: false, access: { has: obj => "waitUntilStarted" in obj, get: obj => obj.waitUntilStarted }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _waitUntilStopped_decorators, { kind: "method", name: "waitUntilStopped", static: false, private: false, access: { has: obj => "waitUntilStopped" in obj, get: obj => obj.waitUntilStopped }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _refreshData_decorators, { kind: "method", name: "refreshData", static: false, private: false, access: { has: obj => "refreshData" in obj, get: obj => obj.refreshData }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _refreshActivity_decorators, { kind: "method", name: "refreshActivity", static: false, private: false, access: { has: obj => "refreshActivity" in obj, get: obj => obj.refreshActivity }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _setAutostopInterval_decorators, { kind: "method", name: "setAutostopInterval", static: false, private: false, access: { has: obj => "setAutostopInterval" in obj, get: obj => obj.setAutostopInterval }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setAutoPauseInterval_decorators, { kind: "method", name: "setAutoPauseInterval", static: false, private: false, access: { has: obj => "setAutoPauseInterval" in obj, get: obj => obj.setAutoPauseInterval }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setTtl_decorators, { kind: "method", name: "setTtl", static: false, private: false, access: { has: obj => "setTtl" in obj, get: obj => obj.setTtl }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _setAutoArchiveInterval_decorators, { kind: "method", name: "setAutoArchiveInterval", static: false, private: false, access: { has: obj => "setAutoArchiveInterval" in obj, get: obj => obj.setAutoArchiveInterval }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _setAutoDeleteInterval_decorators, { kind: "method", name: "setAutoDeleteInterval", static: false, private: false, access: { has: obj => "setAutoDeleteInterval" in obj, get: obj => obj.setAutoDeleteInterval }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _updateNetworkSettings_decorators, { kind: "method", name: "updateNetworkSettings", static: false, private: false, access: { has: obj => "updateNetworkSettings" in obj, get: obj => obj.updateNetworkSettings }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _updateSecrets_decorators, { kind: "method", name: "updateSecrets", static: false, private: false, access: { has: obj => "updateSecrets" in obj, get: obj => obj.updateSecrets }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _updateEnv_decorators, { kind: "method", name: "updateEnv", static: false, private: false, access: { has: obj => "updateEnv" in obj, get: obj => obj.updateEnv }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getPreviewLink_decorators, { kind: "method", name: "getPreviewLink", static: false, private: false, access: { has: obj => "getPreviewLink" in obj, get: obj => obj.getPreviewLink }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getSignedPreviewUrl_decorators, { kind: "method", name: "getSignedPreviewUrl", static: false, private: false, access: { has: obj => "getSignedPreviewUrl" in obj, get: obj => obj.getSignedPreviewUrl }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _expireSignedPreviewUrl_decorators, { kind: "method", name: "expireSignedPreviewUrl", static: false, private: false, access: { has: obj => "expireSignedPreviewUrl" in obj, get: obj => obj.expireSignedPreviewUrl }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _archive_decorators, { kind: "method", name: "archive", static: false, private: false, access: { has: obj => "archive" in obj, get: obj => obj.archive }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _resize_decorators, { kind: "method", name: "resize", static: false, private: false, access: { has: obj => "resize" in obj, get: obj => obj.resize }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _waitForResizeComplete_decorators, { kind: "method", name: "waitForResizeComplete", static: false, private: false, access: { has: obj => "waitForResizeComplete" in obj, get: obj => obj.waitForResizeComplete }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -191,7 +189,8 @@ let Sandbox = (() => {
         clientConfig = __runInitializers(this, _instanceExtraInitializers);
         axiosInstance;
         sandboxApi;
-        volumeService;
+        getAnalyticsApiUrl;
+        subscriptionManager;
         fs;
         git;
         process;
@@ -216,8 +215,10 @@ let Sandbox = (() => {
         backupState;
         backupCreatedAt;
         autoStopInterval;
+        autoPauseInterval;
         autoArchiveInterval;
         autoDeleteInterval;
+        autoDestroyAt;
         volumes;
         buildInfo;
         createdAt;
@@ -230,25 +231,28 @@ let Sandbox = (() => {
         toolboxProxyUrl;
         infoApi;
         serverApi;
+        systemApi;
+        stateWaiters = [];
+        stateWaiterErrorMessageFns = new WeakMap();
+        subId;
         /**
-         * Creates a new Sandbox instance
+         * Creates a new Sandbox instance.
+         *
+         * Internal: obtain sandboxes via {@link Daytona.create}, {@link Daytona.get}, or
+         * {@link Daytona.list} rather than constructing directly.
          *
          * @param {SandboxDto} sandboxDto - The API Sandbox instance
+         * @param {SandboxApi} sandboxApi - API client for Sandbox operations
+         * @param {InfoApi} infoApi - API client for info operations
+         * @param {EventSubscriptionManager} subscriptionManager - Event subscription manager for real-time updates
          */
-        constructor(sandboxDto, clientConfig, axiosInstance, sandboxApi, volumeService) {
+        constructor(sandboxDto, clientConfig, axiosInstance, sandboxApi, getAnalyticsApiUrl, subscriptionManager) {
             this.clientConfig = clientConfig;
             this.axiosInstance = axiosInstance;
             this.sandboxApi = sandboxApi;
-            this.volumeService = volumeService;
+            this.getAnalyticsApiUrl = getAnalyticsApiUrl;
+            this.subscriptionManager = subscriptionManager;
             this.processSandboxDto(sandboxDto);
-            // Set the toolbox base URL
-            let baseUrl = this.toolboxProxyUrl;
-            if (!baseUrl.endsWith('/')) {
-                baseUrl += '/';
-            }
-            this.axiosInstance.defaults.baseURL = baseUrl + this.id;
-            this.clientConfig.basePath = this.axiosInstance.defaults.baseURL;
-            // Initialize Services
             const getPreviewToken = async () => (await this.getPreviewLink(1)).token;
             this.fs = new FileSystem(this.clientConfig, new FileSystemApi(this.clientConfig, '', this.axiosInstance));
             this.git = new Git(new GitApi(this.clientConfig, '', this.axiosInstance));
@@ -258,6 +262,8 @@ let Sandbox = (() => {
             this.computerUse = new ComputerUse(new ComputerUseApi(this.clientConfig, '', this.axiosInstance));
             this.infoApi = new InfoApi(this.clientConfig, '', this.axiosInstance);
             this.serverApi = new ServerApi(this.clientConfig, '', this.axiosInstance);
+            this.systemApi = new SystemApi(this.clientConfig, '', this.axiosInstance);
+            this.subscribeToEvents();
         }
         /**
          * Gets the user's home directory path for the logged in user inside the Sandbox.
@@ -272,6 +278,53 @@ let Sandbox = (() => {
             const response = await this.infoApi.getUserHomeDir();
             return response.data.dir;
         }
+        /**
+         * Gets the most recent resource usage sample directly from the sandbox daemon.
+         *
+         * Unlike {@link getMetrics}, which returns aggregated historical samples, this returns the
+         * single current reading without going through the telemetry backend.
+         *
+         * @returns The current resource usage sample for the sandbox.
+         *
+         * @example
+         * const m = await sandbox.getMetricsLatest()
+         * console.log(`CPU: ${m.cpuUsedPct}%, mem: ${m.memUsed}/${m.memTotal}`)
+         */
+        async getMetricsLatest() {
+            const response = await this.systemApi.getSystemMetrics();
+            return sandboxMetricsFromSystemMetrics(response.data);
+        }
+        /**
+         * Gets historical time-series resource usage metrics for the Sandbox.
+         *
+         * @param {Date} [start] - Start of the time range. Defaults to the Sandbox creation time.
+         * @param {Date} [end] - End of the time range. Defaults to the current time.
+         * @returns Time-ordered usage samples over the requested range.
+         *
+         * @example
+         * const samples = await sandbox.getMetrics()
+         * for (const s of samples) {
+         *   console.log(`${s.timestamp.toISOString()} CPU: ${s.cpuUsedPct}% mem: ${s.memUsed}/${s.memTotal}`)
+         * }
+         */
+        async getMetrics(start, end) {
+            const to = end ?? new Date();
+            const from = start ?? (this.createdAt ? new Date(this.createdAt) : to);
+            const analyticsApiUrl = await this.getAnalyticsApiUrl();
+            if (analyticsApiUrl) {
+                const response = await this.buildAnalyticsTelemetryApi(analyticsApiUrl).organizationOrganizationIdSandboxSandboxIdTelemetryMetricsGet(this.organizationId, this.id, from.toISOString(), to.toISOString(), SANDBOX_METRIC_NAMES.join(','));
+                return pivotSandboxMetricPoints(response.data);
+            }
+            const response = await this.sandboxApi.getSandboxMetrics(this.id, from, to, undefined, SANDBOX_METRIC_NAMES);
+            return pivotSandboxMetrics(response.data.series);
+        }
+        buildAnalyticsTelemetryApi(analyticsApiUrl) {
+            const analyticsConfig = new AnalyticsConfiguration({
+                basePath: analyticsApiUrl,
+                apiKey: this.clientConfig.baseOptions?.headers?.Authorization,
+            });
+            return new AnalyticsTelemetryApi(analyticsConfig, undefined, Daytona.createAxiosInstance());
+        }
         /**
          * @deprecated Use `getUserHomeDir` instead. This method will be removed in a future version.
          */
@@ -292,71 +345,6 @@ let Sandbox = (() => {
             const response = await this.infoApi.getWorkDir();
             return response.data.dir;
         }
-        /**
-         * Mounts a hotmount Volume into the running Sandbox on the fly.
-         *
-         * Unlike legacy and blockmount volumes (which are attached at Sandbox creation), hotmount
-         * volumes are mounted at runtime: this method requests a short-lived mount token from the API
-         * and bootstraps the hotmount agent inside the Sandbox (downloading and running the region's
-         * `init.sh`), mounting the filesystem at the given path.
-         *
-         * The Sandbox must have `/dev/fuse` available, outbound access to the region gateway (ports
-         * 443 and 18443) and binaries bucket, and passwordless sudo (or run as root).
-         *
-         * @param {Volume} volume - The hotmount Volume to mount. Must be of type `VolumeType.HOTMOUNT`.
-         * @param {string} mountPath - The absolute path inside the Sandbox to mount the Volume at
-         * @returns {Promise<void>}
-         * @throws {DaytonaError} If the Volume is not a hotmount volume, or if mounting fails
-         *
-         * @example
-         * const volume = await daytona.volume.get("shared-fs");
-         * await sandbox.mountVolume(volume, "/mnt/shared");
-         */
-        async mountVolume(volume, mountPath) {
-            if (volume.type !== VolumeType.HOTMOUNT) {
-                throw new DaytonaValidationError(`Only hotmount volumes can be mounted on the fly. Volume '${volume.name}' is of type '${volume.type}'.`);
-            }
-            if (!this.volumeService) {
-                throw new DaytonaError('Volume service is not available for this Sandbox instance.');
-            }
-            const mountToken = await this.volumeService.getMountToken(volume);
-            const command = buildHotmountMountCommand(mountToken, mountPath);
-            const response = await this.process.executeCommand(command);
-            if (response.exitCode !== 0) {
-                throw new DaytonaError(`Failed to mount hotmount volume '${volume.name}': ${response.result}`);
-            }
-        }
-        /**
-         * Pulls the latest state of the Sandbox's blockmount Volumes into the running Sandbox.
-         *
-         * Blockmount volumes reconcile in the background: each sandbox writes to a private scratch
-         * that is committed to the shared store periodically, but other sandboxes' commits only
-         * appear locally on re-materialize. This method makes them appear immediately, without
-         * stopping the Sandbox: it commits this Sandbox's local changes (so they participate in the
-         * merge), then applies the volume's latest merged state in place. Files modified locally
-         * after another sandbox's change keep the local version (last-change-wins by mtime).
-         *
-         * @param {Volume} [volume] - The blockmount Volume to pull. Omit to pull every blockmount
-         * Volume attached to the Sandbox.
-         * @returns {Promise<VolumePullResult[]>} Per-volume pull results
-         * @throws {DaytonaError} If the Sandbox has no matching mounted blockmount Volume
-         *
-         * @example
-         * // sandbox B picks up what sandbox A committed, while both keep running
-         * const results = await sandbox.pullVolumes();
-         * console.log(results); // [{ volumeId, upToDate, filesWritten, deleted, ... }]
-         */
-        async pullVolumes(volume) {
-            if (volume && volume.type !== VolumeType.BLOCKMOUNT) {
-                throw new DaytonaValidationError(`Only blockmount volumes can be pulled. Volume '${volume.name}' is of type '${volume.type}'.`);
-            }
-            // Raw toolbox call (the daemon's generated client has no pull op — the runner intercepts
-            // this path), so replicate what the generated clients do: resolve against this sandbox's
-            // clientConfig.basePath (the shared axios instance's default baseURL is mutated by every
-            // Sandbox construction and may point at another sandbox) and inject the auth headers.
-            const response = await this.axiosInstance.post(`${this.clientConfig.basePath}/volumes/pull`, volume ? { volumeId: volume.id } : {}, { headers: this.clientConfig.baseOptions?.headers });
-            return response.data.results ?? [];
-        }
         /**
          * Creates a new Language Server Protocol (LSP) server instance.
          *
@@ -494,9 +482,16 @@ let Sandbox = (() => {
                 timeout: timeout * 1000,
             });
             const sandboxDto = response.data;
-            const forkedSandbox = new Sandbox(sandboxDto, structuredClone(this.clientConfig), Daytona.createAxiosInstance(), this.sandboxApi);
+            const sandboxWithProxyUrl = sandboxDto.toolboxProxyUrl
+                ? sandboxDto
+                : {
+                    ...sandboxDto,
+                    toolboxProxyUrl: (await this.sandboxApi.getToolboxProxyUrl(sandboxDto.id)).data.url,
+                };
+            const forkedSandbox = new Sandbox(sandboxWithProxyUrl, structuredClone(this.clientConfig), Daytona.createAxiosInstance(), this.sandboxApi, this.getAnalyticsApiUrl, this.subscriptionManager);
             const timeElapsed = Date.now() - startTime;
-            await forkedSandbox.waitUntilStarted(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
+            const remainingTimeout = timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout;
+            await forkedSandbox.waitUntilStarted(remainingTimeout);
             return forkedSandbox;
         }
         /**
@@ -524,34 +519,19 @@ let Sandbox = (() => {
             }
             const startTime = Date.now();
             const req = { name };
-            await this.sandboxApi.createSandboxSnapshot(this.id, req, undefined, {
+            const response = await this.sandboxApi.createSandboxSnapshot(this.id, req, undefined, {
                 timeout: timeout * 1000,
             });
-            await this.refreshData();
+            this.processSandboxDto(response.data);
             const timeElapsed = Date.now() - startTime;
             const remainingTimeout = timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout;
             await this.waitForSnapshotComplete(remainingTimeout);
         }
         async waitForSnapshotComplete(timeout) {
-            let checkInterval = 100;
-            const startTime = Date.now();
-            while (this.state === SandboxState.SNAPSHOTTING) {
-                await this.refreshData();
-                // @ts-expect-error this.refreshData() can modify this.state so this check is fine
-                if (this.state === SandboxState.ERROR || this.state === SandboxState.BUILD_FAILED) {
-                    throw new DaytonaError(`Sandbox ${this.id} snapshot failed with state: ${this.state}, error reason: ${this.errorReason}`);
-                }
-                if (this.state !== SandboxState.SNAPSHOTTING) {
-                    return;
-                }
-                if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
-                    throw new DaytonaTimeoutError('Sandbox snapshot did not complete within the timeout period');
-                }
-                await new Promise((resolve) => setTimeout(resolve, checkInterval));
-                if (Date.now() - startTime > 5000) {
-                    checkInterval = Math.min(checkInterval * 1.1, 1000);
-                }
-            }
+            const errorStates = [SandboxState.ERROR, SandboxState.BUILD_FAILED];
+            const excludeStates = new Set([SandboxState.SNAPSHOTTING, ...errorStates]);
+            const targetStates = Object.values(SandboxState).filter((s) => !excludeStates.has(s));
+            return this.waitForState(targetStates, errorStates, timeout, 'Sandbox snapshot did not complete within the timeout period', (state) => `Sandbox ${this.id} snapshot failed with state: ${state}, error reason: ${this.errorReason}`);
         }
         /**
          * Pauses the Sandbox, freezing all running processes.
@@ -582,31 +562,47 @@ let Sandbox = (() => {
             await this.refreshData();
             const timeElapsed = Date.now() - startTime;
             const remainingTimeout = timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout;
-            await this.waitForPauseComplete(remainingTimeout);
-        }
-        async waitForPauseComplete(timeout) {
-            let checkInterval = 100;
-            const startTime = Date.now();
-            while (this.state === SandboxState.PAUSING) {
-                await this.refreshData();
-                // @ts-expect-error this.refreshData() can modify this.state so this check is fine
-                if (this.state === SandboxState.ERROR) {
-                    throw new DaytonaError(`Sandbox ${this.id} pause failed with state: ${this.state}, error reason: ${this.errorReason}`);
-                }
-                if (timeout > 0 && (Date.now() - startTime) / 1000 >= timeout) {
-                    throw new DaytonaError(`Sandbox ${this.id} failed to pause within ${timeout} seconds`);
-                }
-                await new Promise((resolve) => globalThis.setTimeout(resolve, checkInterval));
-                checkInterval = Math.min(checkInterval * 1.5, 1000);
-            }
+            // Main's contract: pause completes when the sandbox has *left* PAUSING
+            // (paused, stopped, archived, ...), not only on exactly PAUSED.
+            const errorStates = [SandboxState.ERROR, SandboxState.BUILD_FAILED];
+            const excludeStates = new Set([SandboxState.PAUSING, ...errorStates]);
+            const targetStates = Object.values(SandboxState).filter((s) => !excludeStates.has(s));
+            await this.waitForState(targetStates, errorStates, remainingTimeout, 'Sandbox failed to become paused within the timeout period', (state) => `Sandbox ${this.id} pause failed with state: ${state}, error reason: ${this.errorReason}`);
         }
         /**
          * Deletes the Sandbox.
+         *
+         * By default this returns as soon as the deletion request is accepted (matching
+         * historical behavior). Pass `wait = true` to block until the Sandbox reaches
+         * the 'destroyed' state.
+         *
+         * @param {number} [timeout] - Timeout in seconds for the request — and, when
+         *                            `wait` is true, for reaching 'destroyed'. 0 means no timeout.
+         *                            Defaults to 60-second timeout.
+         * @param {boolean} [wait] - If true, wait until the Sandbox is destroyed. Defaults to false.
          * @returns {Promise<void>}
          */
-        async delete(timeout = 60) {
-            await this.sandboxApi.deleteSandbox(this.id, undefined, { timeout: timeout * 1000 });
-            this.refreshDataSafe();
+        async delete(timeout = 60, wait = false) {
+            if (timeout < 0) {
+                throw new DaytonaValidationError('Timeout must be a non-negative number');
+            }
+            const startTime = Date.now();
+            const response = await this.sandboxApi.deleteSandbox(this.id, undefined, { timeout: timeout * 1000 });
+            if (response.data) {
+                this.processSandboxDto(response.data);
+            }
+            try {
+                if (wait && this.state !== SandboxState.DESTROYED) {
+                    const timeElapsed = Date.now() - startTime;
+                    await this.waitForState([SandboxState.DESTROYED], [SandboxState.ERROR, SandboxState.BUILD_FAILED], timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout, 'Sandbox failed to be destroyed within the timeout period', (state) => `Sandbox ${this.id} failed to delete with state: ${state}, error reason: ${this.errorReason}`, true);
+                }
+            }
+            finally {
+                if (this.subId) {
+                    this.subscriptionManager.unsubscribe(this.subId);
+                    this.subId = undefined;
+                }
+            }
         }
         /**
          * Waits for the Sandbox to reach the 'started' state.
@@ -623,26 +619,10 @@ let Sandbox = (() => {
             if (timeout < 0) {
                 throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
-            let checkInterval = 100;
-            const startTime = Date.now();
-            while (this.state !== 'started') {
-                await this.refreshData();
-                // @ts-expect-error this.refreshData() can modify this.state so this check is fine
-                if (this.state === 'started') {
-                    return;
-                }
-                if (this.state === 'error') {
-                    const errMsg = `Sandbox ${this.id} failed to start with status: ${this.state}, error reason: ${this.errorReason}`;
-                    throw new DaytonaError(errMsg);
-                }
-                if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
-                    throw new DaytonaTimeoutError('Sandbox failed to become ready within the timeout period');
-                }
-                await new Promise((resolve) => setTimeout(resolve, checkInterval));
-                if (Date.now() - startTime > 5000) {
-                    checkInterval = Math.min(checkInterval * 1.1, 1000);
-                }
+            if (this.state === SandboxState.STARTED) {
+                return;
             }
+            return this.waitForState([SandboxState.STARTED], [SandboxState.ERROR, SandboxState.BUILD_FAILED], timeout, 'Sandbox failed to become ready within the timeout period', (state) => `Sandbox ${this.id} failed to start with status: ${state}, error reason: ${this.errorReason}`);
         }
         /**
          * Wait for Sandbox to reach 'stopped' state.
@@ -659,27 +639,11 @@ let Sandbox = (() => {
             if (timeout < 0) {
                 throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
-            let checkInterval = 100;
-            const startTime = Date.now();
             // Treat destroyed as stopped to cover ephemeral sandboxes that are automatically deleted after stopping
-            while (this.state !== 'stopped' && this.state !== 'destroyed') {
-                this.refreshDataSafe();
-                // @ts-expect-error this.refreshData() can modify this.state so this check is fine
-                if (this.state === 'stopped' || this.state === 'destroyed') {
-                    return;
-                }
-                if (this.state === 'error') {
-                    const errMsg = `Sandbox failed to stop with status: ${this.state}, error reason: ${this.errorReason}`;
-                    throw new DaytonaError(errMsg);
-                }
-                if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
-                    throw new DaytonaTimeoutError('Sandbox failed to become stopped within the timeout period');
-                }
-                await new Promise((resolve) => setTimeout(resolve, checkInterval));
-                if (Date.now() - startTime > 5000) {
-                    checkInterval = Math.min(checkInterval * 1.1, 1000);
-                }
+            if (this.state === SandboxState.STOPPED || this.state === SandboxState.DESTROYED) {
+                return;
             }
+            return this.waitForState([SandboxState.STOPPED, SandboxState.DESTROYED], [SandboxState.ERROR, SandboxState.BUILD_FAILED], timeout, 'Sandbox failed to become stopped within the timeout period', (state) => `Sandbox failed to stop with status: ${state}, error reason: ${this.errorReason}`, true);
         }
         /**
          * Refreshes the Sandbox data from the API.
@@ -736,6 +700,60 @@ let Sandbox = (() => {
             await this.sandboxApi.setAutostopInterval(this.id, interval);
             this.autoStopInterval = interval;
         }
+        /**
+         * Set the auto-pause interval for the Sandbox.
+         *
+         * The Sandbox will automatically pause after being idle (no new events) for the specified interval.
+         * Events include any state changes or interactions with the Sandbox through the sdk.
+         * Interactions using Sandbox Previews are not included.
+         *
+         * Only supported for sandbox classes that support pausing. At most one of the auto-stop
+         * and auto-pause intervals may be non-zero, so disable auto-stop first by setting its
+         * interval to 0.
+         *
+         * @param {number} interval - Number of minutes of inactivity before auto-pausing.
+         *                           Set to 0 to disable auto-pause. For pause-supporting sandbox
+         *                           classes, creation defaults to 60 minutes when neither interval is provided.
+         * @returns {Promise<void>}
+         * @throws {DaytonaError} - `DaytonaError` - If interval is not a non-negative integer
+         *
+         * @example
+         * // Auto-pause after 1 hour
+         * await sandbox.setAutoPauseInterval(60);
+         * // Or disable auto-pause
+         * await sandbox.setAutoPauseInterval(0);
+         */
+        async setAutoPauseInterval(interval) {
+            if (!Number.isInteger(interval) || interval < 0) {
+                throw new DaytonaValidationError('autoPauseInterval must be a non-negative integer');
+            }
+            await this.sandboxApi.setAutoPauseInterval(this.id, interval);
+            this.autoPauseInterval = interval;
+        }
+        /**
+         * Set the TTL (maximum time to live) for the Sandbox.
+         *
+         * The Sandbox will be destroyed once the TTL elapses, counted as wall-clock time regardless of the
+         * Sandbox state - even if it is stopped, paused, or archived. Calling this method re-anchors the
+         * deadline from the current time. Call `refreshData()` afterwards to read the updated `autoDestroyAt`.
+         *
+         * @param {number} ttlMinutes - Number of minutes from now after which the Sandbox will be destroyed.
+         *                           Set to 0 to disable the TTL.
+         * @returns {Promise<void>}
+         * @throws {DaytonaError} - `DaytonaError` - If ttlMinutes is not a non-negative integer
+         *
+         * @example
+         * // Destroy the Sandbox 1 hour from now
+         * await sandbox.setTtl(60);
+         * // Or disable the TTL
+         * await sandbox.setTtl(0);
+         */
+        async setTtl(ttlMinutes) {
+            if (!Number.isInteger(ttlMinutes) || ttlMinutes < 0) {
+                throw new DaytonaValidationError('ttlMinutes must be a non-negative integer');
+            }
+            await this.sandboxApi.setTtl(this.id, ttlMinutes);
+        }
         /**
          * Set the auto-archive interval for the Sandbox.
          *
@@ -958,25 +976,13 @@ let Sandbox = (() => {
             if (timeout < 0) {
                 throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
-            let checkInterval = 100;
-            const startTime = Date.now();
-            while (this.state === SandboxState.RESIZING) {
-                await this.refreshData();
-                // @ts-expect-error this.refreshData() can modify this.state so this check is fine
-                if (this.state === SandboxState.ERROR || this.state === SandboxState.BUILD_FAILED) {
-                    throw new DaytonaError(`Sandbox ${this.id} resize failed with state: ${this.state}, error reason: ${this.errorReason}`);
-                }
-                if (this.state !== SandboxState.RESIZING) {
-                    return;
-                }
-                if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
-                    throw new DaytonaTimeoutError('Sandbox resize did not complete within the timeout period');
-                }
-                await new Promise((resolve) => setTimeout(resolve, checkInterval));
-                if (Date.now() - startTime > 5000) {
-                    checkInterval = Math.min(checkInterval * 1.1, 1000);
-                }
+            if (this.state !== SandboxState.RESIZING) {
+                return;
             }
+            const errorStates = [SandboxState.ERROR, SandboxState.BUILD_FAILED];
+            const excludeStates = new Set([SandboxState.RESIZING, ...errorStates]);
+            const targetStates = Object.values(SandboxState).filter((s) => !excludeStates.has(s));
+            return this.waitForState(targetStates, errorStates, timeout, 'Sandbox resize did not complete within the timeout period', (state) => `Sandbox ${this.id} resize failed with state: ${state}, error reason: ${this.errorReason}`);
         }
         /**
          * Creates an SSH access token for the sandbox.
@@ -1005,6 +1011,172 @@ let Sandbox = (() => {
         async validateSshAccess(token) {
             return (await this.sandboxApi.validateSshAccess(token)).data;
         }
+        /**
+         * Subscribes to real-time events for this sandbox.
+         * Auto-updates sandbox metadata on every event.
+         */
+        subscribeToEvents() {
+            if (this.subId) {
+                return;
+            }
+            this.subId = this.subscriptionManager.subscribe(this.id, this.handleEvent.bind(this), [
+                'sandbox.state.updated',
+                'sandbox.created',
+            ]);
+        }
+        ensureSubscribed() {
+            if (this.subId) {
+                if (this.subscriptionManager.refresh(this.subId)) {
+                    return;
+                }
+                this.subId = undefined;
+            }
+            this.subscribeToEvents();
+        }
+        handleEvent(eventName, data) {
+            if (!data || typeof data !== 'object')
+                return;
+            const raw = data.sandbox ?? data;
+            if (!raw || typeof raw !== 'object')
+                return;
+            if (eventName === 'sandbox.created') {
+                this.processSandboxDto(raw);
+                return;
+            }
+            const newState = raw.state ?? data.newState;
+            if (newState) {
+                this.applyState(newState);
+            }
+        }
+        /**
+         * Waits for the sandbox to reach one of the target states.
+         * Throws on error states or timeout.
+         *
+         * @param targetStates - States that indicate success.
+         * @param errorStates - States that indicate failure.
+         * @param timeout - Maximum time to wait in seconds. 0 means no timeout.
+         * @param timeoutMessage - Error message when timeout is reached.
+         * @param errorMessageFn - Function that produces an error message from the current state.
+         * @param safeRefresh - If true, use refreshDataSafe() for polling (for delete operations where 404 is expected).
+         */
+        waitForState(targetStates, errorStates, timeout, timeoutMessage, errorMessageFn, safeRefresh = false) {
+            this.ensureSubscribed();
+            return new Promise((resolve, reject) => {
+                let timeoutTimer = null;
+                let pollTimer = null;
+                let settled = false;
+                const waiter = {
+                    targetStates: new Set(targetStates),
+                    errorStates: new Set(errorStates),
+                    resolve: (_) => {
+                        if (settled)
+                            return;
+                        cleanup();
+                        resolve();
+                    },
+                    reject: (err) => {
+                        if (settled)
+                            return;
+                        cleanup();
+                        reject(err);
+                    },
+                };
+                this.stateWaiters.push(waiter);
+                this.stateWaiterErrorMessageFns.set(waiter, errorMessageFn);
+                const cleanup = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    if (timeoutTimer)
+                        clearTimeout(timeoutTimer);
+                    if (pollTimer)
+                        clearTimeout(pollTimer);
+                    this.removeStateWaiter(waiter);
+                };
+                // Fast-path only on cached *target* states (parity with main's pre-check).
+                // Cached error states are deliberately NOT evaluated here — main always
+                // refreshed before failing, so a stale ERROR must survive one refresh.
+                if (this.state && waiter.targetStates.has(this.state)) {
+                    waiter.resolve(this.state);
+                    return;
+                }
+                if (timeout !== 0) {
+                    timeoutTimer = setTimeout(() => {
+                        void (async () => {
+                            if (settled)
+                                return;
+                            // Parity with main: complete one final refresh-then-evaluate before
+                            // rejecting, so a clamped/short timeout still observes the latest state.
+                            let refreshed = false;
+                            try {
+                                if (safeRefresh) {
+                                    refreshed = await this.refreshDataSafe();
+                                }
+                                else {
+                                    await this.refreshData();
+                                    refreshed = true;
+                                }
+                            }
+                            catch {
+                                // fall through to the timeout rejection below
+                            }
+                            if (!settled) {
+                                // Explicit evaluation: applyState() no-ops on unchanged state, so a
+                                // persistent error state would otherwise time out generically here.
+                                // Only evaluate when the refresh succeeded — a failed refresh leaves
+                                // the cached state stale and must not be treated as authoritative.
+                                if (refreshed && this.checkStateWaiter(waiter, this.state)) {
+                                    return;
+                                }
+                                cleanup();
+                                reject(new DaytonaTimeoutError(timeoutMessage));
+                            }
+                        })();
+                    }, timeout * 1000);
+                }
+                // Poll as a safety net for missed state changes. With an active event subscription
+                // a sparse 1s cadence suffices; without events (polling mode) replicate main's
+                // cadence exactly: 100ms steady for the first 5s, then exponential backoff capped at 1s.
+                const streaming = !!this.subId;
+                const pollStart = Date.now();
+                let pollInterval = streaming ? 1000 : 100;
+                const doPoll = async () => {
+                    if (settled)
+                        return;
+                    let refreshed = false;
+                    try {
+                        if (safeRefresh) {
+                            refreshed = await this.refreshDataSafe();
+                        }
+                        else {
+                            await this.refreshData();
+                            refreshed = true;
+                        }
+                    }
+                    catch (error) {
+                        waiter.reject(error instanceof Error ? error : new DaytonaError(String(error)));
+                        return;
+                    }
+                    if (!settled) {
+                        // Evaluate the refreshed state explicitly: applyState() no-ops when the
+                        // state is unchanged, so a persistent error state would otherwise never
+                        // reject the waiter. Only evaluate when the refresh succeeded — a failed
+                        // safe refresh leaves the cached state stale, so keep polling instead.
+                        if (refreshed && this.checkStateWaiter(waiter, this.state)) {
+                            return;
+                        }
+                        if (!streaming && Date.now() - pollStart > 5000) {
+                            pollInterval = Math.min(pollInterval * 1.1, 1000);
+                        }
+                        pollTimer = setTimeout(() => {
+                            void doPoll();
+                        }, pollInterval);
+                    }
+                };
+                // First poll runs immediately (main refreshed before any state evaluation).
+                void doPoll();
+            });
+        }
         /**
          * Assigns the API sandbox data to the Sandbox object.
          *
@@ -1012,6 +1184,7 @@ let Sandbox = (() => {
          * @returns {void}
          */
         processSandboxDto(sandboxDto) {
+            const newState = sandboxDto.state;
             this.id = sandboxDto.id;
             this.name = sandboxDto.name;
             this.organizationId = sandboxDto.organizationId;
@@ -1024,17 +1197,17 @@ let Sandbox = (() => {
             this.gpu = sandboxDto.gpu;
             this.memory = sandboxDto.memory;
             this.disk = sandboxDto.disk;
-            this.state = sandboxDto.state;
             this.errorReason = sandboxDto.errorReason;
             this.recoverable = sandboxDto.recoverable;
             this.backupState = sandboxDto.backupState;
             this.autoStopInterval = sandboxDto.autoStopInterval;
+            this.autoPauseInterval = sandboxDto.autoPauseInterval;
             this.autoArchiveInterval = sandboxDto.autoArchiveInterval;
             this.autoDeleteInterval = sandboxDto.autoDeleteInterval;
+            this.autoDestroyAt = sandboxDto.autoDestroyAt;
             this.createdAt = sandboxDto.createdAt;
             this.updatedAt = sandboxDto.updatedAt;
             this.lastActivityAt = sandboxDto.lastActivityAt;
-            this.toolboxProxyUrl = sandboxDto.toolboxProxyUrl;
             // Fields only present in the full SandboxDto (not returned by list endpoint)
             if ('env' in sandboxDto) {
                 this.env = sandboxDto.env;
@@ -1046,6 +1219,21 @@ let Sandbox = (() => {
                 this.buildInfo = sandboxDto.buildInfo;
                 this.backupCreatedAt = sandboxDto.backupCreatedAt;
             }
+            const newProxyUrl = sandboxDto.toolboxProxyUrl;
+            if (newProxyUrl && newProxyUrl !== this.toolboxProxyUrl && this.axiosInstance) {
+                let baseUrl = newProxyUrl;
+                if (!baseUrl.endsWith('/')) {
+                    baseUrl += '/';
+                }
+                this.axiosInstance.defaults.baseURL = baseUrl + this.id;
+                this.clientConfig.basePath = this.axiosInstance.defaults.baseURL;
+            }
+            if (newProxyUrl) {
+                this.toolboxProxyUrl = newProxyUrl;
+            }
+            if (newState) {
+                this.applyState(newState);
+            }
         }
         /**
          * Refreshes the Sandbox data from the API, but does not throw an error if the sandbox has been deleted.
@@ -1053,17 +1241,113 @@ let Sandbox = (() => {
          *
          * @returns {Promise<void>}
          */
+        /**
+         * @returns true when the refresh produced authoritative state (success, or 404
+         *          mapped to DESTROYED); false when a transient error was swallowed and
+         *          the cached state is stale.
+         */
         async refreshDataSafe() {
             try {
                 await this.refreshData();
+                return true;
             }
             catch (error) {
                 if (error instanceof DaytonaNotFoundError) {
-                    this.state = SandboxState.DESTROYED;
+                    this.applyState(SandboxState.DESTROYED);
+                    return true;
                 }
+                // Other errors are deliberately swallowed (parity with main): transient
+                // failures (e.g. 502) mid-poll must not abort stop()/delete() waits.
+                return false;
+            }
+        }
+        applyState(newState) {
+            if (newState === this.state) {
+                return;
+            }
+            this.state = newState;
+            for (const waiter of [...this.stateWaiters]) {
+                this.checkStateWaiter(waiter, this.state);
             }
         }
+        checkStateWaiter(waiter, state) {
+            if (!state) {
+                return false;
+            }
+            if (waiter.targetStates.has(state)) {
+                waiter.resolve(state);
+                return true;
+            }
+            if (waiter.errorStates.has(state)) {
+                const errorMessageFn = this.stateWaiterErrorMessageFns.get(waiter);
+                waiter.reject(new DaytonaError(errorMessageFn ? errorMessageFn(state) : `Sandbox ${this.id} failed with state: ${state}`));
+                return true;
+            }
+            return false;
+        }
+        removeStateWaiter(waiter) {
+            const index = this.stateWaiters.indexOf(waiter);
+            if (index !== -1) {
+                this.stateWaiters.splice(index, 1);
+            }
+            this.stateWaiterErrorMessageFns.delete(waiter);
+        }
     };
 })();
 export { Sandbox };
+const SANDBOX_METRIC_FIELD_BY_NAME = {
+    'daytona.sandbox.cpu.utilization': 'cpuUsedPct',
+    'daytona.sandbox.cpu.limit': 'cpuCount',
+    'daytona.sandbox.memory.usage': 'memUsed',
+    'daytona.sandbox.memory.limit': 'memTotal',
+    'daytona.sandbox.memory.cache': 'memCache',
+    'daytona.sandbox.filesystem.usage': 'diskUsed',
+    'daytona.sandbox.filesystem.total': 'diskTotal',
+};
+const SANDBOX_METRIC_NAMES = Object.keys(SANDBOX_METRIC_FIELD_BY_NAME);
+function sandboxMetricsFromSystemMetrics(m) {
+    return {
+        cpuCount: m.cpuCount ?? 0,
+        cpuUsedPct: m.cpuUsedPct ?? 0,
+        diskTotal: m.diskTotal ?? 0,
+        diskUsed: m.diskUsed ?? 0,
+        memTotal: m.memTotal ?? 0,
+        memUsed: m.memUsed ?? 0,
+        memCache: m.memCache ?? 0,
+        timestamp: m.timestamp ? new Date(m.timestamp) : new Date(),
+    };
+}
+function buildSandboxMetrics(buckets) {
+    return [...buckets.keys()].sort().map((ts) => {
+        const v = buckets.get(ts);
+        return {
+            cpuCount: v.cpuCount ?? 0,
+            cpuUsedPct: v.cpuUsedPct ?? 0,
+            diskTotal: v.diskTotal ?? 0,
+            diskUsed: v.diskUsed ?? 0,
+            memTotal: v.memTotal ?? 0,
+            memUsed: v.memUsed ?? 0,
+            memCache: v.memCache ?? 0,
+            timestamp: new Date(ts),
+        };
+    });
+}
+function pivotMetricTriples(triples) {
+    const buckets = new Map();
+    for (const [name, timestamp, value] of triples) {
+        const field = name ? SANDBOX_METRIC_FIELD_BY_NAME[name] : undefined;
+        if (!field || timestamp === undefined || value === undefined)
+            continue;
+        const bucket = buckets.get(timestamp) ?? {};
+        bucket[field] = value;
+        buckets.set(timestamp, bucket);
+    }
+    return buildSandboxMetrics(buckets);
+}
+function pivotSandboxMetrics(series) {
+    return pivotMetricTriples((series ?? []).flatMap((s) => (s.dataPoints ?? []).map((p) => [s.metricName, p.timestamp, p.value])));
+}
+function pivotSandboxMetricPoints(points) {
+    return pivotMetricTriples((points ?? []).map((p) => [p.metricName, p.timestamp, p.value]));
+}
 //# sourceMappingURL=Sandbox.js.map