@volter/tabnode 0.2.14-volter.88

package/src/shims/fs.ts

@@ -0,0 +1,82 @@
+/**
+ * `createFsShim`: Node's own `fs`, over a tree a caller names.
+ *
+ * This file was 1,764 lines: a hand-written imitation of Node's whole `fs`
+ * layer -- every validation, every encoding, `Stats`, `Dirent`, the streams,
+ * the promises and the error messages -- over the engine's virtual
+ * filesystem. v0.2.14-volter.56 made a guest's `require('fs')` Node's own
+ * file on a binding, and the imitation stayed only because the engine's own
+ * parts still called it. This is what they call, and nothing more.
+ *
+ * WHO CALLS IT, and why it cannot simply be the module: Node's `fs` is one
+ * module for the whole engine and reads its tree off the process of the run
+ * whose code is executing. Three callers have a tree but are not a run --
+ * the engine hands WASI one, the substrate builds with rolldown over a
+ * project's, and the Next dev server reads one -- so each call made through
+ * here names its tree for the length of that call, and inside it Node's own
+ * `fs` runs unchanged.
+ */
+import { fsModule } from '../node-lib/fs-module';
+import { withFilesystem } from '../node-lib/binding/fs';
+import type { VirtualFS } from '../virtual-fs';
+
+/** Node's `fs`, as a caller of `createFsShim` reads it: the module is Node's own file, so its shape is Node's. */
+export type FsShim = typeof import('node:fs');
+
+/** One function, or one nested object of them, bound to a tree. */
+function boundTo(tree: VirtualFS, value: unknown): unknown {
+  if (typeof value === 'function') {
+    return (...args: unknown[]): unknown => withFilesystem(tree, () => (value as (...a: unknown[]) => unknown)(...args));
+  }
+  // `fs.promises` and `fs.constants` are objects of their own; the first
+  // needs the same binding, the second is numbers.
+  if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+    return new Proxy(value as object, {
+      get: (target, key) => boundTo(tree, Reflect.get(target, key)),
+    });
+  }
+  return value;
+}
+
+/**
+ * Node's `fs` is an ordinary module object, and a program may define on it:
+ * `graceful-fs` -- which half of npm loads, openvscode-server through
+ * `fs-extra` and `@vscode/deviceid` -- writes its queue onto the module with
+ * `Object.defineProperty(fs, Symbol.for('graceful-fs.queue'), { get() {…} })`
+ * and then clones the module, which walks its keys. Every trap below read the
+ * module and none read the proxy's own target, so a guest's define landed
+ * where nothing looked: the read came back `undefined`, `key in fs` answered
+ * false for a key the target held non-configurable, and `Reflect.ownKeys(fs)`
+ * threw `'ownKeys' on proxy: trap result did not include
+ * 'Symbol(graceful-fs.queue)'` -- a proxy may not hide a non-configurable own
+ * key of its target. graceful-fs threw out of its own module load, and every
+ * program that loads it died there: in the substrate's tab that was
+ * openvscode-server's server at boot and its extension host, which exited 1
+ * without a word because a forked host's console goes to its parent over IPC.
+ *
+ * What a guest writes is the guest's, and what it did not write is the
+ * module's; the guest global's proxy in `src/runtime.ts` answers the same way.
+ */
+export function createFsShim(tree: VirtualFS, _getCwd?: () => string): FsShim {
+  const own = (target: object, key: PropertyKey): boolean =>
+    Reflect.getOwnPropertyDescriptor(target, key) !== undefined;
+  return new Proxy({} as FsShim, {
+    get: (target, key, receiver) => (own(target, key)
+      ? Reflect.get(target, key, receiver)
+      : boundTo(tree, Reflect.get(fsModule as object, key))),
+    has: (target, key) => own(target, key) || Reflect.has(fsModule as object, key),
+    ownKeys: (target) => {
+      const keys = Reflect.ownKeys(target);
+      for (const key of Reflect.ownKeys(fsModule as object)) if (!keys.includes(key)) keys.push(key);
+      return keys;
+    },
+    getOwnPropertyDescriptor: (target, key) => {
+      const mine = Reflect.getOwnPropertyDescriptor(target, key);
+      if (mine !== undefined) return mine;
+      const descriptor = Reflect.getOwnPropertyDescriptor(fsModule as object, key);
+      return descriptor === undefined ? undefined : { ...descriptor, configurable: true };
+    },
+  });
+}
+
+export default createFsShim;

package/src/shims/http2.ts

