@nimbus-sh/core 0.1.0

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

@@ -0,0 +1,178 @@
+import type { CommandOutputStream } from '../commands/types.js';
+
+export class ProcessExitError extends Error {
+  exitCode: number;
+  constructor(code: number) {
+    super(`process.exit(${code})`);
+    this.name = 'ProcessExitError';
+    this.exitCode = code;
+  }
+}
+
+export interface ProcessOptions {
+  argv: string[];
+  env: Record<string, string>;
+  cwd: string;
+  stdout: CommandOutputStream;
+  stderr: CommandOutputStream;
+}
+
+export function createProcess(opts: ProcessOptions) {
+  const startTime = Date.now();
+  const listeners: Record<string, Array<(...args: unknown[]) => void>> = {};
+
+  const proc = {
+    argv: ['/usr/bin/node', ...opts.argv],
+    argv0: 'node',
+    env: { ...opts.env },
+    cwd: () => opts.cwd,
+    chdir: (_dir: string) => { throw new Error('process.chdir() is not supported in Lifo'); },
+    exit: (code = 0) => {
+      if (code !== 0) {
+        opts.stderr.write(`[process.exit] code=${code}\n`);
+      }
+      throw new ProcessExitError(code);
+    },
+    stdout: {
+      write: (data: string) => { opts.stdout.write(data); return true; },
+      isTTY: false,
+      fd: 1,
+      bytesWritten: 0,
+      columns: 80,
+      on: () => {},
+      once: () => {},
+    },
+    stderr: {
+      write: (data: string) => { opts.stderr.write(data); return true; },
+      isTTY: false,
+      fd: 2,
+      bytesWritten: 0,
+      columns: 80,
+      on: () => {},
+      once: () => {},
+    },
+    stdin: {
+      isTTY: false,
+      fd: 0,
+      on: () => {},
+      once: () => {},
+      resume: () => {},
+      pause: () => {},
+      setEncoding: () => {},
+      read: () => null,
+    },
+    platform: 'linux' as string,
+    arch: 'x64' as string,
+    version: 'v22.14.0',
+    versions: {
+      node: '22.14.0',
+      lifo: '0.1.0',
+    },
+    pid: 1,
+    ppid: 0,
+    title: 'node',
+    execPath: '/usr/bin/node',
+    hrtime: Object.assign(
+      (prev?: [number, number]): [number, number] => {
+        const now = performance.now();
+        const sec = Math.floor(now / 1000);
+        const nano = Math.floor((now % 1000) * 1e6);
+        if (prev) {
+          let ds = sec - prev[0];
+          let dn = nano - prev[1];
+          if (dn < 0) { ds--; dn += 1e9; }
+          return [ds, dn];
+        }
+        return [sec, nano];
+      },
+      {
+        bigint: (): bigint => BigInt(Math.floor(performance.now() * 1e6)),
+      },
+    ),
+    nextTick: (fn: (...args: unknown[]) => void, ...args: unknown[]) => {
+      queueMicrotask(() => fn(...args));
+    },
+    memoryUsage: () => {
+      const m = (performance as unknown as { memory?: { usedJSHeapSize: number; totalJSHeapSize: number; jsHeapSizeLimit: number } }).memory;
+      return {
+        rss: m?.usedJSHeapSize ?? 0,
+        heapTotal: m?.totalJSHeapSize ?? 0,
+        heapUsed: m?.usedJSHeapSize ?? 0,
+        external: 0,
+        arrayBuffers: 0,
+      };
+    },
+    uptime: () => (Date.now() - startTime) / 1000,
+    release: { name: 'node' },
+    config: {},
+    emitWarning: (msg: string) => { opts.stderr.write(`Warning: ${msg}\n`); },
+    // POSIX identity stubs (needed by many npm packages)
+    getuid: () => 1000,
+    getgid: () => 1000,
+    geteuid: () => 1000,
+    getegid: () => 1000,
+    umask: (mask?: number) => mask ?? 0o22,
+    // process.binding() stub — low-level Node.js internal, used by execa/errname etc.
+    binding: (name: string) => {
+      if (name === 'uv') {
+        return {
+          errname: (code: number) => `UV_UNKNOWN_${code}`,
+          UV_EOF: -4095,
+        };
+      }
+      if (name === 'natives') return {};
+      if (name === 'constants') return { os: {}, fs: {}, crypto: {} };
+      return {};
+    },
+    // EventEmitter-like methods (many packages check for process.on('exit'))
+    on: (event: string, fn: (...args: unknown[]) => void) => {
+      if (!listeners[event]) listeners[event] = [];
+      listeners[event].push(fn);
+      return proc;
+    },
+    addListener: (event: string, fn: (...args: unknown[]) => void) => {
+      return proc.on(event, fn);
+    },
+    once: (event: string, fn: (...args: unknown[]) => void) => {
+      const wrapped = (...args: unknown[]) => {
+        proc.removeListener(event, wrapped);
+        fn(...args);
+      };
+      return proc.on(event, wrapped);
+    },
+    off: (event: string, fn: (...args: unknown[]) => void) => {
+      if (listeners[event]) {
+        listeners[event] = listeners[event].filter((f) => f !== fn);
+      }
+      return proc;
+    },
+    removeListener: (event: string, fn: (...args: unknown[]) => void) => proc.off(event, fn),
+    removeAllListeners: (event?: string) => {
+      if (event) delete listeners[event];
+      else Object.keys(listeners).forEach((k) => delete listeners[k]);
+      return proc;
+    },
+    listeners: (event: string) => listeners[event] ? [...listeners[event]] : [],
+    emit: (event: string, ...args: unknown[]) => {
+      const fns = listeners[event];
+      if (!fns || fns.length === 0) return false;
+      for (const fn of [...fns]) fn(...args);
+      return true;
+    },
+    listenerCount: (event: string) => listeners[event]?.length ?? 0,
+    setMaxListeners: () => proc,
+    getMaxListeners: () => 10,
+    prependListener: (event: string, fn: (...args: unknown[]) => void) => {
+      if (!listeners[event]) listeners[event] = [];
+      listeners[event].unshift(fn);
+      return proc;
+    },
+    rawListeners: (event: string) => listeners[event] ? [...listeners[event]] : [],
+    eventNames: () => Object.keys(listeners),
+    // Feature detection flags
+    allowedNodeEnvironmentFlags: new Set<string>(),
+    features: { inspector: false, debug: false, uv: false, tls_alpn: false, tls_sni: false, tls_ocsp: false, tls: false },
+  };
+
+  return proc;
+}

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

