@volter/tabnode 0.2.14-volter.88

package/src/vite-plugin.ts

@@ -0,0 +1,76 @@
+/**
+ * Vite Plugin for tabnode
+ *
+ * Serves the service worker file from the package's dist directory,
+ * enabling seamless integration when tabnode is installed as an npm package.
+ */
+
+import type { Plugin, ViteDevServer } from 'vite';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - import.meta.url is available in ESM
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export interface TabnodePluginOptions {
+  /**
+   * The URL path where the service worker will be served
+   * @default '/__sw__.js'
+   */
+  swPath?: string;
+}
+
+/**
+ * Vite plugin that serves the tabnode service worker file.
+ *
+ * When tabnode is installed as an npm package, the service worker file
+ * is located at node_modules/tabnode/dist/__sw__.js but the browser
+ * tries to load it from the root URL (/__sw__.js). This plugin intercepts
+ * requests to the service worker path and serves the file from the correct location.
+ *
+ * @example
+ * ```typescript
+ * // vite.config.ts
+ * import { defineConfig } from 'vite';
+ * import { tabnodePlugin } from 'tabnode/vite';
+ *
+ * export default defineConfig({
+ *   plugins: [tabnodePlugin()]
+ * });
+ * ```
+ */
+export function tabnodePlugin(options: TabnodePluginOptions = {}): Plugin {
+  const swPath = options.swPath || '/__sw__.js';
+
+  return {
+    name: 'tabnode',
+
+    configureServer(server: ViteDevServer) {
+      server.middlewares.use(swPath, (_req, res) => {
+        // The service worker file is in the dist directory relative to this file
+        // In src: ../dist/__sw__.js
+        // In dist: ./__sw__.js
+        let swFilePath = path.join(__dirname, '__sw__.js');
+
+        // If running from src directory during development, look in dist
+        if (!fs.existsSync(swFilePath)) {
+          swFilePath = path.join(__dirname, '../dist/__sw__.js');
+        }
+
+        if (!fs.existsSync(swFilePath)) {
+          res.statusCode = 404;
+          res.end('Service worker file not found. Make sure tabnode is built.');
+          return;
+        }
+
+        res.setHeader('Content-Type', 'application/javascript');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.end(fs.readFileSync(swFilePath));
+      });
+    },
+  };
+}
+
+export default tabnodePlugin;

package/src/worker/runtime-worker.ts

@@ -0,0 +1,128 @@
+/**
+ * Runtime Worker - Runs the Just Node runtime in a Web Worker
+ *
+ * This worker receives code execution requests from the main thread
+ * and runs them in isolation, preventing UI blocking.
+ */
+
+import { expose } from 'comlink';
+import { VirtualFS } from '../virtual-fs';
+import { Runtime } from '../runtime';
+import type { VFSSnapshot, IRuntimeOptions, IExecuteResult } from '../runtime-interface';
+
+let runtime: Runtime | null = null;
+let vfs: VirtualFS | null = null;
+let consoleCallback: ((method: string, args: unknown[]) => void) | null = null;
+
+/**
+ * Worker API exposed via Comlink
+ */
+const workerApi = {
+  /**
+   * Initialize the worker with a VFS snapshot and runtime options
+   */
+  init(vfsSnapshot: VFSSnapshot, options: IRuntimeOptions): void {
+    console.log('[Worker] Initializing with', vfsSnapshot.files.length, 'files');
+
+    // Restore VFS from snapshot
+    vfs = VirtualFS.fromSnapshot(vfsSnapshot);
+
+    // Create runtime with console forwarding
+    const runtimeOptions: IRuntimeOptions = {
+      ...options,
+      onConsole: (method, args) => {
+        // Forward console output to main thread
+        if (consoleCallback) {
+          consoleCallback(method, args);
+        }
+      },
+    };
+
+    runtime = new Runtime(vfs, runtimeOptions);
+    console.log('[Worker] Runtime initialized');
+  },
+
+  /**
+   * Set the console callback for forwarding output to main thread
+   */
+  setConsoleCallback(callback: ((method: string, args: unknown[]) => void) | null): void {
+    consoleCallback = callback;
+  },
+
+  /**
+   * Sync a file change from the main thread
+   */
+  syncFile(path: string, content: string | null): void {
+    if (!vfs) {
+      console.warn('[Worker] VFS not initialized, cannot sync file:', path);
+      return;
+    }
+
+    if (content === null) {
+      // File was deleted
+      try {
+        vfs.unlinkSync(path);
+        console.log('[Worker] Deleted file:', path);
+      } catch (err) {
+        // File might not exist, that's ok
+      }
+    } else {
+      // File was created or modified
+      vfs.writeFileSync(path, content);
+      console.log('[Worker] Synced file:', path);
+    }
+
+    // Clear module cache for this file to pick up changes
+    if (runtime) {
+      runtime.clearCache();
+    }
+  },
+
+  /**
+   * Execute code in the worker
+   */
+  async execute(code: string, filename?: string): Promise<IExecuteResult> {
+    if (!runtime) {
+      throw new Error('Worker runtime not initialized. Call init() first.');
+    }
+
+    console.log('[Worker] Executing code in file:', filename);
+    return runtime.execute(code, filename);
+  },
+
+  /**
+   * Run a file from the VFS
+   */
+  async runFile(filename: string): Promise<IExecuteResult> {
+    if (!runtime) {
+      throw new Error('Worker runtime not initialized. Call init() first.');
+    }
+
+    console.log('[Worker] Running file:', filename);
+    return runtime.runFile(filename);
+  },
+
+  /**
+   * Clear the module cache
+   */
+  clearCache(): void {
+    if (runtime) {
+      runtime.clearCache();
+      console.log('[Worker] Cache cleared');
+    }
+  },
+
+  /**
+   * Get current VFS state (for debugging)
+   */
+  getVFSSnapshot(): VFSSnapshot | null {
+    if (!vfs) return null;
+    return vfs.toSnapshot();
+  },
+};
+
+// Expose the API via Comlink
+expose(workerApi);
+
+// Log that worker is ready
+console.log('[Worker] Runtime worker loaded and ready');

