almostnode 0.1.0

package/src/shims/http2.ts

@@ -0,0 +1,96 @@
+/**
+ * http2 shim - HTTP/2 is not available in browser
+ */
+
+import { EventEmitter } from './events';
+
+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/https.ts

@@ -0,0 +1,86 @@
+/**
+ * Node.js https module shim
+ * Re-exports http module functionality with https protocol default
+ */
+
+import {
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  ClientRequest,
+  createServer,
+  STATUS_CODES,
+  METHODS,
+  getServer,
+  getAllServers,
+  setServerListenCallback,
+  setServerCloseCallback,
+  _createClientRequest,
+  Agent,
+  globalAgent,
+} from './http';
+
+import type { RequestOptions, AgentOptions } from './http';
+
+// Re-export all http types and classes
+export {
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  ClientRequest,
+  createServer,
+  STATUS_CODES,
+  METHODS,
+  getServer,
+  getAllServers,
+  setServerListenCallback,
+  setServerCloseCallback,
+  Agent,
+  globalAgent,
+};
+
+export type { AgentOptions };
+
+export type { RequestOptions };
+
+/**
+ * Create an HTTPS client request
+ */
+export function request(
+  urlOrOptions: string | URL | RequestOptions,
+  optionsOrCallback?: RequestOptions | ((res: IncomingMessage) => void),
+  callback?: (res: IncomingMessage) => void
+): ClientRequest {
+  return _createClientRequest(urlOrOptions, optionsOrCallback, callback, 'https');
+}
+
+/**
+ * Make an HTTPS GET request
+ */
+export function get(
+  urlOrOptions: string | URL | RequestOptions,
+  optionsOrCallback?: RequestOptions | ((res: IncomingMessage) => void),
+  callback?: (res: IncomingMessage) => void
+): ClientRequest {
+  const req = _createClientRequest(urlOrOptions, optionsOrCallback, callback, 'https');
+  req.end();
+  return req;
+}
+
+export default {
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  ClientRequest,
+  createServer,
+  request,
+  get,
+  STATUS_CODES,
+  METHODS,
+  getServer,
+  getAllServers,
+  setServerListenCallback,
+  setServerCloseCallback,
+  Agent,
+  globalAgent,
+};

package/src/shims/inspector.ts