@@ -0,0 +1,244 @@
+/**
+ * Node.js `readline` module shim for Lifo.
+ *
+ * Provides Interface (createInterface), clearLine, clearScreenDown,
+ * cursorTo, moveCursor, and the promises API.
+ */
+
+import { EventEmitter } from './events.js';
+
+export interface InterfaceOptions {
+  input?: { on?: (event: string, cb: (...args: unknown[]) => void) => void };
+  output?: { write?: (data: string) => void };
+  prompt?: string;
+  terminal?: boolean;
+  historySize?: number;
+  completer?: (line: string) => [string[], string];
+  crlfDelay?: number;
+}
+
+export class Interface extends EventEmitter {
+  private _prompt: string;
+  private _output: { write?: (data: string) => void } | undefined;
+  private _closed = false;
+  private _lines: string[] = [];
+  terminal: boolean;
+
+  constructor(opts: InterfaceOptions = {}) {
+    super();
+    this._prompt = opts.prompt ?? '> ';
+    this._output = opts.output;
+    this.terminal = opts.terminal ?? false;
+
+    // Listen for data on input if provided
+    if (opts.input?.on) {
+      opts.input.on('data', (chunk) => {
+        if (this._closed) return;
+        const lines = String(chunk).split(/\r?\n/);
+        for (const line of lines) {
+          if (line !== '') {
+            this._lines.push(line);
+            this.emit('line', line);
+          }
+        }
+      });
+
+      opts.input.on('end', () => {
+        if (!this._closed) this.close();
+      });
+    }
+  }
+
+  setPrompt(prompt: string): void {
+    this._prompt = prompt;
+  }
+
+  getPrompt(): string {
+    return this._prompt;
+  }
+
+  prompt(preserveCursor = false): void {
+    if (this._closed) return;
+    void preserveCursor;
+    this._output?.write?.(this._prompt);
+  }
+
+  write(data: string): void {
+    if (this._closed) return;
+    const lines = data.split(/\r?\n/);
+    for (const line of lines) {
+      if (line !== '') {
+        this._lines.push(line);
+        this.emit('line', line);
+      }
+    }
+  }
+
+  question(query: string, cb: (answer: string) => void): void;
+  question(query: string, options: { signal?: AbortSignal }, cb: (answer: string) => void): void;
+  question(
+    query: string,
+    optionsOrCb: { signal?: AbortSignal } | ((answer: string) => void),
+    cb?: (answer: string) => void,
+  ): void {
+    if (this._closed) return;
+    const callback = typeof optionsOrCb === 'function' ? optionsOrCb : cb!;
+    this._output?.write?.(query);
+    // Answer comes from next line event
+    this.once('line', (line) => callback(line as string));
+  }
+
+  close(): void {
+    if (this._closed) return;
+    this._closed = true;
+    this.emit('close');
+  }
+
+  pause(): this {
+    this.emit('pause');
+    return this;
+  }
+
+  resume(): this {
+    this.emit('resume');
+    return this;
+  }
+
+  getCursorPos(): { rows: number; cols: number } {
+    return { rows: 0, cols: 0 };
+  }
+
+  get closed(): boolean {
+    return this._closed;
+  }
+
+  [Symbol.asyncIterator](): AsyncIterableIterator<string> {
+    const iface = this;
+    const queue: string[] = [];
+    let resolveNext: ((value: IteratorResult<string>) => void) | null = null;
+
+    iface.on('line', (line) => {
+      if (resolveNext) {
+        const r = resolveNext;
+        resolveNext = null;
+        r({ value: line as string, done: false });
+      } else {
+        queue.push(line as string);
+      }
+    });
+
+    iface.on('close', () => {
+      if (resolveNext) {
+        const r = resolveNext;
+        resolveNext = null;
+        r({ value: undefined as unknown as string, done: true });
+      }
+    });
+
+    return {
+      next(): Promise<IteratorResult<string>> {
+        if (queue.length > 0) {
+          return Promise.resolve({ value: queue.shift()!, done: false });
+        }
+        if (iface._closed) {
+          return Promise.resolve({ value: undefined as unknown as string, done: true });
+        }
+        return new Promise((resolve) => { resolveNext = resolve; });
+      },
+      return(): Promise<IteratorResult<string>> {
+        iface.close();
+        return Promise.resolve({ value: undefined as unknown as string, done: true });
+      },
+      throw(err: Error): Promise<IteratorResult<string>> {
+        iface.close();
+        return Promise.reject(err);
+      },
+      [Symbol.asyncIterator]() { return this; },
+    };
+  }
+}
+
+export function createInterface(opts: InterfaceOptions): Interface;
+export function createInterface(
+  input: InterfaceOptions['input'],
+  output?: InterfaceOptions['output'],
+): Interface;
+export function createInterface(
+  inputOrOpts: InterfaceOptions | InterfaceOptions['input'],
+  output?: InterfaceOptions['output'],
+): Interface {
+  if (inputOrOpts && typeof inputOrOpts === 'object' && ('input' in inputOrOpts || 'output' in inputOrOpts || 'prompt' in inputOrOpts)) {
+    return new Interface(inputOrOpts as InterfaceOptions);
+  }
+  return new Interface({ input: inputOrOpts as InterfaceOptions['input'], output });
+}
+
+export function clearLine(stream: { write?: (data: string) => void }, dir: number, cb?: () => void): boolean {
+  const mode = dir < 0 ? 1 : dir > 0 ? 0 : 2;
+  stream.write?.(`\x1b[${mode}K`);
+  cb?.();
+  return true;
+}
+
+export function clearScreenDown(stream: { write?: (data: string) => void }, cb?: () => void): boolean {
+  stream.write?.('\x1b[0J');
+  cb?.();
+  return true;
+}
+
+export function cursorTo(stream: { write?: (data: string) => void }, x: number, y?: number | (() => void), cb?: () => void): boolean {
+  if (typeof y === 'function') {
+    cb = y;
+    y = undefined;
+  }
+  const col = Math.max(0, Math.floor(Number(x) || 0)) + 1;
+  if (y === undefined) {
+    stream.write?.(`\x1b[${col}G`);
+  } else {
+    const row = Math.max(0, Math.floor(Number(y) || 0)) + 1;
+    stream.write?.(`\x1b[${row};${col}H`);
+  }
+  cb?.();
+  return true;
+}
+
+export function moveCursor(stream: { write?: (data: string) => void }, dx: number, dy: number, cb?: () => void): boolean {
+  const x = Math.trunc(Number(dx) || 0);
+  const y = Math.trunc(Number(dy) || 0);
+  if (x < 0) stream.write?.(`\x1b[${-x}D`);
+  else if (x > 0) stream.write?.(`\x1b[${x}C`);
+  if (y < 0) stream.write?.(`\x1b[${-y}A`);
+  else if (y > 0) stream.write?.(`\x1b[${y}B`);
+  cb?.();
+  return true;
+}
+
+export function emitKeypressEvents(_stream: unknown): void {
+  // no-op
+}
+
+// readline/promises API
+export const promises = {
+  createInterface: (opts: InterfaceOptions): Interface & { question: (query: string, options?: { signal?: AbortSignal }) => Promise<string> } => {
+    const iface = createInterface(opts);
+    const promiseIface = iface as Interface & { question: (query: string, options?: { signal?: AbortSignal }) => Promise<string> };
+    const originalQuestion = iface.question.bind(iface);
+    promiseIface.question = (query: string, _options?: { signal?: AbortSignal }): Promise<string> => {
+      return new Promise((resolve) => {
+        originalQuestion(query, (answer: string) => resolve(answer));
+      });
+    };
+    return promiseIface;
+  },
+};
+
+export default {
+  Interface,
+  createInterface,
+  clearLine,
+  clearScreenDown,
+  cursorTo,
+  moveCursor,
+  emitKeypressEvents,
+  promises,
+};

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

