From 1b1eeee9828775d1f26d0b13e55dea1ae31ff3d4 Mon Sep 17 00:00:00 2001 From: James Chainey Date: Mon, 15 Dec 2025 12:03:32 -0800 Subject: [PATCH 1/5] add mount inline array syntax for storage objects --- src/sdk.ts | 121 +++++++++++- tests/sdk/devbox-ops.test.ts | 345 +++++++++++++++++++++++++++++++++++ 2 files changed, 460 insertions(+), 6 deletions(-) create mode 100644 tests/sdk/devbox-ops.test.ts diff --git a/src/sdk.ts b/src/sdk.ts index 857d19594..c521de963 100644 --- a/src/sdk.ts +++ b/src/sdk.ts @@ -18,6 +18,103 @@ import type { BlueprintListParams } from './resources/blueprints'; import type { ObjectCreateParams, ObjectListParams } from './resources/objects'; import type { AgentCreateParams, AgentListParams } from './resources/agents'; import { PollingOptions } from './lib/polling'; +import * as Shared from './resources/shared'; + +// ============================================================================ +// SDK-specific mount types for convenient StorageObject mounting +// ============================================================================ + +/** + * A convenient mount format that maps a path to a StorageObject. + * The key is the path on the devbox where the object will be mounted, + * and the value is the StorageObject instance. + * + * @example + * ```typescript + * { '/home/user/config.txt': storageObject } + * ``` + */ +export type SDKObjectMount = { [path: string]: StorageObject }; + +/** + * Union type representing all valid mount inputs for the SDK. + * Accepts both the standard API mount format and the convenient SDKObjectMount format. + */ +export type SDKMountInput = Shared.Mount | SDKObjectMount; + +/** + * Extended DevboxCreateParams that accepts the convenient SDK mount syntax. + * Use this type when creating devboxes through the SDK's DevboxOps.create() method. + */ +export interface SDKDevboxCreateParams extends Omit { + /** + * A list of mounts to be included in the Devbox. + * Accepts both standard API mount format and the convenient `{ path: StorageObject }` syntax. + * + * @example + * ```typescript + * mounts: [ + * { '/home/user/file.txt': storageObject }, + * { type: 'code_mount', repo_name: 'my-repo', repo_owner: 'owner' } + * ] + * ``` + */ + mounts?: Array | null; +} + +/** + * Type guard to check if a mount input is an SDKObjectMount (path-to-StorageObject mapping). + * Standard Shared.Mount types have a 'type' discriminator property, while SDKObjectMount does not. + * + * @param mount - The mount input to check + * @returns true if the mount is an SDKObjectMount + */ +function isSDKObjectMount(mount: SDKMountInput): mount is SDKObjectMount { + return typeof mount === 'object' && mount !== null && !('type' in mount); +} + +/** + * Transforms SDK mount inputs to the API-compatible Shared.Mount format. + * Converts convenient `{ path: StorageObject }` syntax to `ObjectMountParameters`. + * + * @param mounts - Array of SDK mount inputs + * @returns Array of API-compatible mounts + */ +function transformMounts(mounts: Array): Array { + return mounts.flatMap((mount) => { + if (isSDKObjectMount(mount)) { + // Convert { "path": StorageObject } to ObjectMountParameters + return Object.entries(mount).map(([path, obj]) => ({ + type: 'object_mount' as const, + object_id: obj.id, + object_path: path, + })); + } + // Already a standard mount + return mount; + }); +} + +/** + * Transforms SDKDevboxCreateParams to DevboxCreateParams by converting SDK mount syntax. + * + * @param params - SDK devbox creation parameters + * @returns API-compatible devbox creation parameters + */ +function transformSDKDevboxCreateParams(params?: SDKDevboxCreateParams): DevboxCreateParams | undefined { + if (!params) { + return undefined; + } + + if (!params.mounts || params.mounts.length === 0) { + return params as DevboxCreateParams; + } + + return { + ...params, + mounts: transformMounts(params.mounts), + }; +} export * from './index'; @@ -167,8 +264,10 @@ export class DevboxOps { * Create a new Devbox and wait for it to reach the running state. * This is the recommended way to create a devbox as it ensures it's ready to use. * - * See the {@link DevboxOps.create} method for calling this - * @private + * Supports the convenient SDK mount syntax for StorageObjects: + * ```typescript + * mounts: [{ '/path/on/devbox': storageObject }] + * ``` * * @example * ```typescript @@ -176,18 +275,28 @@ export class DevboxOps { * const devbox = await runloop.devbox.create({ name: 'my-devbox' }); * * devbox.cmd.exec('echo "Hello, World!"'); - * ... * ``` * - * @param {DevboxCreateParams} [params] - Parameters for creating the devbox. + * @example + * ```typescript + * // Create devbox with mounted storage object + * const storageObject = await runloop.storageObject.uploadFromFile('./config.txt', 'config.txt'); + * const devbox = await runloop.devbox.create({ + * name: 'devbox-with-file', + * mounts: [{ '/home/user/config.txt': storageObject }] + * }); + * ``` + * + * @param {SDKDevboxCreateParams} [params] - Parameters for creating the devbox, with SDK mount syntax support. * @param {Core.RequestOptions & { polling?: Partial> }} [options] - Request options including polling configuration. * @returns {Promise} A {@link Devbox} instance. */ async create( - params?: DevboxCreateParams, + params?: SDKDevboxCreateParams, options?: Core.RequestOptions & { polling?: Partial> }, ): Promise { - return Devbox.create(this.client, params, options); + const transformedParams = transformSDKDevboxCreateParams(params); + return Devbox.create(this.client, transformedParams, options); } /** diff --git a/tests/sdk/devbox-ops.test.ts b/tests/sdk/devbox-ops.test.ts new file mode 100644 index 000000000..5551674fc --- /dev/null +++ b/tests/sdk/devbox-ops.test.ts @@ -0,0 +1,345 @@ +import { DevboxOps, SDKDevboxCreateParams, SDKMountInput, SDKObjectMount } from '../../src/sdk'; +import { Devbox } from '../../src/sdk/devbox'; +import { StorageObject } from '../../src/sdk/storage-object'; +import type { DevboxView } from '../../src/resources/devboxes/devboxes'; +import * as Shared from '../../src/resources/shared'; + +// Mock the Devbox class +jest.mock('../../src/sdk/devbox'); + +describe('DevboxOps', () => { + let mockClient: any; + let devboxOps: DevboxOps; + let mockDevboxData: DevboxView; + let mockDevboxInstance: Devbox; + + beforeEach(() => { + jest.clearAllMocks(); + + // Create mock client + mockClient = { + devboxes: { + createAndAwaitRunning: jest.fn(), + retrieve: jest.fn(), + list: jest.fn(), + }, + } as any; + + devboxOps = new DevboxOps(mockClient); + + // Mock devbox data + mockDevboxData = { + id: 'devbox-123', + status: 'running', + capabilities: [], + create_time_ms: Date.now(), + end_time_ms: null, + launch_parameters: {}, + metadata: {}, + state_transitions: [], + }; + + // Mock Devbox.create to return a mock Devbox instance + mockDevboxInstance = { id: 'devbox-123', getInfo: jest.fn() } as unknown as Devbox; + jest.spyOn(Devbox as any, 'create').mockResolvedValue(mockDevboxInstance); + }); + + describe('create with SDK mount syntax', () => { + describe('SDKObjectMount transformation', () => { + it('should transform a single SDKObjectMount to ObjectMountParameters', async () => { + // Create a mock StorageObject + const mockStorageObject = { id: 'obj-123' } as StorageObject; + + await devboxOps.create({ + name: 'test-devbox', + mounts: [{ '/home/user/file.txt': mockStorageObject }], + }); + + expect(Devbox.create).toHaveBeenCalledWith( + mockClient, + { + name: 'test-devbox', + mounts: [ + { + type: 'object_mount', + object_id: 'obj-123', + object_path: '/home/user/file.txt', + }, + ], + }, + undefined, + ); + }); + + it('should transform multiple SDKObjectMounts in a single object', async () => { + const mockStorageObject1 = { id: 'obj-123' } as StorageObject; + const mockStorageObject2 = { id: 'obj-456' } as StorageObject; + + await devboxOps.create({ + name: 'test-devbox', + mounts: [ + { + '/home/user/file1.txt': mockStorageObject1, + '/home/user/file2.txt': mockStorageObject2, + }, + ], + }); + + expect(Devbox.create).toHaveBeenCalledWith( + mockClient, + { + name: 'test-devbox', + mounts: expect.arrayContaining([ + { + type: 'object_mount', + object_id: 'obj-123', + object_path: '/home/user/file1.txt', + }, + { + type: 'object_mount', + object_id: 'obj-456', + object_path: '/home/user/file2.txt', + }, + ]), + }, + undefined, + ); + }); + + it('should transform multiple separate SDKObjectMount items', async () => { + const mockStorageObject1 = { id: 'obj-123' } as StorageObject; + const mockStorageObject2 = { id: 'obj-456' } as StorageObject; + + await devboxOps.create({ + name: 'test-devbox', + mounts: [ + { '/home/user/config.txt': mockStorageObject1 }, + { '/home/user/data.json': mockStorageObject2 }, + ], + }); + + expect(Devbox.create).toHaveBeenCalledWith( + mockClient, + { + name: 'test-devbox', + mounts: [ + { + type: 'object_mount', + object_id: 'obj-123', + object_path: '/home/user/config.txt', + }, + { + type: 'object_mount', + object_id: 'obj-456', + object_path: '/home/user/data.json', + }, + ], + }, + undefined, + ); + }); + }); + + describe('mixed mount types', () => { + it('should handle mixed SDK and standard mount types', async () => { + const mockStorageObject = { id: 'obj-123' } as StorageObject; + const standardMount: Shared.CodeMountParameters = { + type: 'code_mount', + repo_name: 'my-repo', + repo_owner: 'owner', + }; + + await devboxOps.create({ + name: 'test-devbox', + mounts: [{ '/home/user/file.txt': mockStorageObject }, standardMount], + }); + + expect(Devbox.create).toHaveBeenCalledWith( + mockClient, + { + name: 'test-devbox', + mounts: [ + { + type: 'object_mount', + object_id: 'obj-123', + object_path: '/home/user/file.txt', + }, + { + type: 'code_mount', + repo_name: 'my-repo', + repo_owner: 'owner', + }, + ], + }, + undefined, + ); + }); + + it('should pass through standard ObjectMountParameters unchanged', async () => { + const standardObjectMount: Shared.ObjectMountParameters = { + type: 'object_mount', + object_id: 'obj-789', + object_path: '/home/user/existing.txt', + }; + + await devboxOps.create({ + name: 'test-devbox', + mounts: [standardObjectMount], + }); + + expect(Devbox.create).toHaveBeenCalledWith( + mockClient, + { + name: 'test-devbox', + mounts: [standardObjectMount], + }, + undefined, + ); + }); + + it('should pass through file_mount unchanged', async () => { + const fileMount: Shared.Mount = { + type: 'file_mount', + files: { + '/home/user/config.json': '{"key": "value"}', + }, + }; + + await devboxOps.create({ + name: 'test-devbox', + mounts: [fileMount], + }); + + expect(Devbox.create).toHaveBeenCalledWith( + mockClient, + { + name: 'test-devbox', + mounts: [fileMount], + }, + undefined, + ); + }); + }); + + describe('edge cases', () => { + it('should handle empty mounts array', async () => { + await devboxOps.create({ + name: 'test-devbox', + mounts: [], + }); + + expect(Devbox.create).toHaveBeenCalledWith( + mockClient, + { + name: 'test-devbox', + mounts: [], + }, + undefined, + ); + }); + + it('should handle undefined mounts', async () => { + await devboxOps.create({ + name: 'test-devbox', + }); + + expect(Devbox.create).toHaveBeenCalledWith( + mockClient, + { + name: 'test-devbox', + }, + undefined, + ); + }); + + it('should handle null mounts', async () => { + await devboxOps.create({ + name: 'test-devbox', + mounts: null, + }); + + expect(Devbox.create).toHaveBeenCalledWith( + mockClient, + { + name: 'test-devbox', + mounts: null, + }, + undefined, + ); + }); + + it('should handle undefined params', async () => { + await devboxOps.create(); + + expect(Devbox.create).toHaveBeenCalledWith(mockClient, undefined, undefined); + }); + + it('should pass through other params unchanged', async () => { + const mockStorageObject = { id: 'obj-123' } as StorageObject; + + await devboxOps.create({ + name: 'test-devbox', + blueprint_id: 'bp-123', + environment_variables: { NODE_ENV: 'production' }, + mounts: [{ '/home/user/file.txt': mockStorageObject }], + metadata: { project: 'demo' }, + }); + + expect(Devbox.create).toHaveBeenCalledWith( + mockClient, + { + name: 'test-devbox', + blueprint_id: 'bp-123', + environment_variables: { NODE_ENV: 'production' }, + mounts: [ + { + type: 'object_mount', + object_id: 'obj-123', + object_path: '/home/user/file.txt', + }, + ], + metadata: { project: 'demo' }, + }, + undefined, + ); + }); + + it('should pass options through to Devbox.create', async () => { + await devboxOps.create({ name: 'test-devbox' }, { polling: { maxAttempts: 10 } }); + + expect(Devbox.create).toHaveBeenCalledWith( + mockClient, + { name: 'test-devbox' }, + { polling: { maxAttempts: 10 } }, + ); + }); + }); + }); + + describe('type inference', () => { + // These tests ensure the types work correctly at compile time + it('should accept SDKDevboxCreateParams type', async () => { + const params: SDKDevboxCreateParams = { + name: 'test-devbox', + mounts: [{ '/path': { id: 'obj-123' } as StorageObject }], + }; + + await devboxOps.create(params); + + expect(Devbox.create).toHaveBeenCalled(); + }); + + it('should accept SDKMountInput array', async () => { + const mockStorageObject = { id: 'obj-123' } as StorageObject; + const mounts: SDKMountInput[] = [ + { '/path1': mockStorageObject }, + { type: 'object_mount', object_id: 'obj-456', object_path: '/path2' }, + ]; + + await devboxOps.create({ name: 'test-devbox', mounts }); + + expect(Devbox.create).toHaveBeenCalled(); + }); + }); +}); + From f8afd8006eec2d1b12c0a9d790425ab4cb0cf341 Mon Sep 17 00:00:00 2001 From: James Chainey Date: Mon, 15 Dec 2025 12:22:10 -0800 Subject: [PATCH 2/5] renamed mount types to something more sensible --- src/sdk.ts | 20 ++++++++++---------- tests/sdk/devbox-ops.test.ts | 14 +++++++------- 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/src/sdk.ts b/src/sdk.ts index c521de963..d23fab91b 100644 --- a/src/sdk.ts +++ b/src/sdk.ts @@ -34,13 +34,13 @@ import * as Shared from './resources/shared'; * { '/home/user/config.txt': storageObject } * ``` */ -export type SDKObjectMount = { [path: string]: StorageObject }; +export type InlineObjectMount = { [path: string]: StorageObject }; /** * Union type representing all valid mount inputs for the SDK. - * Accepts both the standard API mount format and the convenient SDKObjectMount format. + * Accepts both the standard API mount format and the convenient InlineObjectMount format. */ -export type SDKMountInput = Shared.Mount | SDKObjectMount; +export type MountInstance = Shared.Mount | InlineObjectMount; /** * Extended DevboxCreateParams that accepts the convenient SDK mount syntax. @@ -59,17 +59,17 @@ export interface SDKDevboxCreateParams extends Omit | null; + mounts?: Array | null; } /** - * Type guard to check if a mount input is an SDKObjectMount (path-to-StorageObject mapping). - * Standard Shared.Mount types have a 'type' discriminator property, while SDKObjectMount does not. + * Type guard to check if a mount input is an InlineObjectMount (path-to-StorageObject mapping). + * Standard Shared.Mount types have a 'type' discriminator property, while InlineObjectMount does not. * * @param mount - The mount input to check - * @returns true if the mount is an SDKObjectMount + * @returns true if the mount is an InlineObjectMount */ -function isSDKObjectMount(mount: SDKMountInput): mount is SDKObjectMount { +function isInlineObjectMount(mount: MountInstance): mount is InlineObjectMount { return typeof mount === 'object' && mount !== null && !('type' in mount); } @@ -80,9 +80,9 @@ function isSDKObjectMount(mount: SDKMountInput): mount is SDKObjectMount { * @param mounts - Array of SDK mount inputs * @returns Array of API-compatible mounts */ -function transformMounts(mounts: Array): Array { +function transformMounts(mounts: Array): Array { return mounts.flatMap((mount) => { - if (isSDKObjectMount(mount)) { + if (isInlineObjectMount(mount)) { // Convert { "path": StorageObject } to ObjectMountParameters return Object.entries(mount).map(([path, obj]) => ({ type: 'object_mount' as const, diff --git a/tests/sdk/devbox-ops.test.ts b/tests/sdk/devbox-ops.test.ts index 5551674fc..98a2a8a03 100644 --- a/tests/sdk/devbox-ops.test.ts +++ b/tests/sdk/devbox-ops.test.ts @@ -1,4 +1,4 @@ -import { DevboxOps, SDKDevboxCreateParams, SDKMountInput, SDKObjectMount } from '../../src/sdk'; +import { DevboxOps, SDKDevboxCreateParams, MountInstance, InlineObjectMount } from '../../src/sdk'; import { Devbox } from '../../src/sdk/devbox'; import { StorageObject } from '../../src/sdk/storage-object'; import type { DevboxView } from '../../src/resources/devboxes/devboxes'; @@ -45,8 +45,8 @@ describe('DevboxOps', () => { }); describe('create with SDK mount syntax', () => { - describe('SDKObjectMount transformation', () => { - it('should transform a single SDKObjectMount to ObjectMountParameters', async () => { + describe('InlineObjectMount transformation', () => { + it('should transform a single InlineObjectMount to ObjectMountParameters', async () => { // Create a mock StorageObject const mockStorageObject = { id: 'obj-123' } as StorageObject; @@ -71,7 +71,7 @@ describe('DevboxOps', () => { ); }); - it('should transform multiple SDKObjectMounts in a single object', async () => { + it('should transform multiple InlineObjectMounts in a single object', async () => { const mockStorageObject1 = { id: 'obj-123' } as StorageObject; const mockStorageObject2 = { id: 'obj-456' } as StorageObject; @@ -106,7 +106,7 @@ describe('DevboxOps', () => { ); }); - it('should transform multiple separate SDKObjectMount items', async () => { + it('should transform multiple separate InlineObjectMount items', async () => { const mockStorageObject1 = { id: 'obj-123' } as StorageObject; const mockStorageObject2 = { id: 'obj-456' } as StorageObject; @@ -329,9 +329,9 @@ describe('DevboxOps', () => { expect(Devbox.create).toHaveBeenCalled(); }); - it('should accept SDKMountInput array', async () => { + it('should accept MountInstance array', async () => { const mockStorageObject = { id: 'obj-123' } as StorageObject; - const mounts: SDKMountInput[] = [ + const mounts: MountInstance[] = [ { '/path1': mockStorageObject }, { type: 'object_mount', object_id: 'obj-456', object_path: '/path2' }, ]; From e266629664971f4ca150c9147d0cd52f3bc836f9 Mon Sep 17 00:00:00 2001 From: James Chainey Date: Mon, 15 Dec 2025 12:38:09 -0800 Subject: [PATCH 3/5] fixed test types --- tests/sdk/devbox-ops.test.ts | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/tests/sdk/devbox-ops.test.ts b/tests/sdk/devbox-ops.test.ts index 98a2a8a03..27bbb4d05 100644 --- a/tests/sdk/devbox-ops.test.ts +++ b/tests/sdk/devbox-ops.test.ts @@ -143,7 +143,7 @@ describe('DevboxOps', () => { describe('mixed mount types', () => { it('should handle mixed SDK and standard mount types', async () => { const mockStorageObject = { id: 'obj-123' } as StorageObject; - const standardMount: Shared.CodeMountParameters = { + const standardMount: Shared.Mount.CodeMount = { type: 'code_mount', repo_name: 'my-repo', repo_owner: 'owner', @@ -176,7 +176,7 @@ describe('DevboxOps', () => { }); it('should pass through standard ObjectMountParameters unchanged', async () => { - const standardObjectMount: Shared.ObjectMountParameters = { + const standardObjectMount: Shared.Mount.ObjectMount = { type: 'object_mount', object_id: 'obj-789', object_path: '/home/user/existing.txt', @@ -198,11 +198,10 @@ describe('DevboxOps', () => { }); it('should pass through file_mount unchanged', async () => { - const fileMount: Shared.Mount = { + const fileMount: Shared.Mount.FileMount = { type: 'file_mount', - files: { - '/home/user/config.json': '{"key": "value"}', - }, + content: '{"key": "value"}', + target: '/home/user/config.json', }; await devboxOps.create({ From f15b53984a8ec3cbae4aeb4652ba70aea6d8ddb8 Mon Sep 17 00:00:00 2001 From: James Chainey Date: Mon, 15 Dec 2025 12:47:23 -0800 Subject: [PATCH 4/5] addressed ant nits --- src/sdk.ts | 53 +++++++++++++++++++++++++++++------- tests/sdk/devbox-ops.test.ts | 9 +++--- 2 files changed, 48 insertions(+), 14 deletions(-) diff --git a/src/sdk.ts b/src/sdk.ts index d23fab91b..c1bf964e9 100644 --- a/src/sdk.ts +++ b/src/sdk.ts @@ -70,7 +70,19 @@ export interface SDKDevboxCreateParams extends Omit 0 && + values.every((v) => v && typeof v === 'object' && 'id' in v && typeof v.id === 'string') + ); } /** @@ -84,11 +96,19 @@ function transformMounts(mounts: Array): Array { return mounts.flatMap((mount) => { if (isInlineObjectMount(mount)) { // Convert { "path": StorageObject } to ObjectMountParameters - return Object.entries(mount).map(([path, obj]) => ({ - type: 'object_mount' as const, - object_id: obj.id, - object_path: path, - })); + return Object.entries(mount).map(([path, obj]) => { + if (!obj || typeof obj !== 'object' || typeof obj.id !== 'string') { + throw new Error( + `Invalid mount value for path "${path}": expected a StorageObject with an 'id' property, ` + + `got ${obj === null ? 'null' : typeof obj}`, + ); + } + return { + type: 'object_mount' as const, + object_id: obj.id, + object_path: path, + }; + }); } // Already a standard mount return mount; @@ -106,13 +126,26 @@ function transformSDKDevboxCreateParams(params?: SDKDevboxCreateParams): DevboxC return undefined; } - if (!params.mounts || params.mounts.length === 0) { - return params as DevboxCreateParams; + // Extract mounts and rest of params + const { mounts, ...rest } = params; + + // If mounts is undefined, don't include it in the result (preserves the optional property) + if (mounts === undefined) { + return rest as DevboxCreateParams; + } + + // If mounts is null or empty array, pass through as-is with correct type + if (mounts === null || mounts.length === 0) { + return { + ...rest, + mounts: mounts as Array | null, + }; } + // Transform non-empty mounts array return { - ...params, - mounts: transformMounts(params.mounts), + ...rest, + mounts: transformMounts(mounts), }; } diff --git a/tests/sdk/devbox-ops.test.ts b/tests/sdk/devbox-ops.test.ts index 27bbb4d05..80faf5182 100644 --- a/tests/sdk/devbox-ops.test.ts +++ b/tests/sdk/devbox-ops.test.ts @@ -4,9 +4,6 @@ import { StorageObject } from '../../src/sdk/storage-object'; import type { DevboxView } from '../../src/resources/devboxes/devboxes'; import * as Shared from '../../src/resources/shared'; -// Mock the Devbox class -jest.mock('../../src/sdk/devbox'); - describe('DevboxOps', () => { let mockClient: any; let devboxOps: DevboxOps; @@ -41,7 +38,11 @@ describe('DevboxOps', () => { // Mock Devbox.create to return a mock Devbox instance mockDevboxInstance = { id: 'devbox-123', getInfo: jest.fn() } as unknown as Devbox; - jest.spyOn(Devbox as any, 'create').mockResolvedValue(mockDevboxInstance); + jest.spyOn(Devbox, 'create').mockResolvedValue(mockDevboxInstance); + }); + + afterEach(() => { + jest.restoreAllMocks(); }); describe('create with SDK mount syntax', () => { From cb59f278b01994767c8681135f72df938dc6047a Mon Sep 17 00:00:00 2001 From: James Chainey Date: Mon, 15 Dec 2025 13:15:35 -0800 Subject: [PATCH 5/5] removed unused import --- tests/sdk/devbox-ops.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/sdk/devbox-ops.test.ts b/tests/sdk/devbox-ops.test.ts index 80faf5182..c6f7d6c94 100644 --- a/tests/sdk/devbox-ops.test.ts +++ b/tests/sdk/devbox-ops.test.ts @@ -1,4 +1,4 @@ -import { DevboxOps, SDKDevboxCreateParams, MountInstance, InlineObjectMount } from '../../src/sdk'; +import { DevboxOps, SDKDevboxCreateParams, MountInstance } from '../../src/sdk'; import { Devbox } from '../../src/sdk/devbox'; import { StorageObject } from '../../src/sdk/storage-object'; import type { DevboxView } from '../../src/resources/devboxes/devboxes';