myde-unix-socket 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter } from "node:events";
+export interface USocketOptions {
+    fd?: number;
+    path?: string;
+}
+export interface USocketWriteChunk {
+    data?: Buffer;
+    fds?: number[];
+}
+export interface ReadWithFdsResult {
+    data: Buffer | null;
+    fds: number[];
+}
+export declare class USocket {
+    fd?: number;
+    private _wrap;
+    constructor(opts?: USocketOptions | string);
+    connect(opts: USocketOptions | string): void;
+    write(data: Buffer, fds?: number[]): number;
+    read(size: number): Buffer | null;
+    readWithFds(size: number): ReadWithFdsResult | null;
+    shutdown(): void;
+    close(): void;
+}
+export declare class UServer extends EventEmitter {
+    fd?: number;
+    listening: boolean;
+    paused: boolean;
+    private _wrap;
+    constructor();
+    listen(path: string, backlog?: number, cb?: () => void): void;
+    listen(path: {
+        path: string;
+        backlog?: number;
+    }, cb?: () => void): void;
+    accept(): USocket | null;
+    pause(): void;
+    resume(): void;
+    close(): void;
+}
+declare const _default: {
+    USocket: typeof USocket;
+    UServer: typeof UServer;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAyB3C,MAAM,WAAW,cAAc;IAC9B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,GAAG,EAAE,MAAM,EAAE,CAAC;CACd;AAED,qBAAa,OAAO;IACnB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,KAAK,CAAa;gBAEd,IAAI,CAAC,EAAE,cAAc,GAAG,MAAM;IAS1C,OAAO,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI;IAiB5C,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM;IAO3C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAKjC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAKnD,QAAQ,IAAI,IAAI;IAKhB,KAAK,IAAI,IAAI;CAKb;AAED,qBAAa,OAAQ,SAAQ,YAAY;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,OAAO,CAAS;IAC3B,MAAM,EAAE,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAa;;IAM1B,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI;IAC7D,MAAM,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,EAAE,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI;IA8BvE,MAAM,IAAI,OAAO,GAAG,IAAI;IAOxB,KAAK,IAAI,IAAI;IAIb,MAAM,IAAI,IAAI;IAId,KAAK,IAAI,IAAI;CAKb;;;;;AAED,wBAGE"}

package/dist/index.mjs

@@ -0,0 +1,67 @@
+import { EventEmitter as e } from "node:events";
+//#endregion
+//#region src/index.ts
+var t = (/* @__PURE__ */ ((e) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(e, { get: (e, t) => (typeof require < "u" ? require : e)[t] }) : e)(function(e) {
+	if (typeof require < "u") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + e + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+}))("../index.node"), n = class {
+	constructor(e) {
+		this._wrap = null, typeof e == "string" && (e = { path: e }), (e?.fd || e?.path) && this.connect(e);
+	}
+	connect(e) {
+		if (this._wrap) throw Error("connect on already connected USocket");
+		if (typeof e == "string" && (e = { path: e }), this._wrap = t.USocketWrap(), typeof e.fd == "number") {
+			let n = t.USocketWrap_adopt(this._wrap, e.fd);
+			this.fd = n >= 0 ? n : void 0;
+		} else if (typeof e.path == "string") {
+			let n = t.USocketWrap_connect(this._wrap, e.path);
+			this.fd = n >= 0 ? n : void 0;
+		}
+	}
+	write(e, n) {
+		if (!this._wrap) throw Error("USocket not connected");
+		return t.USocketWrap_write(this._wrap, e, n);
+	}
+	read(e) {
+		return this._wrap ? t.USocketWrap_read(this._wrap, e) : null;
+	}
+	readWithFds(e) {
+		return this._wrap ? t.USocketWrap_read_with_fds(this._wrap, e) : null;
+	}
+	shutdown() {
+		this._wrap && t.USocketWrap_shutdown(this._wrap);
+	}
+	close() {
+		this._wrap &&= (t.USocketWrap_close(this._wrap), null);
+	}
+}, r = class extends e {
+	constructor() {
+		super(), this.listening = !1, this.paused = !1, this._wrap = null;
+	}
+	listen(e, n, r) {
+		if (this._wrap || this.listening) throw Error("listen on already listened UServer");
+		if (typeof e == "object" ? (n = e.backlog, e = e.path, r = n) : typeof n == "function" && (r = n, n = 0), n ||= 16, typeof e != "string") throw Error("UServer expects valid path");
+		typeof r == "function" && this.once("listening", r), this._wrap = t.UServerWrap();
+		let i = t.UServerWrap_listen(this._wrap, e, n);
+		this.fd = i >= 0 ? i : void 0, this.listening = !0, this.emit("listening"), this.paused || this.resume();
+	}
+	accept() {
+		if (!this._wrap) return null;
+		let e = t.UServerWrap_accept(this._wrap);
+		return e === null ? null : new n({ fd: e });
+	}
+	pause() {
+		this.paused = !0;
+	}
+	resume() {
+		this.paused = !1;
+	}
+	close() {
+		this._wrap &&= (t.UServerWrap_close(this._wrap), null);
+	}
+}, i = {
+	USocket: n,
+	UServer: r
+};
+//#endregion
+export { r as UServer, n as USocket, i as default };

package/dist/socket.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=socket.test.d.ts.map

package/dist/socket.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket.test.d.ts","sourceRoot":"","sources":["../src/socket.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "myde-unix-socket",
+    "version": "0.1.0",
+    "description": "",
+    "main": "dist/index.cjs",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build:rust": "npm run cargo-build -- --release",
+        "build:ts": "vite build",
+        "build:types": "tsc --emitDeclarationOnly --outDir dist",
+        "build": "npm run build:rust && npm run build:ts && npm run build:types",
+        "test:rust": "cargo test",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "test:coverage": "vitest run --coverage",
+        "test:all": "npm run test:rust && npm run test",
+        "cargo-build": "cargo build --message-format=json-render-diagnostics > cargo.log",
+        "cross-build": "cross build --message-format=json-render-diagnostics > cross.log",
+        "postcargo-build": "neon dist < cargo.log",
+        "postcross-build": "neon dist -m /target < cross.log",
+        "debug": "npm run cargo-build --",
+        "cross": "npm run cross-build -- --release"
+    },
+    "exports": {
+        ".": {
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.cjs"
+        },
+        "./native": "./index.node"
+    },
+    "author": "",
+    "license": "Apache-2.0",
+    "devDependencies": {
+        "@neon-rs/cli": "0.1.82",
+        "@types/node": "^25.5.0",
+        "typescript": "^5.9.3",
+        "vite": "^8.0.1",
+        "vitest": "^4.1.0"
+    }
+}

