@liquidmetal-ai/precip 1.0.0

package/src/sandbox/bridges/bucket.test.ts

@@ -0,0 +1,300 @@
+/**
+ * Test storage bridge with mock bucket
+ */
+
+import { describe, it, expect } from 'vitest';
+import { executeWithAsyncHost } from '../test-helper.js';
+import { installStorage, type StorageMountInfo } from './storage.js';
+
+// Mock Bucket that returns a ReadableStream
+function createMockBucket(files: Record<string, string>) {
+  return {
+    async get(key: string) {
+      const content = files[key];
+      if (!content) return null;
+
+      // Create a ReadableStream from the content
+      const encoder = new TextEncoder();
+      const data = encoder.encode(content);
+
+      // Simulate chunked delivery (small chunks to test coalescing)
+      const chunkSize = 100; // Small chunks to test coalescing
+      let offset = 0;
+
+      const stream = new ReadableStream<Uint8Array>({
+        pull(controller) {
+          if (offset >= data.length) {
+            controller.close();
+            return;
+          }
+          const chunk = data.slice(offset, offset + chunkSize);
+          controller.enqueue(chunk);
+          offset += chunkSize;
+        }
+      });
+
+      return {
+        key,
+        body: stream,
+        size: data.length,
+        uploaded: new Date(),
+        httpMetadata: { contentType: 'application/json' }
+      };
+    },
+
+    async put(key: string, content: string) {
+      files[key] = content;
+    },
+
+    async list(options?: { prefix?: string; limit?: number }) {
+      const prefix = options?.prefix || '';
+      const objects = Object.keys(files)
+        .filter(k => k.startsWith(prefix))
+        .map(key => ({
+          key,
+          size: files[key].length,
+          uploaded: new Date()
+        }));
+      return { objects, truncated: false };
+    },
+
+    async delete(key: string) {
+      delete files[key];
+    }
+  };
+}
+
+describe('Storage Bridge', () => {
+  it('should read file with .text()', async () => {
+    const files = {
+      'test.txt': 'Hello, World!'
+    };
+    const mockBucket = createMockBucket(files);
+    const storageMounts = new Map<string, StorageMountInfo>([
+      ['data', { name: 'data', type: 'bucket', resource: mockBucket as any }]
+    ]);
+
+    const result = await executeWithAsyncHost(
+      `
+      const obj = await read("/data/test.txt");
+      return await obj.text();
+    `,
+      {},
+      {
+        bridgeInstallers: [ctx => installStorage(ctx, storageMounts)]
+      }
+    );
+
+    console.log('text() result:', result);
+    expect(result.success).toBe(true);
+    expect(result.result).toBe('Hello, World!');
+  });
+
+  it('should read file with .json()', async () => {
+    const files = {
+      'data.json': JSON.stringify({ name: 'Test', value: 42 })
+    };
+    const mockBucket = createMockBucket(files);
+    const storageMounts = new Map<string, StorageMountInfo>([
+      ['data', { name: 'data', type: 'bucket', resource: mockBucket as any }]
+    ]);
+
+    const result = await executeWithAsyncHost(
+      `
+      const obj = await read("/data/data.json");
+      return await obj.json();
+    `,
+      {},
+      {
+        bridgeInstallers: [ctx => installStorage(ctx, storageMounts)]
+      }
+    );
+
+    console.log('json() result:', result);
+    expect(result.success).toBe(true);
+    expect(result.result).toEqual({ name: 'Test', value: 42 });
+  });
+
+  it('should stream file with body.getReader()', async () => {
+    // Create a larger file to test streaming and coalescing
+    const largeContent = 'X'.repeat(5000); // 5KB - will be chunked into 50 x 100-byte chunks
+    const files = {
+      'large.txt': largeContent
+    };
+    const mockBucket = createMockBucket(files);
+    const storageMounts = new Map<string, StorageMountInfo>([
+      ['data', { name: 'data', type: 'bucket', resource: mockBucket as any }]
+    ]);
+
+    const result = await executeWithAsyncHost(
+      `
+      const obj = await read("/data/large.txt");
+      const reader = obj.body.getReader();
+      const decoder = new TextDecoder();
+      
+      let totalBytes = 0;
+      let chunks = 0;
+      let content = '';
+      
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        totalBytes += value.length;
+        chunks++;
+        content += decoder.decode(value, { stream: true });
+      }
+      
+      return { totalBytes, chunks, contentLength: content.length, matches: content === '${largeContent}' };
+    `,
+      {},
+      {
+        bridgeInstallers: [ctx => installStorage(ctx, storageMounts)],
+        timeoutMs: 10000
+      }
+    );
+
+    console.log('stream result:', result);
+    expect(result.success).toBe(true);
+    expect(result.result.totalBytes).toBe(5000);
+    expect(result.result.matches).toBe(true);
+
+    // With 16KB coalescing and 100-byte source chunks, we should get fewer chunks
+    // (though 5KB is below the 16KB threshold so might still be multiple)
+    console.log(`Chunks: ${result.result.chunks} (coalesced from 50 source chunks)`);
+  });
+
+  it('should have Response-like properties', async () => {
+    const files = {
+      'test.txt': 'Hello'
+    };
+    const mockBucket = createMockBucket(files);
+    const storageMounts = new Map<string, StorageMountInfo>([
+      ['data', { name: 'data', type: 'bucket', resource: mockBucket as any }]
+    ]);
+
+    const result = await executeWithAsyncHost(
+      `
+      const obj = await read("/data/test.txt");
+      return {
+        key: obj.key,
+        size: obj.size,
+        ok: obj.ok,
+        status: obj.status,
+        hasBody: obj.body !== null,
+        hasText: typeof obj.text === 'function',
+        hasJson: typeof obj.json === 'function',
+        contentType: obj.headers.get('content-type')
+      };
+    `,
+      {},
+      {
+        bridgeInstallers: [ctx => installStorage(ctx, storageMounts)]
+      }
+    );
+
+    console.log('properties result:', result);
+    expect(result.success).toBe(true);
+    expect(result.result.key).toBe('/data/test.txt');
+    expect(result.result.size).toBe(5);
+    expect(result.result.ok).toBe(true);
+    expect(result.result.status).toBe(200);
+    expect(result.result.hasBody).toBe(true);
+    expect(result.result.hasText).toBe(true);
+    expect(result.result.hasJson).toBe(true);
+    expect(result.result.contentType).toBe('application/json');
+  });
+
+  it('should handle file not found', async () => {
+    const files = {};
+    const mockBucket = createMockBucket(files);
+    const storageMounts = new Map<string, StorageMountInfo>([
+      ['data', { name: 'data', type: 'bucket', resource: mockBucket as any }]
+    ]);
+
+    const result = await executeWithAsyncHost(
+      `
+      try {
+        await read("/data/nonexistent.txt");
+        return { error: false };
+      } catch (e) {
+        return { error: true, message: String(e) };
+      }
+    `,
+      {},
+      {
+        bridgeInstallers: [ctx => installStorage(ctx, storageMounts)]
+      }
+    );
+
+    console.log('not found result:', result);
+    expect(result.success).toBe(true);
+    expect(result.result.error).toBe(true);
+    expect(result.result.message).toContain('not found');
+  });
+
+  it('should write and list files', async () => {
+    const files: Record<string, string> = {};
+    const mockBucket = createMockBucket(files);
+    const storageMounts = new Map<string, StorageMountInfo>([
+      ['data', { name: 'data', type: 'bucket', resource: mockBucket as any, mode: 'rw' }]
+    ]);
+
+    const result = await executeWithAsyncHost(
+      `
+      // Write some files
+      await write("/data/file1.txt", "content1");
+      await write("/data/file2.txt", "content2");
+      await write("/data/subdir/file3.txt", "content3");
+      
+      // List all files
+      const all = await list("/data/");
+      
+      // List with prefix
+      const subdir = await list("/data/subdir/");
+      
+      return {
+        allCount: all.count,
+        subdirCount: subdir.count,
+        allKeys: all.files.map(f => f.key)
+      };
+    `,
+      {},
+      {
+        bridgeInstallers: [ctx => installStorage(ctx, storageMounts)]
+      }
+    );
+
+    console.log('write/list result:', result);
+    expect(result.success).toBe(true);
+    expect(result.result.allCount).toBe(3);
+    expect(result.result.subdirCount).toBe(1);
+  });
+
+  it('should reject writes on read-only mounts', async () => {
+    const files: Record<string, string> = {};
+    const mockBucket = createMockBucket(files);
+    const storageMounts = new Map<string, StorageMountInfo>([
+      ['data', { name: 'data', type: 'bucket', resource: mockBucket as any }] // no mode = read-only
+    ]);
+
+    const result = await executeWithAsyncHost(
+      `
+      try {
+        await write("/data/test.txt", "content");
+        return { error: false };
+      } catch (e) {
+        return { error: true, message: String(e) };
+      }
+    `,
+      {},
+      {
+        bridgeInstallers: [ctx => installStorage(ctx, storageMounts)]
+      }
+    );
+
+    console.log('read-only write result:', result);
+    expect(result.success).toBe(true);
+    expect(result.result.error).toBe(true);
+    expect(result.result.message).toContain('read-only');
+  });
+});

