@liquidmetal-ai/precip 1.0.0

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

@@ -0,0 +1,157 @@
+import { describe, it, expect } from 'vitest';
+import { executeWithAsyncHost } from '../test-helper.js';
+
+describe('Console Bridge', () => {
+  it('should capture console.log output', async () => {
+    const code = `
+      console.log('Hello World');
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toBeDefined();
+    expect(result.consoleOutput).toContain('Hello World');
+    expect(result.result).toBe('done');
+  });
+
+  it('should capture multiple console.log calls', async () => {
+    const code = `
+      console.log('Line 1');
+      console.log('Line 2');
+      console.log('Line 3');
+      return 'complete'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toHaveLength(3);
+    expect(result.consoleOutput).toContain('Line 1');
+    expect(result.consoleOutput).toContain('Line 2');
+    expect(result.consoleOutput).toContain('Line 3');
+  });
+
+  it('should handle console.log with multiple arguments', async () => {
+    const code = `
+      console.log('User:', { name: 'John', age: 30 }, 'status:', 'active');
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toHaveLength(1);
+    expect(result.consoleOutput[0]).toContain('User:');
+    expect(result.consoleOutput[0]).toContain('name');
+    expect(result.consoleOutput[0]).toContain('John');
+  });
+
+  it('should capture console.error with prefix', async () => {
+    const code = `
+      console.error('Something went wrong');
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toHaveLength(1);
+    expect(result.consoleOutput[0]).toContain('[ERROR]');
+    expect(result.consoleOutput[0]).toContain('Something went wrong');
+  });
+
+  it('should capture console.warn with prefix', async () => {
+    const code = `
+      console.warn('This is a warning');
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toHaveLength(1);
+    expect(result.consoleOutput[0]).toContain('[WARN]');
+    expect(result.consoleOutput[0]).toContain('This is a warning');
+  });
+
+  it('should handle console.log in async code', async () => {
+    const code = `
+      console.log('Before async');
+      await (async () => {
+        // Simulate async operation
+        await Promise.resolve();
+      })();
+      console.log('After async');
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toHaveLength(2);
+    expect(result.consoleOutput).toContain('Before async');
+    expect(result.consoleOutput).toContain('After async');
+  });
+
+  it('should work without any console output', async () => {
+    const code = `
+      return 'no console'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    // consoleOutput will be an empty array if no logs
+    expect(result.consoleOutput || []).toHaveLength(0);
+    expect(result.result).toBe('no console');
+  });
+
+  it('should handle null and undefined in console.log', async () => {
+    const code = `
+      console.log(null, undefined);
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toHaveLength(1);
+    expect(result.consoleOutput[0]).toContain('null');
+    expect(result.consoleOutput[0]).toContain('undefined');
+  });
+
+  it('should handle numbers in console.log', async () => {
+    const code = `
+      console.log('Count:', 42, 'Ratio:', 3.14);
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toHaveLength(1);
+    expect(result.consoleOutput[0]).toContain('Count:');
+    expect(result.consoleOutput[0]).toContain('42');
+    expect(result.consoleOutput[0]).toContain('3.14');
+  });
+
+  it('should handle arrays in console.log', async () => {
+    const code = `
+      console.log('Items:', [1, 2, 3, 4, 5]);
+      return 'done'
+    `;
+
+    const result = await executeWithAsyncHost(code, {});
+
+    expect(result.success).toBe(true);
+    expect(result.consoleOutput).toHaveLength(1);
+    expect(result.consoleOutput[0]).toContain('Items:');
+    expect(result.consoleOutput[0]).toContain('1');
+    expect(result.consoleOutput[0]).toContain('2');
+    expect(result.consoleOutput[0]).toContain('3');
+    expect(result.consoleOutput[0]).toContain('4');
+    expect(result.consoleOutput[0]).toContain('5');
+  });
+});

package/src/sandbox/bridges/console.ts

@@ -0,0 +1,122 @@
+/**
+ * Console API bridge - Provides console.log for sandbox
+ *
+ * Captures console.log output and returns it with the sandbox result
+ */
+
+import type { QuickJSContext, QuickJSHandle } from 'quickjs-emscripten-core';
+import type { BridgeContext } from './types.js';
+
+/** Module-level store for console output, keyed by context (avoids monkey-patching) */
+const consoleOutputMap = new WeakMap<QuickJSContext, string[]>();
+
+/**
+ * Install console API in the sandbox
+ */
+export function installConsole(ctx: BridgeContext): void {
+  const { context, logger } = ctx;
+
+  // Array to store console output
+  const output: string[] = [];
+  consoleOutputMap.set(context, output);
+
+  // Helper function to format arguments
+  const formatArgs = (...args: any[]): string => {
+    return args
+      .map(arg => {
+        if (arg === null) return 'null';
+        if (arg === undefined) return 'undefined';
+        if (typeof arg === 'object') {
+          try {
+            return JSON.stringify(arg, null, 2);
+          } catch {
+            return '[object Object]';
+          }
+        }
+        return String(arg);
+      })
+      .join(' ');
+  };
+
+  {
+    using consoleHandle = context.newObject();
+
+    // Create log method (also used as info and debug per spec)
+    {
+      using logMethod = context.newFunction('log', (...args: QuickJSHandle[]) => {
+        const jsArgs = args.map(arg => {
+          try {
+            return context.dump(arg);
+          } catch {
+            return '[Error converting argument]';
+          }
+        });
+
+        const outputLine = formatArgs(...jsArgs);
+        output.push(outputLine);
+        logger?.info?.('[Console]', outputLine);
+
+        return context.undefined;
+      });
+
+      context.setProp(consoleHandle, 'log', logMethod);
+      // Alias info and debug to log (per spec, they behave like console.log)
+      context.setProp(consoleHandle, 'info', logMethod);
+      context.setProp(consoleHandle, 'debug', logMethod);
+    }
+
+    // Create error method
+    {
+      using errorMethod = context.newFunction('error', (...args: QuickJSHandle[]) => {
+        const jsArgs = args.map(arg => {
+          try {
+            return context.dump(arg);
+          } catch {
+            return '[Error converting argument]';
+          }
+        });
+
+        const outputLine = formatArgs(...jsArgs);
+        output.push('[ERROR] ' + outputLine);
+        logger?.error?.('[Console]', outputLine);
+
+        return context.undefined;
+      });
+
+      context.setProp(consoleHandle, 'error', errorMethod);
+    }
+
+    // Create warn method
+    {
+      using warnMethod = context.newFunction('warn', (...args: QuickJSHandle[]) => {
+        const jsArgs = args.map(arg => {
+          try {
+            return context.dump(arg);
+          } catch {
+            return '[Error converting argument]';
+          }
+        });
+
+        const outputLine = formatArgs(...jsArgs);
+        output.push('[WARN] ' + outputLine);
+        logger?.warn?.('[Console]', outputLine);
+
+        return context.undefined;
+      });
+
+      context.setProp(consoleHandle, 'warn', warnMethod);
+    }
+
+    // Set console global
+    context.setProp(context.global, 'console', consoleHandle);
+  }
+
+  logger?.info?.('[Bridge] console installed');
+}
+
+/**
+ * Get console output from context
+ */
+export function getConsoleOutput(context: QuickJSContext): string[] {
+  return consoleOutputMap.get(context) || [];
+}

package/src/sandbox/bridges/fetch.ts

@@ -0,0 +1,93 @@
+/**
+ * Fetch API bridge - Bridges runtime's native fetch with Response, Headers, and Streams
+ */
+
+import type { QuickJSHandle } from 'quickjs-emscripten-core';
+import type { BridgeContext } from './types.js';
+import {
+  withTrackedPromiseResult,
+  createResponseObject,
+  setupStreamRegistry
+} from './shared/index.js';
+
+/**
+ * Install fetch API in the sandbox
+ * Bridges to runtime's native fetch
+ */
+export function installFetch(ctx: BridgeContext): void {
+  const { context, logger, cleanupHandlers } = ctx;
+
+  // Track AbortControllers for pending fetches so we can abort them on cleanup
+  const pendingAbortControllers = new Set<AbortController>();
+
+  // Flag to track if we're disposing - helps avoid operations on disposed context
+  let isDisposing = false;
+
+  // Create response object context for the factory (includes cleanup handler)
+  const objCtx = setupStreamRegistry(ctx, 'Fetch');
+
+  // Register cleanup handler to abort pending fetches (before stream cleanup)
+  cleanupHandlers.unshift(async () => {
+    isDisposing = true;
+
+    // Abort all pending fetches
+    logger?.info?.(`[Fetch] Aborting ${pendingAbortControllers.size} pending fetch(es)`);
+    for (const controller of pendingAbortControllers) {
+      try {
+        controller.abort('Sandbox cleanup');
+      } catch {
+        // Ignore abort errors
+      }
+    }
+    pendingAbortControllers.clear();
+  });
+
+  // Install fetch function
+  {
+    using fetchHandle = context.newFunction('fetch', (...args: QuickJSHandle[]) => {
+      const jsArgs = args.map(arg => context.dump(arg));
+
+      // Create AbortController for this fetch
+      const abortController = new AbortController();
+      pendingAbortControllers.add(abortController);
+
+      // Merge user's signal with our abort controller if they provided one
+      const userInit = jsArgs[1] || {};
+      // Strip signal from userInit — sandbox signals deserialize as plain objects (not real
+      // AbortSignal instances), so AbortSignal.any() would throw TypeError. Custom abort
+      // signaling from sandbox code is not supported; use fetch timeout instead.
+      if (userInit.signal) {
+        logger?.warn?.('[Fetch] Stripping unsupported AbortSignal from sandbox fetch init. ' +
+          'Custom AbortSignal is not supported in sandbox code.');
+      }
+      const { signal: _ignoredSignal, ...safeInit } = userInit;
+      const fetchInit = {
+        ...safeInit,
+        signal: abortController.signal
+      };
+
+      logger?.info?.('[Fetch] fetch() called');
+
+      return withTrackedPromiseResult(ctx, async () => {
+        // Skip if disposing - let cleanup handle it
+        if (isDisposing) {
+          throw new Error('Sandbox is disposing');
+        }
+
+        try {
+          // Use runtime's native fetch with abort support
+          const response = await (globalThis.fetch as any)(jsArgs[0], fetchInit);
+
+          // Create QuickJS Response object using the unified factory
+          return createResponseObject(ctx, { response }, objCtx);
+        } finally {
+          pendingAbortControllers.delete(abortController);
+        }
+      });
+    });
+
+    context.setProp(context.global, 'fetch', fetchHandle);
+  }
+
+  logger?.info?.('[Bridge] fetch installed');
+}

package/src/sandbox/bridges/index.ts

@@ -0,0 +1,78 @@
+/**
+ * QuickJS Bridge System
+ *
+ * Modular bridge implementations for exposing runtime APIs to QuickJS sandbox.
+ */
+
+export * from './types.js';
+export * from './utils.js';
+export * from './shared/index.js';
+export { installTextEncoder } from './text-encoder.js';
+export { installTextDecoder } from './text-decoder.js';
+export { installFetch } from './fetch.js';
+export { installResponse } from './response.js';
+export { installConsole, getConsoleOutput } from './console.js';
+export { createStreamObject, createReaderObject } from './readable-stream.js';
+export { installStorage, type StorageMountInfo } from './storage.js';
+export { installSearch, type SearchMountInfo } from './search.js';
+export { installActor } from './actor.js';
+
+import type { BridgeContext, PromiseTracker } from './types.js';
+import type { Logger } from '../../types.js';
+import { installTextEncoder } from './text-encoder.js';
+import { installTextDecoder } from './text-decoder.js';
+import { installFetch } from './fetch.js';
+import { installResponse } from './response.js';
+import { installConsole } from './console.js';
+
+/**
+ * Install all standard bridges (fetch, Response, console, TextEncoder, TextDecoder)
+ */
+export function installAllBridges(ctx: BridgeContext): void {
+  installFetch(ctx);
+  installResponse(ctx);
+  installConsole(ctx);
+  installTextEncoder(ctx);
+  installTextDecoder(ctx);
+
+  ctx.logger?.info?.('[Bridge] All bridges installed');
+}
+
+/**
+ * Create a promise tracker for async operations
+ */
+export function createPromiseTracker(): PromiseTracker {
+  let notifyNewPromise: () => void;
+  const newPromiseSignal = new Promise<void>(resolve => {
+    notifyNewPromise = resolve;
+  });
+
+  return {
+    pendingPromises: new Set(),
+    notifyNewPromise: notifyNewPromise!,
+    newPromiseSignal,
+    deferredPromises: new Set()
+  };
+}
+
+/**
+ * Run all cleanup handlers registered by bridges
+ */
+export async function runCleanupHandlers(
+  handlers: Array<() => void | Promise<void>>,
+  logger?: Logger
+): Promise<void> {
+  logger?.info?.(`[Bridge] Running ${handlers.length} cleanup handlers`);
+
+  for (let i = 0; i < handlers.length; i++) {
+    try {
+      const handler = handlers[i]!;
+      await handler();
+      logger?.info?.(`[Bridge] Cleanup handler ${i + 1}/${handlers.length} completed`);
+    } catch (e) {
+      logger?.warn?.(`[Bridge] Cleanup handler ${i + 1}/${handlers.length} failed: ${e}`);
+    }
+  }
+
+  logger?.info?.('[Bridge] All cleanup handlers completed');
+}