@@ -0,0 +1,80 @@
+/**
+ * `rimraf` npm package shim for Lifo.
+ *
+ * Provides the rimraf(path, [opts], cb) callback API, rimraf.sync(path),
+ * and the modern rimraf v4+ promise-based API, all backed by the VFS
+ * fs shim's recursive rmdir.
+ */
+
+import type { VFS } from '../kernel/vfs/index.js';
+import { resolve } from './path.js';
+
+export interface RimrafOptions {
+  glob?: boolean | object;
+  maxRetries?: number;
+  retryDelay?: number;
+  filter?: (path: string) => boolean;
+}
+
+export function createRimraf(vfs: VFS, cwd: string) {
+  function removeSync(p: string): void {
+    const abs = resolve(cwd, p);
+    if (!vfs.exists(abs)) return;
+
+    const stat = vfs.stat(abs);
+    if (stat.type === 'directory') {
+      vfs.rmdirRecursive(abs);
+    } else {
+      vfs.unlink(abs);
+    }
+  }
+
+  function removeAsync(p: string): Promise<void> {
+    return new Promise((res, rej) => {
+      try {
+        removeSync(p);
+        res();
+      } catch (e) {
+        rej(e);
+      }
+    });
+  }
+
+  // rimraf(path, [opts], cb) — classic callback API (rimraf v3)
+  function rimraf(p: string, optsOrCb?: RimrafOptions | ((err: Error | null) => void), cb?: (err: Error | null) => void): void {
+    const callback = typeof optsOrCb === 'function' ? optsOrCb : cb;
+    try {
+      removeSync(p);
+      callback?.(null);
+    } catch (e) {
+      callback?.(e as Error);
+    }
+  }
+
+  // rimraf.sync / rimrafSync
+  rimraf.sync = removeSync;
+
+  // Modern rimraf v4+ returns a promise
+  rimraf.rimraf = removeAsync;
+  rimraf.rimrafSync = removeSync;
+
+  // Native implementations (same thing in our shim)
+  rimraf.native = removeAsync;
+  rimraf.nativeSync = removeSync;
+
+  // Manual implementations (same thing in our shim)
+  rimraf.manual = removeAsync;
+  rimraf.manualSync = removeSync;
+
+  // Windows implementations (same thing in our shim)
+  rimraf.windows = removeAsync;
+  rimraf.windowsSync = removeSync;
+
+  // moveRemove implementations (same thing in our shim)
+  rimraf.moveRemove = removeAsync;
+  rimraf.moveRemoveSync = removeSync;
+
+  rimraf.default = rimraf;
+
+  return rimraf;
+}

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

