Add configured room creation to administration
Create an explicitly owned new host seat with supported rules/modules and ordered AI seats through one live-authorized transaction. Save exact account-bound retries across refresh, record durable audit metadata, and never restore a revoked or transferred host credential. Connect invitation joining and ordinary voluntary host handover. Preserve normal readiness and Advanced preview gates. Verified types, lint, 5240 offline tests, 52 HTTP tests and build. Eight authenticated HTTP groups and independent privacy/persistence review passed. Browser QA confirmed one room after a lost response and refresh/retry, working host controls and saved continuation. Mobile layout passed; requested desktop viewport override did not take effect. Existing games preserved. Authenticated deployed administrator acceptance remains pending explicit QA access.
This commit is contained in:
Quintine committed
1 parent
8c922b446b
commit
e7d4efc3db
21 files changed
+2855
-21
No files matched your search
@@ -43,7 +43,9 @@ The **Administration** link opens `/admin`, with separate administrator sign-in,
|
||||
session controls and a searchable room directory. **Room controls** lets owners
|
||||
and operators pause/resume rooms and lock/unlock new joins. See [room controls](docs/ADMIN_ROOM_CONTROLS.md)
|
||||
and [initial owner setup](docs/ADMIN_PANEL.md#initial-owner-and-access-recovery).
|
||||
Room creation, archive/removal, participant support and backup tools are still being built.
|
||||
Owners/operators can [create a configured lobby](docs/ADMIN_ROOM_CREATION.md) with
|
||||
an explicitly owned new host seat and initial AI players. Neutral lobby management,
|
||||
archive/removal, participant support and backup tools are still being built.
|
||||
|
||||
## Saved seats and reconnecting
|
||||
|
||||
|
||||
@@ -38,12 +38,19 @@
|
||||
.admin-room-control .admin-check input { width: 22px; height: 22px; min-height: 22px; flex-shrink: 0; accent-color: var(--primary); }
|
||||
.admin-room-control .admin-confirm { margin-top: 16px; }
|
||||
.admin-room-control h2:focus-visible { outline: 2px solid var(--primary); outline-offset: 5px; }
|
||||
.admin-room-actions, .admin-created-result { display: flex; flex-wrap: wrap; gap: 12px; align-items: center; }
|
||||
.admin-created-result h3, .admin-created-result p { flex-basis: 100%; }
|
||||
.admin-create-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 210px), 1fr)); gap: 16px; }
|
||||
.admin-create-bot { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1fr) auto; align-items: end; gap: 12px; margin-bottom: 16px; }
|
||||
.admin-room-creation fieldset { min-width: 0; border: 1px solid var(--border); padding: 16px; }
|
||||
.admin-room-link { display: inline-flex; min-height: 44px; align-items: center; padding: 8px 16px; border: 1px solid var(--primary); border-radius: 4px; color: var(--primary); }
|
||||
@media (max-width: 700px) {
|
||||
.admin-shell { padding: 20px 16px; }
|
||||
.admin-header, .admin-section-heading { align-items: start; flex-direction: column; gap: 16px; }
|
||||
.admin-header h1 { font-size: 1.8rem; }
|
||||
.admin-login { padding: 20px; margin: 24px 0; }
|
||||
.admin-room-control { padding: 18px; }
|
||||
.admin-create-bot { grid-template-columns: 1fr; }
|
||||
.admin-room-table { display: block; }
|
||||
.admin-room-table thead { display: none; }
|
||||
.admin-room-table tbody { display: block; }
|
||||
|
||||
+11
-5
@@ -9,6 +9,7 @@ import { ClientRequestError, requestJson } from '@/lib/client-request';
|
||||
import type { AdminDirectory } from '@/lib/admin-directory';
|
||||
import { FACTIONS } from '@/game/catalog';
|
||||
import { AdminRoomControls } from '@/components/admin-room-controls';
|
||||
import { AdminRoomCreation } from '@/components/admin-room-creation';
|
||||
import './admin.css';
|
||||
|
||||
type Account = { id: string; name: string; role: 'owner' | 'operator' | 'viewer' };
|
||||
@@ -27,17 +28,18 @@ export default function Administration() {
|
||||
const [applied, setApplied] = useState(initialFilters);
|
||||
const [confirmAll, setConfirmAll] = useState(false);
|
||||
const [selectedRoom, setSelectedRoom] = useState<string | null>(null);
|
||||
const [creatingRoom, setCreatingRoom] = useState(false);
|
||||
const [operationBusy, setOperationBusy] = useState(false);
|
||||
const controlsBusy = busy || operationBusy;
|
||||
const epoch = useRef(0);
|
||||
const clearSession = useCallback(() => {
|
||||
epoch.current++;
|
||||
setAccount(null); setDirectory(null); setConfirmAll(false);
|
||||
setBusy(false); setSelectedRoom(null);
|
||||
setBusy(false); setSelectedRoom(null); setCreatingRoom(false);
|
||||
}, []);
|
||||
const accessChanged = useCallback(() => {
|
||||
clearSession();
|
||||
setNotice('Administrator access changed. Sign in again to confirm any saved room-settings request.');
|
||||
setNotice('Administrator access changed. Sign in again to confirm any saved room request.');
|
||||
}, [clearSession]);
|
||||
const load = useCallback(async (next: Filters, page = 1) => {
|
||||
const current = ++epoch.current;
|
||||
@@ -109,7 +111,11 @@ export default function Administration() {
|
||||
</section> : <>
|
||||
<section aria-labelledby="admin-rooms-title">
|
||||
<div className="admin-section-heading"><div><h2 id="admin-rooms-title">Rooms</h2><p className="admin-secondary">Public room details. Cards, sealed choices and private discussion stay hidden.</p></div>
|
||||
<Button variant="outline" disabled={controlsBusy} onClick={() => void load(applied, directory?.page ?? 1)}><RefreshCw aria-hidden="true" /> Refresh</Button></div>
|
||||
<div className="admin-room-actions">{account.role !== 'viewer' && <Button disabled={controlsBusy} onClick={() => { setSelectedRoom(null); setCreatingRoom(true); }}>Create a room</Button>}
|
||||
<Button variant="outline" disabled={controlsBusy} onClick={() => void load(applied, directory?.page ?? 1)}><RefreshCw aria-hidden="true" /> Refresh</Button></div></div>
|
||||
{creatingRoom && account.role !== 'viewer' && <AdminRoomCreation key={account.id} accountId={account.id}
|
||||
onClose={() => setCreatingRoom(false)} onDenied={accessChanged} onBusyChange={setOperationBusy}
|
||||
onCreated={code => { const next = { ...initialFilters, q: code }; setFilters(next); void load(next); }} />}
|
||||
<form className="admin-filters" onSubmit={event => { event.preventDefault(); void load(filters); }}>
|
||||
<label className="admin-search" htmlFor="admin-search">Room code or player name<Input id="admin-search" value={filters.q} maxLength={80} disabled={controlsBusy} onChange={e => setFilters({ ...filters, q: e.target.value })} /></label>
|
||||
<label>Status<select disabled={controlsBusy} value={filters.status} onChange={e => setFilters({ ...filters, status: e.target.value })}>
|
||||
@@ -149,7 +155,7 @@ export default function Administration() {
|
||||
<TableCell>{room.turn !== null && room.status !== 'lobby' ? `Turn ${room.turn} · ` : ''}{room.phase}
|
||||
<p>{room.pending.label}{room.pending.owners.length > 0 ? ': ' + room.pending.owners.map(id => room.players.find(p => p.id === id)?.name).filter(Boolean).join(', ') : ''}</p>
|
||||
</TableCell>
|
||||
<TableCell><Button variant="outline" disabled={controlsBusy} onClick={() => setSelectedRoom(room.code)}>Room controls · {room.code}</Button><p><time dateTime={new Date(room.updatedAt).toISOString()}>{new Date(room.updatedAt).toLocaleString()}</time></p><p className="admin-secondary">Version {room.version}</p></TableCell>
|
||||
<TableCell><Button variant="outline" disabled={controlsBusy} onClick={() => { setCreatingRoom(false); setSelectedRoom(room.code); }}>Room controls · {room.code}</Button><p><time dateTime={new Date(room.updatedAt).toISOString()}>{new Date(room.updatedAt).toLocaleString()}</time></p><p className="admin-secondary">Version {room.version}</p></TableCell>
|
||||
</TableRow>)}</TableBody></Table>}
|
||||
<nav className="admin-pagination" aria-label="Room pages">
|
||||
<Button variant="outline" disabled={controlsBusy || directory.page <= 1} onClick={() => void load(applied, 1)}>First</Button>
|
||||
@@ -165,7 +171,7 @@ export default function Administration() {
|
||||
{!confirmAll ? <Button variant="outline" disabled={controlsBusy} onClick={() => setConfirmAll(true)}>Sign out everywhere…</Button> :
|
||||
<div className="admin-confirm"><p>End all your administrator sessions now?</p><Button disabled={controlsBusy} onClick={() => void sessionAction('logoutAll')}>Confirm sign out everywhere</Button><Button variant="outline" disabled={controlsBusy} onClick={() => setConfirmAll(false)}>Cancel</Button></div>}
|
||||
</section>
|
||||
<p className="admin-secondary admin-development">Administration preview: pause/resume and joining locks are available. Room creation, archive/removal, participant support and backup tools are still being implemented.</p>
|
||||
<p className="admin-secondary admin-development">Administration preview: create a lobby with a new host seat, pause/resume rooms and manage joining locks. Archive/removal, participant support and backup tools are still being implemented.</p>
|
||||
</>}
|
||||
</main>;
|
||||
}
|
||||
@@ -1,7 +1,11 @@
|
||||
import { env } from 'cloudflare:workers';
|
||||
import { requireAdmin } from '@/db/admin-access';
|
||||
import { AdminError, requireAdmin } from '@/db/admin-access';
|
||||
import { readAdminDirectory } from '@/db/admin-directory';
|
||||
import { adminFailure, adminResponse, adminToken } from '@/lib/admin-http';
|
||||
import { createAdminRoom } from '@/db/admin-room-creation';
|
||||
import { RuleError } from '@/game/engine';
|
||||
import { adminBody, adminFailure, adminResponse, adminToken } from '@/lib/admin-http';
|
||||
import { validAdminRoomCreationInput } from '@/lib/admin-room-creation';
|
||||
import { requestOrigin } from '@/lib/request-origin';
|
||||
|
||||
export async function GET(request: Request) {
|
||||
try {
|
||||
@@ -9,3 +13,17 @@ export async function GET(request: Request) {
|
||||
return adminResponse(await readAdminDirectory(env.DB, identity, new URL(request.url).searchParams));
|
||||
} catch (error) { return adminFailure(error); }
|
||||
}
|
||||
|
||||
export async function POST(request: Request) {
|
||||
try {
|
||||
const body = await adminBody(request, env.DUNE_PUBLIC_ORIGIN);
|
||||
const identity = await requireAdmin(env.DB, adminToken(request), ['owner', 'operator']);
|
||||
if (request.headers.get('X-Dune-Admin-Id') !== identity.id)
|
||||
throw new AdminError('The signed-in administrator changed. Reload administration before continuing.', 401);
|
||||
if (!validAdminRoomCreationInput(body)) throw new AdminError('Check the host, rules, AI seats and operational reason.', 400);
|
||||
const result = await createAdminRoom(env.DB, identity, body);
|
||||
const headers: Record<string, string> = {};
|
||||
if (result.hostAccess) headers['Set-Cookie'] = `dune_${result.code}=${body.sessionToken}; HttpOnly; SameSite=Strict; Path=/api/rooms/${result.code}; Max-Age=2592000${requestOrigin(request, env.DUNE_PUBLIC_ORIGIN).startsWith('https:') ? '; Secure' : ''}`;
|
||||
return adminResponse(result, headers);
|
||||
} catch (error) { return adminFailure(error instanceof RuleError ? new AdminError(error.message, 400) : error); }
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
'use client';
|
||||
|
||||
import { useEffect, useRef, useState } from 'react';
|
||||
import { Button } from './ui/button';
|
||||
import { Input } from './ui/input';
|
||||
import { FACTIONS, type FactionId } from '@/game/catalog';
|
||||
import { ClientRequestError, requestJson, requestMayHaveCompleted } from '@/lib/client-request';
|
||||
import { retainAdminRoomRequest } from '@/lib/admin-room-control-client';
|
||||
import { clearAdminRoomCreation, completeAdminRoomCreation, newAdminRoomCreationRequest, readAdminRoomCreation, saveAdminRoomCreation, type AdminRoomCreationRecord } from '@/lib/admin-room-creation-client';
|
||||
import type { AdminRoomCreationInput, AdminRoomCreationResult } from '@/lib/admin-room-creation';
|
||||
|
||||
type Props = { accountId: string; onClose: () => void; onCreated: (code: string) => void; onDenied: () => void; onBusyChange: (busy: boolean) => void };
|
||||
const factions = FACTIONS.filter(faction => faction.expansion === 'base');
|
||||
const difficulties = ['Easy', 'Medium', 'Hard', 'Brutal'] as const;
|
||||
const message = (error: unknown) => error instanceof Error ? error.message : 'The room could not be created.';
|
||||
|
||||
export function AdminRoomCreation({ accountId, onClose, onCreated, onDenied, onBusyChange }: Props) {
|
||||
const [name, setName] = useState('');
|
||||
const [faction, setFaction] = useState<FactionId>('atreides');
|
||||
const [advanced, setAdvanced] = useState(false);
|
||||
const [techTokens, setTechTokens] = useState(false);
|
||||
const [strongholdCards, setStrongholdCards] = useState(false);
|
||||
const [bots, setBots] = useState<AdminRoomCreationInput['bots']>([]);
|
||||
const [reason, setReason] = useState('');
|
||||
const [confirmed, setConfirmed] = useState(false);
|
||||
const [record, setRecord] = useState<AdminRoomCreationRecord | null>(null);
|
||||
const [storageProblem, setStorageProblem] = useState(false);
|
||||
const [notice, setNotice] = useState('');
|
||||
const [loading, setLoading] = useState(true);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const alive = useRef(false), inFlight = useRef(false);
|
||||
const heading = useRef<HTMLHeadingElement>(null);
|
||||
|
||||
useEffect(() => {
|
||||
alive.current = true;
|
||||
heading.current?.focus();
|
||||
try {
|
||||
const saved = readAdminRoomCreation(window.sessionStorage, accountId);
|
||||
// oxlint-disable-next-line react/react-compiler -- Restore tab-scoped creation proof after SSR.
|
||||
setRecord(saved);
|
||||
if (saved?.kind === 'pending') setNotice('This tab has an unconfirmed room request. Retry it to find the original room.');
|
||||
} catch (error) { setStorageProblem(true); setNotice(message(error)); }
|
||||
setLoading(false);
|
||||
return () => { alive.current = false; };
|
||||
}, [accountId]);
|
||||
|
||||
async function submit(saved?: AdminRoomCreationInput) {
|
||||
if (inFlight.current || storageProblem || (!saved && (!confirmed || record))) return;
|
||||
let input: AdminRoomCreationInput;
|
||||
try {
|
||||
input = saved ?? newAdminRoomCreationRequest({ name, faction, advanced, techTokens, strongholdCards, bots, reason });
|
||||
saveAdminRoomCreation(window.sessionStorage, accountId, input);
|
||||
} catch (error) { setNotice(message(error)); return; }
|
||||
inFlight.current = true; setBusy(true); onBusyChange(true);
|
||||
setRecord({ kind: 'pending', input }); setNotice('Creating your room…');
|
||||
try {
|
||||
const result = await requestJson<AdminRoomCreationResult>('/api/admin/rooms', {
|
||||
method: 'POST', headers: { 'Content-Type': 'application/json', 'X-Dune-Admin-Id': accountId }, body: JSON.stringify(input),
|
||||
});
|
||||
completeAdminRoomCreation(window.sessionStorage, accountId, input, result);
|
||||
if (alive.current) {
|
||||
setRecord({ kind: 'completed', result }); setConfirmed(false);
|
||||
setNotice(result.replayed ? 'The original room has been found. No duplicate room was created.' : 'Room created. The lobby is ready to configure and invite players.');
|
||||
onCreated(result.code);
|
||||
}
|
||||
} catch (error) {
|
||||
let cleared = false;
|
||||
if (!retainAdminRoomRequest(error)) {
|
||||
try { clearAdminRoomCreation(window.sessionStorage, accountId); cleared = true; } catch { /* Preserve exact retry if storage is unavailable. */ }
|
||||
}
|
||||
if (alive.current) {
|
||||
if (cleared) setRecord(null);
|
||||
setConfirmed(false);
|
||||
setNotice(requestMayHaveCompleted(error) ? `${message(error)} The room may already exist. Retry the saved request to confirm it.` : message(error));
|
||||
if (error instanceof ClientRequestError && [401, 403].includes(error.status ?? 0)) onDenied();
|
||||
}
|
||||
} finally { inFlight.current = false; onBusyChange(false); if (alive.current) setBusy(false); }
|
||||
}
|
||||
|
||||
function clearRecord() {
|
||||
if (busy || (storageProblem && !confirmed)) return;
|
||||
try {
|
||||
clearAdminRoomCreation(window.sessionStorage, accountId);
|
||||
setRecord(null); setStorageProblem(false); setConfirmed(false);
|
||||
setNotice('Local creation record cleared. Existing rooms and saved seats are unchanged.');
|
||||
} catch (error) { setNotice(message(error)); }
|
||||
}
|
||||
|
||||
function addBot() {
|
||||
const next = factions.find(item => item.id !== faction && !bots.some(bot => bot.faction === item.id));
|
||||
if (next) { setBots([...bots, { faction: next.id, difficulty: 'Medium' }]); setConfirmed(false); }
|
||||
}
|
||||
|
||||
const result = record?.kind === 'completed' ? record.result : null;
|
||||
return <section className="admin-room-control admin-room-creation" aria-labelledby="admin-create-title" aria-busy={busy || loading}>
|
||||
<div className="admin-section-heading"><h2 id="admin-create-title" ref={heading} tabIndex={-1}>Create a room</h2><Button variant="outline" disabled={busy} onClick={onClose}>Close room creation</Button></div>
|
||||
{notice && <output className="admin-notice">{notice}</output>}
|
||||
{loading ? <output>Checking this tab’s saved creation request…</output> : storageProblem ? <div className="admin-confirm">
|
||||
<p>A room may already have been created. Check the directory before removing this unreadable record. Removing it cannot cancel creation and may lose this tab’s host-seat retry proof.</p>
|
||||
<label className="admin-check"><input type="checkbox" checked={confirmed} onChange={event => setConfirmed(event.target.checked)} />I checked the directory and want to discard this local record.</label>
|
||||
<Button disabled={!confirmed} onClick={clearRecord}>Discard unreadable local record</Button>
|
||||
</div> : record?.kind === 'pending' ? <div className="admin-confirm">
|
||||
<p>Unconfirmed room: host <strong>{record.input.name}</strong> · {record.input.advanced ? 'Advanced preview' : 'Basic'} · {record.input.bots.length} AI players.</p>
|
||||
<p>The exact request is kept privately in this tab across refresh. Keep the tab and its storage until the result is confirmed. Retrying finds the same room.</p>
|
||||
<Button disabled={busy} onClick={() => void submit(record.input)}>Retry saved room creation</Button>
|
||||
</div> : result ? <div className="admin-created-result">
|
||||
<h3>Room <span className="admin-code">{result.code}</span></h3>
|
||||
<p>Share invitation code <strong>{result.code}</strong>. Players can enter it on the home page to join an available faction.</p>
|
||||
{result.hostAccess ? <><p>When creation was confirmed, this browser received the host seat. Open the lobby to change settings, invite human players, or use <strong>Pass your seat to another player</strong> to give someone else the host seat.</p><a className="admin-room-link" href={`/?room=${result.code}`}>Open your host seat</a></> : <p>The original host seat has since been transferred or its access revoked. This confirmation does not restore old seat access.</p>}
|
||||
<Button variant="outline" onClick={clearRecord}>Create another room</Button>
|
||||
</div> : <form onSubmit={event => { event.preventDefault(); void submit(); }}>
|
||||
<p>Create a lobby with a new human host seat in this browser. Players join by invitation; AI seats can be included below. Nothing starts until the host and players complete normal readiness.</p>
|
||||
<div className="admin-create-grid">
|
||||
<label htmlFor="admin-host-name">Host player name<Input id="admin-host-name" value={name} maxLength={32} required disabled={busy} onChange={event => { setName(event.target.value); setConfirmed(false); }} /></label>
|
||||
<label htmlFor="admin-host-faction">Host faction<select id="admin-host-faction" value={faction} disabled={busy} onChange={event => { setFaction(event.target.value as FactionId); setConfirmed(false); }}>
|
||||
{factions.map(item => <option key={item.id} value={item.id} disabled={bots.some(bot => bot.faction === item.id)}>{item.name}</option>)}
|
||||
</select></label>
|
||||
<label htmlFor="admin-create-rules">Rules<select id="admin-create-rules" value={advanced ? 'advanced' : 'basic'} disabled={busy} onChange={event => { setAdvanced(event.target.value === 'advanced'); if (event.target.value === 'basic') setStrongholdCards(false); setConfirmed(false); }}>
|
||||
<option value="basic">Basic</option><option value="advanced">Advanced preview</option>
|
||||
</select></label>
|
||||
</div>
|
||||
{advanced && <p className="admin-notice">Advanced preview is unfinished. Only the six classic factions are available, and starting requires the existing preview confirmation.</p>}
|
||||
<label className="admin-check"><input type="checkbox" checked={techTokens} disabled={busy} onChange={event => { setTechTokens(event.target.checked); setConfirmed(false); }} />Tech Tokens · at least three players required to start</label>
|
||||
<label className="admin-check"><input type="checkbox" checked={strongholdCards} disabled={busy || !advanced} onChange={event => { setStrongholdCards(event.target.checked); setConfirmed(false); }} />Stronghold Cards · Advanced rules required</label>
|
||||
<fieldset disabled={busy}><legend>Initial AI players</legend>
|
||||
<p className="admin-secondary">The other seats remain available for human players. AI strategy tuning is still in development.</p>
|
||||
{bots.map((bot, index) => <div className="admin-create-bot" key={index}>
|
||||
<label htmlFor={`admin-bot-faction-${index}`}>AI {index + 1} faction<select id={`admin-bot-faction-${index}`} value={bot.faction} onChange={event => { setBots(bots.map((item, at) => at === index ? { ...item, faction: event.target.value as FactionId } : item)); setConfirmed(false); }}>
|
||||
{factions.map(item => <option key={item.id} value={item.id} disabled={item.id === faction || bots.some((other, at) => at !== index && other.faction === item.id)}>{item.name}</option>)}
|
||||
</select></label>
|
||||
<label htmlFor={`admin-bot-difficulty-${index}`}>Difficulty<select id={`admin-bot-difficulty-${index}`} value={bot.difficulty} onChange={event => { const difficulty = difficulties.find(value => value === event.target.value); if (difficulty) setBots(bots.map((item, at) => at === index ? { ...item, difficulty } : item)); setConfirmed(false); }}>
|
||||
{difficulties.map(value => <option key={value}>{value}</option>)}
|
||||
</select></label>
|
||||
<Button type="button" variant="outline" onClick={() => { setBots(bots.filter((_, at) => at !== index)); setConfirmed(false); }}>Remove AI {index + 1}</Button>
|
||||
</div>)}
|
||||
<Button type="button" variant="outline" disabled={bots.length >= 5} onClick={addBot}>Add an AI player</Button>
|
||||
</fieldset>
|
||||
<label htmlFor="admin-create-reason">Reason for the audit history<Input id="admin-create-reason" value={reason} maxLength={300} required disabled={busy} onChange={event => { setReason(event.target.value); setConfirmed(false); }} /></label>
|
||||
<p className="admin-secondary">Use an operational reason; leave out credentials and private game information.</p>
|
||||
<div className="admin-confirm"><label className="admin-check"><input type="checkbox" checked={confirmed} disabled={busy} onChange={event => setConfirmed(event.target.checked)} />This browser will own the new host seat. I have checked these settings.</label>
|
||||
<Button type="submit" disabled={busy || !confirmed || !name.trim() || !reason.trim()}>Create room with host seat</Button>
|
||||
</div>
|
||||
</form>}
|
||||
</section>;
|
||||
}
|
||||
@@ -0,0 +1,210 @@
|
||||
import { applyAction, createGame, newPlayer } from '../game/engine';
|
||||
import { AdminError, type AdminIdentity } from './admin-access';
|
||||
import {
|
||||
validAdminRoomCreationInput,
|
||||
type AdminRoomCreationInput,
|
||||
type AdminRoomCreationResult,
|
||||
} from '../lib/admin-room-creation';
|
||||
|
||||
const authority = `SELECT a.role FROM admin_sessions s JOIN admin_accounts a ON a.id = s.admin_id
|
||||
WHERE s.token_hash = ? AND a.id = ? AND a.enabled = 1 AND s.revoked_at IS NULL
|
||||
AND s.expires_at > ? AND s.generation = a.session_generation
|
||||
AND a.role IN ('owner','operator','viewer')`;
|
||||
const mutationAuthority = authority + " AND a.role IN ('owner','operator')";
|
||||
const MAX_CODE_ATTEMPTS = 5;
|
||||
|
||||
async function hash(value: string) {
|
||||
const digest = await crypto.subtle.digest(
|
||||
'SHA-256',
|
||||
new TextEncoder().encode(value),
|
||||
);
|
||||
return Array.from(new Uint8Array(digest), (byte) =>
|
||||
byte.toString(16).padStart(2, '0'),
|
||||
).join('');
|
||||
}
|
||||
function roomCode() {
|
||||
const alphabet = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
|
||||
return Array.from(
|
||||
crypto.getRandomValues(new Uint8Array(8)),
|
||||
(byte) => alphabet[byte % alphabet.length],
|
||||
).join('');
|
||||
}
|
||||
function configuration(input: AdminRoomCreationInput) {
|
||||
return {
|
||||
name: input.name.trim(),
|
||||
faction: input.faction,
|
||||
advanced: input.advanced,
|
||||
techTokens: input.techTokens,
|
||||
strongholdCards: input.strongholdCards,
|
||||
bots: input.bots.map((bot) => ({
|
||||
faction: bot.faction,
|
||||
difficulty: bot.difficulty,
|
||||
})),
|
||||
};
|
||||
}
|
||||
function createLobby(
|
||||
code: string,
|
||||
hostId: string,
|
||||
input: ReturnType<typeof configuration>,
|
||||
) {
|
||||
let game = createGame(
|
||||
code,
|
||||
newPlayer(hostId, input.name, input.faction),
|
||||
input.advanced,
|
||||
[],
|
||||
);
|
||||
for (const bot of input.bots)
|
||||
game = applyAction(game, hostId, { type: 'addBot', ...bot });
|
||||
if (input.techTokens)
|
||||
game = applyAction(game, hostId, { type: 'techTokens', enabled: true });
|
||||
if (input.strongholdCards)
|
||||
game = applyAction(game, hostId, {
|
||||
type: 'strongholdCards',
|
||||
enabled: true,
|
||||
});
|
||||
return game;
|
||||
}
|
||||
|
||||
/** Creation and its receipt are one live-authorized transaction. Replays never restore revoked access. */
|
||||
export async function createAdminRoom(
|
||||
database: D1Database,
|
||||
identity: AdminIdentity,
|
||||
input: AdminRoomCreationInput,
|
||||
now = Date.now(),
|
||||
): Promise<AdminRoomCreationResult> {
|
||||
if (
|
||||
!identity ||
|
||||
typeof identity.id !== 'string' ||
|
||||
typeof identity.sessionHash !== 'string' ||
|
||||
identity.sessionHash.length !== 64 ||
|
||||
!/^[0-9a-f]{64}$/.test(identity.sessionHash)
|
||||
)
|
||||
throw new AdminError('Administrator sign-in required.', 401);
|
||||
if (!validAdminRoomCreationInput(input))
|
||||
throw new AdminError(
|
||||
'Choose a host name, unique base factions, valid AI difficulties and supported lobby rules, with a fresh private retry proof and a reason of 1–300 characters.',
|
||||
400,
|
||||
);
|
||||
const requestedConfiguration = configuration(input);
|
||||
const publicConfiguration = JSON.stringify(requestedConfiguration);
|
||||
const operationId = input.operationId;
|
||||
const reason = input.reason.trim();
|
||||
const [sessionHash, requestHash] = await Promise.all([
|
||||
hash(input.sessionToken),
|
||||
hash(JSON.stringify({ configuration: requestedConfiguration, reason })),
|
||||
]);
|
||||
const args = [identity.sessionHash, identity.id, now];
|
||||
const hostId = crypto.randomUUID();
|
||||
for (let attempt = 0; attempt < MAX_CODE_ATTEMPTS; attempt++) {
|
||||
const code = roomCode();
|
||||
const game = createLobby(code, hostId, requestedConfiguration);
|
||||
const results = await database.batch([
|
||||
database.prepare(authority).bind(...args),
|
||||
database
|
||||
.prepare(`INSERT INTO rooms(code,state,version,updated_at)
|
||||
SELECT ?,?,0,? WHERE EXISTS (${mutationAuthority})
|
||||
AND NOT EXISTS (SELECT 1 FROM admin_room_creations WHERE operation_id = ? OR session_hash = ?)
|
||||
AND NOT EXISTS (SELECT 1 FROM seats WHERE token_hash = ?)
|
||||
AND NOT EXISTS (SELECT 1 FROM rooms WHERE code = ?)`)
|
||||
.bind(
|
||||
code,
|
||||
JSON.stringify(game),
|
||||
now,
|
||||
...args,
|
||||
operationId,
|
||||
sessionHash,
|
||||
sessionHash,
|
||||
code,
|
||||
),
|
||||
database
|
||||
.prepare(`INSERT INTO seats(token_hash,room_code,player_id)
|
||||
SELECT ?,?,? WHERE changes() = 1`)
|
||||
.bind(sessionHash, code, hostId),
|
||||
database
|
||||
.prepare(`INSERT INTO admin_room_creations
|
||||
(operation_id,actor_admin_id,room_code,host_id,request_hash,session_hash,configuration,reason,created_at)
|
||||
SELECT ?,?,?,?,?,?,?,?,? WHERE changes() = 1`)
|
||||
.bind(
|
||||
operationId,
|
||||
identity.id,
|
||||
code,
|
||||
hostId,
|
||||
requestHash,
|
||||
sessionHash,
|
||||
publicConfiguration,
|
||||
reason,
|
||||
now,
|
||||
),
|
||||
database
|
||||
.prepare(`SELECT c.operation_id,c.actor_admin_id,c.room_code,c.host_id,c.request_hash,c.session_hash,
|
||||
EXISTS (SELECT 1 FROM seats s JOIN rooms r ON r.code = s.room_code
|
||||
WHERE s.token_hash = c.session_hash AND s.room_code = c.room_code AND s.player_id = c.host_id AND s.revoked = 0
|
||||
AND CASE WHEN json_valid(r.state) THEN EXISTS (
|
||||
SELECT 1 FROM json_each(CASE WHEN json_type(r.state, '$.players') = 'array' THEN json_extract(r.state, '$.players') ELSE '[]' END) p
|
||||
WHERE json_extract(CASE WHEN p.type = 'object' THEN p.value ELSE '{}' END, '$.id') = c.host_id
|
||||
) ELSE 0 END) AS host_access
|
||||
FROM admin_room_creations c WHERE c.operation_id = ? AND EXISTS (${mutationAuthority})`)
|
||||
.bind(operationId, ...args),
|
||||
database
|
||||
.prepare(`SELECT
|
||||
EXISTS (SELECT 1 FROM seats WHERE token_hash = ?) OR EXISTS (SELECT 1 FROM admin_room_creations WHERE session_hash = ?) AS token_used,
|
||||
EXISTS (SELECT 1 FROM rooms WHERE code = ?) AS code_used
|
||||
WHERE EXISTS (${mutationAuthority})`)
|
||||
.bind(sessionHash, sessionHash, code, ...args),
|
||||
]);
|
||||
const role = (results[0].results[0] as { role: string } | undefined)?.role;
|
||||
if (!role) throw new AdminError('Administrator sign-in required.', 401);
|
||||
if (role === 'viewer')
|
||||
throw new AdminError(
|
||||
'Your administrator role does not permit this action.',
|
||||
403,
|
||||
);
|
||||
const receipt = results[4].results[0] as
|
||||
| {
|
||||
operation_id: string;
|
||||
actor_admin_id: string;
|
||||
room_code: string;
|
||||
host_id: string;
|
||||
request_hash: string;
|
||||
session_hash: string;
|
||||
host_access: number;
|
||||
}
|
||||
| undefined;
|
||||
if (receipt) {
|
||||
if (
|
||||
receipt.actor_admin_id !== identity.id ||
|
||||
receipt.request_hash !== requestHash ||
|
||||
receipt.session_hash !== sessionHash
|
||||
)
|
||||
throw new AdminError(
|
||||
'This creation operation is bound to different settings, private proof or administrator.',
|
||||
409,
|
||||
);
|
||||
return {
|
||||
operationId: receipt.operation_id,
|
||||
code: receipt.room_code,
|
||||
hostId: receipt.host_id,
|
||||
replayed: results[1].meta.changes !== 1,
|
||||
hostAccess: receipt.host_access === 1,
|
||||
};
|
||||
}
|
||||
const conflict = results[5].results[0] as {
|
||||
token_used: number;
|
||||
code_used: number;
|
||||
};
|
||||
if (conflict.token_used)
|
||||
throw new AdminError(
|
||||
'This host session proof has already been used. Start a new creation request with a fresh private proof.',
|
||||
409,
|
||||
);
|
||||
if (!conflict.code_used)
|
||||
throw new AdminError(
|
||||
'Room creation could not be confirmed. Retry the exact saved request.',
|
||||
409,
|
||||
);
|
||||
}
|
||||
throw new AdminError(
|
||||
'No unused room invitation could be reserved. Retry the exact saved request.',
|
||||
409,
|
||||
);
|
||||
}
|
||||
@@ -68,6 +68,26 @@ export const adminRoomAudit = sqliteTable(
|
||||
],
|
||||
);
|
||||
|
||||
// Durable creation receipts retain public audit metadata after room/account removal.
|
||||
// Secret material is hashed; replay never inserts a replacement seat.
|
||||
export const adminRoomCreations = sqliteTable(
|
||||
'admin_room_creations',
|
||||
{
|
||||
operationId: text('operation_id').primaryKey(),
|
||||
actorAdminId: text('actor_admin_id').notNull(),
|
||||
roomCode: text('room_code').notNull(),
|
||||
hostId: text('host_id').notNull(),
|
||||
requestHash: text('request_hash').notNull(),
|
||||
sessionHash: text('session_hash').notNull().unique(),
|
||||
configuration: text('configuration').notNull(),
|
||||
reason: text('reason').notNull(),
|
||||
createdAt: integer('created_at').notNull(),
|
||||
},
|
||||
(table) => [
|
||||
index('admin_room_creations_room').on(table.roomCode, table.createdAt),
|
||||
],
|
||||
);
|
||||
|
||||
export const seatRecoveryKeys = sqliteTable(
|
||||
'seat_recovery_keys',
|
||||
{
|
||||
|
||||
+5
-3
@@ -11,7 +11,7 @@ recovery and persistence systems where suitable.
|
||||
| --- | --- | --- |
|
||||
| Administrator access | Personal access keys, server-enforced owner/operator/viewer roles, persistent eight-hour sessions, individual/all-session sign-out and operator provisioning/revocation. A room host is not a site administrator. Account-management UI and further operational permissions remain. | Prototyped |
|
||||
| Room directory | Search room codes/public player names, filter status/rules/availability, sort and paginate; show host, roster, modules, game change time, pause/join flags and bounded decision ownership. Detailed setup/shared-window ownership remains. | Prototyped |
|
||||
| Create and configure | Create rooms with supported rules and human/AI seats, manage lobby settings and invitations, and assign a host through an explicit workflow. Preserve normal prerequisites and readiness rules. | Missing |
|
||||
| Create and configure | [Create a lobby](ADMIN_ROOM_CREATION.md) with an explicitly owned new host seat, Basic/Advanced preview and initial AI configuration; invite humans and use ordinary lobby controls/voluntary host-seat handover. Neutral administration of lobby configuration, reserved human seats and reassignment to another existing player remain. | Prototyped, partial |
|
||||
| Lifecycle and removal | [Pause/resume and joining locks](ADMIN_ROOM_CONTROLS.md) have controls, durable audit, exact retries and player/AI enforcement. Close/end, archive, restore and recoverable/permanent removal remain missing. | Prototyped, partial |
|
||||
| Participant support | Remove disruptive participants or revoke access, manage appropriate restrictions, assist saved-seat recovery and host reassignment, and use supported AI takeover/replacement without losing forces, cards or decisions. | Missing |
|
||||
| Saved-game operations | Create/list/download backups, validate imports, restore a selected checkpoint safely, and diagnose or resume interrupted automatic work through authoritative game actions. | Missing |
|
||||
@@ -36,6 +36,8 @@ All three roles may read the current directory and sign out their own sessions.
|
||||
Owners/operators may pause/resume rooms and lock/unlock new joins through
|
||||
[Room controls](ADMIN_ROOM_CONTROLS.md). The role is checked from the live
|
||||
account, never accepted from a client.
|
||||
Owners/operators can also [create a configured lobby](ADMIN_ROOM_CREATION.md),
|
||||
with explicit new-host ownership and saved exact retries.
|
||||
Disabling an account invalidates its sessions; later re-enabling it cannot restore
|
||||
them. The database refuses to disable, demote or delete the final enabled owner.
|
||||
No default key, public account creation or host-to-administrator promotion exists.
|
||||
@@ -103,8 +105,8 @@ checks its ID before proceeding: it creates a named QA room and signs out all
|
||||
sessions of that QA account. Never supply a human operator's normal key. It checks
|
||||
authentication, cookie properties, ordinary-host denial, directory privacy,
|
||||
session revocation and unchanged game/seat continuation. Operator/owner QA keys
|
||||
also create one additional room for joining locks, pause/takeback/resume and
|
||||
account-bound request checks. Private reports retain
|
||||
also create dedicated rooms for joining locks, pause/takeback/resume,
|
||||
administrator creation, invitations and voluntary host handover. Private reports retain
|
||||
room IDs and safe outcomes, never keys/cookies. The container verifier provisions
|
||||
its own disposable QA account and checks admin-session continuity across restart
|
||||
and replacement, followed by the HTTP flow and HTTPS-proxy cookie behavior.
|
||||
|
||||
@@ -0,0 +1,88 @@
|
||||
# Creating rooms from Administration
|
||||
|
||||
Owners and operators can choose **Create a room** in the administrator directory.
|
||||
Select a host name/faction, Basic or Advanced preview, optional Tech Tokens and
|
||||
Stronghold Cards, and zero to five AI players with individual difficulties.
|
||||
Other human players join through the ordinary invitation. The new human host
|
||||
stays unready; nothing starts automatically. Tech Tokens still require three
|
||||
players at start, and Stronghold Cards require Advanced rules. Expansion starts
|
||||
and complete-mode acceptance remain gated.
|
||||
|
||||
Creation explicitly gives this browser the **new** host seat. Open it to change
|
||||
lobby settings, configure player circles, invite humans and start normally. To
|
||||
set up for another person, use the existing **Pass your seat to another player**
|
||||
flow in that lobby; the host player identity and room progress survive transfer.
|
||||
This workflow grants no access to any existing participant's seat.
|
||||
|
||||
This is a connected room-creation prototype, not complete neutral administrator
|
||||
lobby management. Creating reserved human seats, assigning a different existing
|
||||
participant as host and managing lobbies without a playing seat remain part of
|
||||
[the full panel requirements](ADMIN_PANEL.md).
|
||||
|
||||
## Saved confirmation
|
||||
|
||||
Before sending, the client saves one account-scoped creation request privately
|
||||
in this tab. It contains the exact setup, operation identifier and a new host
|
||||
session proof. Keep this tab and its storage until confirmation. A timeout or
|
||||
lost response leaves **Retry saved room creation**; after refresh, reopen
|
||||
**Create a room** to confirm that same request. It never automatically submits a
|
||||
second creation. Expired or switched administrator access retains the original
|
||||
account's pending record for later sign-in.
|
||||
|
||||
A matching response replaces the private retry proof with a safe room receipt.
|
||||
The result stays visible until closed or **Create another room** is selected.
|
||||
Invitation codes are public to intended players; the private session proof must
|
||||
never be placed in a URL, log or shared invitation. This temporary retry record
|
||||
does not replace the host's long-term saved-seat recovery kit.
|
||||
|
||||
An exact server retry returns the original room without resetting its lobby,
|
||||
readiness or later game progress. If the original host session was revoked or
|
||||
transferred, the receipt reports that access is unavailable and sends no seat
|
||||
cookie. A stale creation retry cannot recover a transferred seat or overwrite
|
||||
the recipient's credentials.
|
||||
|
||||
## Authority and persistence
|
||||
|
||||
The [creation endpoint](../app/api/admin/rooms/route.ts) requires the configured
|
||||
origin, an administrator session, an owner/operator role and the displayed
|
||||
account identifier. Ordinary room hosts and viewer administrators cannot use it.
|
||||
The [database operation](../db/admin-room-creation.ts) rechecks the live account,
|
||||
role, session generation and expiry inside its atomic write transaction.
|
||||
|
||||
Existing engine actions construct the configured lobby in memory. The room,
|
||||
hashed host session and durable creation receipt/audit commit together or roll
|
||||
back together. The receipt binds the actor, ordered setup, reason and private
|
||||
session hash. Reusing an operation for different input or another account fails;
|
||||
reusing a session proof already recorded in any seat also fails. Random invitation
|
||||
collisions retry a bounded number of times without replacing another room.
|
||||
|
||||
The additive [migration](../drizzle/0010_admin_room_creation.sql) stores safe
|
||||
configuration, actor, reason, time and hashed receipt identifiers. It does not
|
||||
copy private game contents or plaintext credentials into the audit. Administrator
|
||||
responses contain only the room/host identifiers and confirmation flags. Private
|
||||
gameplay is loaded through the normal authenticated room route.
|
||||
|
||||
## Verification
|
||||
|
||||
Focused tests cover supported setup and start gates, ordered AI seats, exact
|
||||
concurrent retries, transaction rollback, live authority, credential reuse,
|
||||
restart recovery and transfers. Client tests check account-scoped private proof,
|
||||
storage failure and replacing it only with a matching safe receipt.
|
||||
|
||||
The dedicated-operator HTTP verifier creates one extra lobby for this flow,
|
||||
checks invitation joining and performs a voluntary transfer within that QA room.
|
||||
It confirms that subsequent creation retries do not revive the former host's
|
||||
access. The lobby remains saved and does not start AI play. No existing human
|
||||
room is used. The expanded authenticated HTTP verifier passed all eight groups.
|
||||
|
||||
Local browser QA lost one successful creation response, refreshed, reopened the
|
||||
saved request and confirmed exactly one room and receipt. Its configured host
|
||||
seat opened through the ordinary route; readiness survived another refresh, and
|
||||
the QA lobby was left unready. The completed receipt also survived refresh.
|
||||
At a reported 390-pixel viewport, the form used 16-pixel text and a 44-pixel create
|
||||
button without horizontal overflow. A requested 1280-pixel override continued to
|
||||
report 390 pixels, so this run does not establish desktop layout acceptance.
|
||||
|
||||
Source, browser, container and deployed acceptance are separate
|
||||
evidence; authenticated production checks still require explicitly authorized QA
|
||||
administrator access.
|
||||
+15
-9
@@ -6,13 +6,19 @@ Expansion starts and full rules/publication acceptance remain gated.**
|
||||
|
||||
## Current checkpoint and work
|
||||
|
||||
Current implementation adds [administrator pause/resume and joining locks](ADMIN_ROOM_CONTROLS.md):
|
||||
usable controls, availability filters, player guidance, stopped human/AI
|
||||
decisions, durable audit and account-bound exact retries. Recovery, discussion
|
||||
and AI takeback remain available. Focused persistence, authenticated local HTTP
|
||||
and desktop/mobile browser checks accompany the checkpoint. Remaining lifecycle
|
||||
and full-admin requirements stay open; authenticated production acceptance waits
|
||||
for the required QA-access confirmation.
|
||||
Current work adds [administrator room creation](ADMIN_ROOM_CREATION.md): a new
|
||||
explicitly owned human host seat, supported rules/modules, initial AI seats,
|
||||
invitation joining and exact saved retries. Creation uses ordinary engine setup
|
||||
and preserves normal readiness/start gates. Neutral administrator configuration,
|
||||
reserved human seats and reassignment to existing participants remain unfinished.
|
||||
|
||||
Checkpoint `8c922b4` added [pause/resume and joining locks](ADMIN_ROOM_CONTROLS.md)
|
||||
and passed types/lint, 5,223 offline tests, 52 HTTP tests and build, with independent
|
||||
review and dedicated local administrator/browser checks. It is deployed on the
|
||||
NAS: container verification passed, migration 0009 applied, all eight prior rooms
|
||||
and ten seats were preserved, and a saved seat restored through public HTTPS.
|
||||
Anonymous administrator requests remain denied. Authenticated production admin
|
||||
acceptance still requires the pending QA-access confirmation.
|
||||
|
||||
Checkpoint `f29d056` was pushed and deployed to the NAS instance. Readable
|
||||
create/join progress and Continue notices passed actual HTTPS browser acceptance,
|
||||
@@ -27,8 +33,8 @@ Continue control. It does not add confirmation steps to game rules or AI turns.
|
||||
|
||||
Administrator access/directory checkpoint `c2d392e` passed types, lint, 5,196
|
||||
offline tests, 52 HTTP tests and build, plus focused authenticated/browser checks.
|
||||
Its production acceptance is being combined with this readability follow-up to
|
||||
avoid two deployments; saved games and full administration gates remain intact.
|
||||
Its authenticated production acceptance remains pending; the current deployment
|
||||
preserves saved games and full administration gates.
|
||||
|
||||
The user added a complete [administration panel](ADMIN_PANEL.md) to the goal on
|
||||
22 September: secure admin access, room creation/removal and lifecycle controls,
|
||||
|
||||
@@ -1,5 +1,15 @@
|
||||
# Dune implementation status
|
||||
|
||||
## 22 September 2026 — Administrator room creation
|
||||
|
||||
Added [configured lobby creation](ADMIN_ROOM_CREATION.md) with explicit new-host
|
||||
ownership, initial AI factions/difficulties, supported optional rules, invitations
|
||||
and the ordinary voluntary host-seat transfer path. Atomic live-authorized writes
|
||||
and saved account-bound requests keep retries from duplicating rooms or reviving
|
||||
revoked private-seat access. Normal readiness and preview gates remain. Full
|
||||
neutral lobby administration, participant support and authenticated production
|
||||
acceptance remain unfinished; verification evidence accompanies the checkpoint.
|
||||
|
||||
## 22 September 2026 — Administrator room pause and joining locks
|
||||
|
||||
Added reversible pause/resume and joining-lock controls, availability filters
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
CREATE TABLE `admin_room_creations` (
|
||||
`operation_id` text PRIMARY KEY NOT NULL,
|
||||
`actor_admin_id` text NOT NULL,
|
||||
`room_code` text NOT NULL,
|
||||
`host_id` text NOT NULL,
|
||||
`request_hash` text NOT NULL,
|
||||
`session_hash` text NOT NULL,
|
||||
`configuration` text NOT NULL,
|
||||
`reason` text NOT NULL,
|
||||
`created_at` integer NOT NULL
|
||||
);
|
||||
--> statement-breakpoint
|
||||
CREATE UNIQUE INDEX `admin_room_creations_session_hash_unique` ON `admin_room_creations` (`session_hash`);--> statement-breakpoint
|
||||
CREATE INDEX `admin_room_creations_room` ON `admin_room_creations` (`room_code`,`created_at`);
|
||||
File diff suppressed because it is too large.
Load diff
@@ -71,6 +71,13 @@
|
||||
"when": 1790035625313,
|
||||
"tag": "0009_admin_room_controls",
|
||||
"breakpoints": true
|
||||
},
|
||||
{
|
||||
"idx": 10,
|
||||
"version": "6",
|
||||
"when": 1790038013633,
|
||||
"tag": "0010_admin_room_creation",
|
||||
"breakpoints": true
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
import { randomId } from './random-id';
|
||||
import { validAdminRoomCreationInput, type AdminRoomCreationInput, type AdminRoomCreationResult } from './admin-room-creation';
|
||||
|
||||
type Storage = Pick<globalThis.Storage, 'getItem' | 'setItem' | 'removeItem'>;
|
||||
export type AdminRoomCreationRecord = { kind: 'pending'; input: AdminRoomCreationInput } | { kind: 'completed'; result: AdminRoomCreationResult };
|
||||
const key = (account: string) => `dune.admin-room-creation.v1:${account}`;
|
||||
const uuid = (value: unknown) => typeof value === 'string' && value.length === 36 && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(value);
|
||||
|
||||
export function validAdminRoomCreationResult(value: unknown): value is AdminRoomCreationResult {
|
||||
if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
|
||||
const result = value as Record<string, unknown>;
|
||||
return Object.keys(result).length === 5 && typeof result.code === 'string' && result.code.length === 8 && /^[A-Z2-9]{8}$/.test(result.code) &&
|
||||
uuid(result.hostId) && uuid(result.operationId) && typeof result.replayed === 'boolean' && typeof result.hostAccess === 'boolean';
|
||||
}
|
||||
|
||||
export function newAdminRoomCreationRequest(fields: Omit<AdminRoomCreationInput, 'operationId' | 'sessionToken'>): AdminRoomCreationInput {
|
||||
const input = { ...fields, name: fields.name.trim(), reason: fields.reason.trim(), operationId: randomId(),
|
||||
sessionToken: Array.from(globalThis.crypto.getRandomValues(new Uint8Array(32)), byte => byte.toString(16).padStart(2, '0')).join('') };
|
||||
if (!validAdminRoomCreationInput(input)) throw new Error('Check the host, rules, AI seats and operational reason.');
|
||||
return input;
|
||||
}
|
||||
|
||||
export function readAdminRoomCreation(storage: Storage, account: string): AdminRoomCreationRecord | null {
|
||||
const raw = storage.getItem(key(account));
|
||||
if (raw === null) return null;
|
||||
let value: unknown;
|
||||
try { value = raw.length <= 4096 ? JSON.parse(raw) : null; } catch { value = null; }
|
||||
if (value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 2) {
|
||||
const record = value as Record<string, unknown>;
|
||||
if (record.kind === 'pending' && validAdminRoomCreationInput(record.input)) return value as AdminRoomCreationRecord;
|
||||
if (record.kind === 'completed' && validAdminRoomCreationResult(record.result)) return value as AdminRoomCreationRecord;
|
||||
}
|
||||
throw new Error('This tab’s saved room-creation record is unreadable. Keep it until you have checked the room directory; no new request has been sent.');
|
||||
}
|
||||
|
||||
function write(storage: Storage, account: string, record: AdminRoomCreationRecord) {
|
||||
const text = JSON.stringify(record);
|
||||
storage.setItem(key(account), text);
|
||||
if (storage.getItem(key(account)) !== text) throw new Error('The room-creation record could not be saved in this tab.');
|
||||
}
|
||||
|
||||
export function saveAdminRoomCreation(storage: Storage, account: string, input: AdminRoomCreationInput) {
|
||||
if (!validAdminRoomCreationInput(input)) throw new Error('Invalid room-creation request.');
|
||||
const previous = readAdminRoomCreation(storage, account);
|
||||
if (previous && (previous.kind !== 'pending' || JSON.stringify(previous.input) !== JSON.stringify(input)))
|
||||
throw new Error('Resolve the saved room-creation record before creating another room.');
|
||||
write(storage, account, { kind: 'pending', input });
|
||||
}
|
||||
|
||||
export function completeAdminRoomCreation(storage: Storage, account: string, input: AdminRoomCreationInput, result: AdminRoomCreationResult) {
|
||||
if (!validAdminRoomCreationResult(result) || result.operationId !== input.operationId) throw new Error('The server did not confirm this room-creation request.');
|
||||
const previous = readAdminRoomCreation(storage, account);
|
||||
if (!previous || previous.kind !== 'pending' || JSON.stringify(previous.input) !== JSON.stringify(input))
|
||||
throw new Error('The saved room-creation record changed. Keep the current record and inspect the room directory.');
|
||||
// Replace the private retry proof with a safe room receipt in one storage write.
|
||||
write(storage, account, { kind: 'completed', result });
|
||||
}
|
||||
|
||||
export function clearAdminRoomCreation(storage: Storage, account: string) {
|
||||
storage.removeItem(key(account));
|
||||
if (storage.getItem(key(account)) !== null) throw new Error('The local room-creation record could not be cleared.');
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
import { FACTIONS, type FactionId } from '../game/catalog';
|
||||
import { DIFFICULTIES, type Difficulty } from '../game/bot-profiles';
|
||||
|
||||
export type AdminRoomCreationInput = {
|
||||
operationId: string;
|
||||
sessionToken: string;
|
||||
name: string;
|
||||
faction: FactionId;
|
||||
advanced: boolean;
|
||||
techTokens: boolean;
|
||||
strongholdCards: boolean;
|
||||
bots: { faction: FactionId; difficulty: Difficulty }[];
|
||||
reason: string;
|
||||
};
|
||||
|
||||
/** Only creation confirmation; it never contains a game or another seat's data. */
|
||||
export type AdminRoomCreationResult = {
|
||||
operationId: string;
|
||||
code: string;
|
||||
hostId: string;
|
||||
replayed: boolean;
|
||||
hostAccess: boolean;
|
||||
};
|
||||
|
||||
const object = (value: unknown): value is Record<string, unknown> =>
|
||||
!!value && typeof value === 'object' && !Array.isArray(value);
|
||||
const exactKeys = (value: Record<string, unknown>, keys: string[]) =>
|
||||
Object.keys(value).length === keys.length &&
|
||||
keys.every((key) => Object.hasOwn(value, key));
|
||||
const baseFaction = (value: unknown): value is FactionId =>
|
||||
FACTIONS.some(
|
||||
(faction) => faction.id === value && faction.expansion === 'base',
|
||||
);
|
||||
const noControls = (value: string) =>
|
||||
value
|
||||
.split('')
|
||||
.every((char) => char.charCodeAt(0) >= 32 && char.charCodeAt(0) !== 127);
|
||||
|
||||
/** Matches the admitted ordinary lobby profile; actual engine actions construct it. */
|
||||
export function validAdminRoomCreationInput(
|
||||
value: unknown,
|
||||
): value is AdminRoomCreationInput {
|
||||
if (
|
||||
!object(value) ||
|
||||
!exactKeys(value, [
|
||||
'operationId',
|
||||
'sessionToken',
|
||||
'name',
|
||||
'faction',
|
||||
'advanced',
|
||||
'techTokens',
|
||||
'strongholdCards',
|
||||
'bots',
|
||||
'reason',
|
||||
]) ||
|
||||
typeof value.operationId !== 'string' ||
|
||||
value.operationId.length !== 36 ||
|
||||
!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(
|
||||
value.operationId,
|
||||
) ||
|
||||
typeof value.sessionToken !== 'string' ||
|
||||
value.sessionToken.length !== 64 ||
|
||||
!/^[0-9a-f]{64}$/.test(value.sessionToken) ||
|
||||
typeof value.name !== 'string' ||
|
||||
value.name.length > 256 ||
|
||||
value.name.trim().length < 1 ||
|
||||
value.name.trim().length > 32 ||
|
||||
!noControls(value.name) ||
|
||||
!baseFaction(value.faction) ||
|
||||
typeof value.advanced !== 'boolean' ||
|
||||
typeof value.techTokens !== 'boolean' ||
|
||||
typeof value.strongholdCards !== 'boolean' ||
|
||||
(value.strongholdCards && !value.advanced) ||
|
||||
!Array.isArray(value.bots) ||
|
||||
value.bots.length > 5 ||
|
||||
typeof value.reason !== 'string' ||
|
||||
!value.reason.trim() ||
|
||||
value.reason.length > 300 ||
|
||||
!noControls(value.reason)
|
||||
)
|
||||
return false;
|
||||
const factions = new Set([value.faction]);
|
||||
for (const bot of value.bots) {
|
||||
if (
|
||||
!object(bot) ||
|
||||
!exactKeys(bot, ['faction', 'difficulty']) ||
|
||||
!baseFaction(bot.faction) ||
|
||||
!DIFFICULTIES.some((difficulty) => difficulty === bot.difficulty) ||
|
||||
factions.has(bot.faction)
|
||||
)
|
||||
return false;
|
||||
factions.add(bot.faction);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
@@ -26,6 +26,14 @@ void test('admin HTTP denies anonymous, forged admin, room-host and spoofed iden
|
||||
});
|
||||
assert.equal(write.status, 401);
|
||||
assert.deepEqual(Object.keys(await write.json()), ['error']);
|
||||
const create = await fetch(base + '/api/admin/rooms', {
|
||||
method: 'POST', headers: { ...headers, origin: base, 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ operationId: crypto.randomUUID(), sessionToken: 'b'.repeat(64), name: 'Denied creation QA', faction: 'atreides', advanced: false, techTokens: false, strongholdCards: false, bots: [], reason: 'Must not create a room' }),
|
||||
signal: AbortSignal.timeout(15000),
|
||||
});
|
||||
assert.equal(create.status, 401);
|
||||
assert.equal(create.headers.get('set-cookie'), null);
|
||||
assert.deepEqual(Object.keys(await create.json()), ['error']);
|
||||
}
|
||||
});
|
||||
void test('admin HTTP rejects login CSRF, oversized bodies and invalid credentials without setting sessions', async () => {
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { clearAdminRoomCreation, completeAdminRoomCreation, newAdminRoomCreationRequest, readAdminRoomCreation, saveAdminRoomCreation, validAdminRoomCreationResult } from '../lib/admin-room-creation-client';
|
||||
import type { AdminRoomCreationResult } from '../lib/admin-room-creation';
|
||||
|
||||
const fields = () => ({ name: ' Host QA ', faction: 'atreides' as const, advanced: true, techTokens: true, strongholdCards: true,
|
||||
bots: [{ faction: 'fremen' as const, difficulty: 'Easy' as const }, { faction: 'guild' as const, difficulty: 'Hard' as const }], reason: ' Dedicated QA lobby ' });
|
||||
function storage() {
|
||||
const values = new Map<string, string>();
|
||||
return { values, getItem: (key: string) => values.get(key) ?? null, setItem: (key: string, value: string) => { values.set(key, value); }, removeItem: (key: string) => { values.delete(key); } };
|
||||
}
|
||||
const receipt = (operationId: string): AdminRoomCreationResult => ({ operationId, code: 'ABCD2345', hostId: crypto.randomUUID(), replayed: true, hostAccess: true });
|
||||
|
||||
void test('creation retry preserves one exact private host proof and roster order in its original administrator scope', () => {
|
||||
const tab = storage(), input = newAdminRoomCreationRequest(fields());
|
||||
assert.equal(input.name, 'Host QA'); assert.equal(input.reason, 'Dedicated QA lobby');
|
||||
assert.match(input.sessionToken, /^[0-9a-f]{64}$/);
|
||||
saveAdminRoomCreation(tab, 'operator-a', input);
|
||||
assert.deepEqual(readAdminRoomCreation(tab, 'operator-a'), { kind: 'pending', input });
|
||||
assert.equal(readAdminRoomCreation(tab, 'operator-b'), null);
|
||||
assert.throws(() => saveAdminRoomCreation(tab, 'operator-a', newAdminRoomCreationRequest(fields())), /Resolve the saved/);
|
||||
assert.throws(() => saveAdminRoomCreation(tab, 'operator-a', { ...input, bots: [...input.bots].reverse() }), /Resolve the saved/);
|
||||
saveAdminRoomCreation(tab, 'operator-a', input);
|
||||
assert.deepEqual(readAdminRoomCreation(tab, 'operator-a'), { kind: 'pending', input });
|
||||
});
|
||||
|
||||
void test('only a matching valid receipt replaces the private retry proof with safe completed-room metadata', () => {
|
||||
const tab = storage(), input = newAdminRoomCreationRequest(fields());
|
||||
saveAdminRoomCreation(tab, 'a', input);
|
||||
assert.throws(() => completeAdminRoomCreation(tab, 'a', input, receipt(crypto.randomUUID())), /did not confirm/);
|
||||
assert.equal(readAdminRoomCreation(tab, 'a')?.kind, 'pending');
|
||||
const result = receipt(input.operationId);
|
||||
completeAdminRoomCreation(tab, 'a', input, result);
|
||||
assert.deepEqual(readAdminRoomCreation(tab, 'a'), { kind: 'completed', result });
|
||||
const raw = [...tab.values.values()].join('');
|
||||
assert.equal(raw.includes(input.sessionToken), false);
|
||||
assert.equal(raw.includes(input.reason), false);
|
||||
assert.throws(() => saveAdminRoomCreation(tab, 'a', newAdminRoomCreationRequest(fields())), /Resolve the saved/);
|
||||
clearAdminRoomCreation(tab, 'a');
|
||||
assert.equal(readAdminRoomCreation(tab, 'a'), null);
|
||||
});
|
||||
|
||||
void test('unavailable, corrupt or replaced tab storage never silently authorizes a different creation', () => {
|
||||
const tab = storage(), input = newAdminRoomCreationRequest(fields());
|
||||
assert.throws(() => saveAdminRoomCreation({ ...tab, setItem() {} }, 'a', input), /could not be saved/);
|
||||
saveAdminRoomCreation(tab, 'a', input);
|
||||
const key = [...tab.values.keys()][0];
|
||||
tab.values.set(key, '{broken');
|
||||
assert.throws(() => readAdminRoomCreation(tab, 'a'), /unreadable/);
|
||||
assert.throws(() => saveAdminRoomCreation(tab, 'a', input), /unreadable/);
|
||||
assert.equal(tab.values.get(key), '{broken');
|
||||
tab.values.set(key, JSON.stringify({ kind: 'pending', input: newAdminRoomCreationRequest(fields()) }));
|
||||
assert.throws(() => completeAdminRoomCreation(tab, 'a', input, receipt(input.operationId)), /record changed/);
|
||||
});
|
||||
|
||||
void test('revoked host receipts remain readable without claiming access and malformed/secret-bearing results cannot clear proof', () => {
|
||||
const result = { ...receipt(crypto.randomUUID()), hostAccess: false };
|
||||
assert.equal(validAdminRoomCreationResult(result), true);
|
||||
for (const invalid of [null, [], { ...result, hostAccess: undefined }, { ...result, code: result.code + '\n' }, { ...result, hostId: 'not-an-id' }, { ...result, sessionToken: 'private' }])
|
||||
assert.equal(validAdminRoomCreationResult(invalid), false);
|
||||
assert.throws(() => newAdminRoomCreationRequest({ ...fields(), strongholdCards: true, advanced: false }));
|
||||
assert.throws(() => newAdminRoomCreationRequest({ ...fields(), bots: [{ faction: 'atreides', difficulty: 'Easy' }] }));
|
||||
});
|
||||
@@ -0,0 +1,769 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { randomBytes, randomUUID, webcrypto } from 'node:crypto';
|
||||
import { mkdtempSync, readFileSync, readdirSync, rmSync } from 'node:fs';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { join } from 'node:path';
|
||||
import { DatabaseSync } from 'node:sqlite';
|
||||
import { runInNewContext } from 'node:vm';
|
||||
import ts from 'typescript';
|
||||
import { adminStore, pauseAdminBatch, sha256 } from './admin-access-fixture';
|
||||
import {
|
||||
adminLogin,
|
||||
requireAdmin,
|
||||
adminLogoutAll,
|
||||
AdminError,
|
||||
type AdminRole,
|
||||
} from '../db/admin-access';
|
||||
import { createAdminRoom } from '../db/admin-room-creation';
|
||||
import {
|
||||
validAdminRoomCreationInput,
|
||||
type AdminRoomCreationInput,
|
||||
} from '../lib/admin-room-creation';
|
||||
import * as engine from '../game/engine';
|
||||
import * as bots from '../game/bots';
|
||||
import * as seatAiDelegation from '../lib/seat-ai-delegation';
|
||||
import type * as Rooms from '../db/rooms';
|
||||
|
||||
const secret = () => randomBytes(32).toString('hex');
|
||||
const input = (
|
||||
patch: Partial<AdminRoomCreationInput> = {},
|
||||
): AdminRoomCreationInput => ({
|
||||
operationId: randomUUID(),
|
||||
sessionToken: secret(),
|
||||
name: 'Creation QA host',
|
||||
faction: 'atreides',
|
||||
advanced: false,
|
||||
techTokens: false,
|
||||
strongholdCards: false,
|
||||
bots: [{ faction: 'harkonnen', difficulty: 'Hard' }],
|
||||
reason: 'Dedicated QA room creation',
|
||||
...patch,
|
||||
});
|
||||
const status = (wanted: number) => (error: unknown) =>
|
||||
error instanceof AdminError && error.status === wanted;
|
||||
const rows = (sqlite: DatabaseSync, table: string) =>
|
||||
sqlite.prepare(`SELECT * FROM ${table}`).all();
|
||||
const saved = (sqlite: DatabaseSync, code: string) =>
|
||||
JSON.parse(
|
||||
String(
|
||||
sqlite.prepare('SELECT state FROM rooms WHERE code=?').get(code)!.state,
|
||||
),
|
||||
) as engine.Game;
|
||||
|
||||
function loadRooms(database: D1Database) {
|
||||
const exports = {};
|
||||
runInNewContext(
|
||||
ts.transpileModule(
|
||||
readFileSync(new URL('../db/rooms.ts', import.meta.url), 'utf8'),
|
||||
{
|
||||
compilerOptions: {
|
||||
module: ts.ModuleKind.CommonJS,
|
||||
target: ts.ScriptTarget.ES2022,
|
||||
},
|
||||
},
|
||||
).outputText,
|
||||
{
|
||||
exports,
|
||||
crypto: webcrypto,
|
||||
TextEncoder,
|
||||
structuredClone,
|
||||
JSON,
|
||||
require: (name: string) => {
|
||||
if (name === 'cloudflare:workers') return { env: { DB: database } };
|
||||
if (name === '@/game/engine') return engine;
|
||||
if (name === '@/game/bots') return bots;
|
||||
if (name === '@/lib/seat-ai-delegation') return seatAiDelegation;
|
||||
throw new Error('Unexpected dependency ' + name);
|
||||
},
|
||||
},
|
||||
);
|
||||
return exports as typeof Rooms;
|
||||
}
|
||||
async function fixture(role: AdminRole = 'operator') {
|
||||
const store = adminStore();
|
||||
const account = store.provision(role);
|
||||
const login = await adminLogin(store.database, account.key);
|
||||
const identity = await requireAdmin(store.database, login.token);
|
||||
const rooms = loadRooms(store.database);
|
||||
const create = (request = input(), now = 10000) =>
|
||||
createAdminRoom(store.database, identity, request, now);
|
||||
return { ...store, identity, account, login, rooms, create };
|
||||
}
|
||||
|
||||
void test('admin creation migration adds only its durable receipt table and indexes', () => {
|
||||
const store = adminStore(':memory:', false);
|
||||
try {
|
||||
for (const file of readdirSync(new URL('../drizzle/', import.meta.url))
|
||||
.filter((file) => file.endsWith('.sql') && file < '0010')
|
||||
.sort())
|
||||
store.sqlite.exec(
|
||||
readFileSync(new URL('../drizzle/' + file, import.meta.url), 'utf8'),
|
||||
);
|
||||
store.sqlite
|
||||
.prepare(
|
||||
'INSERT INTO rooms(code,state,version,updated_at) VALUES(?,?,?,?)',
|
||||
)
|
||||
.run('PRESERVE', '{"private":"saved game"}', 17, 123);
|
||||
store.sqlite
|
||||
.prepare(
|
||||
'INSERT INTO seats(token_hash,room_code,player_id) VALUES(?,?,?)',
|
||||
)
|
||||
.run(sha256(secret()), 'PRESERVE', randomUUID());
|
||||
const account = store.provision('owner');
|
||||
const before = ['rooms', 'seats', 'admin_accounts', 'admin_audit'].map(
|
||||
(table) => rows(store.sqlite, table),
|
||||
);
|
||||
store.sqlite.exec(
|
||||
readFileSync(
|
||||
new URL('../drizzle/0010_admin_room_creation.sql', import.meta.url),
|
||||
'utf8',
|
||||
),
|
||||
);
|
||||
assert.deepEqual(
|
||||
['rooms', 'seats', 'admin_accounts', 'admin_audit'].map((table) =>
|
||||
rows(store.sqlite, table),
|
||||
),
|
||||
before,
|
||||
);
|
||||
assert.deepEqual(rows(store.sqlite, 'admin_room_creations'), []);
|
||||
assert.throws(
|
||||
() =>
|
||||
store.sqlite
|
||||
.prepare('UPDATE admin_accounts SET enabled=0 WHERE id=?')
|
||||
.run(account.id),
|
||||
/last|final|owner/i,
|
||||
);
|
||||
} finally {
|
||||
store.sqlite.close();
|
||||
}
|
||||
});
|
||||
|
||||
void test('admin creates zero through five AI seats through ordinary lobby actions with one unready human host', async () => {
|
||||
const f = await fixture();
|
||||
try {
|
||||
const factions = [
|
||||
'harkonnen',
|
||||
'emperor',
|
||||
'fremen',
|
||||
'guild',
|
||||
'beneGesserit',
|
||||
] as const;
|
||||
for (let n = 0; n <= 5; n++) {
|
||||
const request = input({
|
||||
bots: factions.slice(0, n).map((faction, index) => ({
|
||||
faction,
|
||||
difficulty: (['Easy', 'Medium', 'Hard', 'Brutal'] as const)[
|
||||
index % 4
|
||||
],
|
||||
})),
|
||||
});
|
||||
const result = await f.create(request);
|
||||
assert.deepEqual(Object.keys(result).sort(), [
|
||||
'code',
|
||||
'hostAccess',
|
||||
'hostId',
|
||||
'operationId',
|
||||
'replayed',
|
||||
]);
|
||||
assert.equal(result.operationId, request.operationId);
|
||||
assert.equal(result.replayed, false);
|
||||
assert.equal(result.hostAccess, true);
|
||||
assert.match(result.code, /^[ABCDEFGHJKLMNPQRSTUVWXYZ23456789]{8}$/);
|
||||
const game = saved(f.sqlite, result.code);
|
||||
assert.equal(game.status, 'lobby');
|
||||
assert.equal(game.version, 0);
|
||||
assert.equal(game.host, result.hostId);
|
||||
assert.equal(game.players.length, n + 1);
|
||||
assert.equal(game.players[0].ready, false);
|
||||
assert.equal(game.players[0].bot, undefined);
|
||||
assert.deepEqual(
|
||||
game.players.slice(1).map((player) => ({
|
||||
faction: player.faction,
|
||||
difficulty: player.bot,
|
||||
})),
|
||||
request.bots,
|
||||
);
|
||||
assert.ok(game.players.slice(1).every((player) => player.ready));
|
||||
assert.deepEqual(game.deck, []);
|
||||
assert.equal(game.botsPending ?? false, false);
|
||||
assert.equal(game.botNextActionAt, undefined);
|
||||
assert.deepEqual(game.expansions, []);
|
||||
assert.equal(game.advancedPreview, undefined);
|
||||
const seat = f.sqlite
|
||||
.prepare('SELECT * FROM seats WHERE room_code=?')
|
||||
.all(result.code);
|
||||
assert.equal(seat.length, 1);
|
||||
assert.equal(seat[0].token_hash, sha256(request.sessionToken));
|
||||
assert.equal(seat[0].player_id, result.hostId);
|
||||
const auth = await f.rooms.authenticate(
|
||||
result.code,
|
||||
request.sessionToken,
|
||||
);
|
||||
const view = await f.rooms.readSeatView(result.code, auth);
|
||||
assert.equal(view.me, result.hostId);
|
||||
assert.equal(view.host, result.hostId);
|
||||
assert.equal(JSON.stringify(view).includes(request.reason), false);
|
||||
}
|
||||
assert.equal(rows(f.sqlite, 'rooms').length, 6);
|
||||
assert.equal(rows(f.sqlite, 'seats').length, 6);
|
||||
} finally {
|
||||
f.sqlite.close();
|
||||
}
|
||||
});
|
||||
|
||||
void test('Basic and explicit Advanced preview genuinely start, retain modules, offer human choices and legally continue AI after JSON restore', async () => {
|
||||
const f = await fixture();
|
||||
try {
|
||||
for (const advanced of [false, true]) {
|
||||
const request = input({
|
||||
advanced,
|
||||
techTokens: true,
|
||||
strongholdCards: advanced,
|
||||
bots: [
|
||||
{ faction: 'harkonnen', difficulty: 'Easy' },
|
||||
{ faction: 'guild', difficulty: 'Medium' },
|
||||
],
|
||||
});
|
||||
const created = await f.create(request);
|
||||
const auth = await f.rooms.authenticate(
|
||||
created.code,
|
||||
request.sessionToken,
|
||||
);
|
||||
let now = 10000;
|
||||
const clock = {
|
||||
now: () => now,
|
||||
sleep: async (ms: number) => {
|
||||
now += ms;
|
||||
},
|
||||
};
|
||||
let view = await f.rooms.readSeatView(created.code, auth);
|
||||
assert.equal(view.status, 'lobby');
|
||||
assert.ok(view.techTokens);
|
||||
assert.equal(!!view.strongholdCards, advanced);
|
||||
await assert.rejects(
|
||||
f.rooms.act(
|
||||
created.code,
|
||||
auth,
|
||||
view.version,
|
||||
{ type: 'start', ...(advanced ? { advancedPreview: true } : {}) },
|
||||
clock,
|
||||
),
|
||||
/ready/i,
|
||||
);
|
||||
view = await f.rooms.act(
|
||||
created.code,
|
||||
auth,
|
||||
view.version,
|
||||
{ type: 'ready' },
|
||||
clock,
|
||||
);
|
||||
if (advanced)
|
||||
await assert.rejects(
|
||||
f.rooms.act(
|
||||
created.code,
|
||||
auth,
|
||||
view.version,
|
||||
{ type: 'start' },
|
||||
clock,
|
||||
),
|
||||
/Advanced.*unfinished|preview/i,
|
||||
);
|
||||
view = await f.rooms.act(
|
||||
created.code,
|
||||
auth,
|
||||
view.version,
|
||||
{ type: 'start', ...(advanced ? { advancedPreview: true } : {}) },
|
||||
clock,
|
||||
);
|
||||
assert.equal(view.status, 'setup');
|
||||
assert.equal(view.advancedPreview, advanced);
|
||||
const ownerChoices = view.players.find(
|
||||
(player) => player.id === view.me,
|
||||
)!.traitorChoices;
|
||||
assert.ok(ownerChoices?.length);
|
||||
await loadRooms(f.database).continueRoomBots(created.code, 4, clock);
|
||||
const restored = await loadRooms(f.database).readSeatView(
|
||||
created.code,
|
||||
auth,
|
||||
);
|
||||
assert.deepEqual(
|
||||
restored.players.find((player) => player.id === view.me)!
|
||||
.traitorChoices,
|
||||
ownerChoices,
|
||||
);
|
||||
assert.ok(restored.version > view.version);
|
||||
for (const player of restored.players.filter(
|
||||
(player) => player.id !== view.me,
|
||||
)) {
|
||||
assert.equal('hand' in player, false);
|
||||
assert.equal('traitors' in player, false);
|
||||
assert.equal('traitorChoices' in player, false);
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
f.sqlite.close();
|
||||
}
|
||||
});
|
||||
|
||||
void test('Tech Tokens remain selectable in a small lobby but ordinary start still requires three players', async () => {
|
||||
const f = await fixture();
|
||||
try {
|
||||
const request = input({ techTokens: true });
|
||||
const created = await f.create(request);
|
||||
const auth = await f.rooms.authenticate(created.code, request.sessionToken);
|
||||
const view = await f.rooms.act(created.code, auth, 0, { type: 'ready' });
|
||||
const before = rows(f.sqlite, 'rooms');
|
||||
await assert.rejects(
|
||||
f.rooms.act(created.code, auth, view.version, { type: 'start' }),
|
||||
/three players/i,
|
||||
);
|
||||
assert.deepEqual(rows(f.sqlite, 'rooms'), before);
|
||||
const added = await f.rooms.act(created.code, auth, view.version, {
|
||||
type: 'addBot',
|
||||
faction: 'guild',
|
||||
difficulty: 'Hard',
|
||||
});
|
||||
const ready = await f.rooms.act(created.code, auth, added.version, {
|
||||
type: 'ready',
|
||||
});
|
||||
assert.equal(
|
||||
(await f.rooms.act(created.code, auth, ready.version, { type: 'start' }))
|
||||
.status,
|
||||
'setup',
|
||||
);
|
||||
} finally {
|
||||
f.sqlite.close();
|
||||
}
|
||||
});
|
||||
|
||||
void test('strict creation input rejects malformed proof, missing or unknown fields, duplicate/expansion factions and unsupported profiles before persistence', async () => {
|
||||
const f = await fixture();
|
||||
try {
|
||||
const missing = input();
|
||||
delete (missing as Partial<AdminRoomCreationInput>).reason;
|
||||
const invalid: unknown[] = [
|
||||
null,
|
||||
[],
|
||||
missing,
|
||||
...[
|
||||
{ operationId: randomUUID() + '\n' },
|
||||
{ sessionToken: secret() + '\n' },
|
||||
{ sessionToken: 'short' },
|
||||
{ name: ' ' },
|
||||
{ name: 'x'.repeat(33) },
|
||||
{ name: 'line\nbreak' },
|
||||
{ reason: ' ' },
|
||||
{ reason: 'x'.repeat(301) },
|
||||
{ reason: 'line\nbreak' },
|
||||
{ advanced: 'true' },
|
||||
{ strongholdCards: true },
|
||||
{ faction: 'ixians' },
|
||||
{ expansion: ['ix'] },
|
||||
{ start: true },
|
||||
{ hostId: randomUUID() },
|
||||
{ bots: Array(6).fill({ faction: 'guild', difficulty: 'Hard' }) },
|
||||
{ bots: [{ faction: 'atreides', difficulty: 'Hard' }] },
|
||||
{
|
||||
bots: [
|
||||
{ faction: 'guild', difficulty: 'Hard' },
|
||||
{ faction: 'guild', difficulty: 'Easy' },
|
||||
],
|
||||
},
|
||||
{ bots: [{ faction: 'ixians', difficulty: 'Hard' }] },
|
||||
{ bots: [{ faction: 'guild', difficulty: 'Impossible' }] },
|
||||
{ bots: [{ faction: 'guild', difficulty: 'Hard', ready: true }] },
|
||||
].map((patch) => ({ ...input(), ...patch })),
|
||||
];
|
||||
for (const request of invalid) {
|
||||
assert.equal(validAdminRoomCreationInput(request), false);
|
||||
await assert.rejects(
|
||||
f.create(request as AdminRoomCreationInput),
|
||||
status(400),
|
||||
);
|
||||
}
|
||||
assert.equal(rows(f.sqlite, 'rooms').length, 0);
|
||||
assert.equal(rows(f.sqlite, 'seats').length, 0);
|
||||
assert.equal(rows(f.sqlite, 'admin_room_creations').length, 0);
|
||||
} finally {
|
||||
f.sqlite.close();
|
||||
}
|
||||
});
|
||||
|
||||
void test('live owner/operator roles authorize creation and viewer, unknown session and forged role cannot create or replay', async () => {
|
||||
for (const role of ['owner', 'operator', 'viewer'] as const) {
|
||||
const f = await fixture(role);
|
||||
try {
|
||||
const request = input();
|
||||
const attempt = createAdminRoom(
|
||||
f.database,
|
||||
{ ...f.identity, role: 'owner' },
|
||||
request,
|
||||
);
|
||||
if (role === 'viewer') {
|
||||
await assert.rejects(attempt, status(403));
|
||||
assert.equal(rows(f.sqlite, 'rooms').length, 0);
|
||||
} else {
|
||||
await attempt;
|
||||
if (role === 'operator') {
|
||||
f.sqlite
|
||||
.prepare("UPDATE admin_accounts SET role='viewer' WHERE id=?")
|
||||
.run(f.identity.id);
|
||||
await assert.rejects(f.create(request), status(403));
|
||||
}
|
||||
}
|
||||
await assert.rejects(
|
||||
createAdminRoom(
|
||||
f.database,
|
||||
{ ...f.identity, sessionHash: secret() },
|
||||
input(),
|
||||
),
|
||||
status(401),
|
||||
);
|
||||
} finally {
|
||||
f.sqlite.close();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
void test('creation and receipt reads recheck disable, logout, expiry and demotion inside the transaction', async () => {
|
||||
for (const replay of [false, true])
|
||||
for (const mode of ['disable', 'logout', 'expiry', 'demote'] as const) {
|
||||
const f = await fixture();
|
||||
try {
|
||||
const request = input();
|
||||
if (replay) await f.create(request);
|
||||
const before = ['rooms', 'seats', 'admin_room_creations'].map((table) =>
|
||||
rows(f.sqlite, table),
|
||||
);
|
||||
const gate = pauseAdminBatch(f);
|
||||
const pending = f.create(request);
|
||||
await gate.waiting;
|
||||
if (mode === 'disable')
|
||||
f.sqlite
|
||||
.prepare('UPDATE admin_accounts SET enabled=0 WHERE id=?')
|
||||
.run(f.identity.id);
|
||||
else if (mode === 'logout')
|
||||
await adminLogoutAll(f.database, f.identity);
|
||||
else if (mode === 'expiry')
|
||||
f.sqlite
|
||||
.prepare(
|
||||
'UPDATE admin_sessions SET expires_at=1 WHERE token_hash=?',
|
||||
)
|
||||
.run(f.identity.sessionHash);
|
||||
else
|
||||
f.sqlite
|
||||
.prepare("UPDATE admin_accounts SET role='viewer' WHERE id=?")
|
||||
.run(f.identity.id);
|
||||
gate.release();
|
||||
await assert.rejects(pending, status(mode === 'demote' ? 403 : 401));
|
||||
assert.deepEqual(
|
||||
['rooms', 'seats', 'admin_room_creations'].map((table) =>
|
||||
rows(f.sqlite, table),
|
||||
),
|
||||
before,
|
||||
);
|
||||
} finally {
|
||||
f.sqlite.close();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
void test('same-operation concurrency and normalized exact retries commit one room, seat and public audit receipt', async () => {
|
||||
const f = await fixture();
|
||||
try {
|
||||
const request = input({
|
||||
name: ' Creation QA host ',
|
||||
reason: ' Dedicated QA room creation ',
|
||||
bots: [
|
||||
{ faction: 'guild', difficulty: 'Hard' },
|
||||
{ faction: 'harkonnen', difficulty: 'Easy' },
|
||||
],
|
||||
});
|
||||
const gate = pauseAdminBatch(f);
|
||||
const pending = f.create(request);
|
||||
await gate.waiting;
|
||||
const winner = await f.create(request);
|
||||
gate.release();
|
||||
const retry = await pending;
|
||||
assert.deepEqual(retry, { ...winner, replayed: true });
|
||||
assert.deepEqual(
|
||||
await f.create({
|
||||
...request,
|
||||
name: request.name.trim(),
|
||||
reason: request.reason.trim(),
|
||||
}),
|
||||
retry,
|
||||
);
|
||||
const before = ['rooms', 'seats', 'admin_room_creations'].map((table) =>
|
||||
rows(f.sqlite, table),
|
||||
);
|
||||
for (const patch of [
|
||||
{ name: 'Changed host' },
|
||||
{ sessionToken: secret() },
|
||||
{ advanced: true },
|
||||
{ techTokens: true },
|
||||
{ bots: [...request.bots].reverse() },
|
||||
{ reason: 'Changed reason' },
|
||||
])
|
||||
await assert.rejects(f.create({ ...request, ...patch }), status(409));
|
||||
const other = f.provision('operator');
|
||||
const login = await adminLogin(f.database, other.key);
|
||||
const identity = await requireAdmin(f.database, login.token);
|
||||
await assert.rejects(
|
||||
createAdminRoom(f.database, identity, request),
|
||||
status(409),
|
||||
);
|
||||
assert.deepEqual(
|
||||
['rooms', 'seats', 'admin_room_creations'].map((table) =>
|
||||
rows(f.sqlite, table),
|
||||
),
|
||||
before,
|
||||
);
|
||||
const audit = rows(f.sqlite, 'admin_room_creations')[0];
|
||||
assert.equal(audit.actor_admin_id, f.identity.id);
|
||||
assert.equal(audit.room_code, winner.code);
|
||||
assert.equal(audit.host_id, winner.hostId);
|
||||
assert.equal(audit.created_at, 10000);
|
||||
assert.equal(audit.session_hash, sha256(request.sessionToken));
|
||||
const config = JSON.parse(String(audit.configuration));
|
||||
assert.deepEqual(Object.keys(config).sort(), [
|
||||
'advanced',
|
||||
'bots',
|
||||
'faction',
|
||||
'name',
|
||||
'strongholdCards',
|
||||
'techTokens',
|
||||
]);
|
||||
assert.deepEqual(config.bots, request.bots);
|
||||
for (const value of [
|
||||
request.sessionToken,
|
||||
f.identity.sessionHash,
|
||||
'traitorChoices',
|
||||
'deck',
|
||||
])
|
||||
assert.equal(JSON.stringify(audit).includes(value), false);
|
||||
} finally {
|
||||
f.sqlite.close();
|
||||
}
|
||||
});
|
||||
|
||||
void test('session hashes cannot be reused from active/revoked seats or durable creation receipts after room removal', async () => {
|
||||
const f = await fixture();
|
||||
try {
|
||||
const original = input();
|
||||
const created = await f.create(original);
|
||||
for (const revoked of [0, 1]) {
|
||||
f.sqlite
|
||||
.prepare('UPDATE seats SET revoked=? WHERE token_hash=?')
|
||||
.run(revoked, sha256(original.sessionToken));
|
||||
await assert.rejects(
|
||||
f.create(input({ sessionToken: original.sessionToken })),
|
||||
status(409),
|
||||
);
|
||||
}
|
||||
f.sqlite.prepare('DELETE FROM rooms WHERE code=?').run(created.code);
|
||||
assert.deepEqual(await f.create(original), {
|
||||
...created,
|
||||
replayed: true,
|
||||
hostAccess: false,
|
||||
});
|
||||
await assert.rejects(
|
||||
f.create(input({ sessionToken: original.sessionToken })),
|
||||
status(409),
|
||||
);
|
||||
const ordinaryToken = secret();
|
||||
const ordinary = await f.rooms.createRoom(
|
||||
'Ordinary QA owner',
|
||||
'atreides',
|
||||
false,
|
||||
[],
|
||||
{ operationId: randomUUID(), sessionToken: ordinaryToken },
|
||||
);
|
||||
await assert.rejects(
|
||||
f.create(input({ sessionToken: ordinaryToken })),
|
||||
status(409),
|
||||
);
|
||||
f.sqlite
|
||||
.prepare('UPDATE seats SET revoked=1 WHERE room_code=?')
|
||||
.run(ordinary.view.code);
|
||||
await assert.rejects(
|
||||
f.create(input({ sessionToken: ordinaryToken })),
|
||||
status(409),
|
||||
);
|
||||
assert.equal(rows(f.sqlite, 'rooms').length, 1);
|
||||
assert.equal(rows(f.sqlite, 'admin_room_creations').length, 1);
|
||||
} finally {
|
||||
f.sqlite.close();
|
||||
}
|
||||
});
|
||||
|
||||
void test('seat/audit storage failures roll back all new room records and preserve other saved games', async () => {
|
||||
const f = await fixture();
|
||||
try {
|
||||
await f.create();
|
||||
for (const table of ['seats', 'admin_room_creations']) {
|
||||
const before = ['rooms', 'seats', 'admin_room_creations'].map((name) =>
|
||||
rows(f.sqlite, name),
|
||||
);
|
||||
f.sqlite.exec(
|
||||
`CREATE TRIGGER reject_creation BEFORE INSERT ON ${table} BEGIN SELECT RAISE(ABORT,'QA creation failure'); END;`,
|
||||
);
|
||||
await assert.rejects(f.create(), /QA creation failure/);
|
||||
assert.deepEqual(
|
||||
['rooms', 'seats', 'admin_room_creations'].map((name) =>
|
||||
rows(f.sqlite, name),
|
||||
),
|
||||
before,
|
||||
);
|
||||
f.sqlite.exec('DROP TRIGGER reject_creation');
|
||||
}
|
||||
} finally {
|
||||
f.sqlite.close();
|
||||
}
|
||||
});
|
||||
|
||||
void test('room invitation collisions retry boundedly without replacing existing games or retaining partial seats', async (t) => {
|
||||
const f = await fixture();
|
||||
try {
|
||||
f.sqlite
|
||||
.prepare(
|
||||
'INSERT INTO rooms(code,state,version,updated_at) VALUES(?,?,?,?)',
|
||||
)
|
||||
.run('AAAAAAAA', '{"private":"preserve"}', 7, 42);
|
||||
const before = rows(f.sqlite, 'rooms')[0];
|
||||
let calls = 0;
|
||||
const random = t.mock.method(globalThis.crypto, 'getRandomValues', (<
|
||||
T extends ArrayBufferView | null,
|
||||
>(
|
||||
array: T,
|
||||
): T => {
|
||||
(array as Uint8Array).fill(calls++ === 0 ? 0 : 1);
|
||||
return array;
|
||||
}) as typeof crypto.getRandomValues);
|
||||
const first = await f.create(input({ bots: [] }));
|
||||
assert.equal(first.code, 'BBBBBBBB');
|
||||
assert.equal(calls, 2);
|
||||
assert.deepEqual(rows(f.sqlite, 'rooms')[0], before);
|
||||
random.mock.restore();
|
||||
const collision = t.mock.method(globalThis.crypto, 'getRandomValues', (<
|
||||
T extends ArrayBufferView | null,
|
||||
>(
|
||||
array: T,
|
||||
): T => {
|
||||
(array as Uint8Array).fill(0);
|
||||
return array;
|
||||
}) as typeof crypto.getRandomValues);
|
||||
const request = input({ bots: [] });
|
||||
await assert.rejects(f.create(request), status(409));
|
||||
assert.equal(collision.mock.callCount(), 5);
|
||||
assert.equal(rows(f.sqlite, 'rooms').length, 2);
|
||||
assert.equal(rows(f.sqlite, 'seats').length, 1);
|
||||
assert.equal(rows(f.sqlite, 'admin_room_creations').length, 1);
|
||||
collision.mock.restore();
|
||||
assert.equal((await f.create(request)).replayed, false);
|
||||
} finally {
|
||||
t.mock.restoreAll();
|
||||
f.sqlite.close();
|
||||
}
|
||||
});
|
||||
|
||||
void test('durable creation receipt and hash-only host seat survive database close/reopen with exact latest-state replay', async () => {
|
||||
const dir = mkdtempSync(join(tmpdir(), 'dune-admin-create-'));
|
||||
let store = adminStore(join(dir, 'rooms.sqlite'));
|
||||
try {
|
||||
const account = store.provision('operator');
|
||||
const login = await adminLogin(store.database, account.key);
|
||||
const identity = await requireAdmin(store.database, login.token);
|
||||
const request = input();
|
||||
const created = await createAdminRoom(store.database, identity, request);
|
||||
const rooms = loadRooms(store.database);
|
||||
const auth = await rooms.authenticate(created.code, request.sessionToken);
|
||||
const ready = await rooms.act(created.code, auth, 0, { type: 'ready' });
|
||||
const before = rows(store.sqlite, 'rooms');
|
||||
store.sqlite.close();
|
||||
store = adminStore(join(dir, 'rooms.sqlite'), false);
|
||||
assert.deepEqual(await createAdminRoom(store.database, identity, request), {
|
||||
...created,
|
||||
replayed: true,
|
||||
});
|
||||
assert.deepEqual(rows(store.sqlite, 'rooms'), before);
|
||||
const restored = await loadRooms(store.database).readSeatView(
|
||||
created.code,
|
||||
auth,
|
||||
);
|
||||
assert.deepEqual(restored, ready);
|
||||
assert.equal(rows(store.sqlite, 'admin_room_creations').length, 1);
|
||||
} finally {
|
||||
store.sqlite.close();
|
||||
rmSync(dir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
void test('exact creation retries never regrant a revoked, recovered, handed-over or removed host seat', async () => {
|
||||
for (const lost of [
|
||||
'revoked',
|
||||
'recovered',
|
||||
'handover',
|
||||
'missing-player',
|
||||
'malformed-game',
|
||||
] as const) {
|
||||
const f = await fixture();
|
||||
try {
|
||||
const request = input();
|
||||
const created = await f.create(request);
|
||||
const auth = await f.rooms.authenticate(
|
||||
created.code,
|
||||
request.sessionToken,
|
||||
);
|
||||
if (lost === 'revoked')
|
||||
f.sqlite
|
||||
.prepare('UPDATE seats SET revoked=1 WHERE token_hash=?')
|
||||
.run(auth.tokenHash);
|
||||
else if (lost === 'recovered') {
|
||||
const recoverySecret = secret();
|
||||
await f.rooms.setRecoveryKey(created.code, auth, 0, recoverySecret);
|
||||
await f.rooms.recoverSeat(created.code, {
|
||||
playerId: auth.playerId,
|
||||
recoverySecret,
|
||||
operationId: randomUUID(),
|
||||
newSessionToken: secret(),
|
||||
});
|
||||
} else if (lost === 'handover') {
|
||||
const offer = { offerId: randomUUID(), handoverSecret: secret() };
|
||||
await f.rooms.createSeatHandover(created.code, auth, 0, offer);
|
||||
await f.rooms.claimSeatHandover(created.code, {
|
||||
playerId: auth.playerId,
|
||||
...offer,
|
||||
operationId: randomUUID(),
|
||||
newSessionToken: secret(),
|
||||
});
|
||||
} else if (lost === 'missing-player')
|
||||
f.sqlite
|
||||
.prepare(
|
||||
"UPDATE rooms SET state=json_set(state,'$.players',json('[]')) WHERE code=?",
|
||||
)
|
||||
.run(created.code);
|
||||
else
|
||||
f.sqlite
|
||||
.prepare('UPDATE rooms SET state=? WHERE code=?')
|
||||
.run('{invalid', created.code);
|
||||
const before = ['rooms', 'seats', 'admin_room_creations'].map((table) =>
|
||||
rows(f.sqlite, table),
|
||||
);
|
||||
assert.deepEqual(await f.create(request), {
|
||||
...created,
|
||||
replayed: true,
|
||||
hostAccess: false,
|
||||
});
|
||||
assert.deepEqual(
|
||||
['rooms', 'seats', 'admin_room_creations'].map((table) =>
|
||||
rows(f.sqlite, table),
|
||||
),
|
||||
before,
|
||||
);
|
||||
} finally {
|
||||
f.sqlite.close();
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,57 @@
|
||||
// Create a dedicated QA lobby; never inspect or mutate an existing human room.
|
||||
import assert from 'node:assert/strict';
|
||||
import { randomBytes, randomUUID } from 'node:crypto';
|
||||
|
||||
export async function verifyRoomCreation(request, adminCookie, report) {
|
||||
const secret = () => randomBytes(32).toString('hex');
|
||||
const input = { operationId: randomUUID(), sessionToken: secret(), name: 'Admin creation QA ' + Date.now(), faction: 'atreides', advanced: true,
|
||||
techTokens: true, strongholdCards: true, bots: [{ faction: 'fremen', difficulty: 'Easy' }, { faction: 'guild', difficulty: 'Hard' }], reason: 'Dedicated admin room creation acceptance' };
|
||||
try {
|
||||
const mismatched = await request('/api/admin/rooms', input, adminCookie, undefined, randomUUID());
|
||||
assert.equal(mismatched.status, 401); assert.equal(mismatched.rawCookie, null);
|
||||
const invalid = await request('/api/admin/rooms', { ...input, advanced: false }, adminCookie);
|
||||
assert.equal(invalid.status, 400); assert.equal(invalid.rawCookie, null);
|
||||
const made = await request('/api/admin/rooms', input, adminCookie);
|
||||
assert.equal(made.status, 200);
|
||||
assert.deepEqual(Object.keys(made.data).sort(), ['code', 'hostAccess', 'hostId', 'operationId', 'replayed']);
|
||||
assert.equal(made.data.operationId, input.operationId); assert.equal(made.data.replayed, false); assert.equal(made.data.hostAccess, true);
|
||||
const code = made.data.code, path = '/api/rooms/' + code, host = made.cookie;
|
||||
report.creationRoom = code;
|
||||
for (const attribute of ['HttpOnly', 'SameSite=Strict', 'Path=/api/rooms/' + code]) assert.ok(made.rawCookie.includes(attribute));
|
||||
const first = await request(path, undefined, host);
|
||||
assert.equal(first.status, 200); assert.equal(first.data.me, made.data.hostId); assert.equal(first.data.host, made.data.hostId);
|
||||
assert.equal(first.data.status, 'lobby'); assert.equal(first.data.advanced, true);
|
||||
assert.ok(first.data.techTokens); assert.ok(first.data.strongholdCards); assert.equal(first.data.players.length, 3);
|
||||
assert.equal(first.data.players.find(player => player.id === first.data.me).ready, false);
|
||||
assert.deepEqual(first.data.players.filter(player => player.bot).map(player => [player.faction, player.bot]), input.bots.map(bot => [bot.faction, bot.difficulty]));
|
||||
const ready = await request(path, { version: first.data.version, action: { type: 'ready' } }, host);
|
||||
assert.equal(ready.status, 200);
|
||||
const replay = await request('/api/admin/rooms', input, adminCookie);
|
||||
assert.equal(replay.status, 200); assert.equal(replay.data.replayed, true); assert.equal(replay.data.code, code); assert.equal(replay.cookie, host);
|
||||
assert.deepEqual((await request(path, undefined, host)).data, ready.data, 'Creation retry must not reset configured or readied lobby');
|
||||
const directory = await request('/api/admin/rooms?q=' + encodeURIComponent(input.name), undefined, adminCookie);
|
||||
assert.equal(directory.status, 200); assert.equal(directory.data.total, 1);
|
||||
const joined = await request(path, { type: 'join', name: 'Creation invited human QA', faction: 'emperor' });
|
||||
assert.equal(joined.status, 200); assert.equal(joined.data.players.length, 4);
|
||||
report.checks.push('Admin creation preserves supported rules and ordered AI seats; exact retry finds one lobby and invitations admit a human');
|
||||
|
||||
const current = (await request(path, undefined, host)).data;
|
||||
const offer = { offerId: randomUUID(), handoverSecret: secret() };
|
||||
const offered = await request(path + '/control', { type: 'createSeatHandover', version: current.version, ...offer }, host);
|
||||
assert.equal(offered.status, 200);
|
||||
const claimed = await request(path + '/control', { type: 'claimSeatHandover', playerId: current.me, ...offer, operationId: randomUUID(), newSessionToken: secret() });
|
||||
assert.equal(claimed.status, 200);
|
||||
const transferred = await request(path, undefined, claimed.cookie);
|
||||
assert.equal(transferred.status, 200); assert.equal(transferred.data.me, current.me); assert.equal(transferred.data.host, current.me);
|
||||
const afterTransfer = await request('/api/admin/rooms', input, adminCookie);
|
||||
assert.equal(afterTransfer.status, 200); assert.equal(afterTransfer.data.code, code);
|
||||
assert.equal(afterTransfer.data.replayed, true); assert.equal(afterTransfer.data.hostAccess, false); assert.equal(afterTransfer.rawCookie, null);
|
||||
assert.notEqual((await request(path, undefined, host)).status, 200);
|
||||
assert.deepEqual((await request(path, undefined, claimed.cookie)).data, transferred.data);
|
||||
report.checks.push('Voluntary host handover preserves lobby; later admin creation retry cannot revive old private-seat access');
|
||||
} catch (error) {
|
||||
report.failureRequest ??= report.lastRequest;
|
||||
report.creationFailure = 'Administrator room creation acceptance failed; the dedicated lobby remains saved.';
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@ import { readFile, mkdir, realpath, writeFile } from 'node:fs/promises';
|
||||
import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { verifyRoomLifecycle } from './admin-lifecycle-verification.mjs';
|
||||
import { verifyRoomCreation } from './admin-creation-verification.mjs';
|
||||
|
||||
const options = {};
|
||||
for (let n = 2; n < process.argv.length; n += 2) {
|
||||
@@ -30,7 +31,7 @@ async function request(path, body, cookie, origin = base, expectedAdminId = admi
|
||||
const response = await fetch(base + path, {
|
||||
method: body === undefined ? 'GET' : 'POST',
|
||||
headers: { ...(body === undefined ? {} : { 'content-type': 'application/json', origin }), ...(cookie ? { cookie } : {}),
|
||||
...(expectedAdminId && /^\/api\/admin\/rooms\/[^/]+\/control$/.test(path) ? { 'X-Dune-Admin-Id': expectedAdminId } : {}) },
|
||||
...(expectedAdminId && (path === '/api/admin/rooms' && body !== undefined || /^\/api\/admin\/rooms\/[^/]+\/control$/.test(path)) ? { 'X-Dune-Admin-Id': expectedAdminId } : {}) },
|
||||
...(body === undefined ? {} : { body: JSON.stringify(body) }), signal: AbortSignal.timeout(15000),
|
||||
});
|
||||
report.lastRequest = { path, status: response.status };
|
||||
@@ -83,6 +84,7 @@ try {
|
||||
assert.equal(lifecycleSession.status, 200);
|
||||
session1 = lifecycleSession.cookie;
|
||||
await verifyRoomLifecycle(request, session1, report);
|
||||
await verifyRoomCreation(request, session1, report);
|
||||
}
|
||||
report.passed = true;
|
||||
} catch (error) {
|
||||
|
||||
Reference in new issue
Block a user