almostnode 0.1.0

package/src/shims/v8.ts

@@ -0,0 +1,113 @@
+/**
+ * v8 shim - V8 engine internals are not available in browser
+ * Provides stubs for common usage patterns
+ */
+
+// Heap statistics stub
+export function getHeapStatistics() {
+  return {
+    total_heap_size: 0,
+    total_heap_size_executable: 0,
+    total_physical_size: 0,
+    total_available_size: 0,
+    used_heap_size: 0,
+    heap_size_limit: 0,
+    malloced_memory: 0,
+    peak_malloced_memory: 0,
+    does_zap_garbage: 0,
+    number_of_native_contexts: 0,
+    number_of_detached_contexts: 0,
+  };
+}
+
+export function getHeapSpaceStatistics() {
+  return [];
+}
+
+export function getHeapCodeStatistics() {
+  return {
+    code_and_metadata_size: 0,
+    bytecode_and_metadata_size: 0,
+    external_script_source_size: 0,
+  };
+}
+
+export function getHeapSnapshot() {
+  return null;
+}
+
+export function writeHeapSnapshot() {
+  return '';
+}
+
+export function setFlagsFromString(_flags: string) {
+  // No-op
+}
+
+export function takeCoverage() {
+  // No-op
+}
+
+export function stopCoverage() {
+  // No-op
+}
+
+// Serialization (basic stubs)
+export function serialize(value: unknown): Buffer {
+  const json = JSON.stringify(value);
+  return Buffer.from(json);
+}
+
+export function deserialize(buffer: Buffer): unknown {
+  return JSON.parse(buffer.toString());
+}
+
+export class Serializer {
+  writeHeader() {}
+  writeValue(_value: unknown) {}
+  releaseBuffer(): Buffer {
+    return Buffer.from('');
+  }
+}
+
+export class Deserializer {
+  constructor(_buffer: Buffer) {}
+  readHeader(): boolean {
+    return true;
+  }
+  readValue(): unknown {
+    return null;
+  }
+}
+
+export class DefaultSerializer extends Serializer {}
+export class DefaultDeserializer extends Deserializer {}
+
+// Promise hooks (stubs)
+export function promiseHooks() {
+  return {
+    onInit: () => {},
+    onSettled: () => {},
+    onBefore: () => {},
+    onAfter: () => {},
+    createHook: () => ({ enable: () => {}, disable: () => {} }),
+  };
+}
+
+export default {
+  getHeapStatistics,
+  getHeapSpaceStatistics,
+  getHeapCodeStatistics,
+  getHeapSnapshot,
+  writeHeapSnapshot,
+  setFlagsFromString,
+  takeCoverage,
+  stopCoverage,
+  serialize,
+  deserialize,
+  Serializer,
+  Deserializer,
+  DefaultSerializer,
+  DefaultDeserializer,
+  promiseHooks,
+};

package/src/shims/vfs-adapter.ts