package/src/sandbox/bridges/cleanup-reproduction.test.ts

@@ -0,0 +1,225 @@
+/**
+ * Tests for cleanup handling when sandbox code has unfinished async operations
+ *
+ * These scenarios previously caused JS_FreeRuntime assertion failures because:
+ * 1. A fetch request is in progress
+ * 2. The sandbox times out or throws an error
+ * 3. The underlying Response and ReadableStream objects are not aborted/closed
+ * 4. Internal stream operations leave GC objects alive
+ * 5. JS_FreeRuntime() would find non-empty GC object lists
+ *
+ * The fix: sandbox.ts now detects lingering promise objects in the GC list
+ * and skips runtime disposal in those cases, accepting a small memory leak
+ * instead of triggering the assertion.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { executeWithAsyncHost } from '../test-helper.js';
+import { createHttpbinMocks } from '../test-mocks.js';
+
+let mockFetch: any;
+
+function setupMockFetch() {
+  const mocks = createHttpbinMocks();
+  mockFetch = vi.fn(async (url: string, _init?: RequestInit) => {
+    const urlKey = url.split('?')[0];
+    const mock = mocks.get(urlKey);
+    if (!mock) {
+      throw new Error(`No mock for: ${urlKey}`);
+    }
+    if (mock.delay) {
+      await new Promise(resolve => setTimeout(resolve, mock.delay));
+    }
+    return new Response(mock.body, {
+      status: mock.status ?? 200,
+      statusText: mock.statusText ?? 'OK',
+      headers: new Headers(mock.headers)
+    });
+  });
+  globalThis.fetch = mockFetch;
+}
+
+function restoreFetch() {
+  vi.restoreAllMocks();
+}
+
+describe('Cleanup - Reproduce Assertion Failure', () => {
+  beforeEach(() => setupMockFetch());
+  afterEach(() => restoreFetch());
+
+  it('should handle timeout during fetch with active stream reader', async () => {
+    // This simulates a slow fetch that times out while reading
+    const code = `
+      const response = await fetch('https://httpbin.org/delay/10');
+      const reader = response.body.getReader();
+
+      let chunks = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks++;
+      }
+
+      return chunks
+    `;
+
+    const result = await executeWithAsyncHost(
+      code,
+      {},
+      {
+        timeoutMs: 500 // Much shorter than the 10s delay
+      }
+    );
+
+    // The execution should fail due to timeout
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/timeout|interrupted/);
+
+    // The cleanup now detects lingering GC objects and skips runtime disposal
+    // to avoid the assertion (accepting a memory leak in this edge case)
+  }, 10000);
+
+  it('should handle error during stream read', async () => {
+    // This uses a small timeout but still starts reading
+    const code = `
+      const response = await fetch('https://httpbin.org/delay/5');
+      const reader = response.body.getReader();
+
+      // Start reading but never finish due to timeout
+      const { value } = await reader.read();
+      return value.length
+    `;
+
+    const result = await executeWithAsyncHost(
+      code,
+      {},
+      {
+        timeoutMs: 500
+      }
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  }, 10000);
+
+  it('should handle multiple concurrent fetches with timeout', async () => {
+    const code = `
+      // Start multiple slow fetches
+      const promises = [
+        fetch('https://httpbin.org/delay/5'),
+        fetch('https://httpbin.org/delay/5'),
+        fetch('https://httpbin.org/delay/5')
+      ];
+
+      // Timeout before any complete
+      const results = await Promise.all(promises);
+      return results.length
+    `;
+
+    const result = await executeWithAsyncHost(
+      code,
+      {},
+      {
+        timeoutMs: 1000
+      }
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  }, 15000);
+
+  it('should handle partial stream read then timeout', async () => {
+    const code = `
+      const response = await fetch('https://httpbin.org/stream-bytes/10000');
+      const reader = response.body.getReader();
+
+      let total = 0;
+      // Read a few chunks
+      for (let i = 0; i < 5; i++) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        total += value.length;
+      }
+
+      // Now simulate a delay (in real scenario, could be slow processing)
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      return total
+    `;
+
+    const result = await executeWithAsyncHost(
+      code,
+      {},
+      {
+        timeoutMs: 1000
+      }
+    );
+
+    expect(result.success).toBe(false);
+  }, 15000);
+
+  it('should properly clean up after successful fetch', async () => {
+    // This test should pass - normal case where fetch completes successfully
+    const code = `
+      const response = await fetch('https://httpbin.org/uuid');
+      const reader = response.body.getReader();
+
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+
+      // Convert Uint8Array to string
+      let text = '';
+      for (const chunk of chunks) {
+        text += new TextDecoder().decode(chunk);
+      }
+
+      return text
+    `;
+
+    const result = await executeWithAsyncHost(
+      code,
+      {},
+      {
+        timeoutMs: 10000
+      }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBeDefined();
+    expect(typeof result.result).toBe('string');
+  }, 15000);
+
+  it('should handle many rapid executions without leaks', async () => {
+    // Run the sandbox multiple times to check for cumulative leaks
+    const iterations = 50;
+
+    for (let i = 0; i < iterations; i++) {
+      const code = `
+        const response = await fetch('https://httpbin.org/uuid');
+        return await response.text()
+      `;
+
+      const result = await executeWithAsyncHost(
+        code,
+        {},
+        {
+          timeoutMs: 5000
+        }
+      );
+
+      if (i === 0) {
+        // First one might succeed
+        // Subsequent ones might hit rate limits or time out
+      }
+      // All should complete without crashing (even if they fail)
+      expect(result.success !== undefined).toBe(true);
+    }
+
+    // If we get here without assertion error, cleanup is working
+    expect(true).toBe(true);
+  }, 60000);
+});

package/src/sandbox/bridges/console-multiple.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect } from 'vitest';
+import { executeWithAsyncHost } from '../test-helper.js';
+
+describe('Console Bridge - Multiple Calls', () => {
+  it('should capture ALL console.log calls (10 times)', async () => {
+    const code = `
+      console.log('Line 1');
+      console.log('Line 2');
+      console.log('Line 3');
+      console.log('Line 4');
+      console.log('Line 5');
+      console.log('Line 6');
+      console.log('Line 7');
+      console.log('Line 8');
+      console.log('Line 9');
+      console.log('Line 10');
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    console.log('Console output:', result.consoleOutput);
+    expect(result.consoleOutput).toBeDefined();
+    expect(result.consoleOutput).toHaveLength(10);
+    for (let i = 1; i <= 10; i++) {
+      expect(result.consoleOutput).toContain(`Line ${i}`);
+    }
+  });
+
+  it('should capture console.log in a loop (20 iterations)', async () => {
+    const code = `
+      for (let i = 0; i < 20; i++) {
+        console.log('Iteration', i);
+      }
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toBeDefined();
+    expect(result.consoleOutput).toHaveLength(20);
+    for (let i = 0; i < 20; i++) {
+      expect(result.consoleOutput[i]).toContain('Iteration');
+      expect(result.consoleOutput[i]).toContain(String(i));
+    }
+  });
+
+  it('should capture console.log with different data types', async () => {
+    const code = `
+      console.log('String:', 'hello');
+      console.log('Number:', 42);
+      console.log('Boolean:', true);
+      console.log('Object:', { a: 1, b: 2 });
+      console.log('Array:', [1, 2, 3]);
+      console.log('Null:', null);
+      console.log('Undefined:', undefined);
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toBeDefined();
+    expect(result.consoleOutput).toHaveLength(7);
+
+    expect(result.consoleOutput[0]).toContain('String:');
+    expect(result.consoleOutput[0]).toContain('hello');
+
+    expect(result.consoleOutput[1]).toContain('Number:');
+    expect(result.consoleOutput[1]).toContain('42');
+
+    expect(result.consoleOutput[2]).toContain('Boolean:');
+    expect(result.consoleOutput[2]).toContain('true');
+
+    expect(result.consoleOutput[3]).toContain('Object:');
+    expect(result.consoleOutput[3]).toContain('a');
+    expect(result.consoleOutput[3]).toContain('1');
+
+    expect(result.consoleOutput[4]).toContain('Array:');
+
+    expect(result.consoleOutput[5]).toContain('Null:');
+    expect(result.consoleOutput[5]).toContain('null');
+
+    expect(result.consoleOutput[6]).toContain('Undefined:');
+    expect(result.consoleOutput[6]).toContain('undefined');
+  });
+
+  it('should capture console.log in async function with multiple calls', async () => {
+    const code = `
+      async function process() {
+        console.log('Step 1: Start');
+        await Promise.resolve();
+        console.log('Step 2: Middle');
+        await Promise.resolve();
+        console.log('Step 3: End');
+        return 'complete';
+      }
+      return await process()
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toBeDefined();
+    expect(result.consoleOutput).toHaveLength(3);
+    expect(result.consoleOutput).toContain('Step 1: Start');
+    expect(result.consoleOutput).toContain('Step 2: Middle');
+    expect(result.consoleOutput).toContain('Step 3: End');
+  });
+
+  it('should capture console.log interleaved with code', async () => {
+    const code = `
+      let sum = 0;
+      console.log('Starting calculation');
+      for (let i = 1; i <= 5; i++) {
+        sum += i;
+        console.log('Added', i, 'Sum is now', sum);
+      }
+      console.log('Final sum:', sum);
+      return sum
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toBeDefined();
+    expect(result.consoleOutput).toHaveLength(7);
+
+    expect(result.consoleOutput[0]).toContain('Starting calculation');
+
+    // Check that we logged each iteration
+    const logs = result.consoleOutput.join('\n');
+    expect(logs).toContain('Added 1');
+    expect(logs).toContain('Added 2');
+    expect(logs).toContain('Added 3');
+    expect(logs).toContain('Added 4');
+    expect(logs).toContain('Added 5');
+
+    expect(result.consoleOutput[6]).toContain('Final sum:');
+    expect(result.consoleOutput[6]).toContain('15');
+  });
+
+  it('should preserve order of console.log calls', async () => {
+    const code = `
+      console.log('First');
+      console.log('Second');
+      console.log('Third');
+      console.log('Fourth');
+      console.log('Fifth');
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toBeDefined();
+    expect(result.consoleOutput).toHaveLength(5);
+
+    expect(result.consoleOutput[0]).toBe('First');
+    expect(result.consoleOutput[1]).toBe('Second');
+    expect(result.consoleOutput[2]).toBe('Third');
+    expect(result.consoleOutput[3]).toBe('Fourth');
+    expect(result.consoleOutput[4]).toBe('Fifth');
+  });
+
+  it('should capture 100 console.log calls', async () => {
+    const code = `
+      for (let i = 0; i < 100; i++) {
+        console.log('Log entry', i);
+      }
+      return 100
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toBeDefined();
+    expect(result.consoleOutput).toHaveLength(100);
+
+    // Check a few entries
+    expect(result.consoleOutput[0]).toContain('Log entry 0');
+    expect(result.consoleOutput[49]).toContain('Log entry 49');
+    expect(result.consoleOutput[99]).toContain('Log entry 99');
+  });
+});