@@ -0,0 +1,96 @@
+/**
+ * http2 shim - HTTP/2 is not available in browser
+ */
+
+import { EventEmitter } from '../node-lib/events-module';
+
+export class Http2Session extends EventEmitter {
+  close(_callback?: () => void): void {
+    if (_callback) setTimeout(_callback, 0);
+  }
+  destroy(_error?: Error, _code?: number): void {}
+  get destroyed(): boolean { return false; }
+  get encrypted(): boolean { return false; }
+  get closed(): boolean { return false; }
+  ping(_callback: (err: Error | null, duration: number, payload: Buffer) => void): boolean {
+    return false;
+  }
+  ref(): void {}
+  unref(): void {}
+  setTimeout(_msecs: number, _callback?: () => void): void {}
+}
+
+export class ClientHttp2Session extends Http2Session {}
+export class ServerHttp2Session extends Http2Session {}
+
+export class Http2Stream extends EventEmitter {
+  close(_code?: number, _callback?: () => void): void {}
+  get id(): number { return 0; }
+  get pending(): boolean { return false; }
+  get destroyed(): boolean { return false; }
+  get closed(): boolean { return false; }
+  priority(_options: unknown): void {}
+  setTimeout(_msecs: number, _callback?: () => void): void {}
+  end(_data?: unknown, _encoding?: string, _callback?: () => void): void {}
+}
+
+export class Http2ServerRequest extends EventEmitter {}
+export class Http2ServerResponse extends EventEmitter {
+  writeHead(_statusCode: number, _headers?: object): this { return this; }
+  end(_data?: unknown): void {}
+}
+
+export function createServer(_options?: unknown, _onRequestHandler?: unknown): EventEmitter {
+  return new EventEmitter();
+}
+
+export function createSecureServer(_options?: unknown, _onRequestHandler?: unknown): EventEmitter {
+  return new EventEmitter();
+}
+
+export function connect(_authority: string, _options?: unknown, _listener?: () => void): ClientHttp2Session {
+  return new ClientHttp2Session();
+}
+
+export const constants = {
+  NGHTTP2_SESSION_SERVER: 0,
+  NGHTTP2_SESSION_CLIENT: 1,
+  HTTP2_HEADER_STATUS: ':status',
+  HTTP2_HEADER_METHOD: ':method',
+  HTTP2_HEADER_AUTHORITY: ':authority',
+  HTTP2_HEADER_SCHEME: ':scheme',
+  HTTP2_HEADER_PATH: ':path',
+  HTTP_STATUS_OK: 200,
+  HTTP_STATUS_NOT_FOUND: 404,
+};
+
+export function getDefaultSettings(): object {
+  return {};
+}
+
+export function getPackedSettings(_settings?: object): Buffer {
+  return Buffer.from('');
+}
+
+export function getUnpackedSettings(_buf: Buffer): object {
+  return {};
+}
+
+export const sensitiveHeaders = Symbol('sensitiveHeaders');
+
+export default {
+  Http2Session,
+  ClientHttp2Session,
+  ServerHttp2Session,
+  Http2Stream,
+  Http2ServerRequest,
+  Http2ServerResponse,
+  createServer,
+  createSecureServer,
+  connect,
+  constants,
+  getDefaultSettings,
+  getPackedSettings,
+  getUnpackedSettings,
+  sensitiveHeaders,
+};

package/src/shims/inspector.ts

@@ -0,0 +1,30 @@
+/**
+ * inspector shim - V8 inspector is not available in browser
+ */
+
+import { EventEmitter } from '../node-lib/events-module';
+
+export class Session extends EventEmitter {
+  connect(): void {}
+  connectToMainThread(): void {}
+  disconnect(): void {}
+  post(_method: string, _params?: object, _callback?: (err: Error | null, result?: object) => void): void {
+    if (_callback) setTimeout(() => _callback(null, {}), 0);
+  }
+}
+
+export function open(_port?: number, _host?: string, _wait?: boolean): void {}
+export function close(): void {}
+export function url(): string | undefined { return undefined; }
+export function waitForDebugger(): void {}
+
+export const console = globalThis.console;
+
+export default {
+  Session,
+  open,
+  close,
+  url,
+  waitForDebugger,
+  console,
+};

package/src/shims/module.ts

@@ -0,0 +1,86 @@
+/**
+ * Node.js module shim
+ * Provides basic module system functionality
+ */
+
+import * as pathShim from './path';
+
+export function createRequire(filename: string): (id: string) => unknown {
+  // Return a require function that can be used by modules
+  return function require(id: string): unknown {
+    throw new Error(`Cannot find module '${id}' from '${filename}'`);
+  };
+}
+
+export const builtinModules = [
+  'assert',
+  'buffer',
+  'child_process',
+  'cluster',
+  'console',
+  'constants',
+  'crypto',
+  'dgram',
+  'dns',
+  'domain',
+  'events',
+  'fs',
+  'http',
+  'https',
+  'module',
+  'net',
+  'os',
+  'path',
+  'perf_hooks',
+  'process',
+  'punycode',
+  'querystring',
+  'readline',
+  'repl',
+  'stream',
+  'stream/web',
+  'string_decoder',
+  'sys',
+  'timers',
+  'tls',
+  'tty',
+  'url',
+  'util',
+  'v8',
+  'vm',
+  'wasi',
+  'worker_threads',
+  'zlib',
+];
+
+export function isBuiltin(moduleName: string): boolean {
+  // Strip node: prefix if present
+  const name = moduleName.startsWith('node:') ? moduleName.slice(5) : moduleName;
+  return builtinModules.includes(name);
+}
+
+export const _cache: Record<string, unknown> = {};
+export const _extensions: Record<string, unknown> = {
+  '.js': () => {},
+  '.json': () => {},
+  '.node': (_module: unknown, filename?: string) => {
+    throw Object.assign(new Error('Cannot load native addon ' + (filename || '') + ': a tab runs no native code.'), { code: 'ERR_DLOPEN_FAILED' });
+  },
+};
+export const _pathCache: Record<string, string> = {};
+
+export function syncBuiltinESMExports(): void {
+  // No-op in browser
+}
+
+export const Module = {
+  createRequire,
+  builtinModules,
+  isBuiltin,
+  _cache,
+  _extensions,
+  _pathCache,
+  syncBuiltinESMExports,
+};
+
+export default Module;

