js-tcp-tunnel 1.0.2 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-tcp-tunnel",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "js tcp tunnel",
   "main": "index.js",
   "type": "module",
@@ -24,10 +24,10 @@
   },
   "homepage": "https://github.com/yuanliwei/js-tunnel#readme",
   "devDependencies": {
-    "@types/node": "^22.9.4",
-    "koa": "^2.15.3",
-    "koa-router": "^13.0.1",
+    "@koa/router": "^14.0.0",
+    "@types/node": "^24.2.1",
+    "koa": "^3.0.1",
     "log4js": "^6.9.1",
-    "ws": "^8.18.0"
+    "ws": "^8.18.3"
   }
 }

package/src/lib.js

@@ -3,10 +3,12 @@ import net from 'node:net'
 import { Readable, Writable } from 'node:stream'
 import http from 'node:http'
 import https from 'node:https'
+import { ReadableStream, TransformStream, WritableStream } from 'node:stream/web'
 
 /**
  * @import {WebSocketServer} from 'ws'
- * @import Router from 'koa-router'
+ * @import Router from '@koa/router'
+ * @import {SocketChannel, TCP_TUNNEL_DATA, TUNNEL_TCP_CLIENT_HELPER, TUNNEL_TCP_DATA_CONNECT, TUNNEL_TCP_DATA_LISTEN, TUNNEL_TCP_DATA_PINGPONG, TUNNEL_TCP_SERVER_HELPER, TunnelTcpClientHelperParam, TunnelTcpServerHelperParam} from './types.js'
  */
 
 const DEBUG_TUNNEL_TCP = false
@@ -53,14 +55,6 @@ export function formatNumber(num) {
     return Number(num.toFixed(2))
 }
 
