@nimbus-sh/core 0.1.0

package/src/substrate/lifo/node-compat/index.ts

@@ -0,0 +1,300 @@
+import type { VFS } from '../kernel/vfs/index.js';
+import type { CommandOutputStream } from '../commands/types.js';
+import { createFs } from './fs.js';
+import pathModule from './path.js';
+import { createOs } from './os.js';
+import { createProcess } from './process.js';
+import { EventEmitter } from './events.js';
+import { Buffer } from './buffer.js';
+import * as utilModule from './util.js';
+import { createHttp } from './http.js';
+import type { LoopbackRouter, VirtualRequestHandler } from '../kernel/index.js';
+import { createChildProcess } from './child_process.js';
+import * as streamModule from './stream.js';
+import * as urlModule from './url.js';
+import * as timersModule from './timers.js';
+import * as cryptoModule from './crypto.js';
+import * as zlibModule from './zlib.js';
+import * as stringDecoderModule from './string_decoder.js';
+import * as ttyModule from './tty.js';
+import * as dnsModule from './dns.js';
+import { createModuleShim } from './module.js';
+import * as readlineModule from './readline.js';
+import { createRimraf } from './rimraf.js';
+import { createEsbuild } from './esbuild.js';
+
+export interface NodeContext {
+  vfs: VFS;
+  cwd: string;
+  env: Record<string, string>;
+  stdout: CommandOutputStream;
+  stderr: CommandOutputStream;
+  argv: string[];
+  filename: string;
+  dirname: string;
+  signal: AbortSignal;
+  executeCapture?: (input: string) => Promise<string>;
+  portRegistry?: Map<number, VirtualRequestHandler>;
+  routeLoopback?: LoopbackRouter;
+}
+
+export function createModuleMap(ctx: NodeContext): Record<string, () => unknown> {
+  const map: Record<string, () => unknown> = {
+    fs: () => createFs(ctx.vfs, ctx.cwd),
+    'fs/promises': () => createFs(ctx.vfs, ctx.cwd).promises,
+    path: () => pathModule,
+    os: () => createOs(ctx.env),
+    process: () => createProcess({
+      argv: ctx.argv,
+      env: ctx.env,
+      cwd: ctx.cwd,
+      stdout: ctx.stdout,
+      stderr: ctx.stderr,
+    }),
+    events: () => {
+      // Node.js CJS: require('events') returns the EventEmitter constructor itself
+      const mod = EventEmitter as typeof EventEmitter & { EventEmitter: typeof EventEmitter; default: typeof EventEmitter };
+      mod.EventEmitter = EventEmitter;
+      mod.default = EventEmitter;
+      return mod;
+    },
+    buffer: () => ({ Buffer }),
+    util: () => utilModule,
+    http: () => createHttp(ctx.portRegistry, 'http:', ctx.routeLoopback),
+    https: () => createHttp(ctx.portRegistry, 'https:', ctx.routeLoopback),
+    child_process: () => createChildProcess(ctx.executeCapture),
+    stream: () => {
+      // Node.js CJS: require('stream') returns the Stream base class with
+      // .Readable, .Writable, .Duplex, .PassThrough, .Stream attached
+      const Stream = EventEmitter as unknown as (typeof EventEmitter & {
+        Stream: typeof EventEmitter;
+        Readable: typeof streamModule.Readable;
+        Writable: typeof streamModule.Writable;
+        Duplex: typeof streamModule.Duplex;
+        PassThrough: typeof streamModule.PassThrough;
+        default: typeof EventEmitter;
+      });
+      Stream.Stream = Stream;
+      Stream.Readable = streamModule.Readable;
+      Stream.Writable = streamModule.Writable;
+      Stream.Duplex = streamModule.Duplex;
+      Stream.PassThrough = streamModule.PassThrough;
+      Stream.default = Stream;
+      return Stream;
+    },
+    url: () => urlModule,
+    timers: () => timersModule,
+    crypto: () => cryptoModule,
+    zlib: () => zlibModule,
+    string_decoder: () => stringDecoderModule,
+    tty: () => ttyModule,
+    dns: () => dnsModule,
+    'dns/promises': () => dnsModule.promises,
+    readline: () => readlineModule,
+    'readline/promises': () => readlineModule.promises,
+    constants: () => {
+      const fs = createFs(ctx.vfs, ctx.cwd);
+      const os = createOs(ctx.env);
+      return { ...os.constants, ...fs.constants };
+    },
+    querystring: () => ({
+      parse: (str: string) => {
+        const out: Record<string, string> = {};
+        new URLSearchParams(str).forEach((value, key) => {
+          out[key] = value;
+        });
+        return out;
+      },
+      stringify: (obj: Record<string, string>) => new URLSearchParams(obj).toString(),
+      escape: encodeURIComponent,
+      unescape: decodeURIComponent,
+    }),
+    assert: () => {
+      const assert = (value: unknown, message?: string) => {
+        if (!value) throw new Error(message || 'AssertionError');
+      };
+      assert.ok = assert;
+      assert.equal = (a: unknown, b: unknown, msg?: string) => { if (a != b) throw new Error(msg || `${a} != ${b}`); };
+      assert.strictEqual = (a: unknown, b: unknown, msg?: string) => { if (a !== b) throw new Error(msg || `${a} !== ${b}`); };
+      assert.notEqual = (a: unknown, b: unknown, msg?: string) => { if (a == b) throw new Error(msg || `${a} == ${b}`); };
+      assert.notStrictEqual = (a: unknown, b: unknown, msg?: string) => { if (a === b) throw new Error(msg || `${a} === ${b}`); };
+      assert.deepStrictEqual = (a: unknown, b: unknown, msg?: string) => {
+        if (JSON.stringify(a) !== JSON.stringify(b)) throw new Error(msg || 'deepStrictEqual failed');
+      };
+      assert.throws = (fn: () => void, msg?: string) => {
+        try { fn(); throw new Error(msg || 'Expected function to throw'); } catch (e) { if (e instanceof Error && e.message === (msg || 'Expected function to throw')) throw e; }
+      };
+      return assert;
+    },
+    // v8 — stub (vite side-effect imports it)
+    v8: () => ({
+      getHeapStatistics: () => ({
+        total_heap_size: 0, used_heap_size: 0, heap_size_limit: 0,
+        total_physical_size: 0, total_available_size: 0,
+        malloced_memory: 0, peak_malloced_memory: 0,
+      }),
+      serialize: (v: unknown) => new Uint8Array(0),
+      deserialize: () => undefined,
+    }),
+    // perf_hooks — vite uses { performance } which is a browser global
+    perf_hooks: () => ({
+      performance,
+      PerformanceObserver: typeof PerformanceObserver === 'undefined'
+        ? class PerformanceObserver { observe() {} disconnect() {} }
+        : PerformanceObserver,
+    }),
+    // net — stub (vite imports it but only uses it for actual TCP in server mode)
+    net: () => ({
+      createServer: () => {
+        const s = new EventEmitter() as unknown as Record<string, unknown>;
+        s.listen = (_port: unknown, _host: unknown, cb?: () => void) => { cb?.(); return s; };
+        s.close = (cb?: () => void) => { cb?.(); return s; };
+        s.address = () => ({ port: 0, family: 'IPv4', address: '127.0.0.1' });
+        s.unref = () => s;
+        s.ref = () => s;
+        return s;
+      },
+      createConnection: () => {
+        const s = new EventEmitter() as unknown as Record<string, unknown>;
+        s.write = () => true;
+        s.end = () => s;
+        s.destroy = () => s;
+        s.connect = () => s;
+        s.unref = () => s;
+        s.ref = () => s;
+        s.setTimeout = () => s;
+        s.setNoDelay = () => s;
+        s.setKeepAlive = () => s;
+        return s;
+      },
+      connect: (...args: unknown[]) => {
+        const s = new EventEmitter() as unknown as Record<string, unknown>;
+        s.write = () => true;
+        s.end = () => s;
+        s.destroy = () => s;
+        s.unref = () => s;
+        s.ref = () => s;
+        s.setTimeout = () => s;
+        s.setNoDelay = () => s;
+        s.setKeepAlive = () => s;
+        // call connection callback if provided
+        const cb = typeof args[args.length - 1] === 'function' ? args[args.length - 1] as () => void : null;
+        if (cb) queueMicrotask(cb);
+        return s;
+      },
+      Socket: class Socket extends EventEmitter {
+        write() { return true; }
+        end() { return this; }
+        destroy() { return this; }
+        connect() { return this; }
+        unref() { return this; }
+        ref() { return this; }
+        setTimeout() { return this; }
+        setNoDelay() { return this; }
+        setKeepAlive() { return this; }
+      },
+      Server: class Server extends EventEmitter {
+        listen(_port: unknown, _host: unknown, cb?: () => void) { cb?.(); return this; }
+        close(cb?: () => void) { cb?.(); return this; }
+        address() { return { port: 0, family: 'IPv4', address: '127.0.0.1' }; }
+        unref() { return this; }
+        ref() { return this; }
+      },
+      isIP: (s: string) => /^\d+\.\d+\.\d+\.\d+$/.test(s) ? 4 : /^[0-9a-f:]+$/i.test(s) ? 6 : 0,
+      isIPv4: (s: string) => /^\d+\.\d+\.\d+\.\d+$/.test(s),
+      isIPv6: (s: string) => /^[0-9a-f:]+$/i.test(s),
+    }),
+    // tls — stub
+    tls: () => ({
+      createServer: () => {
+        const s = new EventEmitter() as unknown as Record<string, unknown>;
+        s.listen = (_port: unknown, _host: unknown, cb?: () => void) => { cb?.(); return s; };
+        s.close = (cb?: () => void) => { cb?.(); return s; };
+        s.address = () => ({ port: 0, family: 'IPv4', address: '127.0.0.1' });
+        return s;
+      },
+      connect: () => {
+        const s = new EventEmitter() as unknown as Record<string, unknown>;
+        s.write = () => true;
+        s.end = () => s;
+        s.destroy = () => s;
+        s.encrypted = true;
+        return s;
+      },
+      TLSSocket: class TLSSocket extends EventEmitter {},
+      SERVER_METHODS: [],
+    }),
+    // worker_threads — stub (vite uses it for thread pool but can fall back)
+    worker_threads: () => ({
+      isMainThread: true,
+      parentPort: null,
+      workerData: null,
+      Worker: class Worker extends EventEmitter {
+        constructor() { super(); }
+        postMessage() {}
+        terminate() { return Promise.resolve(0); }
+      },
+      threadId: 0,
+    }),
+    // http2 — stub (vite imports it for HTTP/2 server but falls back to HTTP/1.1)
+    http2: () => ({
+      createServer: () => {
+        const s = new EventEmitter() as unknown as Record<string, unknown>;
+        s.listen = (_port: unknown, _host: unknown, cb?: () => void) => { cb?.(); return s; };
+        s.close = (cb?: () => void) => { cb?.(); return s; };
+        s.setTimeout = () => s;
+        return s;
+      },
+      createSecureServer: () => {
+        const s = new EventEmitter() as unknown as Record<string, unknown>;
+        s.listen = (_port: unknown, _host: unknown, cb?: () => void) => { cb?.(); return s; };
+        s.close = (cb?: () => void) => { cb?.(); return s; };
+        s.setTimeout = () => s;
+        return s;
+      },
+      connect: () => {
+        const s = new EventEmitter() as unknown as Record<string, unknown>;
+        s.close = () => {};
+        s.destroy = () => {};
+        return s;
+      },
+      constants: {
+        HTTP2_HEADER_PATH: ':path',
+        HTTP2_HEADER_METHOD: ':method',
+        HTTP2_HEADER_STATUS: ':status',
+        HTTP2_HEADER_CONTENT_TYPE: 'content-type',
+        HTTP_STATUS_OK: 200,
+        HTTP_STATUS_INTERNAL_SERVER_ERROR: 500,
+      },
+      sensitiveHeaders: Symbol('nodejs.http2.sensitiveHeaders'),
+      getDefaultSettings: () => ({}),
+      getPackedSettings: () => Buffer.alloc(0),
+      getUnpackedSettings: () => ({}),
+    }),
+    // inspector — stub (vite only uses it in --profile mode)
+    inspector: () => ({
+      Session: class Session extends EventEmitter {
+        connect() {}
+        disconnect() {}
+        post(_method: string, _params?: unknown, cb?: () => void) {
+          if (typeof _params === 'function') { _params(); return; }
+          cb?.();
+        }
+      },
+      open: () => {},
+      close: () => {},
+      url: () => undefined,
+    }),
+  };
+
+  // module shim needs access to the map itself for createRequire
+  map.module = () => createModuleShim(map);
+
+  // npm package shims
+  map.rimraf = () => createRimraf(ctx.vfs, ctx.cwd);
+  map.esbuild = () => createEsbuild();
+
+  return map;
+}
+
+export { ProcessExitError } from './process.js';

