@volter/tabnode 0.2.14-volter.88

package/src/shims/vfs-adapter.ts

@@ -0,0 +1,408 @@
+/**
+ * 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';
+import { uint8ToBinaryString } from '../utils/binary-encoding';
+
+const _decoder = new TextDecoder();
+
+// 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 uint8ToBinaryString(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 : _decoder.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
+      }
+    }
+
+    // Files in .bin/ directories need execute permission for just-bash PATH resolution
+    const isExecutable = isFile && path.includes('/node_modules/.bin/');
+
+    return {
+      isFile,
+      isDirectory,
+      isSymbolicLink: false,
+      mode: isDirectory ? 0o755 : (isExecutable ? 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,132 @@
+/**
+ * vm shim - Basic VM functionality using eval
+ *
+ * `vm.runInNewContext(code, sandbox)` runs the code with the sandbox as its
+ * global: what the code writes on `globalThis` lands on the sandbox, and a name
+ * the sandbox lacks reads from the host's global. This passed the sandbox's
+ * keys as parameters, so `globalThis.x = ...` wrote to the real global and the
+ * caller read nothing back. Next's server evaluates each client-reference
+ * manifest exactly that way and read an empty object.
+ */
+
+import { parse } from 'acorn';
+
+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 sandbox: Record<string | symbol, unknown> = contextObject && typeof contextObject === 'object' ? contextObject as Record<string | symbol, unknown> : {};
+    // A script's top-level `var` and function declarations are properties of
+    // its context's global, as they are of Node's; they are read off the
+    // script and copied onto the sandbox once it has run.
+    const declared: string[] = [];
+    try {
+      const ast = parse(this.code, { ecmaVersion: 'latest', sourceType: 'script', allowReturnOutsideFunction: true, allowAwaitOutsideFunction: true });
+      for (const node of ast.body) {
+        if (node.type === 'FunctionDeclaration' && node.id) declared.push(node.id.name);
+        if (node.type === 'VariableDeclaration' && node.kind === 'var') for (const d of node.declarations) if (d.id.type === 'Identifier') declared.push(d.id.name);
+      }
+    } catch {
+      // A script the parser refuses still runs; its declarations stay its own.
+    }
+    // The scope answers every name but the evaluator's own and the script's declarations.
+    const own = new Set(['__substrateScope', '__substrateCode', '__substrateDeclared', ...declared]);
+    // The context's global as the script sees it through `globalThis`: the
+    // sandbox's own properties answer `in`, a read of a name it lacks
+    // falls back to the host's, a write lands on the sandbox.
+    const globalView: Record<string | symbol, unknown> = new Proxy(sandbox, {
+      has: (target, name) => name in target,
+      get: (target, name) => {
+        if (name === 'globalThis' || name === 'global' || name === 'self') return name in target ? target[name] : globalView;
+        return name in target ? target[name] : (globalThis as unknown as Record<string | symbol, unknown>)[name];
+      },
+      set: (target, name, value) => { target[name] = value; return true; },
+      deleteProperty: (target, name) => { delete target[name]; return true; },
+    });
+    // The scope every bare name resolves through: the sandbox first, the
+    // host's global after, and the evaluator's own names and the script's
+    // declarations left to the function that holds them.
+    const scope = new Proxy(sandbox, {
+      has: (_target, name) => !own.has(name as string),
+      get: (target, name) => {
+        if (name === Symbol.unscopables) return void 0;
+        if (name === 'globalThis' || name === 'global' || name === 'self') return name in target ? target[name] : globalView;
+        if (name in target) return target[name];
+        return (globalThis as unknown as Record<string | symbol, unknown>)[name];
+      },
+      set: (target, name, value) => { target[name] = value; return true; },
+      deleteProperty: (target, name) => { delete target[name]; return true; },
+    });
+    const fn = new Function('__substrateScope', '__substrateCode', '__substrateDeclared', 'with (__substrateScope) { const __substrateResult = eval(__substrateCode); for (const name of __substrateDeclared) { try { __substrateScope[name] = eval(name); } catch {} } return __substrateResult; }');
+    return fn(scope, this.code, declared);
+  }
+
+  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,
+};