@daytona/sdk 0.198.0-alpha.1 → 0.199.0-alpha.1

package/esm/Sandbox.js

@@ -4,9 +4,8 @@
  */
 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, SystemApi, ComputerUseApi, InterpreterApi, ServerApi, } from '@daytona/toolbox-api-client';
+import { FileSystemApi, GitApi, ProcessApi, LspApi, InfoApi, ComputerUseApi, InterpreterApi, ServerApi, } from '@daytona/toolbox-api-client';
 import { FileSystem } from './FileSystem.js';
 import { Git } from './Git.js';
 import { Process } from './Process.js';
@@ -16,12 +15,35 @@ 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';
-function withEvents(target, _context) {
-    return function (...args) {
-        ;
-        this.ensureSubscribed();
-        return target.apply(this, args);
+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,
     };
+    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.
@@ -52,10 +74,8 @@ function withEvents(target, _context) {
  * @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
@@ -77,14 +97,13 @@ function withEvents(target, _context) {
 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;
@@ -93,18 +112,13 @@ 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;
@@ -114,50 +128,43 @@ let Sandbox = (() => {
     return class Sandbox {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _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];
+            _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()];
             _updateNetworkSettings_decorators = [WithInstrumentation()];
             _updateSecrets_decorators = [WithInstrumentation()];
             _updateEnv_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];
+            _getPreviewLink_decorators = [WithInstrumentation()];
+            _archive_decorators = [WithInstrumentation()];
+            _resize_decorators = [WithInstrumentation()];
+            _waitForResizeComplete_decorators = [WithInstrumentation()];
+            _createSshAccess_decorators = [WithInstrumentation()];
+            _revokeSshAccess_decorators = [WithInstrumentation()];
+            _validateSshAccess_decorators = [WithInstrumentation()];
             __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);
@@ -166,18 +173,13 @@ 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);
@@ -189,8 +191,7 @@ let Sandbox = (() => {
         clientConfig = __runInitializers(this, _instanceExtraInitializers);
         axiosInstance;
         sandboxApi;
-        getAnalyticsApiUrl;
-        subscriptionManager;
+        volumeService;
         fs;
         git;
         process;
@@ -215,10 +216,8 @@ let Sandbox = (() => {
         backupState;
         backupCreatedAt;
         autoStopInterval;
-        autoPauseInterval;
         autoArchiveInterval;
         autoDeleteInterval;
-        autoDestroyAt;
         volumes;
         buildInfo;
         createdAt;
@@ -231,28 +230,25 @@ let Sandbox = (() => {
         toolboxProxyUrl;
         infoApi;
         serverApi;
-        systemApi;
-        stateWaiters = [];
-        stateWaiterErrorMessageFns = new WeakMap();
-        subId;
         /**
-         * Creates a new Sandbox instance.
-         *
-         * Internal: obtain sandboxes via {@link Daytona.create}, {@link Daytona.get}, or
-         * {@link Daytona.list} rather than constructing directly.
+         * Creates a new Sandbox instance
          *
          * @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, getAnalyticsApiUrl, subscriptionManager) {
+        constructor(sandboxDto, clientConfig, axiosInstance, sandboxApi, volumeService) {
             this.clientConfig = clientConfig;
             this.axiosInstance = axiosInstance;
             this.sandboxApi = sandboxApi;
-            this.getAnalyticsApiUrl = getAnalyticsApiUrl;
-            this.subscriptionManager = subscriptionManager;
+            this.volumeService = volumeService;
             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));
@@ -262,8 +258,6 @@ 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.
@@ -278,53 +272,6 @@ 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.
          */
@@ -345,6 +292,71 @@ 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.
          *
@@ -482,16 +494,9 @@ let Sandbox = (() => {
                 timeout: timeout * 1000,
             });
             const sandboxDto = response.data;
-            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 forkedSandbox = new Sandbox(sandboxDto, structuredClone(this.clientConfig), Daytona.createAxiosInstance(), this.sandboxApi);
             const timeElapsed = Date.now() - startTime;
-            const remainingTimeout = timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout;
-            await forkedSandbox.waitUntilStarted(remainingTimeout);
+            await forkedSandbox.waitUntilStarted(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
             return forkedSandbox;
         }
         /**
@@ -519,19 +524,34 @@ let Sandbox = (() => {
             }
             const startTime = Date.now();
             const req = { name };
-            const response = await this.sandboxApi.createSandboxSnapshot(this.id, req, undefined, {
+            await this.sandboxApi.createSandboxSnapshot(this.id, req, undefined, {
                 timeout: timeout * 1000,
             });
-            this.processSandboxDto(response.data);
+            await this.refreshData();
             const timeElapsed = Date.now() - startTime;
             const remainingTimeout = timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout;
             await this.waitForSnapshotComplete(remainingTimeout);
         }
         async waitForSnapshotComplete(timeout) {
-            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}`);
+            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);
+                }
+            }
         }
         /**
          * Pauses the Sandbox, freezing all running processes.
@@ -562,48 +582,32 @@ let Sandbox = (() => {
             await this.refreshData();
             const timeElapsed = Date.now() - startTime;
             const remainingTimeout = timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout;
-            // 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}`);
+            await this.waitForPauseComplete(remainingTimeout);
         }
-        /**
-         * 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, wait = false) {
-            if (timeout < 0) {
-                throw new DaytonaValidationError('Timeout must be a non-negative number');
-            }
+        async waitForPauseComplete(timeout) {
+            let checkInterval = 100;
             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);
+            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}`);
                 }
-            }
-            finally {
-                if (this.subId) {
-                    this.subscriptionManager.unsubscribe(this.subId);
-                    this.subId = undefined;
+                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);
             }
         }
+        /**
+         * Deletes the Sandbox.
+         * @returns {Promise<void>}
+         */
+        async delete(timeout = 60) {
+            await this.sandboxApi.deleteSandbox(this.id, undefined, { timeout: timeout * 1000 });
+            this.refreshDataSafe();
+        }
         /**
          * Waits for the Sandbox to reach the 'started' state.
          *
@@ -619,10 +623,26 @@ let Sandbox = (() => {
             if (timeout < 0) {
                 throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
-            if (this.state === SandboxState.STARTED) {
-                return;
+            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);
+                }
             }
-            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.
@@ -639,11 +659,27 @@ 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
-            if (this.state === SandboxState.STOPPED || this.state === SandboxState.DESTROYED) {
-                return;
+            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);
+                }
             }
-            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.
@@ -700,60 +736,6 @@ 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.
          *
@@ -976,13 +958,25 @@ let Sandbox = (() => {
             if (timeout < 0) {
                 throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
-            if (this.state !== SandboxState.RESIZING) {
-                return;
+            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);
+                }
             }
-            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.
@@ -1011,172 +1005,6 @@ 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.
          *
@@ -1184,7 +1012,6 @@ let Sandbox = (() => {
          * @returns {void}
          */
         processSandboxDto(sandboxDto) {
-            const newState = sandboxDto.state;
             this.id = sandboxDto.id;
             this.name = sandboxDto.name;
             this.organizationId = sandboxDto.organizationId;
@@ -1197,17 +1024,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;
@@ -1219,21 +1046,6 @@ 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.
@@ -1241,113 +1053,17 @@ 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.applyState(SandboxState.DESTROYED);
-                    return true;
+                    this.state = SandboxState.DESTROYED;
                 }
-                // 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