@nimbus-sh/core 0.1.0

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

@@ -0,0 +1,561 @@
+import { EventEmitter } from './events.js';
+import {
+  isLoopbackHost,
+  type LoopbackRouter,
+  type VirtualRequestHandler,
+  type VirtualResponse,
+} from '../kernel/index.js';
+
+/** Extended VirtualResponse with a done promise for async middleware */
+export interface VirtualResponseWithDone extends VirtualResponse {
+  _donePromise?: Promise<void>;
+}
+
+interface RequestOptions {
+  hostname?: string;
+  host?: string;
+  port?: number | string;
+  path?: string;
+  method?: string;
+  headers?: Record<string, string>;
+  timeout?: number;
+}
+
+class IncomingMessage extends EventEmitter {
+  statusCode: number;
+  statusMessage: string;
+  headers: Record<string, string>;
+  method?: string;
+  url?: string;
+  httpVersion = '1.1';
+  httpVersionMajor = 1;
+  httpVersionMinor = 1;
+  complete = false;
+  aborted = false;
+  readable = true;
+  // Minimal socket stub that Vite/Connect middleware expects
+  socket: {
+    remoteAddress: string;
+    remotePort: number;
+    encrypted: boolean;
+    destroy: () => void;
+  };
+  connection: {
+    remoteAddress: string;
+    encrypted: boolean;
+  };
+
+  constructor(statusCode: number, statusMessage: string, headers: Record<string, string>) {
+    super();
+    this.statusCode = statusCode;
+    this.statusMessage = statusMessage;
+    this.headers = headers;
+    const socketStub = {
+      remoteAddress: '127.0.0.1',
+      remotePort: 0,
+      encrypted: false,
+      destroy: () => {},
+    };
+    this.socket = socketStub;
+    this.connection = socketStub;
+  }
+
+  setEncoding(_enc: string): this {
+    return this;
+  }
+
+  // Stream-like methods that middleware may call
+  resume(): this {
+    return this;
+  }
+
+  pause(): this {
+    return this;
+  }
+
+  destroy(): this {
+    this.aborted = true;
+    return this;
+  }
+}
+
+class ClientRequest extends EventEmitter {
+  private options: RequestOptions;
+  private body = '';
+  private aborted = false;
+  private portRegistry?: Map<number, VirtualRequestHandler>;
+  private routeLoopback?: LoopbackRouter;
+  private protocol: 'http:' | 'https:';
+
+  constructor(
+    options: RequestOptions,
+    cb?: (res: IncomingMessage) => void,
+    portRegistry?: Map<number, VirtualRequestHandler>,
+    protocol: 'http:' | 'https:' = 'http:',
+    routeLoopback?: LoopbackRouter,
+  ) {
+    super();
+    this.options = options;
+    this.portRegistry = portRegistry;
+    this.protocol = protocol;
+    this.routeLoopback = routeLoopback;
+    if (cb) this.on('response', cb as (...args: unknown[]) => void);
+
+    // Defer the actual fetch
+    queueMicrotask(() => this.execute());
+  }
+
+  write(data: string): void {
+    this.body += data;
+  }
+
+  end(data?: string): void {
+    if (data) this.body += data;
+  }
+
+  abort(): void {
+    this.aborted = true;
+  }
+
+  private async execute(): Promise<void> {
+    if (this.aborted) return;
+
+    const host = this.options.hostname || this.options.host || 'localhost';
+    const port = this.options.port ? Number(this.options.port) : (this.protocol === 'http:' ? 80 : 443);
+    const path = this.options.path || '/';
+    const loopback = isLoopbackHost(host);
+
+    // Check if target is a virtual server
+    if (this.portRegistry && loopback) {
+      const handler = this.portRegistry.get(port);
+      if (handler) {
+        const vReq = {
+          method: this.options.method || 'GET',
+          url: path,
+          headers: this.options.headers || {},
+          body: this.body,
+        };
+        const vRes = {
+          statusCode: 200,
+          headers: {} as Record<string, string>,
+          body: '',
+        };
+
+        try {
+          handler(vReq, vRes);
+
+          const msg = new IncomingMessage(vRes.statusCode, 'OK', vRes.headers);
+          this.emit('response', msg);
+
+          queueMicrotask(() => {
+            msg.emit('data', vRes.body);
+            msg.emit('end');
+          });
+        } catch (e) {
+          this.emit('error', e);
+        }
+        return;
+      }
+    }
+
+    if (loopback) {
+      if (this.routeLoopback) {
+        try {
+          const method = this.options.method || 'GET';
+          const hasBody = method !== 'GET' && method !== 'HEAD' && this.body.length > 0;
+          const response = await this.routeLoopback(port, new Request(
+            `${this.protocol}//${host}:${port}${path}`,
+            {
+              method,
+              headers: this.options.headers,
+              body: hasBody ? this.body : undefined,
+            },
+          ));
+          if (response) {
+            const headers: Record<string, string> = {};
+            response.headers.forEach((value, key) => { headers[key] = value; });
+            const msg = new IncomingMessage(response.status, response.statusText, headers);
+            this.emit('response', msg);
+            const text = await response.text();
+            msg.emit('data', text);
+            msg.emit('end');
+            return;
+          }
+        } catch (error) {
+          this.emit('error', error);
+          return;
+        }
+      }
+      this.emit('error', new Error(`connect ECONNREFUSED ${host}:${port}`));
+      return;
+    }
+
+    // Fall through to real fetch
+    const proto = this.protocol.replace(':', ''); // 'http:' -> 'http' or 'https:' -> 'https'
+    const portStr = this.options.port ? `:${this.options.port}` : '';
+    const url = `${proto}://${host}${portStr}${path}`;
+
+    try {
+      const resp = await fetch(url, {
+        method: this.options.method || 'GET',
+        headers: this.options.headers,
+        body: this.options.method !== 'GET' && this.body ? this.body : undefined,
+      });
+
+      const headers: Record<string, string> = {};
+      resp.headers.forEach((v, k) => { headers[k] = v; });
+
+      const msg = new IncomingMessage(resp.status, resp.statusText, headers);
+      this.emit('response', msg);
+
+      const text = await resp.text();
+      msg.emit('data', text);
+      msg.emit('end');
+    } catch (e) {
+      this.emit('error', e);
+    }
+  }
+
+  setTimeout(_ms: number, cb?: () => void): this {
+    if (cb) this.on('timeout', cb);
+    return this;
+  }
+}
+
+// --- ServerResponse class ---
+
+class ServerResponse extends EventEmitter {
+  statusCode = 200;
+  statusMessage = 'OK';
+  headersSent = false;
+  finished = false;
+  writableEnded = false;
+  writableFinished = false;
+  private _headers: Record<string, string | string[]> = {};
+  private _body = '';
+  private _vRes: { statusCode: number; headers: Record<string, string>; body: string };
+  // Minimal socket stub that middleware may reference
+  socket: { destroy: () => void; writable: boolean; readable: boolean; remoteAddress: string } | null;
+  // Promise that resolves when end() is called (for async middleware)
+  _donePromise: Promise<void>;
+  private _doneResolve!: () => void;
+
+  constructor(vRes: { statusCode: number; headers: Record<string, string>; body: string }) {
+    super();
+    this._vRes = vRes;
+    this._donePromise = new Promise<void>((resolve) => {
+      this._doneResolve = resolve;
+    });
+    // Socket stub that resolves _donePromise on destroy (error abort path)
+    this.socket = {
+      writable: true,
+      readable: true,
+      remoteAddress: '127.0.0.1',
+      destroy: () => {
+        this.socket!.writable = false;
+        if (!this.finished) {
+          this._vRes.statusCode = this.statusCode || 500;
+          this._vRes.headers = {};
+          this._vRes.body = '';
+          this.finished = true;
+          this._doneResolve();
+        }
+      },
+    };
+  }
+
+  writeHead(statusCode: number, reasonOrHeaders?: string | Record<string, string | string[]>, headers?: Record<string, string | string[]>): this {
+    this.statusCode = statusCode;
+    let h: Record<string, string | string[]> | undefined;
+    if (typeof reasonOrHeaders === 'string') {
+      this.statusMessage = reasonOrHeaders;
+      h = headers;
+    } else {
+      h = reasonOrHeaders;
+    }
+    if (h) {
+      for (const [k, v] of Object.entries(h)) {
+        this._headers[k.toLowerCase()] = v;
+      }
+    }
+    this.headersSent = true;
+    return this;
+  }
+
+  setHeader(name: string, value: string | string[]): this {
+    this._headers[name.toLowerCase()] = value;
+    return this;
+  }
+
+  getHeader(name: string): string | string[] | undefined {
+    return this._headers[name.toLowerCase()];
+  }
+
+  getHeaders(): Record<string, string | string[]> {
+    return { ...this._headers };
+  }
+
+  getHeaderNames(): string[] {
+    return Object.keys(this._headers);
+  }
+
+  hasHeader(name: string): boolean {
+    return name.toLowerCase() in this._headers;
+  }
+
+  removeHeader(name: string): void {
+    delete this._headers[name.toLowerCase()];
+  }
+
+  appendHeader(name: string, value: string | string[]): this {
+    const key = name.toLowerCase();
+    const existing = this._headers[key];
+    if (existing === undefined) {
+      this._headers[key] = value;
+    } else if (Array.isArray(existing)) {
+      this._headers[key] = existing.concat(value);
+    } else {
+      this._headers[key] = Array.isArray(value) ? [existing, ...value] : [existing, value];
+    }
+    return this;
+  }
+
+  flushHeaders(): void {
+    this.headersSent = true;
+  }
+
+  write(data: string | Uint8Array): boolean {
+    if (typeof data === 'string') {
+      this._body += data;
+    } else {
+      this._body += new TextDecoder().decode(data);
+    }
+    return true;
+  }
+
+  end(data?: string | Uint8Array | (() => void), _encoding?: string, cb?: () => void): void {
+    if (typeof data === 'function') {
+      cb = data;
+      data = undefined;
+    }
+    if (typeof data === 'string') {
+      this._body += data;
+    } else if (data instanceof Uint8Array) {
+      this._body += new TextDecoder().decode(data);
+    }
+    this.finished = true;
+    this.writableEnded = true;
+    this.writableFinished = true;
+    // Flatten header arrays to comma-separated strings for the virtual response
+    const flatHeaders: Record<string, string> = {};
+    for (const [k, v] of Object.entries(this._headers)) {
+      flatHeaders[k] = Array.isArray(v) ? v.join(', ') : v;
+    }
+    // Flush to virtual response
+    this._vRes.statusCode = this.statusCode;
+    this._vRes.headers = flatHeaders;
+    this._vRes.body = this._body;
+    this.headersSent = true;
+    this.emit('finish');
+    this._doneResolve();
+    if (cb) cb();
+  }
+
+  // Cork/uncork stubs (used by some frameworks)
+  cork(): void {}
+  uncork(): void {}
+}
+
+// --- Server class ---
+
+// Symbol used to track active server promises on the http module instance
+export const ACTIVE_SERVERS = Symbol.for('lifo.http.activeServers');
+
+class Server extends EventEmitter {
+  private portRegistry: Map<number, VirtualRequestHandler>;
+  private _port: number | null = null;
+  private _closeResolve: (() => void) | null = null;
+  private _promise: Promise<void> | null = null;
+  private _activeServers: Server[];
+
+  constructor(
+    portRegistry: Map<number, VirtualRequestHandler>,
+    activeServers: Server[],
+    requestHandler?: (req: unknown, res: unknown) => void,
+  ) {
+    super();
+    this.portRegistry = portRegistry;
+    this._activeServers = activeServers;
+    if (requestHandler) {
+      this.on('request', requestHandler as (...args: unknown[]) => void);
+    }
+  }
+
+  listen(port: number, ...rest: unknown[]): this {
+    let callback: (() => void) | undefined;
+    for (const arg of rest) {
+      if (typeof arg === 'function') {
+        callback = arg as () => void;
+        break;
+      }
+    }
+
+    this._port = port;
+
+    // Create a promise that resolves when server.close() is called
+    this._promise = new Promise<void>((resolve) => {
+      this._closeResolve = resolve;
+    });
+
+    // Register the handler in portRegistry
+    const handler: VirtualRequestHandler = (vReq, vRes) => {
+      const req = new IncomingMessage(0, '', vReq.headers);
+      req.method = vReq.method;
+      req.url = vReq.url;
+
+      const res = new ServerResponse(vRes);
+      // Attach the done promise to vRes so consumers (tunnel, curl) can await async middleware
+      (vRes as VirtualResponseWithDone)._donePromise = res._donePromise;
+      this.emit('request', req, res);
+
+      // Emit body data + end so middleware that reads the request body works
+      queueMicrotask(() => {
+        if (vReq.body) {
+          req.emit('data', vReq.body);
+        }
+        req.complete = true;
+        req.emit('end');
+      });
+    };
+    this.portRegistry.set(port, handler);
+
+    // Track this server
+    this._activeServers.push(this);
+
+    // Emit 'listening' event asynchronously (like Node does) and call callback
+    queueMicrotask(() => {
+      this.emit('listening');
+      if (callback) callback();
+    });
+
+    return this;
+  }
+
+  close(callback?: () => void): this {
+    if (this._port !== null) {
+      this.portRegistry.delete(this._port);
+    }
+
+    // Remove from active servers list
+    const idx = this._activeServers.indexOf(this);
+    if (idx !== -1) this._activeServers.splice(idx, 1);
+
+    if (this._closeResolve) {
+      this._closeResolve();
+      this._closeResolve = null;
+    }
+
+    if (callback) {
+      queueMicrotask(callback);
+    }
+
+    this.emit('close');
+    return this;
+  }
+
+  address(): { port: number; address: string; family: string } | null {
+    if (this._port === null) return null;
+    return { port: this._port, address: '127.0.0.1', family: 'IPv4' };
+  }
+
+  getPromise(): Promise<void> | null {
+    return this._promise;
+  }
+}
+
+// --- Factory function ---
+
+export function createHttp(
+  portRegistry?: Map<number, VirtualRequestHandler>,
+  protocol: 'http:' | 'https:' = 'http:',
+  routeLoopback?: LoopbackRouter,
+) {
+  // Track active servers created by this http module instance
+  const activeServers: Server[] = [];
+
+  function httpRequest(
+    urlOrOptions: string | RequestOptions,
+    optionsOrCb?: RequestOptions | ((res: IncomingMessage) => void),
+    cb?: (res: IncomingMessage) => void,
+  ): ClientRequest {
+    let options: RequestOptions;
+    let callback: ((res: IncomingMessage) => void) | undefined;
+
+    if (typeof urlOrOptions === 'string') {
+      const u = new URL(urlOrOptions);
+      options = {
+        hostname: u.hostname,
+        port: u.port,
+        path: u.pathname + u.search,
+        method: 'GET',
+      };
+      if (typeof optionsOrCb === 'function') {
+        callback = optionsOrCb;
+      } else {
+        options = { ...options, ...optionsOrCb };
+        callback = cb;
+      }
+    } else {
+      options = urlOrOptions;
+      callback = optionsOrCb as ((res: IncomingMessage) => void) | undefined;
+    }
+
+    return new ClientRequest(options, callback, portRegistry, protocol, routeLoopback);
+  }
+
+  function httpGet(
+    urlOrOptions: string | RequestOptions,
+    optionsOrCb?: RequestOptions | ((res: IncomingMessage) => void),
+    cb?: (res: IncomingMessage) => void,
+  ): ClientRequest {
+    const req = httpRequest(urlOrOptions, optionsOrCb, cb);
+    req.end();
+    return req;
+  }
+
+  function httpCreateServer(requestHandler?: (req: unknown, res: unknown) => void): Server {
+    if (!portRegistry) {
+      throw new Error('http.createServer() is not supported in Lifo');
+    }
+    return new Server(portRegistry, activeServers, requestHandler);
+  }
+
+  const mod = {
+    request: httpRequest,
+    get: httpGet,
+    createServer: httpCreateServer,
+    IncomingMessage,
+    ClientRequest,
+    Server,
+    ServerResponse,
+    [ACTIVE_SERVERS]: activeServers,
+  };
+
+  return mod;
+}
+
+// --- Legacy static exports (for backward compatibility) ---
+
+export function request(urlOrOptions: string | RequestOptions, optionsOrCb?: RequestOptions | ((res: IncomingMessage) => void), cb?: (res: IncomingMessage) => void): ClientRequest {
+  return createHttp().request(urlOrOptions, optionsOrCb, cb);
+}
+
+export function get(urlOrOptions: string | RequestOptions, optionsOrCb?: RequestOptions | ((res: IncomingMessage) => void), cb?: (res: IncomingMessage) => void): ClientRequest {
+  return createHttp().get(urlOrOptions, optionsOrCb, cb);
+}
+
+export function createServer(): never {
+  throw new Error('http.createServer() is not supported in Lifo');
+}
+
+export default { request, get, createServer, IncomingMessage, ClientRequest };