@laplace.live/event-bridge-server 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @laplace.live/event-bridge-server
 
+## 0.2.2
+
+### Patch Changes
+
+- 2ef27cf: release artifacts test
+
+## 0.2.1
+
+### Patch Changes
+
+- 818636b: enhance configuration options for authentication and debug mode
+- 6fbc787: add network interface configuration options
+
 ## 0.2.0
 
 ### Minor Changes

package/README.md

@@ -54,6 +54,23 @@ bun run start --auth "your-secure-token"
 
 If the authentication token is set, all connections including the clients must provide it to connect.
 
+### Network Interface
+
+Control which network interface the server listens on:
+
+1. Environment variable: `HOST="127.0.0.1"`
+2. Command line: `--host 127.0.0.1`
+
+```bash
+# Listen only on localhost
+export HOST="localhost"
+
+# Listen on all interfaces
+bun run start --host 0.0.0.0
+```
+
+By default, the server listens on `localhost`.
+
 ### Debug Mode
 
 Enable detailed debug logging using:
@@ -78,13 +95,13 @@ bun run start --debug
 bun run start
 
 # Start with CLI options
-bun run start --debug --auth "your-secure-token"
+bun run start --debug --auth "your-secure-token" --host 0.0.0.0
 
 # Or with hot reloading during development
 bun run dev
 ```
 
-The WebSocket bridge server runs on `http://localhost:9696`.
+The WebSocket bridge server runs on `http://localhost:9696` by default.
 
 ### Connection Types
 

package/index.ts

