feat(rust): chat titles, BetterChat group styles, the voice and popups (phase 17)

PLAN.md §33, D134-D143. Protocol 12. - Chat titles (D135-D137): per-server rules (stat, top N, text, colour) that rank the current wipe, and a mode (first | all | up to N). Worked out once in model/titles and read three ways: pushed whole to the game by a new titleSync loop (on change, restart or wipe), and on every leaderboard row as `titles`. Admin: PUT /servers/:id/titles. - Group styles (D138, D139): a site group may carry all twelve BetterChat fields (rust_perm_group_chat). They ride perm.sync with `expect` from the pushed ledger, which gains a value column; a field changed in game is a `chat-field` drift row with the game's value, adopted into the style or put back. A withdrawn style is one `chat-group` retirement, never for `default`, cleared from the ledger only once BetterChat removed it. - The voice (D140): one fleet setting naming a styled group; news and rust.announce chat lines carry its format and the plugin says them with no sender. Admin: GET/PUT /voice. - Popups (D141, D142): rust.announce gains `delivery` (still version 1, from rust.options.delivery); each server gains news_delivery beside the news switch; `popup-unavailable` is not retried. - GET /servers/:id/integrations reads, live, which optional mods a server has loaded. README lists BetterChat and PopupNotifications as optional. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01E14m6SuuY6i1vASFeGDBeY
2026-09-25 17:48:22 -05:00
parent fb5a581a94
commit 1b70cef5be
43 changed files with 3371 additions and 72 deletions
--- a/server/model/titles/titles.db.js
+++ b/server/model/titles/titles.db.js
@@ -0,0 +1,61 @@
+// ── SQL for chat titles (phase 17) ────────────────────────────────────────
+//
+// The rules an operator writes, per server, and the two columns on
+// `rust_servers` that say how many titles a player shows. The titles themselves
+// are never stored — see `schema.sql` and `titles.js`.
+
+const core = require('../../core')
+
+const RULES = 'rust_title_rules'
+const SERVERS = 'rust_servers'
+
+/** One server's rules, in precedence order. */
+async function listRules(serverId) {
+  return core.query(
+    `SELECT id, stat, top_n AS topN, text, color
+       FROM ${RULES}
+      WHERE server_id = ?
+      ORDER BY position ASC, id ASC`,
+    [serverId],
+  )
+}
+
+/** Every server's rules, for the admin list — one read rather than one per server. */
+async function listAllRules() {
+  return core.query(
+    `SELECT server_id AS serverId, stat, top_n AS topN, text, color
+       FROM ${RULES}
+      ORDER BY server_id ASC, position ASC, id ASC`,
+  )
+}
+
+async function getMode(serverId) {
+  const rows = await core.query(
+    `SELECT title_mode AS mode, title_max AS max FROM ${SERVERS} WHERE id = ?`,
+    [serverId],
+  )
+  return rows[0] || null
+}
+
+async function listModes() {
+  return core.query(`SELECT id AS serverId, title_mode AS mode, title_max AS max FROM ${SERVERS}`)
+}
+
+/**
+ * Replace one server's rules and mode whole. The form edits a list, so the
+ * write is a list — and a rule's position is its place in that list.
+ */
+async function saveSettings(serverId, { mode, max, rules }) {
+  await core.query(`UPDATE ${SERVERS} SET title_mode = ?, title_max = ? WHERE id = ?`, [mode, max, serverId])
+  await core.query(`DELETE FROM ${RULES} WHERE server_id = ?`, [serverId])
+
+  if (!rules.length) return
+
+  await core.query(
+    `INSERT INTO ${RULES} (server_id, position, stat, top_n, text, color)
+          VALUES ${rules.map(() => '(?, ?, ?, ?, ?, ?)').join(',')}`,
+    rules.flatMap((r, i) => [serverId, i, r.stat, r.topN, r.text, r.color]),
+  )
+}
+
+module.exports = { RULES, listRules, listAllRules, getMode, listModes, saveSettings }
--- a/server/model/titles/titles.js
+++ b/server/model/titles/titles.js
@@ -0,0 +1,165 @@
+// ── Chat titles, as rules and as a set (phase 17, D135–D137) ───────────────
+//
+// An operator writes rules per server — "#1 kills", "top 3 playtime" — and the
+// site works out who holds each title from the CURRENT wipe's standings. The
+// same answer goes to three places: BetterChat in the game (`titles.set`), the
+// web leaderboard and the app's. So it is worked out here, once, as pure
+// functions of the rules and the standings, and every consumer reads it.
+//
+// Four readings shape it (§33.4):
+//
+//   1. a rule counts only a stat above zero — a fresh wipe gives no titles,
+//      rather than #1 kills to somebody with none
+//   2. ties follow the leaderboard's own order, so a rule's top N is the first
+//      N rows the web shows for that stat
+//   3. a title's text is at most 24 characters, with markup characters taken
+//      out, and its colour is `#rrggbb`
+//   4. the rule order is precedence: `first` shows the first rule a player meets
+
+const crypto = require('node:crypto')
+
+/** The stats a rule may rank, and the leaderboard sort and column each means. */
+const STATS = {
+  kills: { sort: 'kills', value: (row) => row.kills, label: 'kills' },
+  npckills: { sort: 'npcKills', value: (row) => row.npcKills, label: 'NPC kills' },
+  playtime: { sort: 'playtime', value: (row) => row.playtimeSec, label: 'playtime' },
+}
+
+const MODES = ['first', 'all', 'upto']
+
+const MAX_RULES = 10
+const MAX_TOP_N = 10
+const TEXT_MAX = 24
+const MAX_UPTO = 5
+
+/**
+ * An operator's title text, made safe to put in a chat line: the characters
+ * BetterChat's markup and its placeholders are built from are taken out, then
+ * the whitespace is collapsed. `{` and `}` go too, beyond reading 3's four: a
+ * title is substituted into `{Title}` before `{Message}` is, so a title reading
+ * `{Message}` would print the player's words twice.
+ */
+function cleanText(raw) {
+  return String(raw === undefined || raw === null ? '' : raw)
+    .replace(/[[\]<>{}]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/** A mode word, or `first` — the fewest — for one this build does not know. */
+function normaliseMode(mode) {
+  return MODES.includes(mode) ? mode : 'first'
+}
+
+/**
+ * A server's title settings as the admin form sends them, checked whole.
+ *
+ * Resolves `{ ok: true, value: { mode, max, rules } }` with every rule cleaned,
+ * or `{ ok: false, errors }`, one sentence per problem. A text that is empty
+ * AFTER cleaning is refused rather than saved blank, so a title made entirely of
+ * brackets is a sentence on the form and not an empty chip in the game.
+ */
+function validateSettings(body) {
+  const errors = []
+  const input = body || {}
+  const mode = input.mode === undefined ? 'first' : input.mode
+
+  if (!MODES.includes(mode)) errors.push(`mode must be one of ${MODES.join(', ')}`)
+
+  const max = input.max === undefined || input.max === null || input.max === '' ? 2 : Number(input.max)
+  if (!Number.isInteger(max) || max < 1 || max > MAX_UPTO) errors.push(`max must be a whole number from 1 to ${MAX_UPTO}`)
+
+  const rules = Array.isArray(input.rules) ? input.rules : null
+  if (!rules) errors.push('rules must be a list')
+  else if (rules.length > MAX_RULES) errors.push(`a server has at most ${MAX_RULES} title rules`)
+
+  const clean = []
+
+  for (const [i, rule] of (rules || []).entries()) {
+    const n = i + 1
+    const r = rule || {}
+    if (!STATS[r.stat]) errors.push(`rule ${n}: stat must be one of ${Object.keys(STATS).join(', ')}`)
+
+    const topN = Number(r.topN)
+    if (!Number.isInteger(topN) || topN < 1 || topN > MAX_TOP_N) errors.push(`rule ${n}: top must be from 1 to ${MAX_TOP_N}`)
+
+    const text = cleanText(r.text)
+    if (!text) errors.push(`rule ${n}: the title needs some text`)
+    else if (text.length > TEXT_MAX) errors.push(`rule ${n}: a title is at most ${TEXT_MAX} characters`)
+
+    const color = String(r.color || '').trim().toLowerCase()
+    if (!/^#[0-9a-f]{6}$/.test(color)) errors.push(`rule ${n}: colour must look like #ffaa55`)
+
+    clean.push({ stat: r.stat, topN, text, color })
+  }
+
+  return errors.length ? { ok: false, errors } : { ok: true, value: { mode, max, rules: clean } }
+}
+
+/**
+ * Who holds which title.
+ *
+ * @param {Array} rules              in precedence order: `{ stat, topN, text, color }`
+ * @param {object} standings         stat → leaderboard rows for the current wipe,
+ *                                   in the leaderboard's order, at least `topN` long
+ * @param {object} options
+ * @param {string} options.mode      `first` · `all` · `upto`
+ * @param {number} options.max       how many `upto` shows
+ * @returns {Map<string, Array<{text, color}>>}  Steam id → titles, in rule order
+ */
+function evaluate(rules, standings, { mode = 'first', max = 2 } = {}) {
+  const held = new Map()
+
+  for (const rule of rules || []) {
+    const stat = STATS[rule.stat]
+    if (!stat) continue
+
+    const rows = (standings[rule.stat] || []).filter((row) => Number(stat.value(row)) > 0).slice(0, rule.topN)
+
+    for (const row of rows) {
+      if (!held.has(row.steamId)) held.set(row.steamId, [])
+      held.get(row.steamId).push({ text: rule.text, color: rule.color })
+    }
+  }
+
+  const keep = { first: 1, upto: max, all: Infinity }[normaliseMode(mode)]
+
+  for (const [steamId, list] of held) held.set(steamId, list.slice(0, keep))
+
+  return held
+}
+
+/** One player's titles as BetterChat markup: `[#hex]text[/#]`, space-separated. */
+function markup(list) {
+  return list.map((t) => `[#${t.color.replace(/^#/, '')}]${t.text}[/#]`).join(' ')
+}
+
+/** The wire set, sorted so an unchanged set digests the same on every tick. */
+function wireSet(held) {
+  return [...held.entries()]
+    .map(([steamId, list]) => ({ steamId, text: markup(list) }))
+    .sort((a, b) => a.steamId.localeCompare(b.steamId))
+}
+
+function digest(set) {
+  return crypto
+    .createHash('sha256')
+    .update(set.map((t) => `${t.steamId} ${t.text}`).join('\n'))
+    .digest('hex')
+}
+
+module.exports = {
+  STATS,
+  MODES,
+  MAX_RULES,
+  MAX_TOP_N,
+  MAX_UPTO,
+  TEXT_MAX,
+  cleanText,
+  normaliseMode,
+  validateSettings,
+  evaluate,
+  markup,
+  wireSet,
+  digest,
+}
--- a/server/model/titles/titles.model.js
+++ b/server/model/titles/titles.model.js
@@ -0,0 +1,106 @@
+// ── Chat titles, read against the live standings (phase 17) ────────────────
+//
+// `titles.js` decides; this file fetches what it decides from. One answer per
+// server serves three readers — the push to the game, the web leaderboard and
+// the app's — so it is remembered briefly: the leaderboard is polled by every
+// open page, and each rule is a leaderboard query of its own.
+
+const eventsDb = require('../events/events.db')
+const serversDb = require('../servers/servers.db')
+const db = require('./titles.db')
+const titles = require('./titles')
+
+/** How long one server's answer is reused. The same as the push loop's tick. */
+const MEMO_MS = 30 * 1000
+
+const memo = new Map()
+
+/** A server's settings as the admin form reads them. */
+async function settingsFor(serverId) {
+  const [mode, rules] = await Promise.all([db.getMode(serverId), db.listRules(serverId)])
+  return shapeSettings(mode, rules)
+}
+
+function shapeSettings(mode, rules) {
+  return {
+    mode: titles.normaliseMode(mode && mode.mode),
+    max: mode && Number(mode.max) ? Number(mode.max) : 2,
+    rules: rules.map((r) => ({ stat: r.stat, topN: Number(r.topN), text: r.text, color: r.color })),
+  }
+}
+
+/** Every server's settings, keyed by id, for the admin server list. */
+async function settingsByServer() {
+  const [modes, rules] = await Promise.all([db.listModes(), db.listAllRules()])
+  const out = new Map(modes.map((m) => [m.serverId, shapeSettings(m, [])]))
+
+  for (const r of rules) {
+    const s = out.get(r.serverId)
+    if (s) s.rules.push({ stat: r.stat, topN: Number(r.topN), text: r.text, color: r.color })
+  }
+
+  return out
+}
+
+async function saveSettings(serverId, value) {
+  await db.saveSettings(serverId, value)
+  forget(serverId)
+}
+
+function forget(serverId) {
+  for (const key of memo.keys()) if (key.startsWith(`${serverId} `)) memo.delete(key)
+}
+
+/**
+ * Who holds which title on one server right now: a Map of Steam id to
+ * `[{ text, color }]`, after the server's mode. Empty with no rules, and empty
+ * with no current wipe — a title ranks the current wipe (D135), and a server that
+ * has never said which wipe it is on has none to rank.
+ */
+async function heldFor(serverId, { wipeId, now = Date.now() } = {}) {
+  if (!wipeId) return new Map()
+
+  const key = `${serverId} ${wipeId}`
+  const hit = memo.get(key)
+  if (hit && now - hit.at < MEMO_MS) return hit.held
+
+  const settings = await settingsFor(serverId)
+  const standings = {}
+
+  // One query per STAT, at the deepest top N any rule on it asks for, rather
+  // than one per rule: two rules on kills read the same rows.
+  const depth = new Map()
+  for (const r of settings.rules) depth.set(r.stat, Math.max(depth.get(r.stat) || 0, r.topN))
+
+  await Promise.all(
+    [...depth.entries()].map(async ([stat, limit]) => {
+      standings[stat] = await eventsDb.leaderboard({ serverId, wipeId, sort: titles.STATS[stat].sort, limit })
+    }),
+  )
+
+  const held = titles.evaluate(settings.rules, normalise(standings), settings)
+  memo.set(key, { at: now, held })
+  return held
+}
+
+/** The leaderboard's rows carry numbers as strings from SUM(); the rules compare numbers. */
+function normalise(standings) {
+  const out = {}
+  for (const [stat, rows] of Object.entries(standings)) {
+    out[stat] = rows.map((r) => ({
+      steamId: r.steamId,
+      kills: Number(r.kills) || 0,
+      npcKills: Number(r.npcKills) || 0,
+      playtimeSec: Number(r.playtimeSec) || 0,
+    }))
+  }
+  return out
+}
+
+/** The same, for a server by id, reading its current wipe from its last report. */
+async function currentFor(serverId) {
+  const state = await serversDb.getState(serverId)
+  return heldFor(serverId, { wipeId: state && state.wipeId ? state.wipeId : null })
+}
+
+module.exports = { MEMO_MS, settingsFor, settingsByServer, saveSettings, heldFor, currentFor, forget }