@@ -0,0 +1,402 @@
+/**
+ * VirtualFS Adapter for just-bash
+ * Implements IFileSystem interface to bridge VirtualFS with just-bash
+ */
+
+import type {
+  IFileSystem,
+  FsStat,
+  MkdirOptions,
+  RmOptions,
+  CpOptions,
+  BufferEncoding,
+  FileContent,
+} from 'just-bash';
+import type { VirtualFS } from '../virtual-fs';
+import { createNodeError } from '../virtual-fs';
+
+// Local types for just-bash interface compatibility
+// These are not exported from just-bash main entry point
+interface DirentEntry {
+  name: string;
+  isFile: boolean;
+  isDirectory: boolean;
+  isSymbolicLink: boolean;
+}
+
+interface ReadFileOptions {
+  encoding?: BufferEncoding | null;
+}
+
+interface WriteFileOptions {
+  encoding?: BufferEncoding;
+}
+
+export class VirtualFSAdapter implements IFileSystem {
+  constructor(private vfs: VirtualFS) {}
+
+  /**
+   * Read the contents of a file as a string
+   */
+  async readFile(
+    path: string,
+    options?: ReadFileOptions | BufferEncoding
+  ): Promise<string> {
+    const encoding = typeof options === 'string' ? options : options?.encoding;
+
+    // VirtualFS only natively supports utf8/utf-8
+    // For other encodings, we need to handle the conversion ourselves
+    if (!encoding || encoding === 'utf8' || encoding === 'utf-8') {
+      return this.vfs.readFileSync(path, 'utf8');
+    }
+
+    // For binary/latin1 encoding, convert each byte to a character
+    if (encoding === 'binary' || encoding === 'latin1') {
+      const buffer = this.vfs.readFileSync(path);
+      return String.fromCharCode(...buffer);
+    }
+
+    // For other encodings, fall back to utf8
+    return this.vfs.readFileSync(path, 'utf8');
+  }
+
+  /**
+   * Read the contents of a file as a Uint8Array (binary)
+   */
+  async readFileBuffer(path: string): Promise<Uint8Array> {
+    return this.vfs.readFileSync(path);
+  }
+
+  /**
+   * Write content to a file, creating it if it doesn't exist
+   */
+  async writeFile(
+    path: string,
+    content: FileContent,
+    _options?: WriteFileOptions | BufferEncoding
+  ): Promise<void> {
+    this.vfs.writeFileSync(path, content);
+  }
+
+  /**
+   * Append content to a file, creating it if it doesn't exist
+   */
+  async appendFile(
+    path: string,
+    content: FileContent,
+    _options?: WriteFileOptions | BufferEncoding
+  ): Promise<void> {
+    let existing = '';
+    try {
+      existing = this.vfs.readFileSync(path, 'utf8');
+    } catch {
+      // File doesn't exist, start with empty content
+    }
+    const newContent =
+      typeof content === 'string' ? content : new TextDecoder().decode(content);
+    this.vfs.writeFileSync(path, existing + newContent);
+  }
+
+  /**
+   * Check if a path exists
+   */
+  async exists(path: string): Promise<boolean> {
+    return this.vfs.existsSync(path);
+  }
+
+  /**
+   * Get file/directory information
+   */
+  async stat(path: string): Promise<FsStat> {
+    const stats = this.vfs.statSync(path);
+    const isFile = stats.isFile();
+    const isDirectory = stats.isDirectory();
+
+    let size = 0;
+    if (isFile) {
+      try {
+        const content = this.vfs.readFileSync(path);
+        size = content.length;
+      } catch {
+        // Shouldn't happen, but default to 0
+      }
+    }
+
+    return {
+      isFile,
+      isDirectory,
+      isSymbolicLink: false,
+      mode: isDirectory ? 0o755 : 0o644,
+      size,
+      mtime: new Date(),
+    };
+  }
+
+  /**
+   * Create a directory
+   */
+  async mkdir(path: string, options?: MkdirOptions): Promise<void> {
+    this.vfs.mkdirSync(path, options);
+  }
+
+  /**
+   * Read directory contents
+   */
+  async readdir(path: string): Promise<string[]> {
+    return this.vfs.readdirSync(path);
+  }
+
+  /**
+   * Read directory contents with file type information
+   */
+  async readdirWithFileTypes(path: string): Promise<DirentEntry[]> {
+    const entries = this.vfs.readdirSync(path);
+    const result: DirentEntry[] = [];
+
+    for (const name of entries) {
+      const fullPath = path === '/' ? `/${name}` : `${path}/${name}`;
+      try {
+        const stats = this.vfs.statSync(fullPath);
+        result.push({
+          name,
+          isFile: stats.isFile(),
+          isDirectory: stats.isDirectory(),
+          isSymbolicLink: false,
+        });
+      } catch {
+        // Entry disappeared between readdir and stat, skip it
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Remove a file or directory
+   */
+  async rm(path: string, options?: RmOptions): Promise<void> {
+    const exists = this.vfs.existsSync(path);
+
+    if (!exists) {
+      if (options?.force) {
+        return; // Force mode ignores missing files
+      }
+      throw createNodeError('ENOENT', 'rm', path);
+    }
+
+    const stats = this.vfs.statSync(path);
+
+    if (stats.isFile()) {
+      this.vfs.unlinkSync(path);
+    } else if (stats.isDirectory()) {
+      if (options?.recursive) {
+        await this.rmRecursive(path);
+      } else {
+        this.vfs.rmdirSync(path);
+      }
+    }
+  }
+
+  /**
+   * Recursively remove a directory and its contents
+   */
+  private async rmRecursive(path: string): Promise<void> {
+    const entries = this.vfs.readdirSync(path);
+
+    for (const entry of entries) {
+      const fullPath = path === '/' ? `/${entry}` : `${path}/${entry}`;
+      const stats = this.vfs.statSync(fullPath);
+
+      if (stats.isDirectory()) {
+        await this.rmRecursive(fullPath);
+      } else {
+        this.vfs.unlinkSync(fullPath);
+      }
+    }
+
+    this.vfs.rmdirSync(path);
+  }
+
+  /**
+   * Copy a file or directory
+   */
+  async cp(src: string, dest: string, options?: CpOptions): Promise<void> {
+    const stats = this.vfs.statSync(src);
+
+    if (stats.isFile()) {
+      const content = this.vfs.readFileSync(src);
+      this.vfs.writeFileSync(dest, content);
+    } else if (stats.isDirectory()) {
+      if (!options?.recursive) {
+        throw new Error(
+          `EISDIR: illegal operation on a directory, cannot copy '${src}'`
+        );
+      }
+      await this.cpRecursive(src, dest);
+    }
+  }
+
+  /**
+   * Recursively copy a directory
+   */
+  private async cpRecursive(src: string, dest: string): Promise<void> {
+    // Create destination directory
+    this.vfs.mkdirSync(dest, { recursive: true });
+
+    const entries = this.vfs.readdirSync(src);
+
+    for (const entry of entries) {
+      const srcPath = src === '/' ? `/${entry}` : `${src}/${entry}`;
+      const destPath = dest === '/' ? `/${entry}` : `${dest}/${entry}`;
+      const stats = this.vfs.statSync(srcPath);
+
+      if (stats.isDirectory()) {
+        await this.cpRecursive(srcPath, destPath);
+      } else {
+        const content = this.vfs.readFileSync(srcPath);
+        this.vfs.writeFileSync(destPath, content);
+      }
+    }
+  }
+
+  /**
+   * Move/rename a file or directory
+   */
+  async mv(src: string, dest: string): Promise<void> {
+    this.vfs.renameSync(src, dest);
+  }
+
+  /**
+   * Resolve a relative path against a base path
+   */
+  resolvePath(base: string, path: string): string {
+    // If path is absolute, return it as-is (normalized)
+    if (path.startsWith('/')) {
+      return this.normalizePath(path);
+    }
+
+    // Combine base and relative path
+    const combined = base.endsWith('/')
+      ? `${base}${path}`
+      : `${base}/${path}`;
+
+    return this.normalizePath(combined);
+  }
+
+  /**
+   * Normalize a path (resolve . and .. segments)
+   */
+  private normalizePath(path: string): string {
+    if (!path.startsWith('/')) {
+      path = '/' + path;
+    }
+
+    const parts = path.split('/').filter(Boolean);
+    const resolved: string[] = [];
+
+    for (const part of parts) {
+      if (part === '..') {
+        resolved.pop();
+      } else if (part !== '.') {
+        resolved.push(part);
+      }
+    }
+
+    return '/' + resolved.join('/');
+  }
+
+  /**
+   * Get all paths in the filesystem
+   */
+  getAllPaths(): string[] {
+    const paths: string[] = [];
+    this.collectPaths('/', paths);
+    return paths;
+  }
+
+  /**
+   * Recursively collect all paths
+   */
+  private collectPaths(dir: string, paths: string[]): void {
+    try {
+      const entries = this.vfs.readdirSync(dir);
+      for (const entry of entries) {
+        const fullPath = dir === '/' ? `/${entry}` : `${dir}/${entry}`;
+        paths.push(fullPath);
+        try {
+          const stats = this.vfs.statSync(fullPath);
+          if (stats.isDirectory()) {
+            this.collectPaths(fullPath, paths);
+          }
+        } catch {
+          // Skip if stat fails
+        }
+      }
+    } catch {
+      // Directory doesn't exist or can't be read
+    }
+  }
+
+  /**
+   * Change file/directory permissions (no-op - VFS doesn't track permissions)
+   */
+  async chmod(_path: string, _mode: number): Promise<void> {
+    // VFS doesn't track permissions, but we verify the path exists
+    if (!this.vfs.existsSync(_path)) {
+      throw createNodeError('ENOENT', 'chmod', _path);
+    }
+    // No-op
+  }
+
+  /**
+   * Create a symbolic link (not supported)
+   */
+  async symlink(_target: string, _linkPath: string): Promise<void> {
+    throw new Error('Symbolic links are not supported in VirtualFS');
+  }
+
+  /**
+   * Create a hard link (not supported)
+   */
+  async link(_existingPath: string, _newPath: string): Promise<void> {
+    throw new Error('Hard links are not supported in VirtualFS');
+  }
+
+  /**
+   * Read the target of a symbolic link (not supported)
+   */
+  async readlink(_path: string): Promise<string> {
+    throw new Error('Symbolic links are not supported in VirtualFS');
+  }
+
+  /**
+   * Get file/directory information without following symlinks
+   * Since VFS doesn't support symlinks, this is the same as stat
+   */
+  async lstat(path: string): Promise<FsStat> {
+    return this.stat(path);
+  }
+
+  /**
+   * Resolve all symlinks in a path
+   * Since VFS doesn't support symlinks, just normalize and return
+   */
+  async realpath(path: string): Promise<string> {
+    // Verify path exists
+    if (!this.vfs.existsSync(path)) {
+      throw createNodeError('ENOENT', 'realpath', path);
+    }
+    return this.normalizePath(path);
+  }
+
+  /**
+   * Set access and modification times (no-op - VFS doesn't track times)
+   */
+  async utimes(path: string, _atime: Date, _mtime: Date): Promise<void> {
+    // VFS doesn't track times, but we verify the path exists
+    if (!this.vfs.existsSync(path)) {
+      throw createNodeError('ENOENT', 'utimes', path);
+    }
+    // No-op
+  }
+}

package/src/shims/vm.ts

@@ -0,0 +1,83 @@
+/**
+ * vm shim - Basic VM functionality using eval
+ */
+
+export class Script {
+  private code: string;
+
+  constructor(code: string, _options?: object) {
+    this.code = code;
+  }
+
+  runInThisContext(_options?: object): unknown {
+    return eval(this.code);
+  }
+
+  runInNewContext(contextObject?: object, _options?: object): unknown {
+    const keys = contextObject ? Object.keys(contextObject) : [];
+    const values = contextObject ? Object.values(contextObject) : [];
+    const fn = new Function(...keys, `return eval(${JSON.stringify(this.code)})`);
+    return fn(...values);
+  }
+
+  runInContext(_context: object, _options?: object): unknown {
+    return this.runInNewContext(_context, _options);
+  }
+
+  createCachedData(): Buffer {
+    return Buffer.from('');
+  }
+}
+
+export function createContext(contextObject?: object, _options?: object): object {
+  return contextObject || {};
+}
+
+export function isContext(_sandbox: object): boolean {
+  return true;
+}
+
+export function runInThisContext(code: string, _options?: object): unknown {
+  return eval(code);
+}
+
+export function runInNewContext(code: string, contextObject?: object, _options?: object): unknown {
+  const script = new Script(code);
+  return script.runInNewContext(contextObject);
+}
+
+export function runInContext(code: string, context: object, _options?: object): unknown {
+  return runInNewContext(code, context);
+}
+
+export function compileFunction(code: string, params?: string[], _options?: object): Function {
+  return new Function(...(params || []), code);
+}
+
+export class Module {
+  constructor(_code: string, _options?: object) {}
+  link(_linker: unknown): Promise<void> { return Promise.resolve(); }
+  evaluate(_options?: object): Promise<unknown> { return Promise.resolve(); }
+  get status(): string { return 'unlinked'; }
+  get identifier(): string { return ''; }
+  get context(): object { return {}; }
+  get namespace(): object { return {}; }
+}
+
+export class SourceTextModule extends Module {}
+export class SyntheticModule extends Module {
+  setExport(_name: string, _value: unknown): void {}
+}
+
+export default {
+  Script,
+  createContext,
+  isContext,
+  runInThisContext,
+  runInNewContext,
+  runInContext,
+  compileFunction,
+  Module,
+  SourceTextModule,
+  SyntheticModule,
+};

package/src/shims/worker_threads.ts

@@ -0,0 +1,111 @@
+/**
+ * worker_threads shim - Worker threads API
+ * Stub implementation for browser environment
+ */
+
+import { EventEmitter } from './events';
+
+export const isMainThread = true;
+export const parentPort = null;
+export const workerData = null;
+export const threadId = 0;
+
+export class Worker extends EventEmitter {
+  threadId = 0;
+  resourceLimits = {};
+
+  constructor(filename: string, options?: { workerData?: unknown }) {
+    super();
+    console.warn('Worker threads are not fully supported in browser environment');
+  }
+
+  postMessage(value: unknown, transferList?: unknown[]): void {
+    // No-op
+  }
+
+  terminate(): Promise<number> {
+    return Promise.resolve(0);
+  }
+
+  ref(): void {}
+  unref(): void {}
+
+  getHeapSnapshot(): Promise<unknown> {
+    return Promise.resolve({});
+  }
+}
+
+export class MessageChannel {
+  port1 = new MessagePort();
+  port2 = new MessagePort();
+}
+
+export class MessagePort extends EventEmitter {
+  postMessage(value: unknown, transferList?: unknown[]): void {
+    // No-op
+  }
+
+  start(): void {}
+  close(): void {}
+  ref(): void {}
+  unref(): void {}
+}
+
+export class BroadcastChannel extends EventEmitter {
+  name: string;
+
+  constructor(name: string) {
+    super();
+    this.name = name;
+  }
+
+  postMessage(message: unknown): void {
+    // No-op in single-threaded environment
+  }
+
+  close(): void {}
+  ref(): void {}
+  unref(): void {}
+}
+
+export function moveMessagePortToContext(
+  port: MessagePort,
+  contextifiedSandbox: unknown
+): MessagePort {
+  return port;
+}
+
+export function receiveMessageOnPort(port: MessagePort): { message: unknown } | undefined {
+  return undefined;
+}
+
+export const SHARE_ENV = Symbol.for('nodejs.worker_threads.SHARE_ENV');
+
+export function markAsUntransferable(object: unknown): void {
+  // No-op
+}
+
+export function getEnvironmentData(key: unknown): unknown {
+  return undefined;
+}
+
+export function setEnvironmentData(key: unknown, value: unknown): void {
+  // No-op
+}
+
+export default {
+  isMainThread,
+  parentPort,
+  workerData,
+  threadId,
+  Worker,
+  MessageChannel,
+  MessagePort,
+  BroadcastChannel,
+  moveMessagePortToContext,
+  receiveMessageOnPort,
+  SHARE_ENV,
+  markAsUntransferable,
+  getEnvironmentData,
+  setEnvironmentData,
+};