modularize code, add dummy version of roverd

server/src/globals/config.js

@@ -0,0 +1,6 @@
+const path = require('path');
+
+module.exports = {
+  port: process.env.PORT || 8080,
+  staticDir: path.join(__dirname, '..', '..', 'public'),
+};

server/src/globals/http.js

@@ -0,0 +1,14 @@
+const path = require('path');
+const http = require('http');
+const express = require('express');
+const morgan = require('morgan');
+const config = require('./config');
+
+const app = express();
+app.use(morgan('dev'));
+app.use(express.json());
+app.use(express.static(config.staticDir));
+
+const httpServer = http.createServer(app);
+
+module.exports = { app, httpServer };

server/src/globals/io.js

@@ -0,0 +1,8 @@
+const { Server: SocketIOServer } = require('socket.io');
+const { httpServer } = require('./http');
+
+const io = new SocketIOServer(httpServer, {
+  cors: { origin: '*' },
+});
+
+module.exports = io;

server/src/globals/logger.js

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

server/src/globals/ws.js

@@ -0,0 +1,21 @@
+const { WebSocketServer } = require('ws');
+const { httpServer } = require('./http');
+const logger = require('./logger');
+
+const roverWSS = new WebSocketServer({ noServer: true });
+
+httpServer.on('upgrade', (req, socket, head) => {
+  if (req.url.startsWith('/rover')) {
+    roverWSS.handleUpgrade(req, socket, head, (ws) => {
+      roverWSS.emit('connection', ws, req);
+    });
+  } else {
+    socket.destroy();
+  }
+});
+
+roverWSS.on('connection', () => {
+  logger.info('Rover websocket connected');
+});
+
+module.exports = roverWSS;

server/src/index.js