@@ -0,0 +1,30 @@
+/**
+ * inspector shim - V8 inspector is not available in browser
+ */
+
+import { EventEmitter } from './events';
+
+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,82 @@
+/**
+ * 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',
+  'string_decoder',
+  'sys',
+  'timers',
+  'tls',
+  'tty',
+  'url',
+  'util',
+  'v8',
+  'vm',
+  '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': () => {},
+};
+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/net.ts

@@ -0,0 +1,359 @@
+/**
+ * Node.js net module shim
+ * Basic Socket and Server classes for virtual networking
+ */
+
+import { EventEmitter, EventListener } from './events';
+import { Duplex, Buffer } from './stream';
+
+export interface AddressInfo {
+  address: string;
+  family: string;
+  port: number;
+}
+
+export interface SocketOptions {
+  allowHalfOpen?: boolean;
+  readable?: boolean;
+  writable?: boolean;
+}
+
+export interface ServerOptions {
+  allowHalfOpen?: boolean;
+  pauseOnConnect?: boolean;
+}
+
+export interface ListenOptions {
+  port?: number;
+  host?: string;
+  backlog?: number;
+}
+
+/**
+ * Virtual Socket implementation
+ */
+export class Socket extends Duplex {
+  private _connecting: boolean = false;
+  private _connected: boolean = false;
+  private _destroyed: boolean = false;
+  private _remoteAddress: string = '';
+  private _remotePort: number = 0;
+  private _localAddress: string = '127.0.0.1';
+  private _localPort: number = 0;
+
+  localAddress: string = '127.0.0.1';
+  localPort: number = 0;
+  remoteAddress?: string;
+  remotePort?: number;
+  remoteFamily?: string;
+  connecting: boolean = false;
+  destroyed: boolean = false;
+  readyState: string = 'closed';
+
+  constructor(options?: SocketOptions) {
+    super();
+  }
+
+  connect(
+    portOrOptions: number | { port: number; host?: string },
+    hostOrCallback?: string | (() => void),
+    callback?: () => void
+  ): this {
+    let port: number;
+    let host: string = '127.0.0.1';
+    let cb: (() => void) | undefined;
+
+    if (typeof portOrOptions === 'number') {
+      port = portOrOptions;
+      if (typeof hostOrCallback === 'string') {
+        host = hostOrCallback;
+        cb = callback;
+      } else {
+        cb = hostOrCallback;
+      }
+    } else {
+      port = portOrOptions.port;
+      host = portOrOptions.host || '127.0.0.1';
+      cb = typeof hostOrCallback === 'function' ? hostOrCallback : callback;
+    }
+
+    this._connecting = true;
+    this.connecting = true;
+    this._remoteAddress = host;
+    this._remotePort = port;
+    this.remoteAddress = host;
+    this.remotePort = port;
+    this.remoteFamily = 'IPv4';
+    this.readyState = 'opening';
+
+    // Simulate async connection
+    queueMicrotask(() => {
+      this._connecting = false;
+      this._connected = true;
+      this.connecting = false;
+      this.readyState = 'open';
+      this.emit('connect');
+      if (cb) cb();
+    });
+
+    return this;
+  }
+
+  address(): AddressInfo | null {
+    if (!this._connected) return null;
+    return {
+      address: this._localAddress,
+      family: 'IPv4',
+      port: this._localPort,
+    };
+  }
+
+  setEncoding(encoding: BufferEncoding): this {
+    return this;
+  }
+
+  setTimeout(timeout: number, callback?: () => void): this {
+    if (callback) {
+      this.once('timeout', callback);
+    }
+    return this;
+  }
+
+  setNoDelay(noDelay?: boolean): this {
+    return this;
+  }
+
+  setKeepAlive(enable?: boolean, initialDelay?: number): this {
+    return this;
+  }
+
+  ref(): this {
+    return this;
+  }
+
+  unref(): this {
+    return this;
+  }
+
+  destroy(error?: Error): this {
+    if (this._destroyed) return this;
+
+    this._destroyed = true;
+    this._connected = false;
+    this.destroyed = true;
+    this.readyState = 'closed';
+
+    if (error) {
+      this.emit('error', error);
+    }
+
+    queueMicrotask(() => {
+      this.emit('close', !!error);
+    });
+
+    return this;
+  }
+
+  // Internal: simulate receiving data from remote
+  _receiveData(data: Buffer | string): void {
+    const buffer = typeof data === 'string' ? Buffer.from(data) : data;
+    this.push(buffer);
+  }
+
+  // Internal: signal end of remote data
+  _receiveEnd(): void {
+    this.push(null);
+  }
+}
+
+/**
+ * Virtual Server implementation
+ */
+export class Server extends EventEmitter {
+  private _listening: boolean = false;
+  private _address: AddressInfo | null = null;
+  private _connections: Set<Socket> = new Set();
+  private _maxConnections: number = Infinity;
+
+  listening: boolean = false;
+  maxConnections?: number;
+
+  constructor(
+    optionsOrConnectionListener?: ServerOptions | ((socket: Socket) => void),
+    connectionListener?: (socket: Socket) => void
+  ) {
+    super();
+
+    let listener: ((socket: Socket) => void) | undefined;
+
+    if (typeof optionsOrConnectionListener === 'function') {
+      listener = optionsOrConnectionListener;
+    } else {
+      listener = connectionListener;
+    }
+
+    if (listener) {
+      this.on('connection', listener as EventListener);
+    }
+  }
+
+  listen(
+    portOrOptions?: number | ListenOptions,
+    hostOrCallback?: string | number | (() => void),
+    backlogOrCallback?: number | (() => void),
+    callback?: () => void
+  ): this {
+    let port: number = 0;
+    let host: string = '0.0.0.0';
+    let cb: (() => void) | undefined;
+
+    if (typeof portOrOptions === 'number') {
+      port = portOrOptions;
+
+      if (typeof hostOrCallback === 'string') {
+        host = hostOrCallback;
+        if (typeof backlogOrCallback === 'function') {
+          cb = backlogOrCallback;
+        } else {
+          cb = callback;
+        }
+      } else if (typeof hostOrCallback === 'function') {
+        cb = hostOrCallback;
+      } else if (typeof hostOrCallback === 'number') {
+        // backlog
+        cb = typeof backlogOrCallback === 'function' ? backlogOrCallback : callback;
+      } else {
+        // hostOrCallback is undefined, check if callback is in third position
+        if (typeof backlogOrCallback === 'function') {
+          cb = backlogOrCallback;
+        } else if (typeof callback === 'function') {
+          cb = callback;
+        }
+      }
+    } else if (portOrOptions) {
+      port = portOrOptions.port || 0;
+      host = portOrOptions.host || '0.0.0.0';
+      cb = typeof hostOrCallback === 'function' ? hostOrCallback : callback;
+    }
+
+    // Assign random port if 0
+    if (port === 0) {
+      port = 3000 + Math.floor(Math.random() * 1000);
+    }
+
+    this._address = {
+      address: host,
+      family: 'IPv4',
+      port,
+    };
+
+    this._listening = true;
+    this.listening = true;
+
+    queueMicrotask(() => {
+      this.emit('listening');
+      if (cb) cb();
+    });
+
+    return this;
+  }
+
+  address(): AddressInfo | null {
+    return this._address;
+  }
+
+  close(callback?: (err?: Error) => void): this {
+    this._listening = false;
+    this.listening = false;
+
+    // Close all connections
+    for (const socket of this._connections) {
+      socket.destroy();
+    }
+    this._connections.clear();
+
+    queueMicrotask(() => {
+      this.emit('close');
+      if (callback) callback();
+    });
+
+    return this;
+  }
+
+  getConnections(callback: (err: Error | null, count: number) => void): void {
+    callback(null, this._connections.size);
+  }
+
+  ref(): this {
+    return this;
+  }
+
+  unref(): this {
+    return this;
+  }
+
+  // Internal: handle incoming connection
+  _handleConnection(socket: Socket): void {
+    if (!this._listening) {
+      socket.destroy();
+      return;
+    }
+
+    this._connections.add(socket);
+
+    socket.on('close', () => {
+      this._connections.delete(socket);
+    });
+
+    this.emit('connection', socket);
+  }
+}
+
+export function createServer(
+  optionsOrConnectionListener?: ServerOptions | ((socket: Socket) => void),
+  connectionListener?: (socket: Socket) => void
+): Server {
+  return new Server(optionsOrConnectionListener, connectionListener);
+}
+
+export function createConnection(
+  portOrOptions: number | { port: number; host?: string },
+  hostOrCallback?: string | (() => void),
+  callback?: () => void
+): Socket {
+  const socket = new Socket();
+  return socket.connect(portOrOptions, hostOrCallback as string, callback);
+}
+
+export const connect = createConnection;
+
+export function isIP(input: string): number {
+  // Simple IPv4 check
+  if (/^(\d{1,3}\.){3}\d{1,3}$/.test(input)) {
+    return 4;
+  }
+  // Simple IPv6 check
+  if (/^([0-9a-fA-F]{0,4}:){2,7}[0-9a-fA-F]{0,4}$/.test(input)) {
+    return 6;
+  }
+  return 0;
+}
+
+export function isIPv4(input: string): boolean {
+  return isIP(input) === 4;
+}
+
+export function isIPv6(input: string): boolean {
+  return isIP(input) === 6;
+}
+
+export default {
+  Socket,
+  Server,
+  createServer,
+  createConnection,
+  connect,
+  isIP,
+  isIPv4,
+  isIPv6,
+};