@gjsify/http2 0.1.15 → 0.3.0

package/lib/esm/server.js

@@ -0,0 +1,620 @@
+import Soup from "@girs/soup-3.0";
+import Gio from "@girs/gio-2.0";
+import GLib from "@girs/glib-2.0";
+import { EventEmitter } from "node:events";
+import { Readable, Writable } from "node:stream";
+import { Buffer } from "node:buffer";
+import { deferEmit, ensureMainLoop } from "@gjsify/utils";
+import { constants, getDefaultSettings } from "./protocol.js";
+class Http2ServerRequest extends Readable {
+  method = "GET";
+  url = "/";
+  headers = {};
+  rawHeaders = [];
+  authority = "";
+  scheme = "https";
+  httpVersion = "2.0";
+  httpVersionMajor = 2;
+  httpVersionMinor = 0;
+  complete = false;
+  socket = null;
+  trailers = {};
+  rawTrailers = [];
+  _stream = null;
+  _timeoutTimer = null;
+  get stream() {
+    return this._stream;
+  }
+  // Called by Http2Server after stream is created
+  _setStream(stream) {
+    this._stream = stream;
+  }
+  constructor() {
+    super();
+  }
+  _read(_size) {
+  }
+  // 'close' means connection lost, not body-stream end
+  _autoClose() {
+  }
+  _pushBody(body) {
+    if (body && body.length > 0) {
+      this.push(Buffer.from(body));
+    }
+    this.push(null);
+    this.complete = true;
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+  }
+  setTimeout(msecs, callback) {
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+    if (callback) this.once("timeout", callback);
+    if (msecs > 0) {
+      this._timeoutTimer = setTimeout(() => {
+        this._timeoutTimer = null;
+        this.emit("timeout");
+      }, msecs);
+    }
+    return this;
+  }
+  destroy(error) {
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+    return super.destroy(error);
+  }
+}
+class Http2ServerResponse extends Writable {
+  statusCode = 200;
+  statusMessage = "";
+  headersSent = false;
+  finished = false;
+  sendDate = true;
+  _soupMsg;
+  _headers = /* @__PURE__ */ new Map();
+  _streaming = false;
+  _timeoutTimer = null;
+  _stream = null;
+  get stream() {
+    return this._stream;
+  }
+  get socket() {
+    return null;
+  }
+  // Called by Http2Server after stream is created
+  _setStream(stream) {
+    this._stream = stream;
+  }
+  constructor(soupMsg) {
+    super();
+    this._soupMsg = soupMsg;
+  }
+  setHeader(name, value) {
+    this._headers.set(name.toLowerCase(), typeof value === "number" ? String(value) : value);
+    return this;
+  }
+  getHeader(name) {
+    return this._headers.get(name.toLowerCase());
+  }
+  removeHeader(name) {
+    this._headers.delete(name.toLowerCase());
+  }
+  hasHeader(name) {
+    return this._headers.has(name.toLowerCase());
+  }
+  getHeaderNames() {
+    return Array.from(this._headers.keys());
+  }
+  getHeaders() {
+    const result = {};
+    for (const [key, value] of this._headers) {
+      result[key] = value;
+    }
+    return result;
+  }
+  appendHeader(name, value) {
+    const lower = name.toLowerCase();
+    const existing = this._headers.get(lower);
+    if (existing === void 0) {
+      this._headers.set(lower, value);
+    } else if (Array.isArray(existing)) {
+      Array.isArray(value) ? existing.push(...value) : existing.push(value);
+    } else {
+      this._headers.set(lower, Array.isArray(value) ? [existing, ...value] : [existing, value]);
+    }
+    return this;
+  }
+  flushHeaders() {
+    if (!this.headersSent) this.headersSent = true;
+  }
+  writeHead(statusCode, statusMessage, headers) {
+    this.statusCode = statusCode;
+    if (typeof statusMessage === "object") {
+      headers = statusMessage;
+      statusMessage = void 0;
+    }
+    if (typeof statusMessage === "string") this.statusMessage = statusMessage;
+    if (headers) {
+      for (const [key, value] of Object.entries(headers)) {
+        this.setHeader(key, value);
+      }
+    }
+    return this;
+  }
+  // http2 session-API alias — extracts :status from headers map
+  respond(headers, options) {
+    const status = Number(headers[":status"] ?? 200);
+    const rest = {};
+    for (const [k, v] of Object.entries(headers)) {
+      if (k === ":status") continue;
+      rest[k] = typeof v === "number" ? String(v) : v;
+    }
+    this.writeHead(status, rest);
+    if (options?.endStream) this.end();
+  }
+  writeContinue(callback) {
+    if (callback) Promise.resolve().then(callback);
+  }
+  writeEarlyHints(_hints, callback) {
+    if (callback) Promise.resolve().then(callback);
+  }
+  addTrailers(_headers) {
+  }
+  setTimeout(msecs, callback) {
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+    if (callback) this.once("timeout", callback);
+    if (msecs > 0) {
+      this._timeoutTimer = setTimeout(() => {
+        this._timeoutTimer = null;
+        this.emit("timeout");
+      }, msecs);
+    }
+    return this;
+  }
+  _startStreaming() {
+    if (this._streaming) return;
+    this._streaming = true;
+    this.headersSent = true;
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+    this._soupMsg.set_status(this.statusCode, this.statusMessage || null);
+    const responseHeaders = this._soupMsg.get_response_headers();
+    if (this._headers.has("content-length")) {
+      responseHeaders.set_encoding(Soup.Encoding.CONTENT_LENGTH);
+    } else {
+      responseHeaders.set_encoding(Soup.Encoding.CHUNKED);
+    }
+    for (const [key, value] of this._headers) {
+      if (Array.isArray(value)) {
+        for (const v of value) responseHeaders.append(key, v);
+      } else {
+        responseHeaders.replace(key, value);
+      }
+    }
+  }
+  _write(chunk, encoding, callback) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+    this._startStreaming();
+    const responseBody = this._soupMsg.get_response_body();
+    responseBody.append(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
+    this._soupMsg.unpause();
+    callback();
+  }
+  _final(callback) {
+    if (this._streaming) {
+      const responseBody = this._soupMsg.get_response_body();
+      responseBody.complete();
+      this._soupMsg.unpause();
+    } else {
+      this._sendBatchResponse();
+    }
+    this.finished = true;
+    callback();
+  }
+  _sendBatchResponse() {
+    if (this.headersSent) return;
+    this.headersSent = true;
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = null;
+    }
+    this._soupMsg.set_status(this.statusCode, this.statusMessage || null);
+    const responseHeaders = this._soupMsg.get_response_headers();
+    for (const [key, value] of this._headers) {
+      if (Array.isArray(value)) {
+        for (const v of value) responseHeaders.append(key, v);
+      } else {
+        responseHeaders.replace(key, value);
+      }
+    }
+    const contentType = this._headers.get("content-type") || "text/plain";
+    this._soupMsg.set_response(contentType, Soup.MemoryUse.COPY, new Uint8Array(0));
+  }
+  end(chunk, encoding, callback) {
+    if (typeof chunk === "function") {
+      callback = chunk;
+      chunk = void 0;
+    } else if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = void 0;
+    }
+    if (chunk != null) {
+      this.write(chunk, encoding);
+    }
+    super.end(callback);
+    return this;
+  }
+  // respondWithFD and respondWithFile stubs (Phase 2)
+  respondWithFD(_fd, _headers, _options) {
+    throw new Error("http2 respondWithFD is not yet implemented in GJS (Phase 2)");
+  }
+  respondWithFile(_path, _headers, _options) {
+    throw new Error("http2 respondWithFile is not yet implemented in GJS (Phase 2)");
+  }
+  pushStream(_headers, _options, _callback) {
+    throw new Error("http2 server push is not yet implemented in GJS (Phase 2)");
+  }
+  createPushResponse(_headers, _callback) {
+    throw new Error("http2 server push is not yet implemented in GJS (Phase 2)");
+  }
+}
+class ServerHttp2Stream extends EventEmitter {
+  id = 1;
+  pushAllowed = false;
+  sentHeaders = {};
+  _res;
+  _session;
+  get session() {
+    return this._session;
+  }
+  get headersSent() {
+    return this._res.headersSent;
+  }
+  get closed() {
+    return this._res.writableEnded;
+  }
+  get destroyed() {
+    return this._res.destroyed;
+  }
+  get pending() {
+    return false;
+  }
+  get state() {
+    return this.closed ? constants.NGHTTP2_STREAM_STATE_CLOSED : constants.NGHTTP2_STREAM_STATE_OPEN;
+  }
+  constructor(res, session = null) {
+    super();
+    this._res = res;
+    this._session = session;
+    res.on("finish", () => this.emit("close"));
+    res.on("error", (err) => this.emit("error", err));
+  }
+  // Session API: send response headers
+  respond(headers, options) {
+    this._res.respond(headers, options);
+  }
+  // Writable-like interface delegating to response
+  write(chunk, encoding, callback) {
+    return this._res.write(chunk, encoding, callback);
+  }
+  end(chunk, encoding, callback) {
+    this._res.end(chunk, encoding, callback);
+    return this;
+  }
+  destroy(error) {
+    this._res.destroy(error);
+    return this;
+  }
+  close(code, callback) {
+    if (callback) this.once("close", callback);
+    this._res.end();
+  }
+  priority(_options) {
+  }
+  setTimeout(msecs, callback) {
+    this._res.setTimeout(msecs, callback);
+    return this;
+  }
+  sendTrailers(_headers) {
+  }
+  additionalHeaders(_headers) {
+  }
+  respondWithFD(_fd, _headers, _options) {
+    throw new Error("http2 respondWithFD is not yet implemented in GJS (Phase 2)");
+  }
+  respondWithFile(_path, _headers, _options) {
+    throw new Error("http2 respondWithFile is not yet implemented in GJS (Phase 2)");
+  }
+  pushStream(_headers, _options, _callback) {
+    throw new Error("http2 server push is not yet implemented in GJS (Phase 2)");
+  }
+}
+class ServerHttp2Session extends EventEmitter {
+  type = constants.NGHTTP2_SESSION_SERVER;
+  alpnProtocol = "h2";
+  encrypted = true;
+  _closed = false;
+  _destroyed = false;
+  _settings;
+  constructor() {
+    super();
+    this._settings = getDefaultSettings();
+  }
+  get closed() {
+    return this._closed;
+  }
+  get destroyed() {
+    return this._destroyed;
+  }
+  get pendingSettingsAck() {
+    return false;
+  }
+  get localSettings() {
+    return { ...this._settings };
+  }
+  get remoteSettings() {
+    return getDefaultSettings();
+  }
+  get originSet() {
+    return [];
+  }
+  settings(settings, callback) {
+    Object.assign(this._settings, settings);
+    if (callback) Promise.resolve().then(callback);
+  }
+  goaway(code, _lastStreamId, _data) {
+    this.emit("goaway", code ?? constants.NGHTTP2_NO_ERROR);
+    this.destroy();
+  }
+  ping(_payload, callback) {
+    const buf = new Uint8Array(8);
+    if (callback) Promise.resolve().then(() => callback(null, 0, buf));
+    return true;
+  }
+  close(callback) {
+    if (this._closed) return;
+    this._closed = true;
+    this.emit("close");
+    if (callback) callback();
+  }
+  destroy(error, code) {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    this._closed = true;
+    if (error) this.emit("error", error);
+    if (code !== void 0) this.emit("goaway", code);
+    this.emit("close");
+  }
+  altsvc(_alt, _originOrStream) {
+  }
+  origin(..._origins) {
+  }
+  ref() {
+  }
+  unref() {
+  }
+}
+const _activeServers = /* @__PURE__ */ new Set();
+class Http2Server extends EventEmitter {
+  listening = false;
+  maxHeadersCount = 2e3;
+  timeout = 0;
+  _soupServer = null;
+  _address = null;
+  _options;
+  get soupServer() {
+    return this._soupServer;
+  }
+  constructor(options, handler) {
+    super();
+    if (typeof options === "function") {
+      handler = options;
+      options = {};
+    }
+    this._options = options ?? {};
+    if (handler) this.on("request", handler);
+  }
+  listen(...args) {
+    let port = 0;
+    let hostname = "0.0.0.0";
+    let callback;
+    for (const arg of args) {
+      if (typeof arg === "number") port = arg;
+      else if (typeof arg === "string") hostname = arg;
+      else if (typeof arg === "function") callback = arg;
+    }
+    if (callback) this.once("listening", callback);
+    try {
+      this._soupServer = new Soup.Server({});
+      this._configureSoupServer(this._soupServer);
+      this._soupServer.add_handler(null, (_server, msg, _path) => {
+        this._handleRequest(msg);
+      });
+      this._soupServer.listen_local(port, Soup.ServerListenOptions.IPV4_ONLY);
+      ensureMainLoop();
+      const listeners = this._soupServer.get_listeners();
+      let actualPort = port;
+      if (listeners && listeners.length > 0) {
+        const addr = listeners[0].get_local_address();
+        if (addr && typeof addr.get_port === "function") {
+          actualPort = addr.get_port();
+        }
+      }
+      this.listening = true;
+      this._address = { port: actualPort, family: "IPv4", address: hostname };
+      _activeServers.add(this);
+      deferEmit(this, "listening");
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (this.listenerCount("error") === 0) throw error;
+      deferEmit(this, "error", error);
+    }
+    return this;
+  }
+  // Override in Http2SecureServer to set TLS certificate before listen
+  _configureSoupServer(_server) {
+  }
+  _handleRequest(soupMsg) {
+    const req = new Http2ServerRequest();
+    const res = new Http2ServerResponse(soupMsg);
+    req.method = soupMsg.get_method();
+    const uri = soupMsg.get_uri();
+    const path = uri.get_path();
+    const query = uri.get_query();
+    req.url = query ? path + "?" + query : path;
+    req.authority = uri.get_host() ?? "";
+    req.scheme = uri.get_scheme() ?? "http";
+    const httpVersion = soupMsg.get_http_version();
+    if (httpVersion === Soup.HTTPVersion.HTTP_2_0) {
+      req.httpVersion = "2.0";
+      req.httpVersionMajor = 2;
+      req.httpVersionMinor = 0;
+    } else {
+      req.httpVersion = "1.1";
+      req.httpVersionMajor = 1;
+      req.httpVersionMinor = 1;
+    }
+    const requestHeaders = soupMsg.get_request_headers();
+    requestHeaders.foreach((name, value) => {
+      const lower = name.toLowerCase();
+      req.rawHeaders.push(name, value);
+      if (lower in req.headers) {
+        const existing = req.headers[lower];
+        if (Array.isArray(existing)) {
+          existing.push(value);
+        } else {
+          req.headers[lower] = [existing, value];
+        }
+      } else {
+        req.headers[lower] = value;
+      }
+    });
+    const remoteHost = soupMsg.get_remote_host() ?? "127.0.0.1";
+    const remoteAddr = soupMsg.get_remote_address();
+    const remotePort = remoteAddr instanceof Gio.InetSocketAddress ? remoteAddr.get_port() : 0;
+    req.socket = {
+      remoteAddress: remoteHost,
+      remotePort,
+      localAddress: this._address?.address ?? "127.0.0.1",
+      localPort: this._address?.port ?? 0,
+      encrypted: this instanceof Http2SecureServer
+    };
+    const body = soupMsg.get_request_body();
+    if (body?.data && body.data.length > 0) {
+      req._pushBody(body.data);
+    } else {
+      req._pushBody(null);
+    }
+    const streamHeaders = {
+      ":method": req.method,
+      ":path": req.url,
+      ":authority": req.authority,
+      ":scheme": req.scheme,
+      ...req.headers
+    };
+    soupMsg.pause();
+    res.on("finish", () => soupMsg.unpause());
+    const session = new ServerHttp2Session();
+    const stream = new ServerHttp2Stream(res, session);
+    req._setStream(stream);
+    res._setStream(stream);
+    this.emit("stream", stream, streamHeaders);
+    this.emit("request", req, res);
+  }
+  address() {
+    return this._address;
+  }
+  close(callback) {
+    if (callback) this.once("close", callback);
+    if (this._soupServer) {
+      this._soupServer.disconnect();
+      this._soupServer = null;
+    }
+    this.listening = false;
+    _activeServers.delete(this);
+    deferEmit(this, "close");
+    return this;
+  }
+  setTimeout(msecs, callback) {
+    this.timeout = msecs;
+    if (callback) this.on("timeout", callback);
+    return this;
+  }
+}
+class Http2SecureServer extends Http2Server {
+  _tlsCert = null;
+  constructor(options, handler) {
+    super(options, handler);
+    if (options.cert && options.key) {
+      const certPem = _toPemString(options.cert);
+      const keyPem = _toPemString(options.key);
+      this._tlsCert = _createTlsCertificate(certPem, keyPem);
+    } else if (options.pfx) {
+    }
+  }
+  _configureSoupServer(server) {
+    if (this._tlsCert) {
+      server.set_tls_certificate(this._tlsCert);
+    }
+  }
+  setSecureContext(options) {
+    if (options.cert && options.key) {
+      const certPem = _toPemString(options.cert);
+      const keyPem = _toPemString(options.key);
+      this._tlsCert = _createTlsCertificate(certPem, keyPem);
+      if (this._soupServer && this._tlsCert) {
+        this._soupServer.set_tls_certificate(this._tlsCert);
+      }
+    }
+  }
+}
+function _toPemString(value) {
+  if (Array.isArray(value)) {
+    return value.map(_toPemString).join("\n");
+  }
+  return Buffer.isBuffer(value) ? value.toString("utf8") : value;
+}
+function _createTlsCertificate(certPem, keyPem) {
+  const combined = certPem.trimEnd() + "\n" + keyPem.trimEnd() + "\n";
+  try {
+    return Gio.TlsCertificate.new_from_pem(combined, -1);
+  } catch (err) {
+    const tmpDir = GLib.get_tmp_dir();
+    const certPath = GLib.build_filenamev([tmpDir, "gjsify-http2-cert.pem"]);
+    const keyPath = GLib.build_filenamev([tmpDir, "gjsify-http2-key.pem"]);
+    try {
+      GLib.file_set_contents(certPath, certPem);
+      GLib.file_set_contents(keyPath, keyPem);
+      const tlsCert = Gio.TlsCertificate.new_from_files(certPath, keyPath);
+      return tlsCert;
+    } finally {
+      try {
+        Gio.File.new_for_path(certPath).delete(null);
+      } catch {
+      }
+      try {
+        Gio.File.new_for_path(keyPath).delete(null);
+      } catch {
+      }
+    }
+  }
+}
+export {
+  Http2SecureServer,
+  Http2Server,
+  Http2ServerRequest,
+  Http2ServerResponse,
+  ServerHttp2Session,
+  ServerHttp2Stream
+};