package/src/substrate/lifo/node-compat/module.ts

@@ -0,0 +1,148 @@
+/**
+ * Node.js `module` shim for Lifo.
+ *
+ * Provides the commonly used APIs from the `node:module` built-in:
+ * - Module class with id, filename, exports, paths, require, etc.
+ * - createRequire() — returns a require-like function backed by the module map
+ * - builtinModules — list of shimmed built-in module names
+ * - isBuiltin() — check if a module name is a built-in
+ */
+
+/** All built-in module names available in the Lifo node-compat layer */
+export const builtinModules: string[] = [
+  'assert',
+  'buffer',
+  'child_process',
+  'console',
+  'constants',
+  'crypto',
+  'dns',
+  'dns/promises',
+  'events',
+  'fs',
+  'fs/promises',
+  'http',
+  'https',
+  'module',
+  'net',
+  'os',
+  'path',
+  'process',
+  'querystring',
+  'readline',
+  'stream',
+  'string_decoder',
+  'timers',
+  'tls',
+  'tty',
+  'url',
+  'util',
+  'vm',
+  'worker_threads',
+  'zlib',
+];
+
+/**
+ * Check whether a specifier refers to a Node.js built-in module.
+ * Handles both bare names ("fs") and the "node:" prefix ("node:fs").
+ */
+export function isBuiltin(specifier: string): boolean {
+  const name = specifier.startsWith('node:') ? specifier.slice(5) : specifier;
+  return builtinModules.includes(name);
+}
+
+export type RequireFunction = ((id: string) => unknown) & {
+  resolve: (id: string) => string;
+  cache: Record<string, unknown>;
+};
+
+/**
+ * Factory for createRequire — needs the module map from index.ts at runtime.
+ * Called from createModuleMap() so it has access to the lazily-built map.
+ */
+export function makeCreateRequire(
+  moduleMap: Record<string, () => unknown>,
+): (filename: string | URL) => RequireFunction {
+  return function createRequire(_filename: string | URL): RequireFunction {
+    const cache: Record<string, unknown> = {};
+
+    const req = function require(id: string): unknown {
+      const name = id.startsWith('node:') ? id.slice(5) : id;
+
+      if (cache[name]) return cache[name];
+
+      if (moduleMap[name]) {
+        const mod = moduleMap[name]();
+        cache[name] = mod;
+        return mod;
+      }
+
+      throw new Error(`Cannot find module '${id}'`);
+    } as RequireFunction;
+
+    req.resolve = (id: string): string => {
+      const name = id.startsWith('node:') ? id.slice(5) : id;
+      if (moduleMap[name]) return name;
+      throw new Error(`Cannot find module '${id}'`);
+    };
+
+    req.cache = cache;
+
+    return req;
+  };
+}
+
+/**
+ * Minimal Module class matching the shape code typically expects.
+ */
+export class Module {
+  id: string;
+  filename: string;
+  exports: unknown;
+  parent: Module | null;
+  children: Module[];
+  loaded: boolean;
+  paths: string[];
+
+  constructor(id = '', parent: Module | null = null) {
+    this.id = id;
+    this.filename = id;
+    this.exports = {};
+    this.parent = parent;
+    this.children = [];
+    this.loaded = false;
+    this.paths = [];
+  }
+
+  require(_id: string): unknown {
+    throw new Error('Module.require() is not supported — use createRequire() instead');
+  }
+
+  static builtinModules = builtinModules;
+  static isBuiltin = isBuiltin;
+  // createRequire is attached dynamically in createModuleShim()
+  static createRequire: (filename: string | URL) => RequireFunction;
+
+  static _resolveFilename(request: string): string {
+    return request;
+  }
+
+  static _cache: Record<string, unknown> = {};
+}
+
+/**
+ * Create the full module shim object with createRequire bound to a module map.
+ */
+export function createModuleShim(moduleMap: Record<string, () => unknown>) {
+  const createRequire = makeCreateRequire(moduleMap);
+
+  Module.createRequire = createRequire;
+
+  return {
+    Module,
+    builtinModules,
+    isBuiltin,
+    createRequire,
+    default: Module,
+  };
+}

