@scelar/nodepod 1.0.0

package/src/polyfills/net.ts

@@ -0,0 +1,353 @@
+// TCP / net polyfill -- all networking is simulated, no real kernel sockets
+
+import { EventEmitter, type EventHandler } from "./events";
+import { Duplex } from "./stream";
+import { Buffer } from "./buffer";
+import { PORT_RANGE } from "../constants/config";
+
+
+export interface NetAddress {
+  address: string;
+  family: string;
+  port: number;
+}
+
+export interface SocketConfig {
+  allowHalfOpen?: boolean;
+  readable?: boolean;
+  writable?: boolean;
+}
+
+export interface ServerConfig {
+  allowHalfOpen?: boolean;
+  pauseOnConnect?: boolean;
+}
+
+export interface BindOptions {
+  port?: number;
+  host?: string;
+  backlog?: number;
+}
+
+
+export interface TcpSocket extends Duplex {
+  localAddress: string;
+  localPort: number;
+  remoteAddress?: string;
+  remotePort?: number;
+  remoteFamily?: string;
+  connecting: boolean;
+  pending: boolean;
+  destroyed: boolean;
+  encrypted: boolean;
+  readyState: string;
+  bytesRead: number;
+  bytesWritten: number;
+  connect(portOrOpts: any, hostOrCb?: any, cb?: any): this;
+  address(): NetAddress | null;
+  setEncoding(enc: BufferEncoding): this;
+  setTimeout(ms: number, handler?: () => void): this;
+  setNoDelay(v?: boolean): this;
+  setKeepAlive(on?: boolean, delay?: number): this;
+  ref(): this;
+  unref(): this;
+  destroy(err?: Error): this;
+  _feedData(chunk: Buffer | string): void;
+  _feedEnd(): void;
+}
+
+export interface TcpSocketConstructor {
+  new (cfg?: SocketConfig): TcpSocket;
+  (this: any, cfg?: SocketConfig): void;
+  prototype: any;
+}
+
+export const TcpSocket = function TcpSocket(this: any, _cfg?: SocketConfig) {
+  if (!this) return;
+  Duplex.call(this);
+
+  this._isConnecting = false;
+  this._isConnected = false;
+  this._isDestroyed = false;
+  this._peerAddr = "";
+  this._peerPort = 0;
+  this._selfAddr = "127.0.0.1";
+  this._selfPort = 0;
+
+  this.localAddress = "127.0.0.1";
+  this.localPort = 0;
+  this.remoteAddress = undefined;
+  this.remotePort = undefined;
+  this.remoteFamily = undefined;
+  this.connecting = false;
+  this.pending = false;
+  this.destroyed = false;
+  this.encrypted = false;
+  this.readyState = "closed";
+  this.bytesRead = 0;
+  this.bytesWritten = 0;
+} as unknown as TcpSocketConstructor;
+
+Object.setPrototypeOf(TcpSocket.prototype, Duplex.prototype);
+
+TcpSocket.prototype.connect = function connect(
+  portOrOpts: number | { port: number; host?: string },
+  hostOrCb?: string | (() => void),
+  cb?: () => void,
+): any {
+  let port: number;
+  let host = "127.0.0.1";
+  let done: (() => void) | undefined;
+
+  if (typeof portOrOpts === "number") {
+    port = portOrOpts;
+    if (typeof hostOrCb === "string") {
+      host = hostOrCb;
+      done = cb;
+    } else done = hostOrCb;
+  } else {
+    port = portOrOpts.port;
+    host = portOrOpts.host ?? "127.0.0.1";
+    done = typeof hostOrCb === "function" ? hostOrCb : cb;
+  }
+
+  this._isConnecting = true;
+  this.connecting = true;
+  this._peerAddr = host;
+  this._peerPort = port;
+  this.remoteAddress = host;
+  this.remotePort = port;
+  this.remoteFamily = "IPv4";
+  this.readyState = "opening";
+
+  const self = this;
+  queueMicrotask(() => {
+    self._isConnecting = false;
+    self._isConnected = true;
+    self.connecting = false;
+    self.readyState = "open";
+    self.emit("connect");
+    if (done) done();
+  });
+
+  return this;
+};
+
+TcpSocket.prototype.address = function address(): NetAddress | null {
+  if (!this._isConnected) return null;
+  return { address: this._selfAddr, family: "IPv4", port: this._selfPort };
+};
+
+TcpSocket.prototype.setEncoding = function setEncoding(_enc: BufferEncoding): any {
+  return this;
+};
+
+TcpSocket.prototype.setTimeout = function setTimeout(ms: number, handler?: () => void): any {
+  if (handler) this.once("timeout", handler);
+  return this;
+};
+
+TcpSocket.prototype.setNoDelay = function setNoDelay(_v?: boolean): any {
+  return this;
+};
+
+TcpSocket.prototype.setKeepAlive = function setKeepAlive(_on?: boolean, _delay?: number): any {
+  return this;
+};
+
+TcpSocket.prototype.ref = function ref(): any {
+  return this;
+};
+
+TcpSocket.prototype.unref = function unref(): any {
+  return this;
+};
+
+TcpSocket.prototype.destroy = function destroy(err?: Error): any {
+  if (this._isDestroyed) return this;
+  this._isDestroyed = true;
+  this._isConnected = false;
+  this.destroyed = true;
+  this.readyState = "closed";
+  if (err) this.emit("error", err);
+  const self = this;
+  queueMicrotask(() => self.emit("close", !!err));
+  return this;
+};
+
+TcpSocket.prototype._feedData = function _feedData(chunk: Buffer | string): void {
+  const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+  this.push(buf);
+};
+
+TcpSocket.prototype._feedEnd = function _feedEnd(): void {
+  this.push(null);
+};
+
+
+export interface TcpServer extends EventEmitter {
+  listening: boolean;
+  maxConnections?: number;
+  listen(portOrOpts?: any, hostOrCb?: any, backlogOrCb?: any, cb?: any): this;
+  address(): (NetAddress & { host?: string }) | null;
+  close(cb?: (err?: Error) => void): this;
+  getConnections(cb?: (err: Error | null, n: number) => void): void;
+  ref(): this;
+  unref(): this;
+  _acceptConnection(sock: TcpSocket): void;
+}
+
+export interface TcpServerConstructor {
+  new (cfgOrHandler?: ServerConfig | ((sock: TcpSocket) => void), handler?: (sock: TcpSocket) => void): TcpServer;
+  (this: any, cfgOrHandler?: ServerConfig | ((sock: TcpSocket) => void), handler?: (sock: TcpSocket) => void): void;
+  prototype: any;
+}
+
+export const TcpServer = function TcpServer(
+  this: any,
+  cfgOrHandler?: ServerConfig | ((sock: TcpSocket) => void),
+  handler?: (sock: TcpSocket) => void,
+) {
+  if (!this) return;
+  EventEmitter.call(this);
+
+  this._bound = false;
+  this._addr = null;
+  this._peers = new Set();
+  this._cap = Infinity;
+  this.listening = false;
+  this.maxConnections = undefined;
+
+  let fn: ((s: TcpSocket) => void) | undefined;
+  if (typeof cfgOrHandler === "function") fn = cfgOrHandler;
+  else fn = handler;
+  if (fn) this.on("connection", fn as EventHandler);
+} as unknown as TcpServerConstructor;
+
+Object.setPrototypeOf(TcpServer.prototype, EventEmitter.prototype);
+
+TcpServer.prototype.listen = function listen(
+  portOrOpts?: number | BindOptions,
+  hostOrCb?: string | number | (() => void),
+  backlogOrCb?: number | (() => void),
+  cb?: () => void,
+): any {
+  let port = 0;
+  let host = "0.0.0.0";
+  let done: (() => void) | undefined;
+
+  if (typeof portOrOpts === "number") {
+    port = portOrOpts;
+    if (typeof hostOrCb === "string") {
+      host = hostOrCb;
+      done = typeof backlogOrCb === "function" ? backlogOrCb : cb;
+    } else if (typeof hostOrCb === "function") {
+      done = hostOrCb;
+    } else {
+      done = typeof backlogOrCb === "function" ? backlogOrCb : cb;
+    }
+  } else if (portOrOpts) {
+    port = portOrOpts.port ?? 0;
+    host = portOrOpts.host ?? "0.0.0.0";
+    done = typeof hostOrCb === "function" ? hostOrCb : cb;
+  }
+
+  if (port === 0) port = PORT_RANGE.BASE + Math.floor(Math.random() * PORT_RANGE.RANGE);
+
+  this._addr = { address: host, family: "IPv4", port };
+  this._bound = true;
+  this.listening = true;
+
+  const self = this;
+  queueMicrotask(() => {
+    self.emit("listening");
+    if (done) done();
+  });
+
+  return this;
+};
+
+TcpServer.prototype.address = function address(): (NetAddress & { host?: string }) | null {
+  if (!this._addr) return null;
+  return { ...this._addr, host: this._addr.address };
+};
+
+TcpServer.prototype.close = function close(cb?: (err?: Error) => void): any {
+  this._bound = false;
+  this.listening = false;
+  for (const s of this._peers) s.destroy();
+  this._peers.clear();
+  const self = this;
+  queueMicrotask(() => {
+    self.emit("close");
+    if (cb) cb();
+  });
+  return this;
+};
+
+TcpServer.prototype.getConnections = function getConnections(
+  cb?: (err: Error | null, n: number) => void,
+): void {
+  if (typeof cb === "function") cb(null, this._peers.size);
+};
+
+TcpServer.prototype.ref = function ref(): any {
+  return this;
+};
+
+TcpServer.prototype.unref = function unref(): any {
+  return this;
+};
+
+TcpServer.prototype._acceptConnection = function _acceptConnection(sock: TcpSocket): void {
+  if (!this._bound) {
+    sock.destroy();
+    return;
+  }
+  this._peers.add(sock);
+  const self = this;
+  sock.on("close", function onClose() { self._peers.delete(sock); });
+  this.emit("connection", sock);
+};
+
+
+export function createServer(
+  cfgOrHandler?: ServerConfig | ((sock: TcpSocket) => void),
+  handler?: (sock: TcpSocket) => void,
+): TcpServer {
+  return new TcpServer(cfgOrHandler, handler);
+}
+
+export function createConnection(
+  portOrOpts: number | { port: number; host?: string },
+  hostOrCb?: string | (() => void),
+  cb?: () => void,
+): TcpSocket {
+  return new TcpSocket().connect(portOrOpts, hostOrCb as string, cb);
+}
+
+export const connect = createConnection;
+
+export function isIP(addr: string): number {
+  if (/^(\d{1,3}\.){3}\d{1,3}$/.test(addr)) return 4;
+  if (/^([0-9a-fA-F]{0,4}:){2,7}[0-9a-fA-F]{0,4}$/.test(addr)) return 6;
+  return 0;
+}
+
+export function isIPv4(addr: string): boolean {
+  return isIP(addr) === 4;
+}
+export function isIPv6(addr: string): boolean {
+  return isIP(addr) === 6;
+}
+
+export default {
+  Socket: TcpSocket,
+  Server: TcpServer,
+  createServer,
+  createConnection,
+  connect,
+  isIP,
+  isIPv4,
+  isIPv6,
+};