@@ -0,0 +1,98 @@
+import { EventEmitter } from './events.js';
+
+export class Readable extends EventEmitter {
+  private _buffer: string[] = [];
+  protected _ended = false;
+  readable = true;
+
+  push(chunk: string | null): void {
+    if (chunk === null) {
+      this._ended = true;
+      this.readable = false;
+      this.emit('end');
+    } else {
+      this._buffer.push(chunk);
+      this.emit('data', chunk);
+    }
+  }
+
+  read(): string | null {
+    if (this._buffer.length > 0) return this._buffer.shift()!;
+    return null;
+  }
+
+  pipe<T extends Writable>(dest: T): T {
+    this.on('data', (chunk) => dest.write(chunk as string));
+    this.on('end', () => dest.end());
+    return dest;
+  }
+
+  destroy(): this {
+    this._ended = true;
+    this.readable = false;
+    this.emit('close');
+    return this;
+  }
+
+  setEncoding(_encoding: string): this {
+    return this;
+  }
+
+  resume(): this {
+    return this;
+  }
+
+  pause(): this {
+    return this;
+  }
+}
+
+export class Writable extends EventEmitter {
+  private _ended = false;
+  writable = true;
+
+  write(chunk: string, _encoding?: string, cb?: () => void): boolean {
+    if (this._ended) return false;
+    this.emit('data', chunk);
+    if (cb) cb();
+    return true;
+  }
+
+  end(chunk?: string): void {
+    if (chunk) this.write(chunk);
+    this._ended = true;
+    this.writable = false;
+    this.emit('finish');
+    this.emit('close');
+  }
+
+  destroy(): this {
+    this._ended = true;
+    this.writable = false;
+    this.emit('close');
+    return this;
+  }
+}
+
+export class Duplex extends Readable {
+  writable = true;
+  private _writableEnded = false;
+
+  write(chunk: string, _encoding?: string, cb?: () => void): boolean {
+    if (this._writableEnded) return false;
+    this.emit('data', chunk);
+    if (cb) cb();
+    return true;
+  }
+
+  end(chunk?: string): void {
+    if (chunk) this.write(chunk);
+    this._writableEnded = true;
+    this.writable = false;
+    this.emit('finish');
+  }
+}
+
+export class PassThrough extends Duplex {}
+
+export default { Readable, Writable, Duplex, PassThrough };

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

