buttonboxrewardses

server/src/services/assignmentService.js

@@ -213,6 +213,17 @@ function pickRover(socket) {
   return candidates[0];
 }
 
+function rerollAssignments() {
+  const users = Array.from(socketRefs.values()).filter((socket) => socket && getRole(socket) === 'user');
+  users.forEach((socket) => {
+    unassignSocket(socket);
+  });
+  users.forEach((socket) => {
+    assignSocket(socket);
+  });
+  return users.length;
+}
+
 function describeAssignment(socketId) {
   const assignedRoverId = assignments.get(socketId) || null;
   const adminRoverId = assignedRoverId ? null : roverManager.getPrimaryRoverForSocket(socketId);
@@ -230,6 +241,7 @@ module.exports = {
   assignmentEvents,
   describeAssignment,
   forceRelease,
+  rerollAssignments,
   getAssignedRover: (socketId) => assignments.get(socketId) || null,
   moveAssignment: (socket, roverId, { releasePrevious = true } = {}) => {
     if (!socket || !roverId) return;

server/src/services/buttonBoxService.js

@@ -0,0 +1,306 @@
+const fs = require('fs');
+const path = require('path');
+const express = require('express');
+const { app } = require('../globals/http');
+const io = require('../globals/io');
+const logger = require('../globals/logger').child('buttonBoxService');
+const { publishEvent } = require('./eventBus');
+const { getRewardById, pickRandomReward } = require('../rewards');
+const roverManager = require('./roverManager');
+const { issueCommand } = require('./commandService');
+const { sendAlert } = require('./alertService');
+const { sendExternalTyping, sendExternalMessage, sendSystemMessage } = require('./chatService');
+const { setMode, getMode } = require('./modeManager');
+const { getAdminReason, setAdminReason, clearAdminReason } = require('./adminReasonService');
+const assignmentService = require('./assignmentService');
+const {
+  getState: getHomeAssistantState,
+  setEntityState: setHomeAssistantEntityState,
+} = require('./homeAssistantService');
+const { getRequestIp, isLocalNetwork, normalizeIp } = require('../helpers/ipResolver');
+
+const DATA_DIR = path.join(__dirname, '..', '..', 'data');
+const STORE_PATH = path.join(DATA_DIR, 'buttonbox-state.json');
+const BUTTON_COUNT = 4;
+const STORE_VERSION = 1;
+
+let state = null;
+
+function createDefaultButton(id) {
+  return {
+    id,
+    count: 0,
+    rewardId: null,
+    rewardName: null,
+    rewardNumber: null,
+    goal: null,
+    lastIncrementAt: null,
+    lastRewardAt: null,
+  };
+}
+
+function createDefaultState() {
+  return {
+    version: STORE_VERSION,
+    updatedAt: Date.now(),
+    buttons: Array.from({ length: BUTTON_COUNT }, (_, idx) => createDefaultButton(idx + 1)),
+    effects: {},
+  };
+}
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function normalizeLoaded(raw = {}) {
+  const base = createDefaultState();
+  const sourceButtons = Array.isArray(raw.buttons) ? raw.buttons : [];
+  const buttons = base.buttons.map((button, idx) => {
+    const loaded = sourceButtons[idx] || {};
+    return {
+      ...button,
+      count: Number.isFinite(loaded.count) ? Math.max(0, Math.floor(loaded.count)) : 0,
+      rewardId: typeof loaded.rewardId === 'string' ? loaded.rewardId : null,
+      rewardName: typeof loaded.rewardName === 'string' ? loaded.rewardName : null,
+      rewardNumber: Number.isFinite(loaded.rewardNumber) ? Math.floor(loaded.rewardNumber) : null,
+      goal: Number.isFinite(loaded.goal) ? Math.max(1, Math.floor(loaded.goal)) : null,
+      lastIncrementAt: Number.isFinite(loaded.lastIncrementAt) ? loaded.lastIncrementAt : null,
+      lastRewardAt: Number.isFinite(loaded.lastRewardAt) ? loaded.lastRewardAt : null,
+    };
+  });
+
+  const effects = raw.effects && typeof raw.effects === 'object' ? raw.effects : {};
+  return {
+    version: STORE_VERSION,
+    updatedAt: Number.isFinite(raw.updatedAt) ? raw.updatedAt : Date.now(),
+    buttons,
+    effects,
+  };
+}
+
+function writeState() {
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  const next = {
+    ...state,
+    updatedAt: Date.now(),
+  };
+  const tempPath = `${STORE_PATH}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tempPath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+  fs.renameSync(tempPath, STORE_PATH);
+  state = next;
+}
+
+function loadState() {
+  if (state) return state;
+  try {
+    const raw = JSON.parse(fs.readFileSync(STORE_PATH, 'utf8'));
+    state = normalizeLoaded(raw);
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      logger.warn('Failed to load button box store', err.message);
+    }
+    state = createDefaultState();
+  }
+  ensureRewardAssignments();
+  writeState();
+  return state;
+}
+
+function ensureRewardAssignments() {
+  if (!state) return;
+  state.buttons.forEach((button) => {
+    const reward = getRewardById(button.rewardId);
+    if (reward) {
+      button.rewardName = reward.name || null;
+      button.rewardNumber = reward.number;
+      button.goal = reward.goal;
+      if (!Number.isFinite(button.count) || button.count < 0) {
+        button.count = 0;
+      }
+      return;
+    }
+    assignNewReward(button);
+  });
+}
+
+function assignNewReward(button) {
+  const reward = pickRandomReward(button?.rewardId || null) || pickRandomReward(null);
+  if (!reward) {
+    throw new Error('No rewards configured');
+  }
+  button.rewardId = reward.id;
+  button.rewardName = reward.name || null;
+  button.rewardNumber = reward.number;
+  button.goal = reward.goal;
+  button.count = 0;
+}
+
+function buildRewardContext() {
+  return {
+    logger,
+    issueCommand,
+    listOnlineRovers: () => roverManager.getRoster(),
+    sendAlert,
+    publishEvent,
+    sendExternalTyping,
+    sendExternalMessage,
+    sendSystemMessage,
+    getMode,
+    setMode: (mode, source = 'buttonbox') =>
+      setMode(
+        mode,
+        { data: { role: 'admin', user: { username: source } } },
+        { force: true },
+      ),
+    getAdminReasonText: () => getAdminReason()?.text || null,
+    setAdminReason: (text, source = 'buttonbox') => setAdminReason(text, { by: source }),
+    clearAdminReason: (source = 'buttonbox') => clearAdminReason({ by: source }),
+    rerollAssignments: () => assignmentService.rerollAssignments(),
+    getHomeAssistantEntities: () => {
+      const entities = getHomeAssistantState()?.entities;
+      return Array.isArray(entities) ? entities : [];
+    },
+    setHomeAssistantEntityState,
+    saveEffect: (effectId, payload = {}) => saveEffect(effectId, payload, { broadcast: false }),
+    clearEffect: (effectId) => clearEffect(effectId, { broadcast: false }),
+  };
+}
+
+function getButtonBoxState() {
+  loadState();
+  return clone({ buttons: state.buttons });
+}
+
+function publishUpdated() {
+  publishEvent({
+    source: 'buttonBox',
+    type: 'buttonBox.updated',
+    payload: { updatedAt: Date.now() },
+  });
+}
+
+function saveEffect(effectId, payload = {}, options = {}) {
+  loadState();
+  state.effects = state.effects && typeof state.effects === 'object' ? state.effects : {};
+  state.effects[effectId] = payload;
+  writeState();
+  if (options.broadcast) {
+    publishUpdated();
+  }
+}
+
+function clearEffect(effectId, options = {}) {
+  loadState();
+  if (state.effects && typeof state.effects === 'object' && state.effects[effectId]) {
+    delete state.effects[effectId];
+    writeState();
+    if (options.broadcast) {
+      publishUpdated();
+    }
+  }
+}
+
+function parseButtonId(body) {
+  if (typeof body !== 'string') return null;
+  const value = Number.parseInt(body.trim(), 10);
+  if (Number.isFinite(value)) return value;
+  return null;
+}
+
+function denyIfNotLocal(req, res) {
+  const ip = normalizeIp(getRequestIp(req));
+  if (isLocalNetwork(ip)) {
+    return false;
+  }
+  logger.warn('Rejected non-local button press request', { ip: ip || null });
+  res.status(403).json({ error: 'Button presses must originate from local network' });
+  return true;
+}
+
+async function runRewardForButton(button) {
+  const reward = getRewardById(button.rewardId);
+  if (!reward) {
+    assignNewReward(button);
+    return;
+  }
+  const ctx = buildRewardContext();
+  try {
+    await reward.run(ctx);
+  } catch (err) {
+    logger.warn('Reward execution failed', { rewardId: reward.id, error: err.message });
+  }
+  button.lastRewardAt = Date.now();
+  button.count = 0;
+  assignNewReward(button);
+}
+
+async function applyPress(buttonId) {
+  loadState();
+  const button = state.buttons.find((entry) => entry.id === buttonId);
+  if (!button) {
+    throw new Error('Unknown button');
+  }
+
+  button.count += 1;
+  button.lastIncrementAt = Date.now();
+  writeState();
+
+  io.emit('buttonBox:increment', {
+    buttonId,
+    count: button.count,
+    ts: button.lastIncrementAt,
+  });
+
+  if (button.count >= button.goal) {
+    await runRewardForButton(button);
+    writeState();
+  }
+
+  publishUpdated();
+  return clone(button);
+}
+
+async function recoverEffects() {
+  loadState();
+  const effects = state.effects && typeof state.effects === 'object' ? { ...state.effects } : {};
+  const ctx = buildRewardContext();
+
+  for (const [effectId, payload] of Object.entries(effects)) {
+    const reward = getRewardById(effectId);
+    if (!reward || typeof reward.recover !== 'function') {
+      clearEffect(effectId, { broadcast: false });
+      continue;
+    }
+    try {
+      await reward.recover(ctx, payload);
+    } catch (err) {
+      logger.warn('Effect recovery failed', { effectId, error: err.message });
+      clearEffect(effectId, { broadcast: false });
+    }
+  }
+  publishUpdated();
+}
+
+app.post('/buttonbox/press', express.text({ type: 'text/plain' }), async (req, res) => {
+  if (denyIfNotLocal(req, res)) return;
+  const buttonId = parseButtonId(req.body);
+  if (!Number.isFinite(buttonId) || buttonId < 1 || buttonId > BUTTON_COUNT) {
+    res.status(400).json({ error: 'button must be 1-4' });
+    return;
+  }
+  try {
+    const button = await applyPress(buttonId);
+    res.json({ success: true, button });
+  } catch (err) {
+    res.status(500).json({ error: err.message || 'Button processing failed' });
+  }
+});
+
+loadState();
+recoverEffects().catch((err) => {
+  logger.warn('Button box effect recovery failed', err.message);
+});
+
+module.exports = {
+  getButtonBoxState,
+};

server/src/services/discordBotService.js

@@ -1492,6 +1492,21 @@ function handleBusEvent(event) {
       });
       break;
     }
+    case 'buttonBox.discordStalkerPing': {
+      const message = payload?.message ? String(payload.message) : 'Button box chaos reward triggered.';
+      const stalkerRoleId = roles.stalkerPing || null;
+      const content = stalkerRoleId ? `<@&${stalkerRoleId}> ${message}` : message;
+      announce({
+        channelId: channels.general,
+        pingRoleId: stalkerRoleId,
+        content,
+        color: 0xe91e63,
+        title: 'Button Box Reward',
+        description: message,
+        includeSiteUrl: false,
+      });
+      break;
+    }
     default:
       break;
   }

server/src/services/sessionService.js

@@ -28,6 +28,7 @@ const { subscribe } = require('./eventBus');
 const { getSocketIp, isLocalNetwork } = require('../helpers/ipResolver');
 const { getAudioForwardState, audioForwardEvents } = require('./audioForwardService');
 const { getAudioLevels, audioLevelsEvents } = require('./audioLevelsService');
+const { getButtonBoxState } = require('./buttonBoxService');
 
 const config = loadConfig();
 const discordInvite = config.discord?.invite || null;
@@ -136,6 +137,7 @@ function buildSession(socket) {
     isVerified: Boolean(socket?.data?.isVerified),
     audioForward: getAudioForwardState(),
     audioLevels: getAudioLevels(),
+    buttonBox: getButtonBoxState(),
   };
 }
 
@@ -318,6 +320,10 @@ subscribe('adminReason.updated', () => {
   syncAll();
 });
 
+subscribe('buttonBox.updated', () => {
+  syncAll();
+});
+
 audioForwardEvents.on('change', () => {
   syncAll();
 });