@@ -1,185 +0,0 @@
-const http = require('http');
-const path = require('path');
-const express = require('express');
-const morgan = require('morgan');
-const { Server: SocketIOServer } = require('socket.io');
-const { WebSocketServer } = require('ws');
-const { v4: uuidv4 } = require('uuid');
-const { parseSensorFrame } = require('./sensorDecoder');
-
-const PORT = process.env.PORT || 8080;
-
-const app = express();
-app.use(morgan('dev'));
-app.use(express.json());
-app.use(express.static(path.join(__dirname, '..', 'public')));
-
-const httpServer = http.createServer(app);
-const io = new SocketIOServer(httpServer, {
-  cors: { origin: '*' },
-});
-
-const roverWSS = new WebSocketServer({ noServer: true });
-const rovers = new Map();
-const pendingCommands = new Map();
-
-httpServer.on('upgrade', (req, socket, head) => {
-  if (req.url.startsWith('/rover')) {
-    roverWSS.handleUpgrade(req, socket, head, (ws) => {
-      roverWSS.emit('connection', ws, req);
-    });
-  } else {
-    socket.destroy();
-  }
-});
-
-roverWSS.on('connection', (ws) => {
-  handleRoverConnection(ws);
-});
-
-function handleRoverConnection(ws) {
-  let roverId = null;
-  ws.on('message', (raw) => {
-    let msg;
-    try {
-      msg = JSON.parse(raw.toString());
-    } catch (err) {
-      return;
-    }
-
-    switch (msg.type) {
-      case 'hello':
-        roverId = msg.name;
-        rovers.set(roverId, {
-          id: roverId,
-          ws,
-          meta: msg,
-          lastSensor: null,
-          lastSeen: Date.now(),
-        });
-        broadcastRoster();
-        break;
-      case 'sensor':
-        if (!roverId || !rovers.has(roverId)) {
-          return;
-        }
-        const rover = rovers.get(roverId);
-        const decoded = parseSensorFrame(msg.data);
-        rover.lastSensor = { raw: msg, decoded };
-        rover.lastSeen = Date.now();
-        io.emit('sensorFrame', { roverId, frame: msg, sensors: decoded });
-        break;
-      case 'ack':
-        if (msg.id && pendingCommands.has(msg.id)) {
-          const pending = pendingCommands.get(msg.id);
-          pendingCommands.delete(msg.id);
-          io.emit('commandAck', { roverId: pending.roverId, id: msg.id, status: msg.status, error: msg.error });
-        }
-        break;
-      case 'event':
-        if (!roverId) {
-          return;
-        }
-        io.emit('roverEvent', {
-          roverId,
-          event: msg.event,
-          ts: msg.ts || Date.now(),
-          data: msg.data || {},
-        });
-        break;
-      default:
-        break;
-    }
-  });
-
-  ws.on('close', () => {
-    if (roverId) {
-      rovers.delete(roverId);
-      broadcastRoster();
-    }
-  });
-}
-
-io.on('connection', (socket) => {
-  socket.emit('rovers', getRoster());
-
-  socket.on('command', (payload = {}, cb = () => {}) => {
-    try {
-      const commandId = routeCommand(payload);
-      cb({ id: commandId });
-    } catch (err) {
-      cb({ error: err.message });
-    }
-  });
-});
-
-function getRoster() {
-  return Array.from(rovers.values()).map(({ id, meta, lastSeen }) => ({
-    id,
-    name: meta?.name ?? id,
-    battery: meta?.battery ?? null,
-    maxWheelSpeed: meta?.maxWheelSpeed ?? null,
-    media: meta?.media ?? null,
-    lastSeen,
-  }));
-}
-
-function broadcastRoster() {
-  io.emit('rovers', getRoster());
-}
-
-function routeCommand(payload) {
-  const { roverId, type, data } = payload;
-  if (!roverId) {
-    throw new Error('roverId missing');
-  }
-  if (!rovers.has(roverId)) {
-    throw new Error(`rover ${roverId} not connected`);
-  }
-  const rover = rovers.get(roverId);
-  const message = buildCommand(type, data);
-  const id = uuidv4();
-  message.id = id;
-  rover.ws.send(JSON.stringify(message));
-  pendingCommands.set(id, { roverId, issuedAt: Date.now(), type });
-  return id;
-}
-
-function buildCommand(type, data = {}) {
-  switch (type) {
-    case 'drive':
-      return { type: 'drive', driveDirect: { left: data.left || 0, right: data.right || 0 } };
-    case 'motors':
-      return {
-        type: 'motors',
-        motorPwm: {
-          main: data.main ?? 0,
-          side: data.side ?? 0,
-          vacuum: data.vacuum ?? 0,
-        },
-      };
-    case 'raw':
-      return { type: 'raw', raw: Buffer.from(data.bytes || []).toString('base64') };
-    case 'sensorStream':
-      return { type: 'sensorStream', sensorStream: { enable: Boolean(data.enable) } };
-    case 'media':
-      if (!data || !data.action) {
-        throw new Error('media action required');
-      }
-      return { type: 'media', media: { action: data.action } };
-    default:
-      throw new Error(`unknown command type: ${type}`);
-  }
-}
-
-if (require.main === module) {
-  httpServer.listen(PORT, () => {
-    console.log(`Server listening on :${PORT}`);
-  });
-}
-
-module.exports = {
-  httpServer,
-  io,
-  routeCommand,
-};

server/src/services/alertService.js

@@ -0,0 +1,23 @@
+const io = require('../globals/io');
+
+const COLORS = {
+  info: '#2196f3',
+  success: '#4caf50',
+  warn: '#f0b651',
+  error: '#e53935',
+};
+
+function sendAlert({ color, title, message, ts = Date.now() }) {
+  const payload = {
+    color: color || COLORS.info,
+    title,
+    message,
+    ts,
+  };
+  io.emit('alert', payload);
+}
+
+module.exports = {
+  COLORS,
+  sendAlert,
+};

server/src/services/authService.js

