fix(sdk): Fix exports of the SDK not getting clobbered

.github/workflows/build-package-test.yml

@@ -0,0 +1,29 @@
+name: Build Package Test
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build-package-test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: Checkout
+        uses: runloopai/checkout@main
+
+      - name: Setup Node
+        uses: runloopai/setup-node@main
+        with:
+          node-version: '20'
+          cache: 'yarn'
+
+      - name: Install dependencies
+        run: yarn --frozen-lockfile
+
+      - name: Run build package test
+        run: yarn test:built-package
+

jest.config.ts

@@ -1,11 +1,12 @@
 import type { JestConfigWithTsJest } from 'ts-jest';
 
 const runSmoketests = process.env['RUN_SMOKETESTS'] === '1';
+const runBuiltPackageTest = process.env['RUN_BUILT_PACKAGE_TEST'] === '1';
 
 const config: JestConfigWithTsJest = {
   preset: 'ts-jest/presets/default-esm',
   testEnvironment: 'node',
-  testTimeout: runSmoketests ? 300000 : 120000, // 5 minutes for smoke tests, 2 minutes for regular tests
+  testTimeout: runSmoketests || runBuiltPackageTest ? 300000 : 120000, // 5 minutes for smoke tests, 2 minutes for regular tests
   transform: {
     '^.+\\.(t|j)sx?$': ['@swc/jest', { sourceMaps: 'inline' }],
   },
@@ -23,12 +24,17 @@ const config: JestConfigWithTsJest = {
   testPathIgnorePatterns: [
     'scripts',
     // When running smoke tests, ignore regular tests; when running regular tests, ignore smoke tests
-    ...(runSmoketests ?
-      ['<rootDir>/tests/(?!smoketests).*'] // Ignore all test files except those in smoketests/
+    ...(runSmoketests && !runBuiltPackageTest ?
+      [
+        '<rootDir>/tests/(?!smoketests).*', // Ignore all test files except those in smoketests/
+        '<rootDir>/tests/smoketests/build-package.test.ts', // Exclude build-package test from regular smoke test runs
+      ]
+    : runBuiltPackageTest ?
+      [] // Don't ignore anything when running built-package test
     : ['<rootDir>/tests/smoketests/']), // Ignore smoke tests when running regular tests
   ],
   // Add display name for smoke tests to make it clearer in output
-  ...(runSmoketests && { displayName: 'Smoke Tests' }),
+  ...((runSmoketests || runBuiltPackageTest) && { displayName: 'Smoke Tests' }),
 };
 
 export default config;

package.json

@@ -22,6 +22,7 @@
     "test:objects": "RUN_SMOKETESTS=1 jest --config jest.config.objects.js --verbose",
     "test:objects-coverage": "RUN_SMOKETESTS=1 jest --verbose --config jest.config.objects.js --coverage --coverageReporters=text --coverageReporters=json-summary",
     "test:objects-coverage:html": "RUN_SMOKETESTS=1 jest --verbose --config jest.config.objects.js --coverage --coverageReporters=html --coverageReporters=text && open coverage-objects/index.html",
+    "test:built-package": "yarn build && RUN_BUILT_PACKAGE_TEST=1 jest --verbose tests/smoketests/build-package.test.ts",
     "build": "./scripts/build",
     "prepublishOnly": "echo 'to publish, run yarn build && (cd dist; yarn publish)' && exit 1",
     "format": "prettier --write --cache --cache-strategy metadata . !dist",

scripts/utils/fix-index-exports.cjs

@@ -7,8 +7,10 @@ const sdkJs =
   : path.resolve(__dirname, '..', '..', 'dist', 'sdk.js');
 
 let before = fs.readFileSync(sdkJs, 'utf8');
+// Match exports.default = <anything> and preserve all existing exports
+// by ensuring module.exports points to the exports object instead of replacing it
 let after = before.replace(
-  /^\s*exports\.default\s*=\s*(\w+)/m,
-  'exports = module.exports = $1;\nexports.default = $1',
+  /^\s*exports\.default\s*=\s*([^;]+);/m,
+  'module.exports = exports;\nexports.default = $1;',
 );
 fs.writeFileSync(sdkJs, after, 'utf8');

tests/smoketests/build-package.test.ts

@@ -0,0 +1,155 @@
+import {
+  RunloopSDK,
+  RunloopAPI,
+  Devbox,
+  Blueprint,
+  Snapshot,
+  StorageObject,
+  DevboxOps,
+  BlueprintOps,
+  SnapshotOps,
+  StorageObjectOps,
+  DevboxCmdOps,
+  DevboxFileOps,
+  DevboxNetOps,
+  Execution,
+  ExecutionResult,
+  type ExecuteStreamingCallbacks,
+  type ClientOptions,
+} from '../../dist/sdk';
+
+describe('smoketest: built package import', () => {
+  let sdk: RunloopSDK;
+
+  beforeAll(() => {
+    // Initialize SDK from built package - using dummy token since we're only testing imports/types
+    sdk = new RunloopSDK({
+      bearerToken: 'dummy-token-for-import-test',
+      baseURL: 'https://api.runloop.ai',
+      timeout: 120_000,
+      maxRetries: 1,
+    });
+  });
+
+  describe('RunloopSDK from built package', () => {
+    test('should create SDK instance from built package', () => {
+      expect(sdk).toBeDefined();
+      expect(sdk.devbox).toBeDefined();
+      expect(sdk.blueprint).toBeDefined();
+      expect(sdk.snapshot).toBeDefined();
+      expect(sdk.storageObject).toBeDefined();
+      expect(sdk.api).toBeDefined();
+    });
+
+    test('should provide access to legacy API', () => {
+      expect(sdk.api).toBeDefined();
+      expect(sdk.api.devboxes).toBeDefined();
+      expect(sdk.api.blueprints).toBeDefined();
+      expect(sdk.api.objects).toBeDefined();
+    });
+
+    test('should verify RunloopSDK namespace exports are available', () => {
+      // Test that namespace exports are accessible
+      // These are exported from the RunloopSDK namespace
+      expect(DevboxOps).toBeDefined();
+      expect(BlueprintOps).toBeDefined();
+      expect(SnapshotOps).toBeDefined();
+      expect(StorageObjectOps).toBeDefined();
+      expect(Devbox).toBeDefined();
+      expect(Blueprint).toBeDefined();
+      expect(Snapshot).toBeDefined();
+      expect(StorageObject).toBeDefined();
+    });
+
+    test('should verify additional SDK classes are available', () => {
+      expect(DevboxCmdOps).toBeDefined();
+      expect(DevboxFileOps).toBeDefined();
+      expect(DevboxNetOps).toBeDefined();
+      expect(Execution).toBeDefined();
+      expect(ExecutionResult).toBeDefined();
+    });
+
+    test('should verify types are available', () => {
+      // Type check - if this compiles, the type is available
+      const callback: ExecuteStreamingCallbacks = {
+        stdout: () => {},
+        stderr: () => {},
+        output: () => {},
+      };
+      expect(callback).toBeDefined();
+      expect(typeof callback.stdout).toBe('function');
+      expect(typeof callback.stderr).toBe('function');
+      expect(typeof callback.output).toBe('function');
+    });
+
+    test('should allow wrapping runloop types', () => {
+      // Test that types can be imported and used for type annotations
+      const options: ClientOptions = {
+        bearerToken: 'test-token',
+        baseURL: 'https://api.runloop.ai',
+        timeout: 120_000,
+        maxRetries: 1,
+      };
+      expect(options).toBeDefined();
+      expect(options.bearerToken).toBeDefined();
+      expect(options.baseURL).toBeDefined();
+
+      // Verify type wrapping works by creating a wrapper function
+      function createSDKWithOptions(opts: ClientOptions): RunloopSDK {
+        return new RunloopSDK(opts);
+      }
+      const wrappedSDK = createSDKWithOptions(options);
+      expect(wrappedSDK).toBeInstanceOf(RunloopSDK);
+    });
+
+    test('should verify RunloopAPI namespace and nested resources', () => {
+      expect(RunloopAPI).toBeDefined();
+      expect(RunloopAPI.Devboxes).toBeDefined();
+      expect(RunloopAPI.Blueprints).toBeDefined();
+      expect(RunloopAPI.Objects).toBeDefined();
+      expect(RunloopAPI.Secrets).toBeDefined();
+      expect(RunloopAPI.Agents).toBeDefined();
+      expect(RunloopAPI.Benchmarks).toBeDefined();
+      expect(RunloopAPI.Scenarios).toBeDefined();
+      expect(RunloopAPI.Repositories).toBeDefined();
+    });
+
+    test('should allow creating new types based on execution.result() return type', () => {
+      // Extract the return type from execution.result()
+      // execution.result() returns Promise<ExecutionResult>
+      type ExecutionResultType = Awaited<ReturnType<Execution['result']>>;
+
+      // Create a new type based on the extracted type
+      type WrappedExecutionResult = {
+        result: ExecutionResultType;
+        timestamp: number;
+        metadata?: Record<string, unknown>;
+      };
+
+      // Verify the type works by creating an instance
+      // Note: We can't actually call execution.result() without a real execution,
+      // but we can verify the type extraction works by using ExecutionResult directly
+      const mockResult = new ExecutionResult(sdk.api, 'devbox-123', 'execution-456', {
+        execution_id: 'execution-456',
+        devbox_id: 'devbox-123',
+        status: 'completed',
+        exit_code: 0,
+      } as any);
+
+      const wrapped: WrappedExecutionResult = {
+        result: mockResult,
+        timestamp: Date.now(),
+        metadata: { test: true },
+      };
+
+      expect(wrapped).toBeDefined();
+      expect(wrapped.result).toBeInstanceOf(ExecutionResult);
+      expect(wrapped.timestamp).toBeGreaterThan(0);
+      expect(wrapped.metadata?.['test']).toBe(true);
+
+      // Verify the type is correctly inferred
+      const resultType: ExecutionResultType = mockResult;
+      expect(resultType).toBeInstanceOf(ExecutionResult);
+    });
+  });
+});

tsconfig.json

@@ -1,6 +1,6 @@
 {
   "include": ["src", "tests", "examples"],
-  "exclude": ["src/_shims/**/*-deno.ts"],
+  "exclude": ["src/_shims/**/*-deno.ts", "tests/smoketests/build-package.test.ts"],
   "compilerOptions": {
     "target": "es2020",
     "lib": ["es2020"],