@gjsify/net 0.0.4 → 0.1.0

package/README.md

@@ -1,5 +1,33 @@
 # @gjsify/net
 
-Node.js net module for Gjs
+GJS implementation of the Node.js `net` module using Gio.SocketClient and Gio.SocketService. Provides Socket and Server.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/net
+# or
+yarn add @gjsify/net
+```
+
+## Usage
+
+```typescript
+import { createServer, createConnection } from '@gjsify/net';
+
+const server = createServer((socket) => {
+  socket.on('data', (data) => console.log(data.toString()));
+  socket.end('goodbye');
+});
+server.listen(8080);
+```
+
 ## Inspirations and credits
+
 - https://nodejs.org/api/net.html
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -1,8 +1,13 @@
 import Gio from "@girs/gio-2.0";
+import { Socket, SocketConnectOptions } from "./socket.js";
+import { Server, ListenOptions } from "./server.js";
+import { Socket as Socket2 } from "./socket.js";
+import { Server as Server2 } from "./server.js";
 function isIP(input) {
-  const addr = Gio.InetAddress.new_from_string(input);
-  if (!addr)
-    return 0;
+  if (typeof input !== "string") return 0;
+  const stripped = input.includes("%") ? input.split("%")[0] : input;
+  const addr = Gio.InetAddress.new_from_string(stripped);
+  if (!addr) return 0;
   const family = addr.get_family();
   switch (family) {
     case Gio.SocketFamily.INVALID:
@@ -19,7 +24,33 @@ function isIPv4(input) {
 function isIPv6(input) {
   return isIP(input) === 6;
 }
+function createConnection(options, host, connectionListener) {
+  const socket = new Socket2();
+  return socket.connect(options, host, connectionListener);
+}
+const connect = createConnection;
+function createServer(optionsOrListener, connectionListener) {
+  return new Server2(optionsOrListener, connectionListener);
+}
+var index_default = {
+  Socket: Socket2,
+  Server: Server2,
+  isIP,
+  isIPv4,
+  isIPv6,
+  createConnection,
+  connect,
+  createServer
+};
 export {
+  ListenOptions,
+  Server,
+  Socket,
+  SocketConnectOptions,
+  connect,
+  createConnection,
+  createServer,
+  index_default as default,
   isIP,
   isIPv4,
   isIPv6

package/lib/esm/server.js

@@ -0,0 +1,133 @@
+import Gio from "@girs/gio-2.0";
+import { EventEmitter } from "node:events";
+import { createNodeError, deferEmit, ensureMainLoop } from "@gjsify/utils";
+import { Socket } from "./socket.js";
+const _activeServers = /* @__PURE__ */ new Set();
+class Server extends EventEmitter {
+  listening = false;
+  maxConnections;
+  allowHalfOpen;
+  _service = null;
+  _connections = /* @__PURE__ */ new Set();
+  _address = null;
+  constructor(optionsOrListener, connectionListener) {
+    super();
+    if (typeof optionsOrListener === "function") {
+      connectionListener = optionsOrListener;
+      this.allowHalfOpen = false;
+    } else {
+      this.allowHalfOpen = optionsOrListener?.allowHalfOpen ?? false;
+    }
+    if (connectionListener) {
+      this.on("connection", connectionListener);
+    }
+  }
+  listen(...args) {
+    let port = 0;
+    let host = "0.0.0.0";
+    let backlog = 511;
+    let callback;
+    if (typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0])) {
+      const opts = args[0];
+      port = opts.port ?? 0;
+      host = opts.host ?? "0.0.0.0";
+      backlog = opts.backlog ?? 511;
+      callback = args[1];
+    } else {
+      if (typeof args[0] === "number") port = args[0];
+      for (let i = 1; i < args.length; i++) {
+        if (typeof args[i] === "string") host = args[i];
+        else if (typeof args[i] === "number") backlog = args[i];
+        else if (typeof args[i] === "function") callback = args[i];
+      }
+    }
+    if (callback) {
+      this.once("listening", callback);
+    }
+    try {
+      this._service = new Gio.SocketService();
+      this._service.set_backlog(backlog);
+      let actualPort;
+      if (port === 0) {
+        actualPort = this._service.add_any_inet_port(null);
+      } else {
+        this._service.add_inet_port(port, null);
+        actualPort = port;
+      }
+      this._service.connect("incoming", (_service, connection) => {
+        this._handleConnection(connection);
+        return true;
+      });
+      this._service.start();
+      ensureMainLoop();
+      this.listening = true;
+      _activeServers.add(this);
+      const family = host.includes(":") ? "IPv6" : "IPv4";
+      this._address = { port: actualPort, family, address: host };
+      deferEmit(this, "listening");
+    } catch (err) {
+      const nodeErr = createNodeError(err, "listen", { address: host, port });
+      deferEmit(this, "error", nodeErr);
+    }
+    return this;
+  }
+  _handleConnection(connection) {
+    if (this.maxConnections && this._connections.size >= this.maxConnections) {
+      try {
+        connection.close(null);
+      } catch {
+      }
+      return;
+    }
+    const socket = new Socket({ allowHalfOpen: this.allowHalfOpen });
+    socket._setConnection(connection);
+    socket._setupConnection({});
+    this._connections.add(socket);
+    socket.on("close", () => {
+      this._connections.delete(socket);
+    });
+    this.emit("connection", socket);
+  }
+  /** Get the address the server is listening on. */
+  address() {
+    return this._address;
+  }
+  /** Close the server, stop accepting new connections. */
+  close(callback) {
+    if (callback) {
+      this.once("close", callback);
+    }
+    if (!this._service || !this.listening) {
+      setTimeout(() => {
+        const err = new Error("Server is not running");
+        err.code = "ERR_SERVER_NOT_RUNNING";
+        this.emit("error", err);
+      }, 0);
+      return this;
+    }
+    this._service.stop();
+    this._service.close();
+    this._service = null;
+    this.listening = false;
+    _activeServers.delete(this);
+    for (const socket of this._connections) {
+      socket.destroy();
+    }
+    this._connections.clear();
+    deferEmit(this, "close");
+    return this;
+  }
+  /** Get the number of concurrent connections. */
+  getConnections(callback) {
+    callback(null, this._connections.size);
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+}
+export {
+  Server
+};

package/lib/esm/socket.js

@@ -0,0 +1,332 @@
+import Gio from "@girs/gio-2.0";
+import GLib from "@girs/glib-2.0";
+import { Duplex } from "node:stream";
+import { Buffer } from "node:buffer";
+import { createNodeError, gbytesToUint8Array } from "@gjsify/utils";
+class Socket extends Duplex {
+  // Public properties matching Node.js net.Socket
+  remoteAddress;
+  remotePort;
+  remoteFamily;
+  localAddress;
+  localPort;
+  bytesRead = 0;
+  bytesWritten = 0;
+  connecting = false;
+  destroyed = false;
+  pending = true;
+  readyState = "closed";
+  _connection = null;
+  _ioStream = null;
+  _inputStream = null;
+  _outputStream = null;
+  _cancellable = new Gio.Cancellable();
+  _reading = false;
+  _timeout = 0;
+  _timeoutId = null;
+  constructor(options) {
+    super(options);
+    this.allowHalfOpen = options?.allowHalfOpen ?? false;
+  }
+  /** @internal Set the connection from an accepted server socket. */
+  _setConnection(connection) {
+    this._connection = connection;
+  }
+  /**
+   * @internal Set up this socket from a raw Gio.IOStream (e.g., stolen from Soup.Server
+   * during an HTTP upgrade). Extracts I/O streams, attempts to read address info
+   * if the underlying stream is a SocketConnection, and starts reading.
+   */
+  _setupFromIOStream(ioStream) {
+    this._ioStream = ioStream;
+    try {
+      const sockConn = ioStream;
+      if (typeof sockConn.get_socket === "function") {
+        this._connection = sockConn;
+        const remoteAddr = sockConn.get_remote_address();
+        this.remoteAddress = remoteAddr.get_address().to_string();
+        this.remotePort = remoteAddr.get_port();
+        this.remoteFamily = remoteAddr.get_address().get_family() === Gio.SocketFamily.IPV6 ? "IPv6" : "IPv4";
+        const localAddr = sockConn.get_local_address();
+        this.localAddress = localAddr.get_address().to_string();
+        this.localPort = localAddr.get_port();
+      }
+    } catch {
+    }
+    this._inputStream = ioStream.get_input_stream();
+    this._outputStream = ioStream.get_output_stream();
+    this.connecting = false;
+    this.pending = false;
+    this.readyState = "open";
+    this.emit("connect");
+    this.emit("ready");
+    this._startReading();
+  }
+  connect(options, host, connectionListener) {
+    let opts;
+    if (typeof options === "number") {
+      opts = { port: options, host: typeof host === "string" ? host : "localhost" };
+      if (typeof host === "function") connectionListener = host;
+    } else {
+      opts = options;
+      if (typeof host === "function") connectionListener = host;
+    }
+    if (connectionListener) {
+      this.once("connect", connectionListener);
+    }
+    this.connecting = true;
+    this.readyState = "opening";
+    this.pending = true;
+    const targetHost = opts.host || "localhost";
+    const targetPort = opts.port;
+    const client = new Gio.SocketClient();
+    if (opts.timeout) {
+      client.set_timeout(Math.ceil(opts.timeout / 1e3));
+    }
+    client.connect_to_host_async(
+      targetHost,
+      targetPort,
+      this._cancellable,
+      (_source, asyncResult) => {
+        try {
+          this._connection = client.connect_to_host_finish(asyncResult);
+          this._setupConnection(opts);
+        } catch (err) {
+          this.connecting = false;
+          this.readyState = "closed";
+          const nodeErr = createNodeError(err, "connect", {
+            address: targetHost,
+            port: targetPort
+          });
+          this.destroy(nodeErr);
+        }
+      }
+    );
+    return this;
+  }
+  /** @internal Set up streams and emit connect after connection is established. */
+  _setupConnection(opts) {
+    if (!this._connection) return;
+    const sock = this._connection.get_socket();
+    this._inputStream = this._connection.get_input_stream();
+    this._outputStream = this._connection.get_output_stream();
+    if ("keepAlive" in opts && opts.keepAlive) {
+      sock.set_keepalive(true);
+    }
+    if (!("noDelay" in opts) || opts.noDelay !== false) {
+      try {
+        sock.set_option(6, 1, 1);
+      } catch {
+      }
+    }
+    try {
+      const remoteAddr = this._connection.get_remote_address();
+      this.remoteAddress = remoteAddr.get_address().to_string();
+      this.remotePort = remoteAddr.get_port();
+      this.remoteFamily = remoteAddr.get_address().get_family() === Gio.SocketFamily.IPV6 ? "IPv6" : "IPv4";
+    } catch {
+    }
+    try {
+      const localAddr = this._connection.get_local_address();
+      this.localAddress = localAddr.get_address().to_string();
+      this.localPort = localAddr.get_port();
+    } catch {
+    }
+    this.connecting = false;
+    this.pending = false;
+    this.readyState = "open";
+    this.emit("connect");
+    this.emit("ready");
+    this._startReading();
+  }
+  _startReading() {
+    if (this._reading || !this._inputStream) return;
+    this._reading = true;
+    this._readLoop();
+  }
+  async _readLoop() {
+    const inputStream = this._inputStream;
+    if (!inputStream) return;
+    const CHUNK_SIZE = 16384;
+    try {
+      while (this._reading && inputStream) {
+        const bytes = await new Promise((resolve, reject) => {
+          inputStream.read_bytes_async(
+            CHUNK_SIZE,
+            GLib.PRIORITY_DEFAULT,
+            this._cancellable,
+            (_source, asyncResult) => {
+              try {
+                resolve(inputStream.read_bytes_finish(asyncResult));
+              } catch (err) {
+                reject(err);
+              }
+            }
+          );
+        });
+        if (!bytes || bytes.get_size() === 0) {
+          this._reading = false;
+          if (!this.allowHalfOpen) {
+            this.once("end", () => {
+              this.end();
+              this.readyState = "closed";
+            });
+          } else {
+            this.readyState = this.writable ? "writeOnly" : "closed";
+          }
+          this.push(null);
+          break;
+        }
+        const data = gbytesToUint8Array(bytes);
+        this.bytesRead += data.length;
+        this._resetTimeout();
+        if (!this.push(Buffer.from(data))) {
+          this._reading = false;
+          break;
+        }
+      }
+    } catch (err) {
+      if (!this._cancellable.is_cancelled()) {
+        this.destroy(createNodeError(err, "read", { address: this.remoteAddress }));
+      }
+    }
+  }
+  // Duplex stream interface
+  _read(_size) {
+    if (!this._reading && this._inputStream) {
+      this._startReading();
+    }
+  }
+  _write(chunk, encoding, callback) {
+    if (!this._outputStream) {
+      callback(new Error("Socket is not connected"));
+      return;
+    }
+    const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+    this._outputStream.write_bytes_async(
+      new GLib.Bytes(data),
+      GLib.PRIORITY_DEFAULT,
+      this._cancellable,
+      (_source, asyncResult) => {
+        try {
+          const written = this._outputStream.write_bytes_finish(asyncResult);
+          this.bytesWritten += written;
+          this._resetTimeout();
+          callback(null);
+        } catch (err) {
+          callback(createNodeError(err, "write", { address: this.remoteAddress }));
+        }
+      }
+    );
+  }
+  _final(callback) {
+    if (this._connection) {
+      try {
+        this._connection.get_socket().shutdown(false, true);
+        this.readyState = this.readable ? "readOnly" : "closed";
+      } catch {
+      }
+    } else if (this._ioStream) {
+      try {
+        this._ioStream.close(null);
+        this.readyState = "closed";
+      } catch {
+      }
+      this._ioStream = null;
+      this._inputStream = null;
+      this._outputStream = null;
+    }
+    callback();
+  }
+  _destroy(err, callback) {
+    this._reading = false;
+    this._clearTimeout();
+    this._cancellable.cancel();
+    if (this._connection) {
+      try {
+        this._connection.close(null);
+      } catch {
+      }
+      this._connection = null;
+    } else if (this._ioStream) {
+      try {
+        this._ioStream.close(null);
+      } catch {
+      }
+    }
+    this._ioStream = null;
+    this._inputStream = null;
+    this._outputStream = null;
+    this.readyState = "closed";
+    this.destroyed = true;
+    callback(err);
+  }
+  /** Set the socket timeout in milliseconds. 0 disables. */
+  setTimeout(timeout, callback) {
+    this._timeout = timeout;
+    this._clearTimeout();
+    if (callback) {
+      this.once("timeout", callback);
+    }
+    if (timeout > 0) {
+      this._resetTimeout();
+    }
+    return this;
+  }
+  _resetTimeout() {
+    this._clearTimeout();
+    if (this._timeout > 0) {
+      this._timeoutId = setTimeout(() => {
+        this.emit("timeout");
+      }, this._timeout);
+    }
+  }
+  _clearTimeout() {
+    if (this._timeoutId !== null) {
+      clearTimeout(this._timeoutId);
+      this._timeoutId = null;
+    }
+  }
+  /** Enable/disable TCP keep-alive. */
+  setKeepAlive(enable, _initialDelay) {
+    if (this._connection) {
+      try {
+        this._connection.get_socket().set_keepalive(enable ?? false);
+      } catch {
+      }
+    }
+    return this;
+  }
+  /** Enable/disable TCP_NODELAY (disable Nagle algorithm). */
+  setNoDelay(noDelay) {
+    if (this._connection) {
+      try {
+        this._connection.get_socket().set_option(6, 1, noDelay !== false ? 1 : 0);
+      } catch {
+      }
+    }
+    return this;
+  }
+  /** Get the underlying socket address info. */
+  address() {
+    if (this.localAddress && this.localPort) {
+      return {
+        port: this.localPort,
+        family: this.remoteFamily || "IPv4",
+        address: this.localAddress
+      };
+    }
+    return {};
+  }
+  /** Reference this socket (keep event loop alive). No-op in GJS. */
+  ref() {
+    return this;
+  }
+  /** Unreference this socket. No-op in GJS. */
+  unref() {
+    return this;
+  }
+}
+export {
+  Socket
+};

package/lib/types/index.d.ts

@@ -0,0 +1,30 @@
+export { Socket, SocketConnectOptions } from './socket.js';
+export { Server, ListenOptions } from './server.js';
+import { Socket, SocketConnectOptions } from './socket.js';
+import { Server } from './server.js';
+/** Check if input is a valid IP address. Returns 0, 4, or 6. */
+export declare function isIP(input: string): 0 | 4 | 6;
+/** Check if input is a valid IPv4 address. */
+export declare function isIPv4(input: string): boolean;
+/** Check if input is a valid IPv6 address. */
+export declare function isIPv6(input: string): boolean;
+/** Create a new TCP connection. */
+export declare function createConnection(options: SocketConnectOptions | number, host?: string | (() => void), connectionListener?: () => void): Socket;
+/** Alias for createConnection. */
+export declare const connect: typeof createConnection;
+/** Create a new TCP server. */
+export declare function createServer(connectionListener?: (socket: Socket) => void): Server;
+export declare function createServer(options?: {
+    allowHalfOpen?: boolean;
+}, connectionListener?: (socket: Socket) => void): Server;
+declare const _default: {
+    Socket: typeof Socket;
+    Server: typeof Server;
+    isIP: typeof isIP;
+    isIPv4: typeof isIPv4;
+    isIPv6: typeof isIPv6;
+    createConnection: typeof createConnection;
+    connect: typeof createConnection;
+    createServer: typeof createServer;
+};
+export default _default;

package/lib/types/server.d.ts

@@ -0,0 +1,40 @@
+import { EventEmitter } from 'node:events';
+import { Socket } from './socket.js';
+export interface ListenOptions {
+    port?: number;
+    host?: string;
+    backlog?: number;
+    exclusive?: boolean;
+}
+export declare class Server extends EventEmitter {
+    listening: boolean;
+    maxConnections?: number;
+    allowHalfOpen: boolean;
+    private _service;
+    private _connections;
+    private _address;
+    constructor(connectionListener?: (socket: Socket) => void);
+    constructor(options?: {
+        allowHalfOpen?: boolean;
+    }, connectionListener?: (socket: Socket) => void);
+    /**
+     * Start listening for connections.
+     */
+    listen(port?: number, host?: string, backlog?: number, callback?: () => void): this;
+    listen(port?: number, host?: string, callback?: () => void): this;
+    listen(port?: number, callback?: () => void): this;
+    listen(options?: ListenOptions, callback?: () => void): this;
+    private _handleConnection;
+    /** Get the address the server is listening on. */
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | null;
+    /** Close the server, stop accepting new connections. */
+    close(callback?: (err?: Error) => void): this;
+    /** Get the number of concurrent connections. */
+    getConnections(callback: (err: Error | null, count: number) => void): void;
+    ref(): this;
+    unref(): this;
+}

package/lib/types/socket.d.ts

@@ -0,0 +1,78 @@
+import Gio from '@girs/gio-2.0';
+import { Duplex } from 'node:stream';
+import type { DuplexOptions } from 'node:stream';
+export interface SocketConnectOptions {
+    port: number;
+    host?: string;
+    localAddress?: string;
+    localPort?: number;
+    family?: 4 | 6 | 0;
+    keepAlive?: boolean;
+    keepAliveInitialDelay?: number;
+    noDelay?: boolean;
+    timeout?: number;
+}
+export interface SocketOptions extends DuplexOptions {
+    allowHalfOpen?: boolean;
+}
+export declare class Socket extends Duplex {
+    remoteAddress?: string;
+    remotePort?: number;
+    remoteFamily?: string;
+    localAddress?: string;
+    localPort?: number;
+    bytesRead: number;
+    bytesWritten: number;
+    connecting: boolean;
+    destroyed: boolean;
+    pending: boolean;
+    readyState: 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed';
+    allowHalfOpen: boolean;
+    private _connection;
+    private _ioStream;
+    private _inputStream;
+    private _outputStream;
+    private _cancellable;
+    private _reading;
+    private _timeout;
+    private _timeoutId;
+    constructor(options?: SocketOptions);
+    /** @internal Set the connection from an accepted server socket. */
+    _setConnection(connection: Gio.SocketConnection): void;
+    /**
+     * @internal Set up this socket from a raw Gio.IOStream (e.g., stolen from Soup.Server
+     * during an HTTP upgrade). Extracts I/O streams, attempts to read address info
+     * if the underlying stream is a SocketConnection, and starts reading.
+     */
+    _setupFromIOStream(ioStream: Gio.IOStream): void;
+    /**
+     * Initiate a TCP connection.
+     */
+    connect(options: SocketConnectOptions | number, host?: string | (() => void), connectionListener?: () => void): this;
+    /** @internal Set up streams and emit connect after connection is established. */
+    _setupConnection(opts: SocketConnectOptions | Record<string, never>): void;
+    private _startReading;
+    private _readLoop;
+    _read(_size: number): void;
+    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    _destroy(err: Error | null, callback: (error?: Error | null) => void): void;
+    /** Set the socket timeout in milliseconds. 0 disables. */
+    setTimeout(timeout: number, callback?: () => void): this;
+    private _resetTimeout;
+    private _clearTimeout;
+    /** Enable/disable TCP keep-alive. */
+    setKeepAlive(enable?: boolean, _initialDelay?: number): this;
+    /** Enable/disable TCP_NODELAY (disable Nagle algorithm). */
+    setNoDelay(noDelay?: boolean): this;
+    /** Get the underlying socket address info. */
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | {};
+    /** Reference this socket (keep event loop alive). No-op in GJS. */
+    ref(): this;
+    /** Unreference this socket. No-op in GJS. */
+    unref(): this;
+}