@@ -0,0 +1,12 @@
+function isAdmin(/* socket */) {
+  return false;
+}
+
+function isLockdownAdmin(/* socket */) {
+  return false;
+}
+
+module.exports = {
+  isAdmin,
+  isLockdownAdmin,
+};

server/src/services/commandService.js

@@ -0,0 +1,53 @@
+const { v4: uuidv4 } = require('uuid');
+const io = require('../globals/io');
+const roverManager = require('./roverManager');
+const { isAdmin } = require('./authService');
+
+const pendingCommands = new Map(); // id -> { roverId }
+
+function issueCommand(roverId, payload) {
+  const record = roverManager.rovers.get(roverId);
+  if (!record || !record.ws) {
+    throw new Error('Rover offline');
+  }
+  const id = uuidv4();
+  const message = { ...payload, id };
+  record.ws.send(JSON.stringify(message));
+  pendingCommands.set(id, { roverId, ts: Date.now(), type: payload.type });
+  return id;
+}
+
+function handleAck(msg) {
+  const pending = pendingCommands.get(msg.id);
+  if (!pending) return;
+  pendingCommands.delete(msg.id);
+  io.emit('commandAck', {
+    roverId: pending.roverId,
+    id: msg.id,
+    status: msg.status || 'ok',
+    error: msg.error,
+  });
+}
+
+module.exports = {
+  issueCommand,
+  handleAck,
+};
+
+io.on('connection', (socket) => {
+  socket.on('command', ({ roverId, type, data } = {}, cb = () => {}) => {
+    try {
+      if (!roverId) {
+        throw new Error('roverId required');
+      }
+      if (!roverManager.isDriver(roverId, socket) && !isAdmin(socket)) {
+        throw new Error('Not controlling this rover');
+      }
+      const payload = data ? { ...data } : {};
+      const id = issueCommand(roverId, { type, ...payload });
+      cb({ id });
+    } catch (err) {
+      cb({ error: err.message });
+    }
+  });
+});

server/src/services/httpServer.js

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

server/src/services/modeManager.js

@@ -0,0 +1,58 @@
+const io = require('../globals/io');
+const { sendAlert, COLORS } = require('./alertService');
+const { isAdmin, isLockdownAdmin } = require('./authService');
+
+const MODES = {
+  OPEN: 'open',
+  TURNS: 'turns',
+  ADMIN: 'admin',
+  LOCKDOWN: 'lockdown',
+};
+
+let currentMode = MODES.OPEN;
+
+function canChangeMode(socket, nextMode) {
+  if (nextMode === MODES.LOCKDOWN) {
+    return isLockdownAdmin(socket);
+  }
+  return isAdmin(socket);
+}
+
+function setMode(nextMode, socket) {
+  if (!Object.values(MODES).includes(nextMode)) {
+    throw new Error(`Unknown mode ${nextMode}`);
+  }
+  if (!canChangeMode(socket, nextMode)) {
+    throw new Error('Not authorized to change mode');
+  }
+  if (currentMode === nextMode) {
+    return currentMode;
+  }
+  currentMode = nextMode;
+  sendAlert({
+    color: COLORS.info,
+    title: 'Mode Changed',
+    message: `Server mode set to ${nextMode}`,
+  });
+  return currentMode;
+}
+
+function getMode() {
+  return currentMode;
+}
+
+module.exports = {
+  MODES,
+  getMode,
+  setMode,
+};
+
+io.on('connection', (socket) => {
+  socket.on('setMode', ({ mode }) => {
+    try {
+      setMode(mode, socket);
+    } catch (err) {
+      sendAlert({ color: COLORS.error, title: 'Mode change failed', message: err.message });
+    }
+  });
+});

server/src/services/roverConnectionService.js