package/src/index.ts

@@ -0,0 +1,166 @@
+import { EventEmitter } from "node:events";
+
+// 加载原生模块 - 使用动态导入以兼容 CJS 和 ESM
+const native = require("../index.node");
+
+interface NativeModule {
+	USocketWrap: () => any;
+	USocketWrap_connect: (wrap: any, path: string) => number;
+	USocketWrap_adopt: (wrap: any, fd: number) => number;
+	USocketWrap_write: (wrap: any, data?: Buffer, fds?: number[]) => number;
+	USocketWrap_read: (wrap: any, size: number) => Buffer;
+	USocketWrap_read_with_fds: (
+		wrap: any,
+		size: number,
+	) => { data: Buffer | null; fds: number[] };
+	USocketWrap_shutdown: (wrap: any) => void;
+	USocketWrap_close: (wrap: any) => void;
+	UServerWrap: () => any;
+	UServerWrap_listen: (wrap: any, path: string, backlog: number) => number;
+	UServerWrap_accept: (wrap: any) => number | null;
+	UServerWrap_close: (wrap: any) => void;
+}
+
+const nativeModule = native as NativeModule;
+
+export interface USocketOptions {
+	fd?: number;
+	path?: string;
+}
+
+export interface USocketWriteChunk {
+	data?: Buffer;
+	fds?: number[];
+}
+
+export interface ReadWithFdsResult {
+	data: Buffer | null;
+	fds: number[];
+}
+
+export class USocket {
+	fd?: number;
+	private _wrap: any = null;
+
+	constructor(opts?: USocketOptions | string) {
+		if (typeof opts === "string") {
+			opts = { path: opts };
+		}
+		if (opts?.fd || opts?.path) {
+			this.connect(opts);
+		}
+	}
+
+	connect(opts: USocketOptions | string): void {
+		if (this._wrap) {
+			throw new Error("connect on already connected USocket");
+		}
+		if (typeof opts === "string") {
+			opts = { path: opts };
+		}
+		this._wrap = nativeModule.USocketWrap();
+		if (typeof opts.fd === "number") {
+			const result = nativeModule.USocketWrap_adopt(this._wrap, opts.fd);
+			this.fd = result >= 0 ? result : undefined;
+		} else if (typeof opts.path === "string") {
+			const result = nativeModule.USocketWrap_connect(this._wrap, opts.path);
+			this.fd = result >= 0 ? result : undefined;
+		}
+	}
+
+	write(data: Buffer, fds?: number[]): number {
+		if (!this._wrap) {
+			throw new Error("USocket not connected");
+		}
+		return nativeModule.USocketWrap_write(this._wrap, data, fds);
+	}
+
+	read(size: number): Buffer | null {
+		if (!this._wrap) return null;
+		return nativeModule.USocketWrap_read(this._wrap, size);
+	}
+
+	readWithFds(size: number): ReadWithFdsResult | null {
+		if (!this._wrap) return null;
+		return nativeModule.USocketWrap_read_with_fds(this._wrap, size);
+	}
+
+	shutdown(): void {
+		if (!this._wrap) return;
+		nativeModule.USocketWrap_shutdown(this._wrap);
+	}
+
+	close(): void {
+		if (!this._wrap) return;
+		nativeModule.USocketWrap_close(this._wrap);
+		this._wrap = null;
+	}
+}
+
+export class UServer extends EventEmitter {
+	fd?: number;
+	listening: boolean = false;
+	paused: boolean = false;
+	private _wrap: any = null;
+
+	constructor() {
+		super();
+	}
+
+	listen(path: string, backlog?: number, cb?: () => void): void;
+	listen(path: { path: string; backlog?: number }, cb?: () => void): void;
+	listen(path: any, backlog?: any, cb?: any): void {
+		if (this._wrap || this.listening) {
+			throw new Error("listen on already listened UServer");
+		}
+		if (typeof path === "object") {
+			backlog = path.backlog;
+			path = path.path;
+			cb = backlog;
+		} else if (typeof backlog === "function") {
+			cb = backlog;
+			backlog = 0;
+		}
+		backlog = backlog || 16;
+		if (typeof path !== "string") {
+			throw new Error("UServer expects valid path");
+		}
+		if (typeof cb === "function") {
+			this.once("listening", cb);
+		}
+		this._wrap = nativeModule.UServerWrap();
+		const result = nativeModule.UServerWrap_listen(this._wrap, path, backlog);
+		this.fd = result >= 0 ? result : undefined;
+		this.listening = true;
+		this.emit("listening");
+		if (!this.paused) {
+			this.resume();
+		}
+	}
+
+	accept(): USocket | null {
+		if (!this._wrap) return null;
+		const fd = nativeModule.UServerWrap_accept(this._wrap);
+		if (fd === null) return null;
+		return new USocket({ fd });
+	}
+
+	pause(): void {
+		this.paused = true;
+	}
+
+	resume(): void {
+		this.paused = false;
+	}
+
+	close(): void {
+		if (!this._wrap) return;
+		nativeModule.UServerWrap_close(this._wrap);
+		this._wrap = null;
+	}
+}
+
+export default {
+	USocket,
+	UServer,
+};

