auuuhm

server/src/globals/logger.js

@@ -1,9 +1,20 @@
-function stamp(level, args) {
-  return [new Date().toISOString(), `[${level}]`, ...args];
+function stamp(level, label, args) {
+  const fields = [new Date().toISOString(), `[${level}]`];
+  if (label) {
+    fields.push(`[${label}]`);
+  }
+  return [...fields, ...args];
+}
+
+function baseLogger(label) {
+  return {
+    info: (...args) => console.log(...stamp('INFO', label, args)),
+    warn: (...args) => console.warn(...stamp('WARN', label, args)),
+    error: (...args) => console.error(...stamp('ERROR', label, args)),
+  };
 }
 
 module.exports = {
-  info: (...args) => console.log(...stamp('INFO', args)),
-  warn: (...args) => console.warn(...stamp('WARN', args)),
-  error: (...args) => console.error(...stamp('ERROR', args)),
+  ...baseLogger(),
+  child: (label) => baseLogger(label),
 };

server/src/services/assignmentService.js

@@ -0,0 +1,135 @@
+const io = require('../globals/io');
+const logger = require('../globals/logger').child('assignment');
+const { MODES, getMode, modeEvents } = require('./modeManager');
+const { roleEvents, getRole, isAdmin } = require('./roleService');
+const roverManager = require('./roverManager');
+
+const socketRefs = new Map(); // socketId -> socket
+const assignments = new Map(); // socketId -> roverId
+const waiting = new Set(); // socketIds waiting for placement
+
+io.on('connection', (socket) => {
+  socketRefs.set(socket.id, socket);
+  socket.on('disconnect', () => {
+    socketRefs.delete(socket.id);
+    unassignSocket(socket);
+  });
+});
+
+roleEvents.on('change', ({ socket, role }) => {
+  if (!socket || !socket.id) return;
+  if (role === 'user') {
+    assignSocket(socket);
+  } else {
+    unassignSocket(socket);
+  }
+});
+
+modeEvents.on('change', (mode) => {
+  if (mode === MODES.ADMIN || mode === MODES.LOCKDOWN) {
+    // release non-admin drivers
+    for (const [socketId, roverId] of assignments.entries()) {
+      const socket = socketRefs.get(socketId);
+      if (socket && !isAdmin(socket)) {
+        releaseAssignment(socket, roverId);
+      }
+    }
+  }
+  reassignWaiting();
+});
+
+roverManager.managerEvents.on('lock', ({ roverId, locked }) => {
+  if (locked) {
+    reassignFromRover(roverId);
+  } else {
+    reassignWaiting();
+  }
+});
+
+roverManager.managerEvents.on('rover', ({ action }) => {
+  if (action === 'removed' || action === 'upsert') {
+    reassignWaiting();
+  }
+});
+
+function assignSocket(socket) {
+  if (!socket || isAdmin(socket) || getRole(socket) !== 'user') {
+    return;
+  }
+  // avoid double assignment
+  if (assignments.has(socket.id)) {
+    return;
+  }
+  const target = pickRover();
+  if (!target) {
+    waiting.add(socket.id);
+    logger.info('No rover available, user waiting', socket.id);
+    return;
+  }
+  try {
+    roverManager.requestControl(target.id, socket, { allowUser: true });
+    assignments.set(socket.id, target.id);
+    waiting.delete(socket.id);
+    logger.info('Assigned user to rover', socket.id, target.id);
+  } catch (err) {
+    logger.warn('Failed to assign user', err.message);
+    waiting.add(socket.id);
+  }
+}
+
+function unassignSocket(socket) {
+  if (!socket) return;
+  waiting.delete(socket.id);
+  const roverId = assignments.get(socket.id);
+  if (roverId) {
+    roverManager.releaseControl(roverId, socket);
+    assignments.delete(socket.id);
+  }
+}
+
+function reassignFromRover(roverId) {
+  for (const [socketId, rid] of assignments.entries()) {
+    if (rid !== roverId) continue;
+    const socket = socketRefs.get(socketId);
+    if (!socket) {
+      assignments.delete(socketId);
+      continue;
+    }
+    roverManager.releaseControl(rid, socket);
+    assignments.delete(socketId);
+    assignSocket(socket);
+  }
+}
+
+function reassignWaiting() {
+  for (const socketId of Array.from(waiting)) {
+    const socket = socketRefs.get(socketId);
+    if (socket) {
+      assignSocket(socket);
+    } else {
+      waiting.delete(socketId);
+    }
+  }
+}
+
+function releaseAssignment(socket, roverId) {
+  roverManager.releaseControl(roverId, socket);
+  assignments.delete(socket.id);
+  waiting.add(socket.id);
+}
+
+function pickRover() {
+  const mode = getMode();
+  if (mode === MODES.ADMIN || mode === MODES.LOCKDOWN) {
+    return null;
+  }
+  const candidates = Array.from(roverManager.rovers.values()).filter((rover) => {
+    if (!rover || rover.locked) return false;
+    return true;
+  });
+  if (candidates.length === 0) {
+    return null;
+  }
+  candidates.sort((a, b) => a.drivers.size - b.drivers.size);
+  return candidates[0];
+}

server/src/services/authService.js

@@ -1,8 +1,9 @@
 const bcrypt = require('bcrypt');
 const io = require('../globals/io');
+const logger = require('../globals/logger').child('authService');
 const { loadConfig } = require('../helpers/configLoader');
 const { clearLockdownTimer } = require('./lockdownGuard');
-const { setRole, roleEvents } = require('./roleService');
+const { setRole } = require('./roleService');
 
 const config = loadConfig();
 const admins = config.admins || [];
@@ -32,8 +33,10 @@ function isLockdownAdmin(socket) {
 }
 
 io.on('connection', (socket) => {
-  setRole(socket, 'user');
-  socket.emit('auth:role', { role: 'user' });
+  const requestedRole = socket.handshake?.query?.role;
+  const initialRole = requestedRole === 'spectator' ? 'spectator' : 'user';
+  setRole(socket, initialRole);
+  socket.emit('auth:role', { role: initialRole });
   socket.on('auth:login', async ({ username, password }, cb = () => {}) => {
     try {
       const admin = await authenticate(username, password);

server/src/services/httpServer.js

@@ -1,6 +1,6 @@
 const { httpServer } = require('../globals/http');
 const config = require('../globals/config');
-const logger = require('../globals/logger');
+const logger = require('../globals/logger').child('httpServer');
 
 httpServer.listen(config.port, () => {
   logger.info(`Server listening on :${config.port}`);

server/src/services/modeManager.js

@@ -37,6 +37,7 @@ function setMode(nextMode, socket) {
     message: `Server mode set to ${nextMode}`,
   });
   modeEvents.emit('change', currentMode);
+  io.emit('mode', { mode: currentMode });
   return currentMode;
 }
 
@@ -52,6 +53,7 @@ module.exports = {
 };
 
 io.on('connection', (socket) => {
+  socket.emit('mode', { mode: currentMode });
   socket.on('setMode', ({ mode }) => {
     try {
       setMode(mode, socket);

server/src/services/roverConnectionService.js

@@ -1,5 +1,5 @@
 const roverWSS = require('../globals/ws');
-const logger = require('../globals/logger');
+const logger = require('../globals/logger').child('roverConnection');
 const roverManager = require('./roverManager');
 const { sendAlert, COLORS } = require('./alertService');
 const { handleAck } = require('./commandService');

server/src/services/roverManager.js

@@ -1,5 +1,6 @@
+const EventEmitter = require('events');
 const io = require('../globals/io');
-const logger = require('../globals/logger');
+const logger = require('../globals/logger').child('roverManager');
 const { sendAlert, COLORS } = require('./alertService');
 const { parseSensorFrame } = require('../helpers/sensorDecoder');
 const { MODES, getMode } = require('./modeManager');
@@ -9,6 +10,7 @@ const rovers = new Map(); // roverId -> record
 const socketToRovers = new Map(); // socketId -> Set(roverId)
 const spectatorSockets = new Set();
 const turnService = require('./turnService');
+const managerEvents = new EventEmitter();
 
 function ensureRecord(id) {
   if (!rovers.has(id)) {
@@ -37,6 +39,7 @@ function upsertRover(meta, ws) {
     const sock = io.sockets.sockets.get(socketId);
     sock?.join(record.room);
   });
+  managerEvents.emit('rover', { roverId: id, action: 'upsert', record });
   broadcastRoster();
   return record;
 }
@@ -51,6 +54,7 @@ function removeRover(id) {
     sock?.leave(record.room);
   });
   broadcastRoster();
+  managerEvents.emit('rover', { roverId: id, action: 'removed' });
 }
 
 function lockRover(id, locked, actorSocket) {
@@ -66,6 +70,7 @@ function lockRover(id, locked, actorSocket) {
     sendAlert({ color: COLORS.success, title: 'Rover Unlocked', message: `${id} unlocked.` });
   }
   broadcastRoster();
+  managerEvents.emit('lock', { roverId: id, locked: record.locked });
   return record.locked;
 }
 
@@ -115,22 +120,23 @@ function removeSocket(socket) {
   disableSpectator(socket);
 }
 
-function requestControl(roverId, socket) {
+function requestControl(roverId, socket, options = {}) {
+  const { force = false, allowUser = false } = options;
   const record = rovers.get(roverId);
   if (!record) {
     throw new Error('Unknown rover');
   }
-  if (!isAdmin(socket)) {
+  if (!allowUser && !isAdmin(socket)) {
     throw new Error('Only admins can request control');
   }
-  if (record.locked && !isAdmin(socket)) {
+  if (record.locked && !isAdmin(socket) && !allowUser) {
     throw new Error('Rover locked');
   }
   const mode = getMode();
-  if (mode === MODES.ADMIN && !isAdmin(socket)) {
+  if (!allowUser && mode === MODES.ADMIN && !isAdmin(socket)) {
     throw new Error('Admins only');
   }
-  if (mode === MODES.LOCKDOWN && !isAdmin(socket)) {
+  if (!allowUser && mode === MODES.LOCKDOWN && !isAdmin(socket)) {
     throw new Error('Server in lockdown');
   }
   record.drivers.add(socket.id);
@@ -139,7 +145,8 @@ function requestControl(roverId, socket) {
   }
   socketToRovers.get(socket.id).add(roverId);
   socket.join(record.room);
-  turnService.driverAdded(roverId, socket.id);
+  turnService.driverAdded(roverId, socket.id, force && isAdmin(socket));
+  socket.emit('controlGranted', { roverId });
   sendAlert({
     color: COLORS.success,
     title: 'Control Granted',
@@ -188,6 +195,7 @@ module.exports = {
   enableSpectator,
   disableSpectator,
   rovers,
+  managerEvents,
 };
 
 roleEvents.on('change', ({ socket, role }) => {
@@ -204,13 +212,13 @@ io.on('connection', (socket) => {
     enableSpectator(socket);
   }
 
-  socket.on('requestControl', ({ roverId } = {}) => {
+  socket.on('requestControl', ({ roverId, force } = {}) => {
     try {
       const targetId = roverId || Array.from(rovers.keys())[0];
       if (!targetId) {
         throw new Error('No rovers available');
       }
-      requestControl(targetId, socket);
+      requestControl(targetId, socket, { force: Boolean(force) });
       socket.emit('controlGranted', { roverId: targetId });
     } catch (err) {
       sendAlert({ color: COLORS.warn, title: 'Control denied', message: err.message });

server/src/services/turnService.js

@@ -6,12 +6,12 @@ const driverQueues = new Map(); // roverId -> { queue: [], current: socketId, ti
 const activeDrivers = new Map();
 const TURN_DURATION_MS = 60 * 1000;
 
-function driverAdded(roverId, socketId) {
+function driverAdded(roverId, socketId, force) {
   const queue = ensureQueue(roverId);
   if (!queue.queue.includes(socketId)) {
     queue.queue.push(socketId);
   }
-  if (!queue.current) {
+  if (!queue.current || force) {
     queue.current = socketId;
   }
   syncState(roverId);