@@ -0,0 +1,26 @@
+export class StringDecoder {
+  private decoder: TextDecoder;
+
+  constructor(encoding?: string) {
+    const enc = (encoding || 'utf8').toLowerCase().replace('-', '');
+    const map: Record<string, string> = {
+      utf8: 'utf-8',
+      utf16le: 'utf-16le',
+      latin1: 'latin1',
+      ascii: 'ascii',
+      binary: 'latin1',
+    };
+    this.decoder = new TextDecoder(map[enc] || 'utf-8');
+  }
+
+  write(buffer: Uint8Array): string {
+    return this.decoder.decode(buffer, { stream: true });
+  }
+
+  end(buffer?: Uint8Array): string {
+    if (buffer) return this.decoder.decode(buffer);
+    return this.decoder.decode();
+  }
+}
+
+export default { StringDecoder };

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

@@ -0,0 +1,21 @@
+export const _setTimeout = globalThis.setTimeout;
+export const _setInterval = globalThis.setInterval;
+export const _clearTimeout = globalThis.clearTimeout;
+export const _clearInterval = globalThis.clearInterval;
+
+export function setImmediate(fn: (...args: unknown[]) => void, ...args: unknown[]): ReturnType<typeof setTimeout> {
+  return _setTimeout(() => fn(...args), 0);
+}
+
+export function clearImmediate(id: ReturnType<typeof setTimeout>): void {
+  _clearTimeout(id);
+}
+
+export default {
+  setTimeout: _setTimeout,
+  setInterval: _setInterval,
+  clearTimeout: _clearTimeout,
+  clearInterval: _clearInterval,
+  setImmediate,
+  clearImmediate,
+};