wtclaude
383e89442e
Phase 8's website half. Phase 7 made the site the author of in-game
privilege and gave an operator every view of it; this is the other side,
and it is the first time a player can see what they hold without asking
one.
`GET /player/rust/permissions` is self-scoped in SQL and read-only by
construction — a grant a player could change would not be a grant. Three
things make it a different shape from the admin read rather than a
filtered one:
* the scope arithmetic is answered on the server. A client handed `*`
would have to know what the fleet is to say anything, and then
`inScope` exists twice. Each entry carries the servers it reaches,
already resolved and already marked.
* `live` is the pushed ledger, never the authored row. A grant is not a
privilege in a game until a sync confirmed it, and phase 7 is careful
never to record a push that silently did nothing — so "waiting" is
honest, and the alternative is the site claiming to have given
something it has not.
* nothing says WHY it is waiting. An offline server, a permission no
loaded plugin registered and a store that has never seen the account
all look the same from here; telling them apart is an operator's
diagnosis and an inventory of what is installed.
An entitlement that reaches nobody still lists, and the page says so —
authored against the website account, it exists before a Steam id does,
and hiding it until one turns up is the defect the admin user page
shipped in phase 7 (PLAN.md §20.5).
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PMH6bw1jXMgbyF3ZWGEzSM
123 lines
7.5 KiB
JavaScript
123 lines
7.5 KiB
JavaScript
// ── Player · Rust ─────────────────────────────────────────────────────────
|
||
//
|
||
// Mounted at `/api/v1/player/rust`. The tier's gate is already applied: `player`
|
||
// sits behind `noindex, requireAuth`, so every handler here has a signed-in user
|
||
// and none of them re-implements that check.
|
||
//
|
||
// ── Why this tier exists in phase 1, and what it holds now ────────────────
|
||
//
|
||
// R14 puts this module on all three tiers from the start, and the loader holds
|
||
// `module.json`'s `mounts` against what is actually registered in **both**
|
||
// directions — a declared prefix that never gets a router fails the load. So the
|
||
// declaration and the registration land together or not at all.
|
||
//
|
||
// Phase 1 said this tier would carry the signed-in view of a server — the
|
||
// viewer's own linked Steam identity, their own presence, their own entitlements
|
||
// — and that identity was a later phase. This is that phase: `/links`, `/link`
|
||
// and `DELETE /links/:steamId` are R1, and everything phases 7 and 13 hand out is
|
||
// hung off the row they write.
|
||
//
|
||
// `/servers` stays what it was: the same list the public tier serves, answered on
|
||
// the authenticated tier so per-player detail can be added without moving the
|
||
// address. It delegates to the same model, so the two cannot drift.
|
||
|
||
const core = require('../../core')
|
||
|
||
const express = core.express
|
||
const { body, param } = core.validator
|
||
|
||
const rust = require('./rust.controller')
|
||
const { validate, rateLimit } = core.middleware
|
||
|
||
const playerRustRouter = express.Router()
|
||
|
||
// A Steam id as the game states it — `BasePlayer.UserIDString`, a 17-digit
|
||
// SteamID64. Bounded rather than pinned at 17 because the column is a string and
|
||
// a test rig's ids are shorter; what matters is that nothing but digits reaches a
|
||
// `WHERE steam_id = ?`.
|
||
const STEAM_ID_RE = /^[0-9]{5,32}$/
|
||
|
||
/**
|
||
* R1 requires the link code be rate-limited, and this is where that lands.
|
||
*
|
||
* The code is six characters from a 32-glyph alphabet, so guessing one is a
|
||
* 1-in-10⁹ shot — but only while the guesser is made to pay for each attempt.
|
||
* Ten per quarter-hour per IP turns that into centuries; without it a script
|
||
* could work through the space in an afternoon, and phases 7 and 13 make the
|
||
* prize a set of in-game permissions and entitlements rather than a cosmetic
|
||
* badge.
|
||
*
|
||
* Its own limiter rather than core's `accountChangeLimiter`: this is guessing
|
||
* somebody else's secret, not changing your own password, and sharing a counter
|
||
* would mean one of the two silently sets the policy for the other.
|
||
*/
|
||
const linkLimiter = rateLimit({
|
||
windowMs: 15 * 60 * 1000,
|
||
max: 10,
|
||
label: 'rust-link-code',
|
||
message: 'Too many link attempts. Please try again later.',
|
||
})
|
||
|
||
playerRustRouter.get(
|
||
'/servers',
|
||
// #swagger.tags = ['Player · Rust']
|
||
// #swagger.summary = 'The Rust servers, for a signed-in player'
|
||
// #swagger.description = 'The same servers the public list carries, answered on the authenticated tier. It is the address a signed-in client calls, so that per-player detail can be added here without moving it. Requires a session.'
|
||
/* #swagger.responses[200] = { description: 'The server list', content: { "application/json": { schema: { $ref: "#/components/schemas/RustServerList" } } } } */
|
||
rust.listServers,
|
||
)
|
||
|
||
playerRustRouter.get(
|
||
'/links',
|
||
// #swagger.tags = ['Player · Rust']
|
||
// #swagger.summary = 'The Steam accounts the caller has linked'
|
||
// #swagger.description = 'Every Steam account linked to the signed-in user, newest first. A link is fleet-wide: it is keyed by Steam id, not by server, because a Steam account is one person across every server an operator runs.'
|
||
// #swagger.security = [{ "cookieAuth": [] }, { "bearerAuth": [] }]
|
||
/* #swagger.responses[200] = { description: 'Linked accounts', content: { "application/json": { schema: { $ref: "#/components/schemas/RustLinkList" } } } } */
|
||
rust.listLinks,
|
||
)
|
||
|
||
playerRustRouter.get(
|
||
'/permissions',
|
||
// #swagger.tags = ['Player · Rust']
|
||
// #swagger.summary = 'What the site has given the caller in game'
|
||
// #swagger.description = 'The groups and direct grants the site holds for the signed-in user, each resolved to the servers its scope reaches and marked with whether that server has it yet. Read-only: a grant a player could change would not be a grant. `live` is the pushed ledger rather than the authored row, so an entitlement that has not reached a game reads as waiting — which is also what an offline server, a permission no loaded plugin registered, and an account the store has never seen all look like from here.'
|
||
// #swagger.security = [{ "cookieAuth": [] }, { "bearerAuth": [] }]
|
||
/* #swagger.responses[200] = { description: 'What the caller holds', content: { "application/json": { schema: { $ref: "#/components/schemas/RustPlayerPermissions" } } } } */
|
||
rust.listPermissions,
|
||
)
|
||
|
||
playerRustRouter.post(
|
||
'/link',
|
||
// #swagger.tags = ['Player · Rust']
|
||
// #swagger.summary = 'Link a Steam account with a one-time code from /link in game'
|
||
// #swagger.description = 'The player types /link in game, the plugin hands them a six-character code privately, and they enter it here within five minutes. The site asks each configured server in turn until one recognises the code. A Steam account already linked to a different website account is refused rather than moved — the way out is /unlink in game.'
|
||
// #swagger.security = [{ "cookieAuth": [] }, { "bearerAuth": [] }]
|
||
/* #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/RustLinkRequest" } } } } */
|
||
/* #swagger.responses[200] = { description: 'Linked', content: { "application/json": { schema: { $ref: "#/components/schemas/RustLinkResult" } } } } */
|
||
/* #swagger.responses[400] = { description: 'Unknown or expired code', content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } } */
|
||
/* #swagger.responses[409] = { description: 'That Steam account is linked to another website account', content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } } */
|
||
/* #swagger.responses[429] = { description: 'Too many link attempts', content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } } */
|
||
/* #swagger.responses[503] = { description: 'A server could not be reached — the code is still good', content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } } */
|
||
linkLimiter,
|
||
body('code').isString().trim().isLength({ min: 4, max: 32 }),
|
||
validate,
|
||
rust.confirmLink,
|
||
)
|
||
|
||
playerRustRouter.delete(
|
||
'/links/:steamId',
|
||
// #swagger.tags = ['Player · Rust']
|
||
// #swagger.summary = 'Release a Steam account the caller has linked'
|
||
// #swagger.description = 'Removes the caller’s own link. Scoped to the caller in the statement, so a link belonging to somebody else answers the same 404 as one that does not exist.'
|
||
// #swagger.security = [{ "cookieAuth": [] }, { "bearerAuth": [] }]
|
||
// #swagger.parameters['steamId'] = { in: 'path', required: true, schema: { type: 'string' }, description: 'The Steam id to release.' }
|
||
/* #swagger.responses[200] = { description: 'Unlinked', content: { "application/json": { schema: { type: "object", properties: { unlinked: { type: "boolean", example: true } } } } } } */
|
||
/* #swagger.responses[404] = { description: 'Not linked to the caller', content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } } */
|
||
param('steamId').matches(STEAM_ID_RE),
|
||
validate,
|
||
rust.removeLink,
|
||
)
|
||
|
||
module.exports = playerRustRouter
|