@@ -0,0 +1,191 @@
+import { parseArgs } from 'util'
+import type { LaplaceEvent } from '@laplace.live/event-types'
+
+// Parse command line arguments properly
+const { values } = parseArgs({
+  args: Bun.argv,
+  options: {
+    debug: {
+      type: 'boolean',
+    },
+    auth: {
+      type: 'string',
+    },
+    host: {
+      type: 'string',
+    },
+  },
+  strict: false,
+})
+
+// Get authentication token from environment variable or CLI
+const AUTH_TOKEN = process.env['LEB_AUTH'] || process.env['LAPLACE_EVENT_BRIDGE_AUTH'] || values.auth || ''
+
+// Debug mode configuration
+const DEBUG_MODE = process.env['DEBUG'] === '1' || process.env['DEBUG']?.toLowerCase() === 'true' || !!values.debug
+
+// Network interface configuration
+const HOST = process.env['HOST'] || (values.host as string) || 'localhost'
+
+interface Client {
+  id: string
+  isServer: boolean // Flag to identify if this client is the laplace-chat server
+}
+
+const clients = new Map<any, Client>()
+let nextClientId = 1
+
+const server = Bun.serve<Client, {}>({
+  port: 9696,
+  hostname: HOST,
+  fetch(req, server) {
+    // Check if this is the laplace-chat server connecting
+    // Format: "laplace-event-bridge-role-server, password123"
+    const protocol = req.headers.get('sec-websocket-protocol')
+    const protocolParts = protocol ? protocol.split(',') : []
+    const role = protocolParts[0]?.trim()
+    const password = protocolParts[1]?.trim() // Password for verification
+
+    const isServer = role === 'laplace-event-bridge-role-server'
+
+    if (AUTH_TOKEN) {
+      if (password !== AUTH_TOKEN) {
+        console.log(`Authentication failed: Invalid token for ${isServer ? 'server' : 'client'} connection`)
+        return new Response('Unauthorized', { status: 401 })
+      }
+    }
+
+    // Upgrade the request to a WebSocket connection
+    const success = server.upgrade(req, {
+      data: {
+        id: `${isServer ? 'server' : 'client'}-${nextClientId++}`,
+        isServer,
+      },
+    })
+
+    if (!success) {
+      return new Response('WebSocket upgrade failed. This is a WebSocket server.', { status: 400 })
+    }
+
+    return undefined
+  },
+  websocket: {
+    open(ws) {
+      const clientId = ws.data.id
+      const isServer = ws.data.isServer
+      clients.set(ws, ws.data)
+
+      console.log(`Client connected: ${clientId}${isServer ? ' (laplace-chat server)' : ''}`)
+
+      // Welcome message
+      ws.send(
+        JSON.stringify({
+          type: 'established',
+          clientId,
+          isServer,
+          message: 'Connected to LAPLACE Event bridge',
+        })
+      )
+    },
+    message(ws, message) {
+      const clientId = ws.data.id
+      const isServer = ws.data.isServer
+
+      try {
+        const messageStr = message.toString()
+        let parsedMessage: LaplaceEvent
+        let broadcastMessage
+
+        try {
+          // Try to parse as JSON
+          parsedMessage = JSON.parse(messageStr)
+
+          if (DEBUG_MODE) {
+            console.log(`Received ${parsedMessage.type} from ${clientId}:`, parsedMessage)
+          } else {
+            console.log(`Received ${parsedMessage.type} from ${clientId}`)
+          }
+
+          // Prepare broadcast message in the same format
+          broadcastMessage = JSON.stringify({
+            ...parsedMessage,
+            source: clientId,
+          })
+        } catch (e) {
+          // Handle as plain text if not JSON
+          console.log(`Received message from ${clientId}: ${messageStr}`)
+
+          // Prepare broadcast message for plain text
+          broadcastMessage = JSON.stringify({
+            type: 'unknown-message',
+            text: messageStr,
+            source: clientId,
+            timestamp: Date.now(),
+          })
+        }
+
+        // Broadcast to all clients EXCEPT the server
+        // If the message is from the server, broadcast to all clients
+        // If from a client, don't broadcast (or optionally can be enabled)
+        if (isServer) {
+          // console.log(`Broadcasting message from laplace-chat to all clients`)
+
+          // Broadcast to all clients except the server
+          for (const [client, data] of clients.entries()) {
+            if (client !== ws) {
+              client.send(broadcastMessage)
+            }
+          }
+
+          // Send confirmation back to the server
+          ws.send(
+            JSON.stringify({
+              type: 'broadcast-success',
+              clientCount: clients.size - 1, // Excluding the server
+              timestamp: Date.now(),
+            })
+          )
+        } else {
+          // Optional: Echo back to the client that their message was received
+          ws.send(
+            JSON.stringify({
+              type: 'client-message-received',
+              message: 'Message received (client-to-server messages are not relayed)',
+              timestamp: Date.now(),
+            })
+          )
+        }
+      } catch (error) {
+        console.error(`Error processing message from ${clientId}:`, error)
+        ws.send(
+          JSON.stringify({
+            type: 'error',
+            message: 'Failed to process your message',
+            timestamp: Date.now(),
+          })
+        )
+      }
+    },
+    close(ws) {
+      const clientId = ws.data.id
+      const isServer = ws.data.isServer
+      clients.delete(ws)
+      console.log(`Client disconnected: ${clientId}${isServer ? ' (laplace-chat server)' : ''}`)
+    },
+    drain(ws) {
+      console.log(`WebSocket backpressure: ${ws.getBufferedAmount()}`)
+    },
+  },
+})
+
+// Create a banner display at startup
+function displayBanner() {
+  console.log('🌸 LAPLACE Event Bridge Server')
+  console.log(`🚀 Server running at http://${server.hostname}:${server.port}`)
+  console.log(`🔐 Authentication: ${AUTH_TOKEN ? '✅ Enabled' : '❌ Disabled'}`)
+  console.log(`🐛 Debug Mode: ${DEBUG_MODE ? '✅ Enabled' : '❌ Disabled'}`)
+  console.log(`⏱️ Started at: ${new Date().toLocaleString()}`)
+  console.log(`\nWaiting for connections...\n`)
+}
+
+displayBanner()

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@laplace.live/event-bridge-server",
   "description": "LAPLACE Event Bridge Server",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "license": "AGPL-3.0",
   "type": "module",
   "module": "index.ts",

package/.env

@@ -1 +0,0 @@
-# LAPLACE_EVENT_BRIDGE_AUTH=laplace