package/src/substrate/lifo/node-compat/os.ts

@@ -0,0 +1,44 @@
+export function createOs(env: Record<string, string>) {
+  return {
+    arch: () => 'wasm',
+    platform: () => 'lifo',
+    type: () => 'Lifo',
+    release: () => '0.1.0',
+    hostname: () => env.HOSTNAME || 'lifo',
+    homedir: () => env.HOME || '/home/user',
+    tmpdir: () => '/tmp',
+    cpus: () => {
+      const count = navigator.hardwareConcurrency || 4;
+      return Array.from({ length: count }, () => ({
+        model: 'Browser CPU',
+        speed: 2400,
+        times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 },
+      }));
+    },
+    totalmem: () => {
+      const m = (performance as unknown as { memory?: { jsHeapSizeLimit: number } }).memory;
+      return m?.jsHeapSizeLimit ?? 4 * 1024 * 1024 * 1024;
+    },
+    freemem: () => {
+      const m = (performance as unknown as { memory?: { jsHeapSizeLimit: number; usedJSHeapSize: number } }).memory;
+      if (m) return m.jsHeapSizeLimit - m.usedJSHeapSize;
+      return 2 * 1024 * 1024 * 1024;
+    },
+    uptime: () => Math.floor(performance.now() / 1000),
+    loadavg: () => [0, 0, 0],
+    networkInterfaces: () => ({}),
+    userInfo: () => ({
+      uid: 1000,
+      gid: 1000,
+      username: env.USER || 'user',
+      homedir: env.HOME || '/home/user',
+      shell: env.SHELL || '/bin/sh',
+    }),
+    EOL: '\n',
+    endianness: () => 'LE' as const,
+    constants: {
+      signals: {} as Record<string, number>,
+      errno: {} as Record<string, number>,
+    },
+  };
+}

