move from /pi to /rover because it isnt just pi anymore.

new json config stuff and ui
This commit is contained in:
legop3
2026-11-16 17:45:38 -05:00
parent 6b57ac1725
commit 9b6bdec116
110 changed files with 2695 additions and 1202 deletions
+1
View File
@@ -28,6 +28,7 @@ require('./src/services/roverManager');
require('./src/services/roverHelpService');
require('./src/services/commandService');
require('./src/services/roverConnectionService');
require('./src/services/roverManagementService');
require('./src/services/assignmentService');
require('./src/services/roverRebootService');
require('./src/services/nicknameService');
+8 -3
View File
@@ -5,11 +5,14 @@ const { httpServer } = require('./http');
const logger = require('./logger');
const roverWSS = new WebSocketServer({ noServer: true });
const managementWSS = new WebSocketServer({ noServer: true, maxPayload: 1024 * 1024 });
httpServer.on('upgrade', (req, socket, head) => {
if (req.url.startsWith('/rover')) {
roverWSS.handleUpgrade(req, socket, head, (ws) => {
roverWSS.emit('connection', ws, req);
const path = new URL(req.url, 'http://localhost').pathname;
const target = path === '/rover/management' ? managementWSS : path === '/rover' ? roverWSS : null;
if (target) {
target.handleUpgrade(req, socket, head, (ws) => {
target.emit('connection', ws, req);
});
}
});
@@ -19,3 +22,5 @@ roverWSS.on('connection', () => {
});
module.exports = roverWSS;
module.exports.managementWSS = managementWSS;
+13 -4
View File
@@ -2,6 +2,7 @@
// Purpose: Defines the command Service module and the helpers/state used by this service unit.
// Scope: Keeps runtime behavior unchanged while isolating responsibilities into a clear module boundary.
const { v4: uuidv4 } = require('uuid');
const roverManagement = require('../roverManagementService');
const EventEmitter = require('events');
const io = require('../../globals/io');
const roverManager = require('../roverManager');
@@ -86,6 +87,9 @@ function normalizeOutboundCommandPayload(payload = {}) {
}
function issueCommand(roverId, payload, options = {}) {
if (['reboot', 'update', 'media'].includes(payload?.type)) {
return roverManagement.issueCommand(roverId, payload);
}
const record = roverManager.rovers.get(roverId);
if (!record || !record.ws) {
throw new Error('Rover offline');
@@ -168,10 +172,10 @@ function issueUpdateToAllRovers() {
const updated = [];
const failed = [];
roverManager.rovers.forEach((record) => {
roverManagement.rovers.forEach((record) => {
if (!record?.ws) return;
const roverId = String(record.id);
const roverId = String(record.roverId);
try {
// Use the same narrow update payload as the per-rover admin action. The
// browser only asks for "update all"; the Pi still owns the privileged
@@ -304,6 +308,7 @@ function submitCommand(socket, { roverId, type, data } = {}, cb) {
}
const isRebootCommand = type === 'reboot';
const isUpdateCommand = type === 'update';
const isManagementCommand = isRebootCommand || isUpdateCommand || type === 'media';
const isSongCommand = type === 'song' || (type === 'raw' && isSongRawPayload(payload));
const isAdminSocket = isAdmin(socket);
if (!isAdminSocket && isDeterred(socket)) {
@@ -321,10 +326,14 @@ function submitCommand(socket, { roverId, type, data } = {}, cb) {
// in the same explicit admin-only branch as reboot instead of relying on
// drive ownership checks, because having a turn should not grant system
// maintenance privileges.
if ((isRebootCommand || isUpdateCommand) && !isAdminSocket) {
if (isManagementCommand && !isAdminSocket) {
throw new Error('Not authorized');
}
if (!isSongCommand && !isRebootCommand && !isUpdateCommand && !roverManager.canDrive(roverId, socket)) {
if (isManagementCommand) {
reply({ id: issueCommand(roverId, { ...payload, type }) });
return;
}
if (!isSongCommand && !roverManager.canDrive(roverId, socket)) {
throw new Error('Not your turn or no control');
}
const record = roverManager.rovers.get(roverId);
@@ -41,32 +41,6 @@ function handleToggleEvent(roverId, msg) {
return false;
}
function handleMessage(roverId, msg) {
switch (msg.type) {
case 'hello':
roverManager.upsertRover(msg, this);
sendAlert({ color: ALERT_COLOR, title: 'Rover Connected', message: roverId });
break;
case 'sensor':
roverManager.handleSensorFrame(roverId, msg);
break;
case 'hostStats':
// Host stats are periodic Pi metadata, not user-facing rover events, so
// they are routed directly to roverManager instead of becoming alerts.
roverManager.handleHostStats(roverId, msg);
break;
case 'event': {
if (handleToggleEvent(roverId, msg)) {
break;
}
sendAlert({ color: ALERT_COLOR, title: `${roverId} event`, message: msg.event });
break;
}
default:
break;
}
}
roverWSS.on('connection', (ws) => {
let roverId = null;
ws.isAlive = true;
@@ -109,16 +83,10 @@ roverWSS.on('connection', (ws) => {
if (!roverId) return;
if (msg.type === 'sensor') {
roverManager.handleSensorFrame(roverId, msg);
} else if (msg.type === 'hostStats') {
// Keep the Pi health stream separate from both Roomba sensorFrame data
// and generic rover events, which are surfaced as alerts.
roverManager.handleHostStats(roverId, msg);
} else if (msg.type === 'ack') {
handleAck(msg);
} else if (msg.type === 'event') {
if (!handleToggleEvent(roverId, msg)) {
sendAlert({ color: ALERT_COLOR, title: `${roverId}`, message: msg.event });
}
handleToggleEvent(roverId, msg);
}
});
@@ -0,0 +1,184 @@
const { randomUUID } = require('node:crypto');
const io = require('../../globals/io');
const { managementWSS } = require('../../globals/ws');
const { isAdmin } = require('../roleService');
const { sendAlert } = require('../alertService');
const logger = require('../../globals/logger').child('roverManagement');
// Management availability is independent of the control roster: a rover with
// failed hardware must still be configurable. All state here is memory-only.
const rovers = new Map();
const pending = new Map();
const MAX_MESSAGE_BYTES = 1024 * 1024;
function snapshot(record) {
return {
roverId: record.roverId,
config: record.config,
schema: record.schema,
profiles: record.profiles,
hostStats: record.hostStats || null,
notices: record.notices,
};
}
function notifyAdmins(event, value) {
for (const socket of io.sockets.sockets.values()) {
if (isAdmin(socket)) socket.emit(event, value);
}
}
function finish(id, error, ack) {
const item = pending.get(id);
if (!item) return;
clearTimeout(item.timer);
pending.delete(id);
if (error) item.reject(error); else item.resolve(ack);
}
function request(roverId, payload) {
const record = rovers.get(String(roverId));
if (!record || record.ws.readyState !== 1) throw new Error('Rover management offline');
const id = randomUUID();
const data = JSON.stringify({ ...payload, id });
if (Buffer.byteLength(data) > MAX_MESSAGE_BYTES) throw new Error('Management request too large');
const result = new Promise((resolve, reject) => {
const timer = setTimeout(() => finish(id, new Error('Rover management acknowledgement timed out')), 30000);
pending.set(id, { roverId: record.roverId, ws: record.ws, resolve, reject, timer });
try {
record.ws.send(data, (error) => { if (error) finish(id, error); });
} catch (error) { finish(id, error); }
});
return { id, result };
}
// Existing reboot/update callers retain their permission gates and commandAck
// UI, but transport and acknowledgement ownership now live on management.
function issueCommand(roverId, payload) {
const { id, result } = request(roverId, payload);
result.then(
() => io.emit('commandAck', { roverId, id, status: 'ok' }),
(error) => io.emit('commandAck', { roverId, id, status: 'error', error: error.message }),
);
return id;
}
managementWSS.on('connection', (ws) => {
let record;
let alive = true;
const helloTimeout = setTimeout(() => ws.terminate(), 10000);
const heartbeat = setInterval(() => {
if (!alive) return ws.terminate();
alive = false;
ws.ping();
}, 15000);
ws.on('pong', () => { alive = true; });
ws.on('error', (error) => logger.warn('Management socket error', error.message));
ws.on('message', (raw) => {
alive = true;
try {
const msg = JSON.parse(raw.toString());
if (msg.type === 'hello' && !record) {
if (typeof msg.name !== 'string' || !msg.name || !msg.config || !msg.schema) throw new Error('Invalid management hello');
clearTimeout(helloTimeout);
const previous = rovers.get(msg.name);
record = { roverId: msg.name, ws, config: msg.config, schema: msg.schema, profiles: msg.profiles, notices: [] };
rovers.set(record.roverId, record);
previous?.ws.close(1000, 'Replaced by new connection');
notifyAdmins('roverManagement:changed', snapshot(record));
return;
}
if (!record || rovers.get(record.roverId) !== record) return;
if (msg.type === 'ack') {
if (pending.get(msg.id)?.ws !== ws) return;
finish(msg.id, msg.status === 'ok' ? null : new Error(msg.error || 'Management action failed'), msg);
} else if (msg.type === 'hostStats') {
record.hostStats = msg;
require('../roverManager').handleHostStats(record.roverId, msg);
notifyAdmins('roverManagement:hostStats', { roverId: record.roverId, ...msg });
} else if (msg.type === 'event') {
record.notices.push(msg);
if (record.notices.length > 100) record.notices.shift();
notifyAdmins('roverManagement:event', { roverId: record.roverId, ...msg });
sendAlert({ color: '#00bcd4', title: record.roverId, message: msg.data?.message || msg.event });
}
} catch (error) {
logger.warn('Invalid management message', error.message);
ws.close(1008, 'Invalid management message');
}
});
ws.on('close', () => {
clearTimeout(helloTimeout);
clearInterval(heartbeat);
for (const [id, item] of pending) {
if (item.ws === ws) finish(id, new Error('Rover management disconnected before acknowledgement'));
}
if (record && rovers.get(record.roverId) === record) {
rovers.delete(record.roverId);
notifyAdmins('roverManagement:offline', { roverId: record.roverId });
}
});
});
io.on('connection', (socket) => {
const bind = (event, handler) => socket.on(event, async (payload = {}, callback) => {
const reply = typeof callback === 'function' ? callback : () => {};
try {
if (!isAdmin(socket)) throw new Error('Not authorized');
reply({ success: true, ...await handler(payload) });
} catch (error) { reply({ error: error.message }); }
});
bind('roverManagement:list', () => ({ rovers: [...rovers.values()].map(snapshot) }));
bind('roverManagement:get', ({ roverId }) => {
const record = rovers.get(String(roverId));
if (!record) throw new Error('Rover management offline');
return snapshot(record);
});
bind('roverManagement:save', async ({ roverId, config }) => {
const { id, result } = request(roverId, { type: 'config.set', config });
await result;
// The next hello is authoritative; do not replace cached state optimistically.
return { id };
});
bind('roverManagement:applyField', async ({ path, value }) => {
if (!Array.isArray(path) || path.length === 0 || value === undefined
|| path.some((key) => typeof key !== 'string' || !key
|| ['__proto__', 'constructor', 'prototype'].includes(key))) {
throw new Error('A nonempty field path and value are required');
}
// Snapshot the connected fleet before any save restarts a rover. Each
// object is independent; never copy one rover's unrelated settings across.
const targets = [...rovers.values()];
const results = await Promise.all(targets.map(async (record) => {
try {
const config = structuredClone(record.config);
let parent = config;
for (const key of path.slice(0, -1)) {
if (!parent || typeof parent !== 'object' || Array.isArray(parent)
|| !Object.hasOwn(parent, key)) throw new Error('Field does not exist on this rover');
parent = parent[key];
}
const key = path.at(-1);
if (!parent || typeof parent !== 'object' || Array.isArray(parent)
|| !Object.hasOwn(parent, key)) throw new Error('Field does not exist on this rover');
parent[key] = structuredClone(value);
// Do not submit a stale snapshot to a replacement connection.
if (rovers.get(record.roverId) !== record) throw new Error('Rover connection changed');
const { id, result } = request(record.roverId, { type: 'config.set', config });
await result;
return { roverId: record.roverId, success: true, id };
} catch (error) {
return { roverId: record.roverId, success: false, error: error.message };
}
}));
return { results };
});
bind('roverManagement:command', async ({ roverId, type, reboot, media }) => {
if (!['reboot', 'update', 'media'].includes(type)) throw new Error('Unsupported management command');
const { id, result } = request(roverId, { type, reboot, media });
await result;
return { id };
});
});
module.exports = { rovers, request, issueCommand };