@rooms-haxball/connector 0.1.0

package/README.md

@@ -0,0 +1,41 @@
+# @rooms-haxball/connector
+
+Conecta una sala de HaxBall al dashboard multi-tenant de Rooms HaxBall sin tener que gestionar Socket.IO manualmente.
+
+## Installation
+
+```bash
+npm install @rooms-haxball/connector socket.io-client
+```
+
+`socket.io-client` se declara como **peer dependency** para evitar versiones duplicadas en tu bot.
+
+## Environment Variables
+
+- `DASHBOARD_HUB_URL`: URL base del dashboard (ej. `https://dashboard.example.com`).
+- `DASHBOARD_API_KEY`: API key de tu sala (`rhb_...`) generada desde `/keys`.
+
+## 5-line Usage Example
+
+```js
+const { connectToDashboard } = require('@rooms-haxball/connector');
+const room = createRoom();
+process.env.DASHBOARD_HUB_URL = 'https://dashboard.example.com';
+process.env.DASHBOARD_API_KEY = 'rhb_1234567890abcdef1234567890abcdef';
+connectToDashboard(room, { roomId: 'my-room', roomName: 'My Room' });
+```
+
+## Configuration
+
+`connectToDashboard(room, { roomId, roomName })`:
+
+- `roomId`: identificador estable de la sala (ej. `rambo`, `rs-4v4`).
+- `roomName`: nombre visible en el dashboard.
+- El conector envía `connectorVersion` en el handshake para telemetría y compatibilidad operativa.
+
+## Troubleshooting
+
+- **No conecta al dashboard**: verifica `DASHBOARD_HUB_URL` y `DASHBOARD_API_KEY`.
+- **Error 401/403**: la API key puede estar revocada o asociada a otra sala.
+- **Dashboard reiniciado**: la reconexión es automática (`reconnection: true`).
+- **Advertencia por `INTERNAL_API_KEY`**: migra a `DASHBOARD_API_KEY`; el fallback es temporal.

package/index.js