package/src/substrate/lifo/node-compat/path.ts

@@ -0,0 +1,74 @@
+import {
+  normalize,
+  isAbsolute,
+  join,
+  resolve,
+  dirname,
+  basename,
+  extname,
+} from '../utils/path.js';
+
+export function relative(from: string, to: string): string {
+  const fromParts = normalize(from).split('/').filter(Boolean);
+  const toParts = normalize(to).split('/').filter(Boolean);
+
+  let common = 0;
+  while (
+    common < fromParts.length &&
+    common < toParts.length &&
+    fromParts[common] === toParts[common]
+  ) {
+    common++;
+  }
+
+  const ups = fromParts.length - common;
+  const rest = toParts.slice(common);
+  const parts = [...Array(ups).fill('..'), ...rest];
+  return parts.join('/') || '.';
+}
+
+export interface ParsedPath {
+  root: string;
+  dir: string;
+  base: string;
+  ext: string;
+  name: string;
+}
+
+export function parse(path: string): ParsedPath {
+  const root = isAbsolute(path) ? '/' : '';
+  const dir = dirname(path);
+  const base = basename(path);
+  const ext = extname(path);
+  const name = ext ? base.slice(0, -ext.length) : base;
+  return { root, dir, base, ext, name };
+}
+
+export function format(pathObj: Partial<ParsedPath>): string {
+  const dir = pathObj.dir || pathObj.root || '';
+  const base = pathObj.base || ((pathObj.name || '') + (pathObj.ext || ''));
+  if (dir) {
+    return dir.endsWith('/') ? dir + base : dir + '/' + base;
+  }
+  return base;
+}
+
+export const sep = '/';
+export const delimiter = ':';
+export const posix = {
+  normalize, isAbsolute, join, resolve: (...args: string[]) => resolve('/', ...args),
+  dirname, basename, extname, relative, parse, format, sep, delimiter,
+};
+// Minimal win32 path — Lifo is posix-only but packages like vite reference win32.sep
+export const win32 = {
+  normalize, isAbsolute, join, resolve: (...args: string[]) => resolve('/', ...args),
+  dirname, basename, extname, relative, parse, format,
+  sep: '\\',
+  delimiter: ';',
+};
+
+export { normalize, isAbsolute, join, resolve, dirname, basename, extname };
+export default {
+  normalize, isAbsolute, join, resolve: (...args: string[]) => resolve('/', ...args),
+  dirname, basename, extname, relative, parse, format, sep, delimiter, posix, win32,
+};