package/src/shims/os.ts

@@ -0,0 +1,195 @@
+/**
+ * Node.js os module shim
+ * Provides operating system utilities
+ */
+
+export function hostname(): string {
+  return 'localhost';
+}
+
+export function platform(): string {
+  return 'linux';
+}
+
+export function arch(): string {
+  return 'x64';
+}
+
+export function type(): string {
+  return 'Linux';
+}
+
+export function release(): string {
+  return '5.10.0';
+}
+
+export function version(): string {
+  return '#1 SMP';
+}
+
+export function machine(): string {
+  return 'x86_64';
+}
+
+export function tmpdir(): string {
+  return '/tmp';
+}
+
+export function homedir(): string {
+  return '/home/user';
+}
+
+export function cpus(): Array<{
+  model: string;
+  speed: number;
+  times: { user: number; nice: number; sys: number; idle: number; irq: number };
+}> {
+  const cpu = {
+    model: 'Virtual CPU',
+    speed: 2400,
+    times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 },
+  };
+  return [cpu, cpu]; // Simulate 2 CPUs
+}
+
+export function totalmem(): number {
+  return 4 * 1024 * 1024 * 1024; // 4GB
+}
+
+export function freemem(): number {
+  return 2 * 1024 * 1024 * 1024; // 2GB
+}
+
+export function uptime(): number {
+  return Math.floor(performance.now() / 1000);
+}
+
+export function loadavg(): [number, number, number] {
+  return [0.5, 0.5, 0.5];
+}
+
+export function networkInterfaces(): Record<
+  string,
+  Array<{
+    address: string;
+    netmask: string;
+    family: string;
+    mac: string;
+    internal: boolean;
+    cidr: string;
+  }>
+> {
+  return {
+    lo: [
+      {
+        address: '127.0.0.1',
+        netmask: '255.0.0.0',
+        family: 'IPv4',
+        mac: '00:00:00:00:00:00',
+        internal: true,
+        cidr: '127.0.0.1/8',
+      },
+    ],
+  };
+}
+
+export function userInfo(): {
+  username: string;
+  uid: number;
+  gid: number;
+  shell: string;
+  homedir: string;
+} {
+  return {
+    username: 'user',
+    uid: 1000,
+    gid: 1000,
+    shell: '/bin/bash',
+    homedir: '/home/user',
+  };
+}
+
+export function endianness(): 'BE' | 'LE' {
+  return 'LE';
+}
+
+export function getPriority(pid?: number): number {
+  return 0;
+}
+
+export function setPriority(pid: number | number, priority?: number): void {
+  // No-op
+}
+
+export const EOL = '\n';
+
+export const constants = {
+  signals: {
+    SIGHUP: 1,
+    SIGINT: 2,
+    SIGQUIT: 3,
+    SIGILL: 4,
+    SIGTRAP: 5,
+    SIGABRT: 6,
+    SIGBUS: 7,
+    SIGFPE: 8,
+    SIGKILL: 9,
+    SIGUSR1: 10,
+    SIGSEGV: 11,
+    SIGUSR2: 12,
+    SIGPIPE: 13,
+    SIGALRM: 14,
+    SIGTERM: 15,
+    SIGCHLD: 17,
+    SIGCONT: 18,
+    SIGSTOP: 19,
+    SIGTSTP: 20,
+    SIGTTIN: 21,
+    SIGTTOU: 22,
+    SIGURG: 23,
+    SIGXCPU: 24,
+    SIGXFSZ: 25,
+    SIGVTALRM: 26,
+    SIGPROF: 27,
+    SIGWINCH: 28,
+    SIGIO: 29,
+    SIGPWR: 30,
+    SIGSYS: 31,
+  },
+  errno: {},
+  priority: {
+    PRIORITY_LOW: 19,
+    PRIORITY_BELOW_NORMAL: 10,
+    PRIORITY_NORMAL: 0,
+    PRIORITY_ABOVE_NORMAL: -7,
+    PRIORITY_HIGH: -14,
+    PRIORITY_HIGHEST: -20,
+  },
+};
+
+export const devNull = '/dev/null';
+
+export default {
+  hostname,
+  platform,
+  arch,
+  type,
+  release,
+  version,
+  machine,
+  tmpdir,
+  homedir,
+  cpus,
+  totalmem,
+  freemem,
+  uptime,
+  loadavg,
+  networkInterfaces,
+  userInfo,
+  endianness,
+  getPriority,
+  setPriority,
+  EOL,
+  constants,
+  devNull,
+};