@lanmower/entrypoint 0.16.0

package/src/storage/StorageAdapter.js

@@ -0,0 +1,7 @@
+export class StorageAdapter {
+  async get(key) { throw new Error('not implemented') }
+  async set(key, value) { throw new Error('not implemented') }
+  async delete(key) { throw new Error('not implemented') }
+  async list(prefix) { throw new Error('not implemented') }
+  async has(key) { throw new Error('not implemented') }
+}

package/src/transport/TransportWrapper.js

@@ -0,0 +1,25 @@
+import { EventEmitter } from '../protocol/EventEmitter.js'
+
+export class TransportWrapper extends EventEmitter {
+  constructor() {
+    super()
+    this.type = 'base'
+    this.ready = false
+  }
+
+  get isOpen() {
+    return this.ready
+  }
+
+  send(data) {
+    throw new Error('send() not implemented')
+  }
+
+  sendUnreliable(data) {
+    return this.send(data)
+  }
+
+  close() {
+    this.ready = false
+  }
+}

package/src/transport/WebSocketTransport.js

@@ -0,0 +1,55 @@
+import { TransportWrapper } from './TransportWrapper.js'
+
+export class WebSocketTransport extends TransportWrapper {
+  constructor(socket) {
+    super()
+    this.type = 'websocket'
+    this.socket = socket
+    this.ready = socket.readyState === 1
+
+    socket.on('message', (data) => {
+      this.emit('message', data)
+    })
+
+    socket.on('close', () => {
+      this.ready = false
+      this.emit('close')
+    })
+
+    socket.on('error', (err) => {
+      this.ready = false
+      this.emit('error', err)
+    })
+
+    if (!this.ready) {
+      socket.on('open', () => {
+        this.ready = true
+      })
+    }
+  }
+
+  get isOpen() {
+    return this.socket.readyState === 1
+  }
+
+  send(data) {
+    if (this.socket.readyState !== 1) return false
+    try {
+      this.socket.send(data)
+      return true
+    } catch (e) {
+      return false
+    }
+  }
+
+  sendUnreliable(data) {
+    return this.send(data)
+  }
+
+  close() {
+    super.close()
+    if (this.socket.readyState === 1) {
+      this.socket.close()
+    }
+  }
+}

package/src/transport/WebTransportServer.js

@@ -0,0 +1,83 @@
+import { existsSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { EventEmitter } from '../protocol/EventEmitter.js'
+import { WebTransportTransport } from './WebTransportTransport.js'
+
+let Http3Server = null
+let nativeAvailable = false
+
+try {
+  const require = createRequire(import.meta.url)
+  const quichePath = require.resolve('@fails-components/webtransport-transport-http3-quiche')
+  const nativePath = quichePath.replace(/lib[/\\]index\.js$/, 'build/Release/webtransport.node')
+  if (existsSync(nativePath)) {
+    const mod = await import('@fails-components/webtransport')
+    Http3Server = mod.Http3Server
+    nativeAvailable = true
+  }
+} catch (e) {}
+
+export const WEBTRANSPORT_AVAILABLE = nativeAvailable
+
+export class WebTransportServer extends EventEmitter {
+  constructor(options = {}) {
+    super()
+    this.port = options.port || 4433
+    this.cert = options.cert || null
+    this.key = options.key || null
+    this.server = null
+    this.running = false
+  }
+
+  async start() {
+    if (!nativeAvailable || !Http3Server) {
+      console.log('[webtransport] Native binary not available, skipping')
+      return false
+    }
+    if (!this.cert || !this.key) {
+      console.log('[webtransport] TLS cert/key not provided, skipping')
+      return false
+    }
+    try {
+      this.server = new Http3Server({
+        port: this.port,
+        host: '0.0.0.0',
+        secret: 'changeit',
+        cert: this.cert,
+        privKey: this.key
+      })
+      this.server.startServer()
+      this.running = true
+      this._acceptSessions()
+      return true
+    } catch (e) {
+      console.error('[webtransport] Failed to start:', e.message)
+      return false
+    }
+  }
+
+  async _acceptSessions() {
+    const sessionStream = await this.server.sessionStream('/')
+    const reader = sessionStream.getReader()
+    while (this.running) {
+      try {
+        const { value, done } = await reader.read()
+        if (done) break
+        if (value) {
+          const transport = new WebTransportTransport(value)
+          this.emit('session', transport)
+        }
+      } catch (e) {
+        if (this.running) console.error('[webtransport] Session error:', e.message)
+      }
+    }
+  }
+
+  stop() {
+    this.running = false
+    if (this.server) {
+      try { this.server.destroy() } catch (e) {}
+      this.server = null
+    }
+  }
+}

package/src/transport/WebTransportTransport.js

@@ -0,0 +1,94 @@
+import { TransportWrapper } from './TransportWrapper.js'
+
+export class WebTransportTransport extends TransportWrapper {
+  constructor(session) {
+    super()
+    this.type = 'webtransport'
+    this.session = session
+    this.ready = true
+    this.reliableWriter = null
+    this.reliableReader = null
+    this._closed = false
+    this._init()
+  }
+
+  async _init() {
+    try {
+      await this._setupReliableStream()
+      this._readDatagrams()
+    } catch (e) {
+      this._handleClose()
+    }
+  }
+
+  async _setupReliableStream() {
+    const stream = await this.session.createBidirectionalStream()
+    this.reliableWriter = stream.writable.getWriter()
+    this.reliableReader = stream.readable.getReader()
+    this._readReliableStream()
+  }
+
+  async _readReliableStream() {
+    try {
+      while (!this._closed) {
+        const { value, done } = await this.reliableReader.read()
+        if (done) break
+        if (value) this.emit('message', value)
+      }
+    } catch (e) {
+      if (!this._closed) this._handleClose()
+    }
+  }
+
+  async _readDatagrams() {
+    try {
+      const reader = this.session.datagrams.readable.getReader()
+      while (!this._closed) {
+        const { value, done } = await reader.read()
+        if (done) break
+        if (value) this.emit('message', value)
+      }
+    } catch (e) {
+      if (!this._closed) this._handleClose()
+    }
+  }
+
+  _handleClose() {
+    if (this._closed) return
+    this._closed = true
+    this.ready = false
+    this.emit('close')
+  }
+
+  get isOpen() {
+    return this.ready && !this._closed
+  }
+
+  send(data) {
+    if (!this.isOpen || !this.reliableWriter) return false
+    try {
+      this.reliableWriter.write(data)
+      return true
+    } catch (e) {
+      return false
+    }
+  }
+
+  sendUnreliable(data) {
+    if (!this.isOpen) return false
+    try {
+      const writer = this.session.datagrams.writable.getWriter()
+      writer.write(data)
+      writer.releaseLock()
+      return true
+    } catch (e) {
+      return this.send(data)
+    }
+  }
+
+  close() {
+    super.close()
+    this._closed = true
+    try { this.session.close() } catch (e) {}
+  }
+}