almostnode 0.2.6 → 0.2.8

package/src/frameworks/tailwind-config-loader.ts

@@ -109,7 +109,7 @@ export function stripTypescriptSyntax(content: string): string {
 
   // Remove type annotations on variables
   // e.g., const config: Config = { ... }
-  result = result.replace(/:\s*Config\s*=/g, ' =');
+  result = result.replace(/:\s*[A-Z]\w*\s*=/g, ' =');
 
   // Remove 'as const' assertions
   result = result.replace(/\s+as\s+const\s*/g, ' ');

package/src/frameworks/vite-dev-server.ts

@@ -7,6 +7,7 @@ import { DevServer, DevServerOptions, ResponseData, HMRUpdate } from '../dev-ser
 import { VirtualFS } from '../virtual-fs';
 import { Buffer } from '../shims/stream';
 import { simpleHash } from '../utils/hash';
+import { addReactRefresh as _addReactRefresh } from './code-transforms';
 
 // Check if we're in a real browser environment (not jsdom or Node.js)
 // jsdom has window but doesn't have ServiceWorker or SharedArrayBuffer
@@ -574,68 +575,8 @@ export class ViteDevServer extends DevServer {
     return result.code;
   }
 
-  /**
-   * Add React Refresh registration to transformed code
-   * This enables true HMR (state-preserving) for React components
-   */
   private addReactRefresh(code: string, filename: string): string {
-    // Find React components (functions starting with uppercase letter)
-    const components: string[] = [];
-
-    // Match function declarations: function App() { ... }
-    // Also handles: export function App() { ... }
-    const funcDeclRegex = /(?:^|\n)(?:export\s+)?function\s+([A-Z][a-zA-Z0-9]*)\s*\(/g;
-    let match;
-    while ((match = funcDeclRegex.exec(code)) !== null) {
-      if (!components.includes(match[1])) {
-        components.push(match[1]);
-      }
-    }
-
-    // Match arrow function components: const App = () => { ... }
-    // Also handles: export const App = () => { ... }
-    // And: const App = function() { ... }
-    const arrowRegex = /(?:^|\n)(?:export\s+)?(?:const|let|var)\s+([A-Z][a-zA-Z0-9]*)\s*=/g;
-    while ((match = arrowRegex.exec(code)) !== null) {
-      if (!components.includes(match[1])) {
-        components.push(match[1]);
-      }
-    }
-
-    // If no components found, just add hot module setup without refresh
-    if (components.length === 0) {
-      return `// HMR Setup
-import.meta.hot = window.__vite_hot_context__("${filename}");
-
-${code}
-
-// HMR Accept
-if (import.meta.hot) {
-  import.meta.hot.accept();
-}
-`;
-    }
-
-    // Build React Refresh registration calls
-    const registrations = components
-      .map(name => `  $RefreshReg$(${name}, "${filename} ${name}");`)
-      .join('\n');
-
-    return `// HMR Setup
-import.meta.hot = window.__vite_hot_context__("${filename}");
-
-${code}
-
-// React Refresh Registration
-if (import.meta.hot) {
-${registrations}
-  import.meta.hot.accept(() => {
-    if (window.$RefreshRuntime$) {
-      window.$RefreshRuntime$.performReactRefresh();
-    }
-  });
-}
-`;
+    return _addReactRefresh(code, filename);
   }
 
   /**

package/src/index.ts

@@ -76,6 +76,7 @@ export function createContainer(options?: ContainerOptions): {
   serverBridge: ServerBridge;
   execute: (code: string, filename?: string) => { exports: unknown };
   runFile: (filename: string) => { exports: unknown };
+  createREPL: () => { eval: (code: string) => unknown };
   on: (event: string, listener: (...args: unknown[]) => void) => void;
 } {
   const vfs = new VirtualFS();
@@ -93,6 +94,7 @@ export function createContainer(options?: ContainerOptions): {
     serverBridge,
     execute: (code: string, filename?: string) => runtime.execute(code, filename),
     runFile: (filename: string) => runtime.runFile(filename),
+    createREPL: () => runtime.createREPL(),
     on: (event: string, listener: (...args: unknown[]) => void) => {
       serverBridge.on(event, listener);
     },

package/src/runtime.ts

@@ -9,6 +9,7 @@ import { VirtualFS } from './virtual-fs';
 import type { IRuntime, IExecuteResult, IRuntimeOptions } from './runtime-interface';
 import type { PackageJson } from './types/package-json';
 import { simpleHash } from './utils/hash';
+import { uint8ToBase64, uint8ToHex } from './utils/binary-encoding';
 import { createFsShim, FsShim } from './shims/fs';
 import * as pathShim from './shims/path';
 import { createProcess, Process } from './shims/process';
@@ -548,6 +549,12 @@ function createRequire(
     // Cache before loading to handle circular dependencies
     moduleCache[resolvedPath] = module;
 
+    // Evict oldest entry if cache exceeds bounds
+    const cacheKeys = Object.keys(moduleCache);
+    if (cacheKeys.length > 2000) {
+      delete moduleCache[cacheKeys[0]];
+    }
+
     // Handle JSON files
     if (resolvedPath.endsWith('.json')) {
       const content = vfs.readFileSync(resolvedPath, 'utf8');
@@ -907,27 +914,15 @@ export class Runtime {
           : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
 
         if (this.encoding === 'base64') {
-          let binary = '';
-          for (let i = 0; i < bytes.length; i++) {
-            binary += String.fromCharCode(bytes[i]);
-          }
-          return btoa(binary);
+          return uint8ToBase64(bytes);
         }
 
         if (this.encoding === 'base64url') {
-          let binary = '';
-          for (let i = 0; i < bytes.length; i++) {
-            binary += String.fromCharCode(bytes[i]);
-          }
-          return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+          return uint8ToBase64(bytes).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
         }
 
         if (this.encoding === 'hex') {
-          let hex = '';
-          for (let i = 0; i < bytes.length; i++) {
-            hex += bytes[i].toString(16).padStart(2, '0');
-          }
-          return hex;
+          return uint8ToHex(bytes);
         }
 
         // Fallback: decode as utf-8
@@ -1085,6 +1080,90 @@ ${code}
   getProcess(): Process {
     return this.process;
   }
+
+  /**
+   * Create a REPL context that evaluates expressions and persists state.
+   *
+   * Returns an object with an `eval` method that:
+   * - Returns the value of the last expression (unlike `execute` which returns module.exports)
+   * - Persists variables between calls (`var x = 1` then `x` works)
+   * - Has access to `require`, `console`, `process`, `Buffer` (same as execute)
+   *
+   * Security: The eval runs inside a Generator's local scope via direct eval,
+   * NOT in the global scope. Only the runtime's own require/console/process are
+   * exposed — the same sandbox boundary as execute(). Variables created in the
+   * REPL are confined to the generator's closure and cannot leak to the page.
+   *
+   * Note: `const`/`let` are transformed to `var` so they persist across calls
+   * (var hoists to the generator's function scope, const/let are block-scoped
+   * to each eval call and would be lost).
+   */
+  createREPL(): { eval: (code: string) => unknown } {
+    const require = createRequire(
+      this.vfs,
+      this.fsShim,
+      this.process,
+      '/',
+      this.moduleCache,
+      this.options,
+      this.processedCodeCache
+    );
+    const consoleWrapper = createConsoleWrapper(this.options.onConsole);
+    const process = this.process;
+    const buffer = bufferShim.Buffer;
+
+    // Use a Generator to maintain a persistent eval scope.
+    // Generator functions preserve their local scope across yields, so
+    // var declarations from eval() persist between calls. Direct eval
+    // runs in the generator's scope (not global), providing isolation.
+    const GeneratorFunction = Object.getPrototypeOf(function* () {}).constructor;
+    const replGen = new GeneratorFunction(
+      'require',
+      'console',
+      'process',
+      'Buffer',
+      `var __code, __result;
+while (true) {
+  __code = yield;
+  try {
+    __result = eval(__code);
+    yield { value: __result, error: null };
+  } catch (e) {
+    yield { value: undefined, error: e };
+  }
+}`
+    )(require, consoleWrapper, process, buffer);
+    replGen.next(); // prime the generator
+
+    return {
+      eval(code: string): unknown {
+        // Transform const/let to var for persistence across REPL calls.
+        // var declarations in direct eval are added to the enclosing function
+        // scope (the generator), so they survive across yields.
+        const transformed = code.replace(/^\s*(const|let)\s+/gm, 'var ');
+
+        // Try as expression first (wrapping in parens), fall back to statement.
+        // replGen.next(code) sends code to the generator, which evals it and
+        // yields the result — so the result is in the return value of .next().
+        const exprResult = replGen.next('(' + transformed + ')').value as { value: unknown; error: unknown };
+        if (!exprResult.error) {
+          // Advance past the wait-for-code yield so it's ready for next call
+          replGen.next();
+          return exprResult.value;
+        }
+
+        // Expression parse failed — advance past wait-for-code, then try as statement
+        replGen.next();
+        const stmtResult = replGen.next(transformed).value as { value: unknown; error: unknown };
+        if (stmtResult.error) {
+          replGen.next(); // advance past wait-for-code yield
+          throw stmtResult.error;
+        }
+        replGen.next(); // advance past wait-for-code yield
+        return stmtResult.value;
+      },
+    };
+  }
 }
 
 /**

package/src/server-bridge.ts

@@ -12,6 +12,9 @@ import {
 } from './shims/http';
 import { EventEmitter } from './shims/events';
 import { Buffer } from './shims/stream';
+import { uint8ToBase64 } from './utils/binary-encoding';
+
+const _encoder = new TextEncoder();
 
 /**
  * Interface for virtual servers that can be registered with the bridge
@@ -50,11 +53,13 @@ export interface InitServiceWorkerOptions {
  * Server Bridge manages virtual HTTP servers and routes requests
  */
 export class ServerBridge extends EventEmitter {
+  static DEBUG = false;
   private servers: Map<number, VirtualServer> = new Map();
   private baseUrl: string;
   private options: BridgeOptions;
   private messageChannel: MessageChannel | null = null;
   private serviceWorkerReady: boolean = false;
+  private keepaliveInterval: ReturnType<typeof setInterval> | null = null;
 
   constructor(options: BridgeOptions = {}) {
     super();
@@ -164,6 +169,15 @@ export class ServerBridge extends EventEmitter {
 
     const swUrl = options?.swUrl ?? '/__sw__.js';
 
+    // Set up controllerchange listener BEFORE registration so we don't miss the event.
+    // clients.claim() in the SW's activate handler fires controllerchange, and it can
+    // happen before our activation wait completes.
+    const controllerReady = navigator.serviceWorker.controller
+      ? Promise.resolve()
+      : new Promise<void>((resolve) => {
+          navigator.serviceWorker.addEventListener('controllerchange', () => resolve(), { once: true });
+        });
+
     // Register service worker
     const registration = await navigator.serviceWorker.register(swUrl, {
       scope: '/',
@@ -180,11 +194,13 @@ export class ServerBridge extends EventEmitter {
       if (sw.state === 'activated') {
         resolve();
       } else {
-        sw.addEventListener('statechange', () => {
+        const handler = () => {
           if (sw.state === 'activated') {
+            sw.removeEventListener('statechange', handler);
             resolve();
           }
-        });
+        };
+        sw.addEventListener('statechange', handler);
       }
     });
 
@@ -197,6 +213,36 @@ export class ServerBridge extends EventEmitter {
       this.messageChannel.port2,
     ]);
 
+    // Wait for SW to actually control this page (clients.claim() in SW activate handler)
+    // Without this, fetch requests bypass the SW and go directly to the server
+    await controllerReady;
+
+    // Re-establish communication when the SW loses its port (idle termination)
+    // or when the SW is replaced (new deployment). The SW sends 'sw-needs-init'
+    // to all clients when a request arrives but mainPort is null.
+    const reinit = () => {
+      if (navigator.serviceWorker.controller) {
+        this.messageChannel = new MessageChannel();
+        this.messageChannel.port1.onmessage = this.handleServiceWorkerMessage.bind(this);
+        navigator.serviceWorker.controller.postMessage(
+          { type: 'init', port: this.messageChannel.port2 },
+          [this.messageChannel.port2]
+        );
+      }
+    };
+    navigator.serviceWorker.addEventListener('controllerchange', reinit);
+    navigator.serviceWorker.addEventListener('message', (event) => {
+      if (event.data?.type === 'sw-needs-init') {
+        reinit();
+      }
+    });
+
+    // Keep the SW alive with periodic pings. Browsers terminate idle SWs
+    // after ~30s, losing the MessageChannel port and all in-memory state.
+    this.keepaliveInterval = setInterval(() => {
+      this.messageChannel?.port1.postMessage({ type: 'keepalive' });
+    }, 20_000);
+
     this.serviceWorkerReady = true;
     this.emit('sw-ready');
   }
@@ -207,14 +253,14 @@ export class ServerBridge extends EventEmitter {
   private async handleServiceWorkerMessage(event: MessageEvent): Promise<void> {
     const { type, id, data } = event.data;
 
-    console.log('[ServerBridge] SW message:', type, id, data?.url);
+    ServerBridge.DEBUG && console.log('[ServerBridge] SW message:', type, id, data?.url);
 
     if (type === 'request') {
       const { port, method, url, headers, body, streaming } = data;
 
-      console.log('[ServerBridge] Handling request:', port, method, url, 'streaming:', streaming);
+      ServerBridge.DEBUG && console.log('[ServerBridge] Handling request:', port, method, url, 'streaming:', streaming);
       if (streaming) {
-        console.log('[ServerBridge] 🔴 Will use streaming handler');
+        ServerBridge.DEBUG && console.log('[ServerBridge] 🔴 Will use streaming handler');
       }
 
       try {
@@ -224,21 +270,16 @@ export class ServerBridge extends EventEmitter {
         } else {
           // Handle regular request
           const response = await this.handleRequest(port, method, url, headers, body);
-          console.log('[ServerBridge] Response:', response.statusCode, 'body length:', response.body?.length);
+          ServerBridge.DEBUG && console.log('[ServerBridge] Response:', response.statusCode, 'body length:', response.body?.length);
 
           // Convert body to base64 string to avoid structured cloning issues with Uint8Array
           let bodyBase64 = '';
           if (response.body && response.body.length > 0) {
-            // Convert Uint8Array to base64 string
             const bytes = response.body instanceof Uint8Array ? response.body : new Uint8Array(0);
-            let binary = '';
-            for (let i = 0; i < bytes.length; i++) {
-              binary += String.fromCharCode(bytes[i]);
-            }
-            bodyBase64 = btoa(binary);
+            bodyBase64 = uint8ToBase64(bytes);
           }
 
-          console.log('[ServerBridge] Sending response to SW, body base64 length:', bodyBase64.length);
+          ServerBridge.DEBUG && console.log('[ServerBridge] Sending response to SW, body base64 length:', bodyBase64.length);
 
           this.messageChannel?.port1.postMessage({
             type: 'response',
@@ -287,7 +328,7 @@ export class ServerBridge extends EventEmitter {
     // Check if the server supports streaming (has handleStreamingRequest method)
     const server = virtualServer.server as any;
     if (typeof server.handleStreamingRequest === 'function') {
-      console.log('[ServerBridge] 🟢 Server has streaming support, calling handleStreamingRequest');
+      ServerBridge.DEBUG && console.log('[ServerBridge] 🟢 Server has streaming support, calling handleStreamingRequest');
       // Use streaming handler
       const bodyBuffer = body ? Buffer.from(new Uint8Array(body)) : undefined;
 
@@ -298,7 +339,7 @@ export class ServerBridge extends EventEmitter {
         bodyBuffer,
         // onStart - called with headers
         (statusCode: number, statusMessage: string, respHeaders: Record<string, string>) => {
-          console.log('[ServerBridge] 🟢 onStart called, sending stream-start');
+          ServerBridge.DEBUG && console.log('[ServerBridge] 🟢 onStart called, sending stream-start');
           this.messageChannel?.port1.postMessage({
             type: 'stream-start',
             id,
@@ -307,13 +348,9 @@ export class ServerBridge extends EventEmitter {
         },
         // onChunk - called for each chunk
         (chunk: string | Uint8Array) => {
-          const bytes = typeof chunk === 'string' ? new TextEncoder().encode(chunk) : chunk;
-          let binary = '';
-          for (let i = 0; i < bytes.length; i++) {
-            binary += String.fromCharCode(bytes[i]);
-          }
-          const chunkBase64 = btoa(binary);
-          console.log('[ServerBridge] 🟡 onChunk called, sending stream-chunk, size:', chunkBase64.length);
+          const bytes = typeof chunk === 'string' ? _encoder.encode(chunk) : chunk;
+          const chunkBase64 = uint8ToBase64(bytes);
+          ServerBridge.DEBUG && console.log('[ServerBridge] 🟡 onChunk called, sending stream-chunk, size:', chunkBase64.length);
           this.messageChannel?.port1.postMessage({
             type: 'stream-chunk',
             id,
@@ -322,7 +359,7 @@ export class ServerBridge extends EventEmitter {
         },
         // onEnd - called when response is complete
         () => {
-          console.log('[ServerBridge] 🟢 onEnd called, sending stream-end');
+          ServerBridge.DEBUG && console.log('[ServerBridge] 🟢 onEnd called, sending stream-end');
           this.messageChannel?.port1.postMessage({ type: 'stream-end', id });
         }
       );
@@ -344,14 +381,10 @@ export class ServerBridge extends EventEmitter {
 
       if (response.body && response.body.length > 0) {
         const bytes = response.body instanceof Uint8Array ? response.body : new Uint8Array(0);
-        let binary = '';
-        for (let i = 0; i < bytes.length; i++) {
-          binary += String.fromCharCode(bytes[i]);
-        }
         this.messageChannel?.port1.postMessage({
           type: 'stream-chunk',
           id,
-          data: { chunkBase64: btoa(binary) },
+          data: { chunkBase64: uint8ToBase64(bytes) },
         });
       }
 

package/src/shims/crypto.ts

@@ -16,6 +16,18 @@ export function randomBytes(size: number): Buffer {
   return Buffer.from(array);
 }
 
+export function randomFillSync(
+  buffer: Uint8Array | Buffer,
+  offset?: number,
+  size?: number
+): Uint8Array | Buffer {
+  const start = offset || 0;
+  const len = size !== undefined ? size : (buffer.length - start);
+  const view = new Uint8Array(buffer.buffer, buffer.byteOffset + start, len);
+  crypto.getRandomValues(view);
+  return buffer;
+}
+
 export function randomUUID(): string {
   return crypto.randomUUID();
 }
@@ -808,6 +820,7 @@ async function importKey(
 
 export default {
   randomBytes,
+  randomFillSync,
   randomUUID,
   randomInt,
   getRandomValues,

package/src/shims/esbuild.ts

@@ -717,7 +717,7 @@ export async function build(options: BuildOptions): Promise<BuildResult> {
   // This preserves the original paths for esbuild's output file naming.
   let entryPoints = options.entryPoints;
   if (entryPoints && globalVFS) {
-    const absWorkingDir = options.absWorkingDir || '/';
+    const absWorkingDir = options.absWorkingDir || (typeof globalThis !== 'undefined' && globalThis.process && typeof globalThis.process.cwd === 'function' ? globalThis.process.cwd() : '/');
     entryPoints = entryPoints.map(ep => {
       // Handle paths that came from previous builds with vfs: namespace prefix
       if (ep.includes('vfs:')) {
@@ -750,11 +750,14 @@ export async function build(options: BuildOptions): Promise<BuildResult> {
   }
 
   // In browser, we need write: false to get outputFiles
+  // Pass absWorkingDir so metafile paths are relative to the correct directory
+  const resolvedAbsWorkingDir = options.absWorkingDir || (typeof globalThis !== 'undefined' && globalThis.process && typeof globalThis.process.cwd === 'function' ? globalThis.process.cwd() : '/');
   const result = await esbuildInstance.build({
     ...options,
     entryPoints,
     plugins,
     write: false,
+    absWorkingDir: resolvedAbsWorkingDir,
   }) as BuildResult;
 
   // Strip 'vfs:' namespace prefix from output file paths

package/src/shims/fs.ts

@@ -5,9 +5,13 @@
 
 import { VirtualFS, createNodeError } from '../virtual-fs';
 import type { Stats, FSWatcher, WatchListener, WatchEventType } from '../virtual-fs';
+import { uint8ToBase64, uint8ToHex } from '../utils/binary-encoding';
 
 export type { Stats, FSWatcher, WatchListener, WatchEventType };
 
+const _decoder = new TextDecoder();
+const _encoder = new TextEncoder();
+
 export interface FsShim {
   readFileSync(path: string): Buffer;
   readFileSync(path: string, encoding: 'utf8' | 'utf-8'): string;
@@ -131,19 +135,13 @@ function createBuffer(data: Uint8Array): Buffer {
   Object.defineProperty(buffer, 'toString', {
     value: function (encoding?: string) {
       if (encoding === 'utf8' || encoding === 'utf-8' || !encoding) {
-        return new TextDecoder().decode(this);
+        return _decoder.decode(this);
       }
       if (encoding === 'base64') {
-        let binary = '';
-        for (let i = 0; i < this.length; i++) {
-          binary += String.fromCharCode(this[i]);
-        }
-        return btoa(binary);
+        return uint8ToBase64(this);
       }
       if (encoding === 'hex') {
-        return Array.from(this as Uint8Array)
-          .map((b) => b.toString(16).padStart(2, '0'))
-          .join('');
+        return uint8ToHex(this);
       }
       throw new Error(`Unsupported encoding: ${encoding}`);
     },
@@ -437,7 +435,7 @@ export function createFsShim(vfs: VirtualFS, getCwd?: () => string): FsShim {
           throw err;
         }
         // Convert string to Uint8Array if needed
-        const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+        const bytes = typeof data === 'string' ? _encoder.encode(data) : data;
         // Replace entire content
         entry.content = new Uint8Array(bytes);
         entry.position = bytes.length;
@@ -620,7 +618,7 @@ export function createFsShim(vfs: VirtualFS, getCwd?: () => string): FsShim {
       // Handle string input
       let data: Uint8Array;
       if (typeof buffer === 'string') {
-        data = new TextEncoder().encode(buffer);
+        data = _encoder.encode(buffer);
         offset = 0;
         length = data.length;
       } else {