@laplace.live/event-bridge-server 0.2.1

package/.env.example

@@ -0,0 +1,8 @@
+# Deprecated, use LEB_AUTH instead
+LAPLACE_EVENT_BRIDGE_AUTH=
+
+# Auth token
+LEB_AUTH=
+
+# Debug mode
+DEBUG=

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# @laplace.live/event-bridge-server
+
+## 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
+
+- 80e6660: general first stable release
+
+## 0.1.0
+
+### Minor Changes
+
+- Add binaries

package/README.md

@@ -0,0 +1,135 @@
+# LAPLACE Event Bridge Server
+
+A specialized WebSocket bridge server that connects LAPLACE Chat to clients.
+
+## Features
+
+- Acts as a bridge between LAPLACE Chat and clients
+- Server-to-clients message broadcasting
+- Role-based connection system
+- Token-based authentication
+
+## Use Cases
+
+The event bridge enables various use cases:
+
+- Integrate user message events directly with Discord
+- Create custom chat layouts in your favorite frontend languages to display chat messages
+- Create custom interactions with chat messages in VTube Studio
+- Connect to streamer.bot, SAMMI, or other 3rd party services for advanced automation and integrations
+
+## Requirements
+
+- [Bun](https://bun.sh/) v1.0.0 or higher
+
+## Installation
+
+### From Source
+
+```bash
+# Clone the repository
+git clone https://github.com/laplace-live/event-bridge
+cd event-bridge
+
+# Install dependencies
+bun install
+```
+
+## Configuration
+
+### Authentication
+
+You can set authentication in order of precedence:
+
+1. Environment variable: `LEB_AUTH="your-secure-token"`
+2. Command line: `--auth "your-secure-token"`
+
+```bash
+# Example using environment variable
+export LEB_AUTH="your-secure-token"
+
+# Example using CLI
+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:
+
+1. Environment variable: `DEBUG=1` or `DEBUG=true`
+2. Command line: `--debug`
+
+```bash
+# Enable debug mode using environment variable
+export DEBUG=1
+
+# Enable debug mode using CLI
+bun run start --debug
+```
+
+## Usage
+
+### Start the Bridge Server
+
+```bash
+# Start the server
+bun run start
+
+# Start with CLI options
+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` by default.
+
+### Connection Types
+
+The bridge supports two types of connections:
+
+1. **LAPLACE Chat** - Connects with the special protocol `laplace-event-bridge-role-server` and broadcasts messages to all clients
+2. **Clients** - Regular connections that receive broadcasts from the server
+
+### Authentication
+
+When authentication is enabled, clients must provide the auth token in the WebSocket protocol:
+
+- For clients: `['laplace-event-bridge-role-client', 'your-auth-token']`
+
+### Message Flow
+
+- Messages from the LAPLACE Chat are broadcast to all connected clients
+- Messages from clients are acknowledged but not relayed to other clients or the server
+
+## Client Demo
+
+A simple HTML client demo is included for testing (`client-demo.html`):
+
+1. Open the file in your web browser
+2. Configure connection settings (URL, authentication)
+3. Connect to the bridge
+4. Receive broadcasts from the LAPLACE Chat
+
+## License
+
+AGPL

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

@@ -0,0 +1,23 @@
+{
+  "name": "@laplace.live/event-bridge-server",
+  "description": "LAPLACE Event Bridge Server",
+  "version": "0.2.1",
+  "license": "AGPL-3.0",
+  "type": "module",
+  "module": "index.ts",
+  "main": "index.ts",
+  "types": "index.ts",
+  "scripts": {
+    "start": "bun run index.ts",
+    "dev": "bun --hot run index.ts",
+    "build": "bun build ./index.ts --outdir ./dist --target node --minify --sourcemap",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@laplace.live/event-types": "^2.0.4"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "typescript": "^5.0.0"
+  }
+}