package/src/polyfills/os.ts

@@ -0,0 +1,238 @@
+// OS polyfill returning plausible Linux-like values
+
+
+import { MOCK_OS, MOCK_IDS, MOCK_CPU, MOCK_MEMORY, MOCK_LOADAVG } from "../constants/config";
+
+export function hostname(): string {
+  return MOCK_OS.HOSTNAME;
+}
+
+export function platform(): string {
+  return MOCK_OS.PLATFORM;
+}
+
+export function arch(): string {
+  return MOCK_OS.ARCH;
+}
+
+export function type(): string {
+  return MOCK_OS.TYPE;
+}
+
+export function release(): string {
+  return MOCK_OS.RELEASE;
+}
+
+export function version(): string {
+  return MOCK_OS.VERSION;
+}
+
+export function machine(): string {
+  return MOCK_OS.MACHINE;
+}
+
+export function tmpdir(): string {
+  return MOCK_OS.TMPDIR;
+}
+
+export function homedir(): string {
+  return MOCK_OS.HOMEDIR;
+}
+
+interface CpuEntry {
+  model: string;
+  speed: number;
+  times: { user: number; nice: number; sys: number; idle: number; irq: number };
+}
+
+export function cpus(): CpuEntry[] {
+  const template: CpuEntry = {
+    model: MOCK_CPU.MODEL,
+    speed: MOCK_CPU.SPEED,
+    times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 },
+  };
+  return Array.from({ length: MOCK_CPU.COUNT }, () => ({ ...template }));
+}
+
+export function totalmem(): number {
+  return MOCK_MEMORY.TOTAL;
+}
+
+export function freemem(): number {
+  return MOCK_MEMORY.FREE;
+}
+
+export function uptime(): number {
+  return Math.floor(performance.now() / 1000);
+}
+
+export function loadavg(): [number, number, number] {
+  return [...MOCK_LOADAVG];
+}
+
+interface NetIface {
+  address: string;
+  netmask: string;
+  family: string;
+  mac: string;
+  internal: boolean;
+  cidr: string;
+}
+
+export function networkInterfaces(): Record<string, NetIface[]> {
+  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: MOCK_OS.USERNAME,
+    uid: MOCK_IDS.UID,
+    gid: MOCK_IDS.GID,
+    shell: MOCK_OS.SHELL,
+    homedir: MOCK_OS.HOMEDIR,
+  };
+}
+
+export function endianness(): 'BE' | 'LE' {
+  return MOCK_OS.ENDIANNESS;
+}
+
+export function getPriority(_pid?: number): number {
+  return 0;
+}
+
+export function setPriority(_pidOrPriority: number, _priority?: number): void {
+  // no-op in browser
+}
+
+export const EOL = '\n';
+
+export const devNull = '/dev/null';
+
+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: {
+    EPERM: -1,
+    ENOENT: -2,
+    ESRCH: -3,
+    EINTR: -4,
+    EIO: -5,
+    ENXIO: -6,
+    E2BIG: -7,
+    ENOEXEC: -8,
+    EBADF: -9,
+    ECHILD: -10,
+    EAGAIN: -11,
+    ENOMEM: -12,
+    EACCES: -13,
+    EFAULT: -14,
+    EBUSY: -16,
+    EEXIST: -17,
+    EXDEV: -18,
+    ENODEV: -19,
+    ENOTDIR: -20,
+    EISDIR: -21,
+    EINVAL: -22,
+    ENFILE: -23,
+    EMFILE: -24,
+    ENOTTY: -25,
+    EFBIG: -27,
+    ENOSPC: -28,
+    ESPIPE: -29,
+    EROFS: -30,
+    EMLINK: -31,
+    EPIPE: -32,
+    EDOM: -33,
+    ERANGE: -34,
+    ENOTEMPTY: -39,
+    ENOSYS: -38,
+    ELOOP: -40,
+    ENAMETOOLONG: -36,
+    ECONNRESET: -104,
+    ECONNREFUSED: -111,
+    EADDRINUSE: -98,
+    EADDRNOTAVAIL: -99,
+    ETIMEDOUT: -110,
+  },
+  priority: {
+    PRIORITY_LOW: 19,
+    PRIORITY_BELOW_NORMAL: 10,
+    PRIORITY_NORMAL: 0,
+    PRIORITY_ABOVE_NORMAL: -7,
+    PRIORITY_HIGH: -14,
+    PRIORITY_HIGHEST: -20,
+  },
+};
+
+export default {
+  hostname,
+  platform,
+  arch,
+  type,
+  release,
+  version,
+  machine,
+  tmpdir,
+  homedir,
+  cpus,
+  totalmem,
+  freemem,
+  uptime,
+  loadavg,
+  networkInterfaces,
+  userInfo,
+  endianness,
+  getPriority,
+  setPriority,
+  EOL,
+  devNull,
+  constants,
+};