-/**
- * @typedef {{
- * promise: Promise<any>;
- * resolve: (value: any | null) => void;
- * reject: (reason: any | null) => void;
- * }} PromiseResolvers
- */
-
 export function Promise_withResolvers() {
     /** @type{(value?:object)=>void} */
     let resolve = null
@@ -74,8 +68,8 @@ export function Promise_withResolvers() {
 }
 
 /**
- * @param {Promise<[CryptoKey,Uint8Array]>} key_iv
- * @returns {TransformStream<Uint8Array, Uint8Array>}
+ * @param {Promise<[CryptoKey,Uint8Array<ArrayBuffer>]>} key_iv
+ * @returns {TransformStream<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>}
  */
 export function createEncodeStream(key_iv) {
     let key = null
@@ -92,8 +86,8 @@ export function createEncodeStream(key_iv) {
 }
 
 /**
- * @param {Promise<[CryptoKey,Uint8Array]>} key_iv
- * @returns {TransformStream<Uint8Array, Uint8Array>}
+ * @param {Promise<[CryptoKey,Uint8Array<ArrayBuffer>]>} key_iv
+ * @returns {TransformStream<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>}
  */
 export function createDecodeStream(key_iv) {
     let key = null
@@ -116,10 +110,10 @@ export function createDecodeStream(key_iv) {
 const HEADER_CHECK = 0xb1f7705f
 
 /**
- * @param {Uint8Array[]} queue
+ * @param {Uint8Array<ArrayBuffer>[]} queue
  * @param {CryptoKey} key
- * @param {Uint8Array} iv
- * @returns {Promise<Uint8Array>}
+ * @param {Uint8Array<ArrayBuffer>} iv
+ * @returns {Promise<Uint8Array<ArrayBuffer>>}
  */
 export async function buildBufferData(queue, key, iv) {
     let buffers = []
@@ -138,11 +132,11 @@ export async function buildBufferData(queue, key, iv) {
 /**
  * @param {Uint8Array<ArrayBuffer>} buffer
  * @param {CryptoKey} key
- * @param {Uint8Array} iv
- * @returns {Promise<[Uint8Array[],Uint8Array<ArrayBuffer>]>}
+ * @param {Uint8Array<ArrayBuffer>} iv
+ * @returns {Promise<[Uint8Array<ArrayBuffer>[],Uint8Array<ArrayBuffer>]>}
  */
 export async function parseBufferData(buffer, key, iv) {
-    /** @type{Uint8Array[]} */
+    /** @type{Uint8Array<ArrayBuffer>[]} */
     let queue = []
     let offset = 0
     let remain = new Uint8Array(0)
@@ -303,17 +297,17 @@ let tcpTunnelDataSend = 0
  */
 export function printTcpTunnelData(data) {
     return `id: ${`${data.srcId}:${data.dstId}`.padEnd(10)} channel: ${`${data.srcChannel}:${data.dstChannel}`.padEnd(10)} ${{
-        0xa9b398d5: 'TUNNEL_TCP_TYPE_INIT      ',
-        0xe41957d3: 'TUNNEL_TCP_TYPE_LISTEN    ',
-        0x20993e38: 'TUNNEL_TCP_TYPE_ONLISTEN  ',
-        0x11d949f8: 'TUNNEL_TCP_TYPE_CONNECT   ',
-        0x377b2181: 'TUNNEL_TCP_TYPE_ONCONNECT ',
-        0x48678f39: 'TUNNEL_TCP_TYPE_DATA      ',
-        0x8117f762: 'TUNNEL_TCP_TYPE_ERROR     ',
-        0x72fd6470: 'TUNNEL_TCP_TYPE_CLOSE     ',
-        0x4768e1ba: 'TUNNEL_TCP_TYPE_PING      ',
-        0x106f43fb: 'TUNNEL_TCP_TYPE_PONG      ',
-        0xc5870539: 'TUNNEL_TCP_TYPE_ACK       ',
+        [TUNNEL_TCP_TYPE_INIT]: 'TUNNEL_TCP_TYPE_INIT      ',
+        [TUNNEL_TCP_TYPE_LISTEN]: 'TUNNEL_TCP_TYPE_LISTEN    ',
+        [TUNNEL_TCP_TYPE_ONLISTEN]: 'TUNNEL_TCP_TYPE_ONLISTEN  ',
+        [TUNNEL_TCP_TYPE_CONNECT]: 'TUNNEL_TCP_TYPE_CONNECT   ',
+        [TUNNEL_TCP_TYPE_ONCONNECT]: 'TUNNEL_TCP_TYPE_ONCONNECT ',
+        [TUNNEL_TCP_TYPE_DATA]: 'TUNNEL_TCP_TYPE_DATA      ',
+        [TUNNEL_TCP_TYPE_ERROR]: 'TUNNEL_TCP_TYPE_ERROR     ',
+        [TUNNEL_TCP_TYPE_CLOSE]: 'TUNNEL_TCP_TYPE_CLOSE     ',
+        [TUNNEL_TCP_TYPE_PING]: 'TUNNEL_TCP_TYPE_PING      ',
+        [TUNNEL_TCP_TYPE_PONG]: 'TUNNEL_TCP_TYPE_PONG      ',
+        [TUNNEL_TCP_TYPE_ACK]: 'TUNNEL_TCP_TYPE_ACK       ',
     }[data.type]} recv: ${(tcpTunnelDataRecv)} send: ${(tcpTunnelDataSend)} size:${data.buffer.length}`
 }
 
@@ -321,7 +315,7 @@ export function printTcpTunnelData(data) {
  * 
  * @param {string} password 
  * @param {number} iterations 
- * @returns {Promise<[CryptoKey,Uint8Array]>}
+ * @returns {Promise<[CryptoKey,Uint8Array<ArrayBuffer>]>}
  */
 export async function buildKeyIv(password, iterations) {
     if (!TUNNEL_TCP_WITH_CRYPTO) return [null, null]
@@ -357,9 +351,9 @@ export async function buildKeyIv(password, iterations) {
 
 /**
  * 
- * @param {Uint8Array} data 
+ * @param {Uint8Array<ArrayBuffer>} data 
  * @param {CryptoKey} key 
- * @param {Uint8Array} iv 
+ * @param {Uint8Array<ArrayBuffer>} iv 
  * @returns 
  */
 export async function encrypt(data, key, iv) {
@@ -372,9 +366,9 @@ export async function encrypt(data, key, iv) {
 }
 
 /**
- * @param {Uint8Array} data 
+ * @param {Uint8Array<ArrayBuffer>} data 
  * @param {CryptoKey} key 
- * @param {Uint8Array} iv 
+ * @param {Uint8Array<ArrayBuffer>} iv 
  * @returns 
  */
 export async function decrypt(data, key, iv) {
@@ -428,83 +422,6 @@ export const TUNNEL_TCP_TYPE_PING = 0x4768e1ba
 export const TUNNEL_TCP_TYPE_PONG = 0x106f43fb
 export const TUNNEL_TCP_TYPE_ACK = 0xc5870539
 
-/**
- * @typedef {TUNNEL_TCP_TYPE_INIT
- * |TUNNEL_TCP_TYPE_LISTEN
- * |TUNNEL_TCP_TYPE_ONLISTEN
- * |TUNNEL_TCP_TYPE_CONNECT
- * |TUNNEL_TCP_TYPE_ONCONNECT
- * |TUNNEL_TCP_TYPE_DATA
- * |TUNNEL_TCP_TYPE_ERROR
- * |TUNNEL_TCP_TYPE_CLOSE
- * |TUNNEL_TCP_TYPE_PING
- * |TUNNEL_TCP_TYPE_PONG
- * |TUNNEL_TCP_TYPE_ACK} TUNNEL_TCP_TYPE
- */
-
-/**
- * @typedef {{
- * type:TUNNEL_TCP_TYPE;
- * srcId:number;
- * dstId:number;
- * srcChannel:number;
- * dstChannel:number;
- * buffer:Uint8Array;
- * }} TCP_TUNNEL_DATA
- */
-
-/**
- * @typedef {{
- * key:string;
- * }} TUNNEL_TCP_DATA_LISTEN
- */
-
-/**
- * @typedef {{
- * key:string;
- * }} TUNNEL_TCP_DATA_CONNECT
- */
-
-/**
- * @typedef {{
- * time:number;
- * }} TUNNEL_TCP_DATA_PINGPONG
- */
-
-/**
- * @typedef {{
- * id:number;
- * encodeWriter:WritableStreamDefaultWriter<Uint8Array>;
- * }} TUNNEL_TCP_SERVER
- */
-
-/**
- * @typedef {{
- *     readable:ReadableStream<Uint8Array>;
- *     writable:WritableStream<Uint8Array>;
- *     reader:ReadableStreamDefaultReader<Uint8Array>;
- *     writer:WritableStreamDefaultWriter<Uint8Array>;
- *     dstId:number;
- * }} TUNNEL_TCP_SERVER_HELPER
- * @typedef {{
- *     readable:ReadableStream<Uint8Array>;
- *     writable:WritableStream<Uint8Array>;
- *     reader:ReadableStreamDefaultReader<Uint8Array>;
- *     writer:WritableStreamDefaultWriter<Uint8Array>;
- *     listen:(param:{ 
- *          clientKey?:string;
- *          tunnelKey:string;
- *          host?:string;
- *          port:number; 
- *        })=>Promise<void>;
- *     connect:(param:{ 
- *          clientKey?:string;
- *          tunnelKey: string;
- *          port: number;
- *        })=>Promise<void>;
- * }} TUNNEL_TCP_CLIENT_HELPER
- */
-
 /**
  * @param {TCP_TUNNEL_DATA} box
  */
@@ -520,7 +437,7 @@ export function buildTcpTunnelData(box) {
 }
 
 /**
- * @param {Uint8Array} buffer
+ * @param {Uint8Array<ArrayBuffer>} buffer
  */
 export function parseTcpTunnelData(buffer) {
     let offset = 0
@@ -617,25 +534,43 @@ export function pipeSocketDataWithChannel(channelMap, channelId, encodeWriter) {
     let signal = Promise_withResolvers()
     signal.resolve()
     let sendPackSize = 0
-    let recvPackSize = 0
+    let remoteRecvPackSize = 0
     channel.notify = (size) => {
-        recvPackSize = size
+        remoteRecvPackSize = size
         signal.resolve()
     }
     let [clientKey, clientIv] = channel.key_iv
     let bufferedTransform = createTimeBufferedTransformStream(50)
+    let backPressureTimer = null
     Readable.toWeb(socket).pipeThrough(bufferedTransform).pipeTo(new WritableStream({
+        /**
+         * @param {Uint8Array<ArrayBuffer>} chunk
+         */
         async write(chunk) {
             const buffer = await encrypt(chunk, clientKey, clientIv)
-            let bufferPackSize = sendPackSize - recvPackSize
+            let bufferPackSize = sendPackSize - remoteRecvPackSize
+            if (DEBUG_TUNNEL_TCP) {
+                console.warn('bufferPackSize:', bufferPackSize)
+            }
             if (bufferPackSize > 10) {
                 signal.resolve()
                 signal = Promise_withResolvers()
+                const s = signal
+                backPressureTimer = setTimeout(() => {
+                    s.resolve()
+                    console.error('pipeSocketDataWithChannel timeout close channel')
+                    sendPackSize = 0
+                    this.close()
+                }, 10_000).unref()
                 if (DEBUG_TUNNEL_TCP) {
-                    console.info('stop wait signal', ' sendPackSize:', sendPackSize, ' recvPackSize:', recvPackSize, ' bufferPackSize:', bufferPackSize)
+                    console.info('stop wait signal', ' sendPackSize:', sendPackSize, ' recvPackSize:', remoteRecvPackSize, ' bufferPackSize:', bufferPackSize)
                 }
             }
             await signal.promise
+            if (backPressureTimer) {
+                clearTimeout(backPressureTimer)
+                backPressureTimer = null
+            }
             await encodeWriter.write(buildTcpTunnelData({
                 type: TUNNEL_TCP_TYPE_DATA,
                 srcId: channel.srcId,
@@ -647,7 +582,7 @@ export function pipeSocketDataWithChannel(channelMap, channelId, encodeWriter) {
             sendPackSize++
         },
         async close() {
-            await encodeWriter.write(buildTcpTunnelData({
+            encodeWriter.write(buildTcpTunnelData({
                 type: TUNNEL_TCP_TYPE_CLOSE,
                 srcId: channel.srcId,
                 srcChannel: channel.srcChannel,
@@ -656,6 +591,7 @@ export function pipeSocketDataWithChannel(channelMap, channelId, encodeWriter) {
                 buffer: new Uint8Array(0),
             })).catch((err) => { console.error('web stream write error', err.message) })
             channelMap.delete(channelId)
+            socket.destroy()
         }
     })).catch((err) => {
         console.error('web stream error', err.message)
@@ -694,8 +630,8 @@ function natTunnelData(param, data) {
 
 /**
  * @param {TunnelTcpServerHelperParam} param
- * @param {WritableStreamDefaultWriter<Uint8Array<ArrayBufferLike>>} encodeWriter
- * @param {Uint8Array<ArrayBufferLike>} chunk
+ * @param {WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>} encodeWriter
+ * @param {Uint8Array<ArrayBuffer>} chunk
  */
 async function dispatchServerBufferData(param, encodeWriter, chunk) {
     let data = parseTcpTunnelData(chunk)
@@ -741,10 +677,10 @@ async function dispatchServerBufferData(param, encodeWriter, chunk) {
 /**
  * @param {TunnelTcpClientHelperParam} param
  * @param {{ (): Promise<void>; }} setup
- * @param {Map<string,{host:string;port:number;key_iv:[CryptoKey, Uint8Array]}>} listenKeyParamMap
+ * @param {Map<string,{host:string;port:number;key_iv:[CryptoKey, Uint8Array<ArrayBuffer>]}>} listenKeyParamMap
  * @param {Map<number, SocketChannel>} channelMap
- * @param {WritableStreamDefaultWriter<Uint8Array<ArrayBufferLike>>} encodeWriter
- * @param {Uint8Array<ArrayBufferLike>} buffer
+ * @param {WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>} encodeWriter
+ * @param {Uint8Array<ArrayBuffer>} buffer
  */
 async function dispatchClientBufferData(param, setup, listenKeyParamMap, channelMap, encodeWriter, buffer) {
     let data = parseTcpTunnelData(buffer)
@@ -846,7 +782,7 @@ async function dispatchClientBufferData(param, setup, listenKeyParamMap, channel
         let channel = channelMap.get(channelId)
         if (channel) {
             channelMap.delete(channelId)
-            channel.socket.end()
+            channel.socket.destroy()
         }
     }
     if (data.type == TUNNEL_TCP_TYPE_ERROR) {
@@ -923,39 +859,6 @@ export async function closeRemoteChannel(encodeWriter, data) {
     })).catch((err) => { console.error('closeRemoteChannel stream write error', err.message) })
 }
 
-/**
- * @typedef {{
- * writer:WritableStreamDefaultWriter<Uint8Array>;
- * socket:net.Socket;
- * srcId:number;
- * dstId:number;
- * srcChannel:number;
- * dstChannel:number;
- * notify:(size:number)=>void;
- * recvPackSize:number;
- * key_iv:[CryptoKey, Uint8Array];
- * }} SocketChannel
- */
-
-
-/**
- * @typedef {{
- * uniqueId:number;
- * listenMap:Map<string,number>;
- * dstMap:Map<number,TUNNEL_TCP_SERVER>;
- * serverKey?:string;
- * }} TunnelTcpServerHelperParam
- */
-
-/**
- * @typedef {{
- * signal:AbortSignal;
- * serverKey?:string;
- * uniqueId:number;
- * clientDataId:number;
- * }} TunnelTcpClientHelperParam 
- */
-
 /**
  * @param {TunnelTcpServerHelperParam} param 
  */
@@ -1010,7 +913,7 @@ export function createTunnelTcpClientHelper(param) {
     /** @type{Map<number,SocketChannel>} */
     let channelMap = new Map()
 
-    /** @type{Map<string,{host:string;port:number;key_iv:[CryptoKey, Uint8Array]}>} */
+    /** @type{Map<string,{host:string;port:number;key_iv:[CryptoKey, Uint8Array<ArrayBuffer>]}>} */
     let listenKeyParamMap = new Map()
 
     let server_key_iv = buildKeyIv(param.serverKey, 10)
@@ -1037,6 +940,9 @@ export function createTunnelTcpClientHelper(param) {
     }
 
     decode.readable.pipeTo(new WritableStream({
+        /**
+         * @param {Uint8Array<ArrayBuffer>} buffer
+         */
         async write(buffer) {
             try {
                 await dispatchClientBufferData(param, setup, listenKeyParamMap, channelMap, encodeWriter, buffer)
@@ -1144,7 +1050,7 @@ export function createTunnelTcpClientHelper(param) {
     }
 
     /** @type{TUNNEL_TCP_CLIENT_HELPER} */
-    let helper = { readable: encode.readable, writable: decode.writable, reader: null, writer: null, listen, connect }
+    let helper = { readable: encode.readable, writable: decode.writable, reader: null, writer: null, listen, connect, param: outParam }
     return helper
 
 }
@@ -1467,6 +1373,9 @@ export function createTunnelTcpClientHttp(param) {
     let socketWriter = null
     let bufferedTransform = createTimeBufferedTransformStream(50)
     helper.readable.pipeThrough(bufferedTransform).pipeTo(new WritableStream({
+        /**
+         * @param {Uint8Array<ArrayBufferLike>} chunk
+         */
         async write(chunk) {
             while (!param.signal.aborted && socketWriter == null) {
                 await signal.promise
@@ -1521,6 +1430,11 @@ export function createTunnelTcpClientHttp(param) {
                 console.error('createConnectionHttpx res close ')
                 promise.resolve()
             })
+            setTimeout(() => {
+                if (helper.param.clientDataId < 1) {
+                    res.destroy(new Error('init clientId failed!'))
+                }
+            }, 10_000).unref()
         })
         Readable.fromWeb(transform.readable).pipe(req)
         req.flushHeaders()

package/src/lib.test.js

@@ -5,7 +5,7 @@ import net from 'net'
 import http from 'http'
 import { Readable, Transform } from 'node:stream'
 import Koa from 'koa'
-import Router from 'koa-router'
+import Router from '@koa/router'
 import { WebSocketServer } from 'ws'
 import log4js from 'log4js'
 
@@ -62,7 +62,7 @@ test('tunnel-tcp-socket-test', async () => {
             console.error(err.message)
         })
 
-        let rec = null
+        let rec = ''
 
         await new Promise((resolve) => {
             socket.on('connect', async () => {
@@ -86,7 +86,8 @@ test('tunnel-tcp-socket-test', async () => {
             socketServer.close()
         })
 
-        strictEqual(rec, 'qwertyuiop - 99')
+        let from = rec.length - 'qwertyuiop - 99'.length
+        strictEqual(rec.substring(from), 'qwertyuiop - 99')
 
     })
     console.info('over!')
@@ -508,4 +509,144 @@ test('test-connect', { skip: SKIP_MANAUAL_TEST }, async () => {
 
         await sleep(10000_000)
     })
+})
+
+test('terminal-server', async () => {
+    // node --test-name-pattern="^terminal-server$" src/lib.test.js
+    using stack = new DisposableStack()
+    const ac = new AbortController()
+    stack.adopt(ac, () => { ac.abort() })
+    let transformSize = 0
+
+    async function createEchoServer() {
+        console.info('创建socket服务')
+        let socketServer = net.createServer((socket) => {
+            socket.pipe(new Transform({
+                transform(chunk, _, callback) {
+                    // console.info('transform chunk', chunk.length)
+                    transformSize += chunk.length
+                    this.push("echo::::")
+                    this.push(chunk)
+                    callback()
+                }
+            })).pipe(socket).on('error', (err) => console.error(err.message))
+        }).listen(9036)
+        await sleep(100)
+        socketServer.on('error', (err) => {
+            console.error(err.message)
+        })
+        ac.signal.addEventListener('abort', () => {
+            socketServer.close()
+        })
+    }
+
+    /**
+     * 
+     * @param {AbortController} ac 
+     */
+    async function createDispatchServer(ac) {
+        console.info('创建转发服务 http')
+        let app = new Koa()
+        let router = new Router()
+        createTunnelTcpServerKoaRouter({
+            signal: ac.signal,
+            router: router,
+            path: '/tunnel/0f7c5b2c9080eaa9e4d6139126daac04',
+            serverKey: '2934c57f790f9e99a52a121802df231c',
+        })
+        app.use(router.routes())
+        app.use(router.allowedMethods())
+        app.onerror = (err) => console.info(err.message)
+        let koaServer = http.createServer(app.callback())
+        koaServer.listen(9035)
+        koaServer.on('error', (e) => { console.error(e.message) })
+        ac.signal.addEventListener('abort', () => {
+            console.info('close koa server')
+            koaServer.close((err) => {
+                console.info('on server close result ', err)
+            })
+            koaServer.closeAllConnections()
+        })
+        await sleep(1000)
+    }
+
+    async function createListenClient() {
+        console.info('创建监听服务 http')
+        let connection1 = createTunnelTcpClientHttp({
+            url: 'http://127.0.0.1:9035/tunnel/0f7c5b2c9080eaa9e4d6139126daac04',
+            signal: ac.signal,
+            serverKey: '2934c57f790f9e99a52a121802df231c',
+        })
+        connection1.listen({
+            clientKey: 'mmm',
+            tunnelKey: 'b0f5014acad2060d6bd3730a1721c97f',
+            host: '127.0.0.1',
+            port: 9036,
+        })
+        await sleep(100)
+    }
+
+    async function createConnectClient() {
+        console.info('创建连接服务 http 1')
+        let connection2 = createTunnelTcpClientHttp({
+            url: 'http://127.0.0.1:9035/tunnel/0f7c5b2c9080eaa9e4d6139126daac04',
+            signal: ac.signal,
+            serverKey: '2934c57f790f9e99a52a121802df231c',
+        })
+        connection2.connect({
+            clientKey: 'mmm',
+            tunnelKey: 'b0f5014acad2060d6bd3730a1721c97f',
+            port: 9037,
+        })
+
+        await sleep(1000)
+    }
+
+    let socketCreateCount = 0
+    let recvCount = 0
+    async function startSendRecvTest() {
+        socketCreateCount++
+        console.info('tcp透传测试 start')
+        let socket1 = net.createConnection({ host: '127.0.0.1', port: 9037 })
+        socket1.on('error', (err) => { console.error(err.message) })
+        ac.signal.addEventListener('abort', () => { socket1.destroy() })
+        socket1.on('connect', async () => {
+            socket1.on('data', (chunk) => {
+                console.info('receive chunk ', Uint8Array_toString(chunk))
+                recvCount++
+            })
+            while (!ac.signal.aborted && !socket1.closed) {
+                await sleep(1000)
+                socket1.write(`iiiiiii>>>>>>> ${new Date().toLocaleString()}`)
+            }
+            console.info('finished socket.')
+            setTimeout(() => {
+                startSendRecvTest()
+            }, 1)
+        })
+    }
+
+    await createEchoServer()
+    let ac2 = new AbortController()
+    stack.adopt(0, () => ac2.abort())
+    await createDispatchServer(ac2)
+    await createListenClient()
+    await createConnectClient()
+    await startSendRecvTest()
+
+    await sleep(5000)
+    ac2.abort()
+    console.info('stop dispatch server')
+    await sleep(5_000)
+    ac2 = new AbortController()
+    stack.adopt(0, () => ac2.abort())
+    console.info('recreate dispatch server')
+    await createDispatchServer(ac2)
+
+    await sleep(20_000)
+
+    strictEqual(socketCreateCount, 2)
+    strictEqual(recvCount, 14)
+
+    console.info('over!')
 })

package/src/types.ts

@@ -0,0 +1,114 @@
+import net from 'node:net'
+import { WritableStream, ReadableStream, ReadableStreamDefaultReader, WritableStreamDefaultWriter } from "stream/web"
+
+
+export type PromiseResolvers = {
+    promise: Promise<any>
+    resolve: (value: any | null) => void
+    reject: (reason: any | null) => void
+}
+
+export type TUNNEL_TCP_TYPE_INIT = 0xa9b398d5 // 链接建立后返回id
+export type TUNNEL_TCP_TYPE_LISTEN = 0xe41957d3
+export type TUNNEL_TCP_TYPE_ONLISTEN = 0x20993e38
+export type TUNNEL_TCP_TYPE_CONNECT = 0x11d949f8
+export type TUNNEL_TCP_TYPE_ONCONNECT = 0x377b2181
+export type TUNNEL_TCP_TYPE_DATA = 0x48678f39
+export type TUNNEL_TCP_TYPE_ERROR = 0x8117f762
+export type TUNNEL_TCP_TYPE_CLOSE = 0x72fd6470
+export type TUNNEL_TCP_TYPE_PING = 0x4768e1ba
+export type TUNNEL_TCP_TYPE_PONG = 0x106f43fb
+export type TUNNEL_TCP_TYPE_ACK = 0xc5870539
+
+export type TUNNEL_TCP_TYPE = TUNNEL_TCP_TYPE_INIT |
+    TUNNEL_TCP_TYPE_LISTEN |
+    TUNNEL_TCP_TYPE_ONLISTEN |
+    TUNNEL_TCP_TYPE_CONNECT |
+    TUNNEL_TCP_TYPE_ONCONNECT |
+    TUNNEL_TCP_TYPE_DATA |
+    TUNNEL_TCP_TYPE_ERROR |
+    TUNNEL_TCP_TYPE_CLOSE |
+    TUNNEL_TCP_TYPE_PING |
+    TUNNEL_TCP_TYPE_PONG |
+    TUNNEL_TCP_TYPE_ACK
+
+export type TCP_TUNNEL_DATA = {
+    type: TUNNEL_TCP_TYPE
+    srcId: number
+    dstId: number
+    srcChannel: number
+    dstChannel: number
+    buffer: Uint8Array<ArrayBuffer>
+}
+
+export type TUNNEL_TCP_DATA_LISTEN = {
+    key: string
+}
+
+export type TUNNEL_TCP_DATA_CONNECT = {
+    key: string
+}
+
+export type TUNNEL_TCP_DATA_PINGPONG = {
+    time: number
+}
+
+export type TUNNEL_TCP_SERVER = {
+    id: number
+    encodeWriter: WritableStreamDefaultWriter<Uint8Array>
+}
+
+export type TUNNEL_TCP_SERVER_HELPER = {
+    readable: ReadableStream<Uint8Array<ArrayBuffer>>
+    writable: WritableStream<Uint8Array<ArrayBuffer>>
+    reader: ReadableStreamDefaultReader<Uint8Array<ArrayBuffer>>
+    writer: WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>
+    dstId: number
+}
+
+export type TUNNEL_TCP_CLIENT_HELPER = {
+    readable: ReadableStream<Uint8Array<ArrayBuffer>>
+    writable: WritableStream<Uint8Array<ArrayBuffer>>
+    reader: ReadableStreamDefaultReader<Uint8Array<ArrayBuffer>>
+    writer: WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>
+    param: TunnelTcpClientHelperParam
+    listen: (param: {
+        clientKey?: string
+        tunnelKey: string
+        host?: string
+        port: number
+    }) => Promise<void>
+    connect: (param: {
+        clientKey?: string
+        tunnelKey: string
+        port: number
+    }) => Promise<void>
+}
+
+
+export type SocketChannel = {
+    writer: WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>
+    socket: net.Socket
+    srcId: number
+    dstId: number
+    srcChannel: number
+    dstChannel: number
+    notify: (size: number) => void
+    recvPackSize: number
+    key_iv: [CryptoKey, Uint8Array<ArrayBuffer>]
+}
+
+
+export type TunnelTcpServerHelperParam = {
+    uniqueId: number
+    listenMap: Map<string, number>
+    dstMap: Map<number, TUNNEL_TCP_SERVER>
+    serverKey?: string
+}
+
+export type TunnelTcpClientHelperParam = {
+    signal: AbortSignal
+    serverKey?: string
+    uniqueId: number
+    clientDataId: number
+}