@bobfrankston/node-tcp-transport 0.1.1

package/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @bobfrankston/node-tcp-transport — Node.js TCP transport implementing
+ * @bobfrankston/tcp-transport's TcpTransport interface.
+ *
+ * Replaces the older @bobfrankston/iflow-node NodeTransport (which is now a
+ * back-compat re-export). Use this directly for new code.
+ */
+export { NodeTcpTransport } from "./node-tcp-transport.js";
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,9 @@
+/**
+ * @bobfrankston/node-tcp-transport — Node.js TCP transport implementing
+ * @bobfrankston/tcp-transport's TcpTransport interface.
+ *
+ * Replaces the older @bobfrankston/iflow-node NodeTransport (which is now a
+ * back-compat re-export). Use this directly for new code.
+ */
+export { NodeTcpTransport } from "./node-tcp-transport.js";
+//# sourceMappingURL=index.js.map

package/node-tcp-transport.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Node.js TCP transport — implements @bobfrankston/tcp-transport using
+ * node:net and node:tls. Desktop / server side.
+ *
+ * Renamed from NodeTransport (formerly in @bobfrankston/iflow-node) to make
+ * the protocol-agnostic role explicit: this is for any TCP byte-stream
+ * protocol, not just IMAP.
+ */
+import type { TcpTransport } from "@bobfrankston/tcp-transport";
+export declare class NodeTcpTransport implements TcpTransport {
+    private socket;
+    private dataHandler;
+    private closeHandler;
+    private errorHandler;
+    private _connected;
+    private rejectUnauthorized;
+    constructor(options?: {
+        rejectUnauthorized?: boolean;
+    });
+    get connected(): boolean;
+    connect(host: string, port: number, useTls: boolean, servername?: string): Promise<void>;
+    upgradeTLS(servername?: string): Promise<void>;
+    write(data: string | Uint8Array): Promise<void>;
+    onData(handler: (data: string) => void): void;
+    onClose(handler: (hadError: boolean) => void): void;
+    onError(handler: (err: Error) => void): void;
+    close(): void;
+}
+//# sourceMappingURL=node-tcp-transport.d.ts.map

package/node-tcp-transport.js

@@ -0,0 +1,111 @@
+/**
+ * Node.js TCP transport — implements @bobfrankston/tcp-transport using
+ * node:net and node:tls. Desktop / server side.
+ *
+ * Renamed from NodeTransport (formerly in @bobfrankston/iflow-node) to make
+ * the protocol-agnostic role explicit: this is for any TCP byte-stream
+ * protocol, not just IMAP.
+ */
+import * as net from "node:net";
+import * as tls from "node:tls";
+export class NodeTcpTransport {
+    socket = null;
+    dataHandler = null;
+    closeHandler = null;
+    errorHandler = null;
+    _connected = false;
+    rejectUnauthorized;
+    constructor(options) {
+        this.rejectUnauthorized = options?.rejectUnauthorized ?? true;
+    }
+    get connected() { return this._connected; }
+    async connect(host, port, useTls, servername) {
+        return new Promise((resolve, reject) => {
+            const onConnect = () => {
+                this._connected = true;
+                resolve();
+            };
+            const onError = (err) => {
+                this._connected = false;
+                reject(err);
+            };
+            if (useTls) {
+                this.socket = tls.connect({
+                    host, port,
+                    servername: servername || host,
+                    rejectUnauthorized: this.rejectUnauthorized,
+                }, onConnect);
+            }
+            else {
+                this.socket = net.connect({ host, port }, onConnect);
+            }
+            this.socket.once("error", onError);
+            this.socket.setKeepAlive(true, 5000);
+            this.socket.on("data", (chunk) => {
+                if (this.dataHandler)
+                    this.dataHandler(chunk.toString("utf-8"));
+            });
+            this.socket.on("close", (hadError) => {
+                this._connected = false;
+                if (this.closeHandler)
+                    this.closeHandler(hadError);
+            });
+            this.socket.on("error", (err) => {
+                if (this.errorHandler)
+                    this.errorHandler(err);
+            });
+        });
+    }
+    async upgradeTLS(servername) {
+        if (!this.socket)
+            throw new Error("Not connected");
+        return new Promise((resolve, reject) => {
+            const plainSocket = this.socket;
+            const tlsSocket = tls.connect({
+                socket: plainSocket,
+                servername: servername || undefined,
+                rejectUnauthorized: this.rejectUnauthorized,
+            }, () => {
+                this.socket = tlsSocket;
+                tlsSocket.on("data", (chunk) => {
+                    if (this.dataHandler)
+                        this.dataHandler(chunk.toString("utf-8"));
+                });
+                tlsSocket.on("close", (hadError) => {
+                    this._connected = false;
+                    if (this.closeHandler)
+                        this.closeHandler(hadError);
+                });
+                tlsSocket.on("error", (err) => {
+                    if (this.errorHandler)
+                        this.errorHandler(err);
+                });
+                resolve();
+            });
+            tlsSocket.once("error", reject);
+        });
+    }
+    async write(data) {
+        if (!this.socket || this.socket.destroyed)
+            throw new Error("Not connected");
+        return new Promise((resolve, reject) => {
+            this.socket.write(data, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    onData(handler) { this.dataHandler = handler; }
+    onClose(handler) { this.closeHandler = handler; }
+    onError(handler) { this.errorHandler = handler; }
+    close() {
+        this._connected = false;
+        if (this.socket && !this.socket.destroyed) {
+            this.socket.destroy();
+        }
+        this.socket = null;
+    }
+}
+//# sourceMappingURL=node-tcp-transport.js.map

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@bobfrankston/node-tcp-transport",
+  "version": "0.1.1",
+  "description": "Node.js TCP transport implementing @bobfrankston/tcp-transport. Uses node:net and node:tls. Sibling to udp/node-transport.",
+  "main": "index.js",
+  "types": "index.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -watch",
+    "check": "tsc --noEmit"
+  },
+  "keywords": [
+    "tcp",
+    "transport",
+    "node"
+  ],
+  "author": "Bob Frankston",
+  "license": "ISC",
+  "dependencies": {
+    "@bobfrankston/tcp-transport": "^0.1.2"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.ts",
+      "default": "./index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BobFrankston/node-tcp-transport.git"
+  },
+  ".dependencies": {
+    "@bobfrankston/tcp-transport": "file:../tcp-transport"
+  },
+  ".transformedSnapshot": {
+    "dependencies": {
+      "@bobfrankston/tcp-transport": "^0.1.2"
+    }
+  }
+}