@@ -0,0 +1,57 @@
+const roverWSS = require('../globals/ws');
+const logger = require('../globals/logger');
+const roverManager = require('./roverManager');
+const { sendAlert, COLORS } = require('./alertService');
+const { handleAck } = require('./commandService');
+
+function handleMessage(roverId, msg) {
+  switch (msg.type) {
+    case 'hello':
+      roverManager.upsertRover(msg, this);
+      sendAlert({ color: COLORS.info, title: 'Rover Connected', message: roverId });
+      break;
+    case 'sensor':
+      roverManager.handleSensorFrame(roverId, msg);
+      break;
+    case 'event':
+      sendAlert({ color: COLORS.info, title: `${roverId} event`, message: msg.event });
+      break;
+    default:
+      break;
+  }
+}
+
+roverWSS.on('connection', (ws) => {
+  let roverId = null;
+  ws.on('message', (raw) => {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch (err) {
+      logger.warn('Invalid rover message', err.message);
+      return;
+    }
+    if (msg.type === 'hello') {
+      roverId = msg.name;
+      roverManager.upsertRover(msg, ws);
+      roverManager.broadcastRoster();
+      sendAlert({ color: COLORS.success, title: 'Rover Online', message: roverId });
+      return;
+    }
+    if (!roverId) return;
+    if (msg.type === 'sensor') {
+      roverManager.handleSensorFrame(roverId, msg);
+    } else if (msg.type === 'ack') {
+      handleAck(msg);
+    } else if (msg.type === 'event') {
+      sendAlert({ color: COLORS.info, title: `${roverId}`, message: msg.event });
+    }
+  });
+
+  ws.on('close', () => {
+    if (roverId) {
+      roverManager.removeRover(roverId);
+      sendAlert({ color: COLORS.warn, title: 'Rover Offline', message: roverId });
+    }
+  });
+});

server/src/services/roverManager.js