package/src/worker-runtime.ts

@@ -0,0 +1,145 @@
+/**
+ * WorkerRuntime - Runs code in a Web Worker for non-blocking execution
+ *
+ * This class provides the same IRuntime interface as Runtime,
+ * but executes code in a separate Web Worker thread.
+ */
+
+import { wrap, proxy, Remote } from 'comlink';
+import type { VirtualFS } from './virtual-fs';
+import type { IRuntime, IExecuteResult, IRuntimeOptions, VFSSnapshot } from './runtime-interface';
+
+/**
+ * Type for the worker API
+ */
+interface WorkerApi {
+  init(vfsSnapshot: VFSSnapshot, options: IRuntimeOptions): void;
+  setConsoleCallback(callback: ((method: string, args: unknown[]) => void) | null): void;
+  syncFile(path: string, content: string | null): void;
+  execute(code: string, filename?: string): Promise<IExecuteResult>;
+  runFile(filename: string): Promise<IExecuteResult>;
+  clearCache(): void;
+  getVFSSnapshot(): VFSSnapshot | null;
+}
+
+/**
+ * WorkerRuntime - Executes code in a Web Worker
+ */
+export class WorkerRuntime implements IRuntime {
+  private worker: Worker;
+  private workerApi: Remote<WorkerApi>;
+  private vfs: VirtualFS;
+  private options: IRuntimeOptions;
+  private initialized: Promise<void>;
+  private changeListener: ((path: string, content: string) => void) | null = null;
+  private deleteListener: ((path: string) => void) | null = null;
+
+  constructor(vfs: VirtualFS, options: IRuntimeOptions = {}) {
+    this.vfs = vfs;
+    this.options = options;
+
+    // Create the worker
+    // Using Vite's worker import syntax
+    this.worker = new Worker(
+      new URL('./worker/runtime-worker.ts', import.meta.url),
+      { type: 'module' }
+    );
+
+    // Wrap with Comlink
+    this.workerApi = wrap<WorkerApi>(this.worker);
+
+    // Initialize the worker
+    this.initialized = this.initWorker();
+
+    // Set up VFS change listeners
+    this.setupVFSListeners();
+  }
+
+  /**
+   * Initialize the worker with VFS snapshot and options
+   */
+  private async initWorker(): Promise<void> {
+    const snapshot = this.vfs.toSnapshot();
+
+    // Create options without the onConsole callback (we'll set it separately via proxy)
+    const workerOptions: IRuntimeOptions = {
+      cwd: this.options.cwd,
+      env: this.options.env,
+    };
+
+    await this.workerApi.init(snapshot, workerOptions);
+
+    // Set up console forwarding if callback provided
+    if (this.options.onConsole) {
+      await this.workerApi.setConsoleCallback(
+        proxy(this.options.onConsole)
+      );
+    }
+
+    console.log('[WorkerRuntime] Worker initialized');
+  }
+
+  /**
+   * Set up listeners for VFS changes to sync to worker
+   */
+  private setupVFSListeners(): void {
+    // Listen for file changes
+    this.changeListener = (path: string, content: string) => {
+      this.workerApi.syncFile(path, content);
+    };
+    this.vfs.on('change', this.changeListener);
+
+    // Listen for file deletions
+    this.deleteListener = (path: string) => {
+      this.workerApi.syncFile(path, null);
+    };
+    this.vfs.on('delete', this.deleteListener);
+  }
+
+  /**
+   * Execute code in the worker
+   */
+  async execute(code: string, filename?: string): Promise<IExecuteResult> {
+    await this.initialized;
+    return this.workerApi.execute(code, filename);
+  }
+
+  /**
+   * Run a file from the VFS in the worker
+   */
+  async runFile(filename: string): Promise<IExecuteResult> {
+    await this.initialized;
+    return this.workerApi.runFile(filename);
+  }
+
+  /**
+   * Clear the module cache in the worker
+   */
+  clearCache(): void {
+    this.workerApi.clearCache();
+  }
+
+  /**
+   * Get the VFS (main thread instance)
+   */
+  getVFS(): VirtualFS {
+    return this.vfs;
+  }
+
+  /**
+   * Terminate the worker
+   */
+  terminate(): void {
+    // Remove VFS listeners
+    if (this.changeListener) {
+      this.vfs.off('change', this.changeListener);
+    }
+    if (this.deleteListener) {
+      this.vfs.off('delete', this.deleteListener);
+    }
+
+    // Terminate the worker
+    this.worker.terminate();
+    console.log('[WorkerRuntime] Worker terminated');
+  }
+}