package/lib/types/client-session.d.ts

@@ -0,0 +1,100 @@
+import Soup from '@girs/soup-3.0';
+import { EventEmitter } from 'node:events';
+import { Duplex } from 'node:stream';
+import { Buffer } from 'node:buffer';
+import { type Http2Settings } from './protocol.js';
+export type { Http2Settings };
+export interface ClientSessionOptions {
+    maxDeflateDynamicTableSize?: number;
+    maxSessionMemory?: number;
+    maxHeaderListPairs?: number;
+    maxOutstandingPings?: number;
+    maxReservedRemoteStreams?: number;
+    maxSendHeaderBlockLength?: number;
+    paddingStrategy?: number;
+    peerMaxHeaderListSize?: number;
+    protocol?: string;
+    settings?: Http2Settings;
+    rejectUnauthorized?: boolean;
+    ca?: string | Buffer | Array<string | Buffer>;
+    cert?: string | Buffer | Array<string | Buffer>;
+    key?: string | Buffer | Array<string | Buffer>;
+    ALPNProtocols?: string[];
+}
+export interface ClientStreamOptions {
+    endStream?: boolean;
+    exclusive?: boolean;
+    parent?: number;
+    weight?: number;
+    waitForTrailers?: boolean;
+    signal?: AbortSignal;
+}
+export declare class Http2Session extends EventEmitter {
+    readonly type: number;
+    readonly alpnProtocol: string | undefined;
+    readonly encrypted: boolean;
+    private _closed;
+    private _destroyed;
+    private _settings;
+    constructor();
+    get closed(): boolean;
+    get destroyed(): boolean;
+    get connecting(): boolean;
+    get pendingSettingsAck(): boolean;
+    get localSettings(): Http2Settings;
+    get remoteSettings(): Http2Settings;
+    get originSet(): Set<string>;
+    settings(settings: Http2Settings, callback?: () => void): void;
+    goaway(code?: number, _lastStreamId?: number, _data?: Uint8Array): void;
+    ping(payload?: Uint8Array, callback?: (err: Error | null, duration: number, payload: Uint8Array) => void): boolean;
+    close(callback?: () => void): void;
+    destroy(error?: Error, code?: number): void;
+    ref(): void;
+    unref(): void;
+}
+export declare class ClientHttp2Stream extends Duplex {
+    readonly id = 1;
+    readonly pending = false;
+    readonly aborted = false;
+    readonly bufferSize = 0;
+    readonly endAfterHeaders = false;
+    private _session;
+    private _requestHeaders;
+    private _requestChunks;
+    private _cancellable;
+    private _state;
+    private _responseHeaders;
+    get state(): number;
+    get rstCode(): number;
+    get session(): ClientHttp2Session;
+    get sentHeaders(): Record<string, string | string[]>;
+    constructor(session: ClientHttp2Session, requestHeaders: Record<string, string | string[]>);
+    _read(_size: number): void;
+    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    private _sendRequest;
+    close(code?: number, callback?: () => void): void;
+    priority(_options: {
+        exclusive?: boolean;
+        parent?: number;
+        weight?: number;
+        silent?: boolean;
+    }): void;
+    sendTrailers(_headers: Record<string, string | string[]>): void;
+    setTimeout(_msecs: number, _callback?: () => void): this;
+}
+export declare class ClientHttp2Session extends Http2Session {
+    readonly type: 1;
+    readonly encrypted: boolean;
+    private _authority;
+    private _soupSession;
+    private _streams;
+    constructor(authority: string, options?: ClientSessionOptions);
+    /** @internal Used by ClientHttp2Stream to get the Soup.Session */
+    _getSoupSession(): Soup.Session;
+    /** @internal Used by ClientHttp2Stream to build the request URL */
+    _getAuthority(): string;
+    request(headers: Record<string, string | string[]>, options?: ClientStreamOptions): ClientHttp2Stream;
+    close(callback?: () => void): void;
+    destroy(error?: Error, code?: number): void;
+}

package/lib/types/http2.gjs.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;