@@ -0,0 +1,203 @@
+const io = require('../globals/io');
+const logger = require('../globals/logger');
+const { sendAlert, COLORS } = require('./alertService');
+const { parseSensorFrame } = require('../helpers/sensorDecoder');
+const { MODES, getMode } = require('./modeManager');
+const { isAdmin } = require('./authService');
+
+const rovers = new Map(); // roverId -> record
+const socketToRovers = new Map(); // socketId -> Set(roverId)
+
+function ensureRecord(id) {
+  if (!rovers.has(id)) {
+    rovers.set(id, {
+      id,
+      meta: null,
+      ws: null,
+      lastSensor: null,
+      drivers: new Set(),
+      locked: false,
+      room: `rover:${id}`,
+      lastSeen: Date.now(),
+    });
+  }
+  return rovers.get(id);
+}
+
+function upsertRover(meta, ws) {
+  const id = meta.name || meta.id;
+  const record = ensureRecord(id);
+  record.meta = meta;
+  record.ws = ws;
+  record.lastSeen = Date.now();
+  rovers.set(id, record);
+  broadcastRoster();
+  return record;
+}
+
+function removeRover(id) {
+  const record = rovers.get(id);
+  if (!record) return;
+  rovers.delete(id);
+  broadcastRoster();
+}
+
+function lockRover(id, locked, actorSocket) {
+  const record = rovers.get(id);
+  if (!record) {
+    throw new Error('Unknown rover');
+  }
+  if (locked) {
+    record.locked = true;
+    sendAlert({ color: COLORS.warn, title: 'Rover Locked', message: `${id} locked by admin.` });
+  } else {
+    record.locked = false;
+    sendAlert({ color: COLORS.success, title: 'Rover Unlocked', message: `${id} unlocked.` });
+  }
+  broadcastRoster();
+  return record.locked;
+}
+
+function getRoster() {
+  return Array.from(rovers.values()).map((record) => ({
+    id: record.id,
+    name: record.meta?.name || record.id,
+    battery: record.meta?.battery,
+    maxWheelSpeed: record.meta?.maxWheelSpeed,
+    media: record.meta?.media,
+    locked: record.locked,
+    lastSeen: record.lastSeen,
+  }));
+}
+
+function broadcastRoster() {
+  io.emit('rovers', getRoster());
+}
+
+function handleSensorFrame(roverId, frame) {
+  const record = rovers.get(roverId);
+  if (!record) return;
+  record.lastSeen = Date.now();
+  const decoded = parseSensorFrame(frame.data);
+  record.lastSensor = { raw: frame, decoded };
+  io.to(record.room).emit('sensorFrame', {
+    roverId,
+    frame,
+    sensors: decoded,
+  });
+}
+
+function removeSocket(socket) {
+  const joined = socketToRovers.get(socket.id);
+  if (!joined) return;
+  for (const roverId of joined) {
+    const record = rovers.get(roverId);
+    if (record) {
+      record.drivers.delete(socket.id);
+    }
+  }
+  socketToRovers.delete(socket.id);
+}
+
+function requestControl(roverId, socket) {
+  const record = rovers.get(roverId);
+  if (!record) {
+    throw new Error('Unknown rover');
+  }
+  if (record.locked && !isAdmin(socket)) {
+    throw new Error('Rover locked');
+  }
+  const mode = getMode();
+  if (mode === MODES.ADMIN && !isAdmin(socket)) {
+    throw new Error('Admins only');
+  }
+  if (mode === MODES.LOCKDOWN && !isAdmin(socket)) {
+    throw new Error('Server in lockdown');
+  }
+  // TODO: future turns logic
+  record.drivers.add(socket.id);
+  if (!socketToRovers.has(socket.id)) {
+    socketToRovers.set(socket.id, new Set());
+  }
+  socketToRovers.get(socket.id).add(roverId);
+  socket.join(record.room);
+  sendAlert({
+    color: COLORS.success,
+    title: 'Control Granted',
+    message: `${socket.id} now driving ${roverId}`,
+  });
+  return { roverId, room: record.room };
+}
+
+function releaseControl(roverId, socket) {
+  const record = rovers.get(roverId);
+  if (!record) return;
+  record.drivers.delete(socket.id);
+  const joined = socketToRovers.get(socket.id);
+  if (joined) {
+    joined.delete(roverId);
+    if (joined.size === 0) {
+      socketToRovers.delete(socket.id);
+    }
+  }
+  socket.leave(record.room);
+}
+
+function isDriver(roverId, socket) {
+  const record = rovers.get(roverId);
+  if (!record) return false;
+  return record.drivers.has(socket.id);
+}
+
+module.exports = {
+  upsertRover,
+  removeRover,
+  lockRover,
+  getRoster,
+  broadcastRoster,
+  handleSensorFrame,
+  requestControl,
+  releaseControl,
+  removeSocket,
+  isDriver,
+  rovers,
+};
+
+io.on('connection', (socket) => {
+  socket.on('requestControl', ({ roverId } = {}) => {
+    try {
+      const targetId = roverId || Array.from(rovers.keys())[0];
+      if (!targetId) {
+        throw new Error('No rovers available');
+      }
+      requestControl(targetId, socket);
+      socket.emit('controlGranted', { roverId: targetId });
+    } catch (err) {
+      sendAlert({ color: COLORS.warn, title: 'Control denied', message: err.message });
+    }
+  });
+
+  socket.on('releaseControl', ({ roverId }) => {
+    if (!roverId) return;
+    releaseControl(roverId, socket);
+  });
+
+  socket.on('lockRover', ({ roverId, locked }) => {
+    if (!isAdmin(socket)) return;
+    try {
+      lockRover(roverId, locked);
+    } catch (err) {
+      sendAlert({ color: COLORS.error, title: 'Lock failed', message: err.message });
+    }
+  });
+
+  socket.on('subscribeAll', () => {
+    for (const record of rovers.values()) {
+      socket.join(record.room);
+    }
+  });
+
+  socket.on('disconnect', () => {
+    removeSocket(socket);
+  });
+});