@@ -0,0 +1,194 @@
+const { io } = require('socket.io-client');
+const { version: connectorVersion } = require('./package.json');
+
+let dashboardSocket = null;
+const playerIdentities = new Map();
+
+function getHubUrl() {
+  const rawHubUrl = process.env.DASHBOARD_HUB_URL || 'http://localhost:4000';
+  return rawHubUrl.replace(/\/+$/, '');
+}
+
+function getApiKey() {
+  const dashboardApiKey = process.env.DASHBOARD_API_KEY;
+  const apiKey = dashboardApiKey || process.env.INTERNAL_API_KEY;
+
+  if (!apiKey) {
+    console.log('[DASHBOARD] DASHBOARD_API_KEY / INTERNAL_API_KEY not set, skipping dashboard connection');
+    return null;
+  }
+
+  if (!dashboardApiKey) {
+    console.log('[DASHBOARD] Deprecation warning: using INTERNAL_API_KEY fallback, configure DASHBOARD_API_KEY');
+  }
+
+  return apiKey;
+}
+
+function connectToDashboard(room, { roomId, roomName }) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    return null;
+  }
+
+  const socket = io(`${getHubUrl()}/bot`, {
+    auth: { apiKey, roomId, roomName, connectorVersion },
+    transports: ['websocket'],
+    reconnection: true,
+    reconnectionDelay: 3000,
+  });
+
+  dashboardSocket = socket;
+  setupSocketHandlers(socket, room, roomName);
+  wrapRoomEventForwarders(socket, room);
+
+  return socket;
+}
+
+function setupSocketHandlers(socket, room, roomName) {
+  socket.on('connect', () => {
+    console.log(`[DASHBOARD] Conectado al Centro de Comando como "${roomName}"`);
+    const players = room.getPlayerList().filter((player) => player.id !== 0);
+    socket.emit('playerCount', players.length);
+
+    for (const player of players) {
+      playerIdentities.set(player.id, { auth: player.auth, conn: player.conn, name: player.name });
+      socket.emit('playerJoined', {
+        id: player.id,
+        name: player.name,
+        auth: player.auth,
+        conn: player.conn,
+        team: player.team,
+      });
+    }
+  });
+
+  socket.on('disconnect', (reason) => {
+    console.log(`[DASHBOARD] Desconectado del Centro de Comando: ${reason}`);
+  });
+
+  socket.on('connect_error', (err) => {
+    console.log(`[DASHBOARD] Error de conexion: ${err.message}`);
+  });
+
+  socket.on('sendAnnouncement', ({ message }) => {
+    if (typeof message === 'string' && message) {
+      room.sendAnnouncement(`[ADMIN] ${message}`, null, 0xFF8C00, 'bold', 2);
+    }
+  });
+
+  socket.on('executeCommand', ({ message }) => {
+    emitRoomControlEvent(room, 'onDashboardExecuteCommand', { message });
+  });
+
+  socket.on('banPlayer', (payload, callback) => {
+    emitRoomControlEvent(room, 'onDashboardBanPlayer', payload, callback);
+  });
+
+  socket.on('unbanPlayer', (payload, callback) => {
+    emitRoomControlEvent(room, 'onDashboardUnbanPlayer', payload, callback);
+  });
+
+  socket.on('getBanList', (payload, callback) => {
+    emitRoomControlEvent(room, 'onDashboardGetBanList', payload, callback);
+  });
+
+  socket.on('getPlayers', (payload, callback) => {
+    emitRoomControlEvent(room, 'onDashboardGetPlayers', payload, callback);
+  });
+}
+
+function emitRoomControlEvent(room, handlerName, payload, callback) {
+  const handler = room && room[handlerName];
+  if (typeof handler !== 'function') {
+    if (typeof callback === 'function') {
+      callback([]);
+    }
+    return;
+  }
+
+  try {
+    const result = handler(payload);
+    if (typeof callback === 'function') {
+      callback(result);
+    }
+  } catch (err) {
+    console.error('[DASHBOARD] Error in control handler:', err.message);
+    if (typeof callback === 'function') {
+      callback([]);
+    }
+  }
+}
+
+function wrapRoomEventForwarders(socket, room) {
+  const originalOnPlayerChat = room.onPlayerChat;
+  room.onPlayerChat = function onPlayerChat(player, message) {
+    socket.emit('chatMessage', { type: 'player', playerName: player.name, message });
+    if (originalOnPlayerChat) {
+      return originalOnPlayerChat.call(this, player, message);
+    }
+    return true;
+  };
+
+  const originalOnPlayerJoin = room.onPlayerJoin;
+  room.onPlayerJoin = function onPlayerJoin(player) {
+    playerIdentities.set(player.id, { auth: player.auth, conn: player.conn, name: player.name });
+    socket.emit('chatMessage', {
+      type: 'system',
+      playerName: 'Sistema',
+      message: `${player.name} se unio a la sala`,
+    });
+    const count = room.getPlayerList().filter((p) => p.id !== 0).length;
+    socket.emit('playerCount', count);
+    socket.emit('playerJoined', {
+      id: player.id,
+      name: player.name,
+      auth: player.auth,
+      conn: player.conn,
+      team: player.team,
+    });
+
+    if (originalOnPlayerJoin) {
+      return originalOnPlayerJoin.call(this, player);
+    }
+
+    return undefined;
+  };
+
+  const originalOnPlayerLeave = room.onPlayerLeave;
+  room.onPlayerLeave = function onPlayerLeave(player) {
+    const identity = playerIdentities.get(player.id) || {};
+    socket.emit('chatMessage', {
+      type: 'system',
+      playerName: 'Sistema',
+      message: `${player.name} salio de la sala`,
+    });
+    const count = room.getPlayerList().filter((p) => p.id !== 0 && p.id !== player.id).length;
+    socket.emit('playerCount', count);
+    socket.emit('playerLeft', {
+      id: player.id,
+      name: player.name,
+      auth: identity.auth || null,
+      conn: identity.conn || null,
+    });
+
+    playerIdentities.delete(player.id);
+
+    if (originalOnPlayerLeave) {
+      return originalOnPlayerLeave.call(this, player);
+    }
+
+    return undefined;
+  };
+}
+
+function notifyAfkChange(playerId, playerName, isAfk) {
+  if (dashboardSocket && dashboardSocket.connected) {
+    dashboardSocket.emit('playerAfkChanged', { id: playerId, name: playerName, isAfk });
+  }
+}
+
+module.exports = {
+  connectToDashboard,
+  notifyAfkChange,
+};

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@rooms-haxball/connector",
+  "version": "0.1.0",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "socket.io-client": "^4.8.3"
+  }
+}