package/src/lib.rs

@@ -0,0 +1 @@
+mod socket;

package/src/socket.rs

@@ -0,0 +1,334 @@
+use neon::prelude::*;
+use neon::types::buffer::TypedArray;
+use std::cell::RefCell;
+use std::io::{self, IoSlice, IoSliceMut, Read};
+use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
+use std::os::unix::net::{UnixListener, UnixStream};
+
+use nix::sys::socket::{recvmsg, sendmsg, ControlMessage, ControlMessageOwned, MsgFlags, UnixAddr};
+
+pub struct USocketWrap {
+    stream: RefCell<Option<UnixStream>>,
+    fd: RefCell<Option<RawFd>>,
+}
+
+impl Finalize for USocketWrap {}
+
+impl USocketWrap {
+    pub fn new() -> Self {
+        Self {
+            stream: RefCell::new(None),
+            fd: RefCell::new(None),
+        }
+    }
+
+    pub fn connect(&self, path: &str) -> Result<(), io::Error> {
+        let stream = UnixStream::connect(path)?;
+        *self.fd.borrow_mut() = Some(stream.as_raw_fd());
+        *self.stream.borrow_mut() = Some(stream);
+        Ok(())
+    }
+
+    pub fn adopt(&self, fd: RawFd) -> Result<(), io::Error> {
+        let stream = unsafe { UnixStream::from_raw_fd(fd) };
+        *self.fd.borrow_mut() = Some(fd);
+        *self.stream.borrow_mut() = Some(stream);
+        Ok(())
+    }
+
+    pub fn write(&self, data: Option<&[u8]>, fds: Option<&[RawFd]>) -> Result<usize, io::Error> {
+        let stream = self.stream.borrow();
+        if let Some(stream) = stream.as_ref() {
+            let raw_fd = stream.as_raw_fd();
+
+            let data_buf = data.unwrap_or(&[]);
+            let iov = [IoSlice::new(data_buf)];
+
+            let written = if let Some(fds) = fds {
+                let cmsg = ControlMessage::ScmRights(fds);
+                sendmsg::<UnixAddr>(raw_fd, &iov, &[cmsg], MsgFlags::empty(), None)
+                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?
+            } else {
+                sendmsg::<UnixAddr>(raw_fd, &iov, &[], MsgFlags::empty(), None)
+                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?
+            };
+
+            Ok(written)
+        } else {
+            Err(io::Error::new(io::ErrorKind::NotConnected, "Not connected"))
+        }
+    }
+
+    pub fn read(&self, buf: &mut [u8]) -> Result<usize, io::Error> {
+        let mut stream = self.stream.borrow_mut();
+        if let Some(stream) = stream.as_mut() {
+            stream.read(buf)
+        } else {
+            Err(io::Error::new(io::ErrorKind::NotConnected, "Not connected"))
+        }
+    }
+
+    pub fn read_with_fds(&self, buf: &mut [u8]) -> Result<(usize, Vec<RawFd>), io::Error> {
+        let stream = self.stream.borrow();
+        if let Some(stream) = stream.as_ref() {
+            let raw_fd = stream.as_raw_fd();
+            let mut iov = [IoSliceMut::new(buf)];
+
+            // 分配控制消息缓冲区，足够接收 fd
+            let mut cmsg_buf = nix::cmsg_space!([RawFd; 3]);
+
+            let msg = recvmsg::<UnixAddr>(raw_fd, &mut iov, Some(&mut cmsg_buf), MsgFlags::empty())
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+
+            let mut fds = Vec::new();
+            for cmsg in msg.cmsgs() {
+                if let ControlMessageOwned::ScmRights(received_fds) = cmsg {
+                    fds.extend(received_fds);
+                }
+            }
+
+            Ok((msg.bytes, fds))
+        } else {
+            Err(io::Error::new(io::ErrorKind::NotConnected, "Not connected"))
+        }
+    }
+
+    pub fn shutdown(&self) -> Result<(), io::Error> {
+        let stream = self.stream.borrow();
+        if let Some(stream) = stream.as_ref() {
+            stream.shutdown(std::net::Shutdown::Both)?;
+        }
+        Ok(())
+    }
+
+    pub fn close(&self) {
+        *self.stream.borrow_mut() = None;
+        *self.fd.borrow_mut() = None;
+    }
+}
+
+pub struct UServerWrap {
+    listener: RefCell<Option<UnixListener>>,
+    fd: RefCell<Option<RawFd>>,
+}
+
+impl Finalize for UServerWrap {}
+
+impl UServerWrap {
+    pub fn new() -> Self {
+        Self {
+            listener: RefCell::new(None),
+            fd: RefCell::new(None),
+        }
+    }
+
+    pub fn listen(&self, path: &str, backlog: i32) -> Result<(), io::Error> {
+        let _ = std::fs::remove_file(path);
+        let listener = UnixListener::bind(path)?;
+        listener.set_nonblocking(true)?;
+        *self.fd.borrow_mut() = Some(listener.as_raw_fd());
+        *self.listener.borrow_mut() = Some(listener);
+        let _ = backlog;
+        Ok(())
+    }
+
+    pub fn accept(&self) -> Result<Option<RawFd>, io::Error> {
+        let listener = self.listener.borrow();
+        if let Some(listener) = listener.as_ref() {
+            match listener.accept() {
+                Ok((stream, _)) => {
+                    let fd = stream.as_raw_fd();
+                    std::mem::forget(stream);
+                    Ok(Some(fd))
+                }
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => Ok(None),
+                Err(e) => Err(e),
+            }
+        } else {
+            Err(io::Error::new(io::ErrorKind::NotConnected, "Not listening"))
+        }
+    }
+
+    pub fn close(&self) {
+        *self.listener.borrow_mut() = None;
+        *self.fd.borrow_mut() = None;
+    }
+}
+
+fn usocket_wrap_new(mut cx: FunctionContext) -> JsResult<JsBox<USocketWrap>> {
+    Ok(cx.boxed(USocketWrap::new()))
+}
+
+fn usocket_wrap_connect(mut cx: FunctionContext) -> JsResult<JsNumber> {
+    let usocket_wrap = cx.argument::<JsBox<USocketWrap>>(0)?;
+    let path = cx.argument::<JsString>(1)?.value(&mut cx);
+    match usocket_wrap.connect(&path) {
+        Ok(_) => {
+            let fd = usocket_wrap.fd.borrow();
+            Ok(cx.number(fd.unwrap_or(-1) as f64))
+        }
+        Err(e) => cx.throw_error(format!("Connect failed: {}", e)),
+    }
+}
+
+fn usocket_wrap_adopt(mut cx: FunctionContext) -> JsResult<JsNumber> {
+    let usocket_wrap = cx.argument::<JsBox<USocketWrap>>(0)?;
+    let fd = cx.argument::<JsNumber>(1)?.value(&mut cx) as RawFd;
+    match usocket_wrap.adopt(fd) {
+        Ok(_) => Ok(cx.number(fd as f64)),
+        Err(e) => cx.throw_error(format!("Adopt failed: {}", e)),
+    }
+}
+
+fn usocket_wrap_write(mut cx: FunctionContext) -> JsResult<JsNumber> {
+    let usocket_wrap = cx.argument::<JsBox<USocketWrap>>(0)?;
+    let data_opt = cx.argument_opt(1);
+    let fds_opt = cx.argument_opt(2);
+
+    let data_vec;
+    let data_bytes = if let Some(data) = data_opt {
+        if data.is_a::<JsBuffer, _>(&mut cx) {
+            let buffer = data.downcast_or_throw::<JsBuffer, _>(&mut cx)?;
+            data_vec = buffer.as_slice(&cx).to_vec();
+            Some(data_vec.as_slice())
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    let fds_vec;
+    let fds_slice = if let Some(fds) = fds_opt {
+        if fds.is_a::<JsArray, _>(&mut cx) {
+            let array = fds.downcast_or_throw::<JsArray, _>(&mut cx)?;
+            let mut vec = Vec::new();
+            for i in 0..array.len(&mut cx) {
+                let fd = array.get::<JsNumber, _, _>(&mut cx, i)?;
+                vec.push(fd.value(&mut cx) as RawFd);
+            }
+            fds_vec = vec;
+            Some(fds_vec.as_slice())
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    match usocket_wrap.write(data_bytes, fds_slice) {
+        Ok(n) => Ok(cx.number(n as f64)),
+        Err(e) => cx.throw_error(format!("Write failed: {}", e)),
+    }
+}
+
+fn usocket_wrap_read(mut cx: FunctionContext) -> JsResult<JsBuffer> {
+    let usocket_wrap = cx.argument::<JsBox<USocketWrap>>(0)?;
+    let size = cx.argument::<JsNumber>(1)?.value(&mut cx) as usize;
+    let mut buf = vec![0u8; size];
+    match usocket_wrap.read(&mut buf) {
+        Ok(n) => {
+            let mut result = JsBuffer::new(&mut cx, n)?;
+            let slice = result.as_mut_slice(&mut cx);
+            slice.copy_from_slice(&buf[..n]);
+            Ok(result)
+        }
+        Err(e) => cx.throw_error(format!("Read failed: {}", e)),
+    }
+}
+
+fn usocket_wrap_read_with_fds(mut cx: FunctionContext) -> JsResult<JsObject> {
+    let usocket_wrap = cx.argument::<JsBox<USocketWrap>>(0)?;
+    let size = cx.argument::<JsNumber>(1)?.value(&mut cx) as usize;
+    let mut buf = vec![0u8; size];
+
+    match usocket_wrap.read_with_fds(&mut buf) {
+        Ok((n, fds)) => {
+            let data = if n > 0 {
+                let mut result = JsBuffer::new(&mut cx, n)?;
+                let slice = result.as_mut_slice(&mut cx);
+                slice.copy_from_slice(&buf[..n]);
+                result.as_value(&mut cx)
+            } else {
+                cx.null().upcast()
+            };
+
+            let fds_array = JsArray::new(&mut cx, fds.len());
+            for (i, fd) in fds.iter().enumerate() {
+                let fd_js = cx.number(*fd as f64);
+                fds_array.set(&mut cx, i as u32, fd_js)?;
+            }
+
+            let obj = JsObject::new(&mut cx);
+            obj.set(&mut cx, "data", data)?;
+            obj.set(&mut cx, "fds", fds_array)?;
+            Ok(obj)
+        }
+        Err(e) => cx.throw_error(format!("Read with fds failed: {}", e)),
+    }
+}
+
+fn usocket_wrap_shutdown(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let usocket_wrap = cx.argument::<JsBox<USocketWrap>>(0)?;
+    match usocket_wrap.shutdown() {
+        Ok(_) => Ok(cx.undefined()),
+        Err(e) => cx.throw_error(format!("Shutdown failed: {}", e)),
+    }
+}
+
+fn usocket_wrap_close(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let usocket_wrap = cx.argument::<JsBox<USocketWrap>>(0)?;
+    usocket_wrap.close();
+    Ok(cx.undefined())
+}
+
+fn userver_wrap_new(mut cx: FunctionContext) -> JsResult<JsBox<UServerWrap>> {
+    Ok(cx.boxed(UServerWrap::new()))
+}
+
+fn userver_wrap_listen(mut cx: FunctionContext) -> JsResult<JsNumber> {
+    let userver_wrap = cx.argument::<JsBox<UServerWrap>>(0)?;
+    let path = cx.argument::<JsString>(1)?.value(&mut cx);
+    let backlog = cx.argument::<JsNumber>(2)?.value(&mut cx) as i32;
+    match userver_wrap.listen(&path, backlog) {
+        Ok(_) => {
+            let fd = userver_wrap.fd.borrow();
+            Ok(cx.number(fd.unwrap_or(-1) as f64))
+        }
+        Err(e) => cx.throw_error(format!("Listen failed: {}", e)),
+    }
+}
+
+fn userver_wrap_accept(mut cx: FunctionContext) -> JsResult<JsValue> {
+    let userver_wrap = cx.argument::<JsBox<UServerWrap>>(0)?;
+    match userver_wrap.accept() {
+        Ok(Some(fd)) => Ok(cx.number(fd as f64).upcast()),
+        Ok(None) => Ok(cx.null().upcast()),
+        Err(e) => cx.throw_error(format!("Accept failed: {}", e)),
+    }
+}
+
+fn userver_wrap_close(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let userver_wrap = cx.argument::<JsBox<UServerWrap>>(0)?;
+    userver_wrap.close();
+    Ok(cx.undefined())
+}
+
+#[neon::main]
+fn main(mut cx: ModuleContext) -> NeonResult<()> {
+    cx.export_function("USocketWrap", usocket_wrap_new)?;
+    cx.export_function("USocketWrap_connect", usocket_wrap_connect)?;
+    cx.export_function("USocketWrap_adopt", usocket_wrap_adopt)?;
+    cx.export_function("USocketWrap_write", usocket_wrap_write)?;
+    cx.export_function("USocketWrap_read", usocket_wrap_read)?;
+    cx.export_function("USocketWrap_read_with_fds", usocket_wrap_read_with_fds)?;
+    cx.export_function("USocketWrap_shutdown", usocket_wrap_shutdown)?;
+    cx.export_function("USocketWrap_close", usocket_wrap_close)?;
+
+    cx.export_function("UServerWrap", userver_wrap_new)?;
+    cx.export_function("UServerWrap_listen", userver_wrap_listen)?;
+    cx.export_function("UServerWrap_accept", userver_wrap_accept)?;
+    cx.export_function("UServerWrap_close", userver_wrap_close)?;
+
+    Ok(())
+}