Referees and anti-cheat

// The leaderboard's referee: rebuild a case from its number with the
// Register's own engine and report who the killer is.
//
//   node referee/solve.mjs CODE DIFFICULTY MODE   →   {"engine":8,"killer":1234,...}
import { generateCase, unseal } from '../games/static/games/the-register/engine/generator.js';

const [code, difficulty, mode] = process.argv.slice(2);
try {
  const c = generateCase(code, difficulty, mode);
  if (!c.validation.ok) throw new Error('case failed validation');
  process.stdout.write(JSON.stringify({ engine: c.engine, killer: unseal(c.solution), title: c.title, names: c.names.length }));
} catch (e) {
  process.stderr.write(String(e.message || e));
  process.exit(1);
}

@require_POST
def submit(request):
    if not request.user.is_authenticated:
        return _fail(401, "Sign in to post your time.", login=reverse("accounts:login", args=["the-register"]), signup=reverse("accounts:signup", args=["the-register"]))
    try:
        body = json.loads(request.body)
        code, difficulty, mode = str(body["code"]).upper(), body["difficulty"], body["mode"]
        engine, accused = int(body["engine"]), int(body["accused"])
        seconds, wrong, hints = int(body["seconds"]), int(body.get("wrong", 0)), int(body.get("hints", 0))
    except (ValueError, KeyError, TypeError):
        return _fail(400, "That submission was incomplete.")
    if not CODE_RE.match(code) or difficulty not in DIFFICULTIES or mode not in MODES or not (0 <= wrong <= 999 and 0 <= hints <= 999):
        return _fail(400, "That submission didn’t describe a case.")
    if not scoring.MIN_SECONDS <= seconds <= scoring.MAX_SECONDS:
        return _fail(422, "That time doesn’t look like a real solve.")
    if not cached(code, difficulty, mode, engine) and not _may_build(request.user):
        return _fail(429, "That’s a lot of new cases in an hour. Try posting again later.")
    try:
        case = solution(code, difficulty, mode, engine)
    except RefereeBusy as e:
        return _fail(202, str(e), retry=True)
    except RefereeError as e:
        return _fail(422, str(e))
    if accused != case.killer:
        return _fail(422, "That isn’t the killer of this case.")

    existing = Score.objects.filter(user=request.user, case=case).first()
    if existing:
        return _done(existing, already=True)
    try:
        score = Score.objects.create(
            user=request.user, case=case, seconds=seconds, wrong=wrong, hints=hints,
            final_seconds=scoring.final_seconds(seconds, wrong, hints), points=scoring.points(difficulty, mode, wrong, hints),
        )
    except IntegrityError:
        return _done(Score.objects.get(user=request.user, case=case), already=True)
    record(request, "score_submitted", game="the-register", mode=mode, difficulty=difficulty)
    return _done(score)

def build(code, difficulty, mode, timeout=120):
    """Run the engine. Returns {engine, killer, title, names}."""
    try:
        done = node.run([SCRIPT, code, difficulty, mode], timeout=timeout)
    except subprocess.TimeoutExpired as e:
        raise RefereeBusy("Still checking this case. Try posting again in a moment.") from e
    # What went wrong is for the logs; the player gets a sentence with a way
    # forward, never the engine's raw output (docs/design-language.md, rule 15).
    except OSError as e:
        log.error("Referee couldn't start for %s/%s/%s: %s", code, difficulty, mode, e)
        raise RefereeError(UNCHECKED) from e
    if done.returncode:
        log.error("Referee failed for %s/%s/%s: %s", code, difficulty, mode, done.stderr.strip()[:500])
        raise RefereeError(UNCHECKED)
    return json.loads(done.stdout)

def solution(code, difficulty, mode, engine):
    """The case's killer: from the cache, or by building it within a request's time."""
    found = cached(code, difficulty, mode, engine)
    if found:
        return found
    if engine != ENGINE:  # Node would build this server's engine's case, then the answer would be refused: don't run it
        raise RefereeError("This case was made by a different version of the game, so it can’t be checked.")
    try:
        return _save(code, difficulty, mode, engine, build(code, difficulty, mode, timeout=REQUEST_TIMEOUT))
    except RefereeBusy:
        warm(code, difficulty, mode, engine)
        raise

def warm(code, difficulty, mode, engine):
    """Queue a case to be checked in the background, unless it's known or queued."""
    global _worker
    if not settings.REFEREE_WARM:
        return
    if engine != ENGINE:
        return
    key = (code, difficulty, mode, engine)
    if cached(*key):
        return
    with _lock:
        if key in _waiting or len(_waiting) >= MAX_WAITING:
            return
        _waiting.add(key)
        if _worker is None or not _worker.is_alive():
            _worker = threading.Thread(target=_work, name="referee", daemon=True)
            _worker.start()
    _queue.put(key)

def _work():
    while True:
        key = _queue.get()
        close_old_connections()
        try:
            if not cached(*key):
                _save(*key, build(*key[:3]))
        except Exception:  # a background check must never take the site down
            log.exception("Background check of %s failed", key)
        finally:
            with _lock:
                _waiting.discard(key)
            close_old_connections()

// Hashi's referee: make a puzzle from its code with the game's own engine and
// report its islands, so the server can check a posted solve against them.
//
//   node referee/hashi.mjs CODE SIZE [VERSION]   →   {"engine":3,"w":10,"h":10,"islands":[[x,y,n],…]}
//
// VERSION, if given, is an earlier engine version the engine still makes
// (its VERSIONS), for a daily made under it; any other is refused.
import { generate, ENGINE_VERSION } from '../games/static/games/hashi/engine/generate.js';

const [code, size, version] = process.argv.slice(2);
try {
  const p = generate(code, size, version ?? ENGINE_VERSION);
  process.stdout.write(JSON.stringify({ engine: p.engine, w: p.w, h: p.h, islands: p.islands }));
} catch (e) {
  process.stderr.write(String(e.message || e));
  process.exit(1);
}

def puzzle(code, size, engine, legacy=""):
    """The puzzle, from the cache or made now. A puzzle cached under an older
    engine still checks, since its islands were kept; so does one of an
    earlier version the engine still makes (a daily made under it); any
    other the server's engine didn't make can't be."""
    found = _cache(code, size, engine, legacy).first()
    if found:
        return found
    if engine not in VERSIONS:
        raise RefereeError(OLD_VERSION)
    built = build(code, size, engine)
    if built.get("engine") != engine:
        raise RefereeError(OLD_VERSION)
    made, _ = Puzzle.objects.get_or_create(
        code=code, size=size, legacy_difficulty="", engine=engine,
        defaults={"w": built["w"], "h": built["h"], "islands": built["islands"]},
    )
    return made

def solves(w, h, islands, bridges):
    """True if the bridges solve the puzzle: each island has exactly its
    number, no built bridge crosses another, and it's all one piece."""
    links, crosses = layout(w, h, islands)
    counts = counts_from(links, bridges)
    if counts is None:
        return False
    have = [0] * len(islands)
    for (a, b, *_), c in zip(links, counts):
        have[a] += c
        have[b] += c
    if any(have[i] != n for i, (_, _, n) in enumerate(islands)):
        return False
    if any(counts[k] and any(counts[j] for j in crosses[k]) for k in range(len(links))):
        return False
    # One piece: follow the built bridges out from the first island.
    near = [[] for _ in islands]
    for (a, b, *_), c in zip(links, counts):
        if c:
            near[a].append(b)
            near[b].append(a)
    seen, todo = {0}, [0]
    while todo:
        for j in near[todo.pop()]:
            if j not in seen:
                seen.add(j)
                todo.append(j)
    return len(seen) == len(islands)

@require_POST
def submit(request):
    if not request.user.is_authenticated:
        return _fail(401, "Sign in to post your time.", login=reverse("accounts:login", args=["hashi"]), signup=reverse("accounts:signup", args=["hashi"]))
    try:
        body = json.loads(request.body)
        code, size = str(body["code"]).upper(), _number(body["size"])
        engine, seconds = _number(body["engine"]), _number(body["seconds"])
        # Hashi no longer has difficulties (ADR 0024). A solve of a puzzle from
        # before that, posted from a tab left open or held for sign-in, still
        # names it, and it's how that puzzle is told apart from its siblings.
        legacy = str(body.get("difficulty", "")) if engine == 1 else ""
        bridges = [tuple(_index(n) for n in bridge) for bridge in body["bridges"]]
    except (ValueError, KeyError, TypeError, RecursionError):  # RecursionError: JSON nested a hundred thousand deep
        return _fail(400, "That submission was incomplete.")
    if not CODE_RE.match(code) or size not in SIZES or (legacy and legacy not in LEGACY_DIFFICULTIES) or not 0 < len(bridges) <= 1000 or any(len(b) != 3 for b in bridges):
        return _fail(400, "That submission didn’t describe a puzzle.")
    if not plausible(size, seconds):
        return _fail(422, "That time doesn’t look like a real solve.")
    if not cached(code, size, engine, legacy) and not _may_build(request.user):
        return _fail(429, "That’s a lot of new puzzles in an hour. Try posting again later.")
    try:
        found = puzzle(code, size, engine, legacy)
    except RefereeDown as e:
        return _fail(503, str(e), retry=True)
    except RefereeError as e:
        return _fail(422, str(e))
    if not check.solves(found.w, found.h, found.islands, bridges):
        return _fail(422, "Those bridges don’t solve this puzzle.")

    existing = Solve.objects.filter(user=request.user, puzzle=found).select_related("puzzle", "daily").first()
    if existing:
        return _done(existing, already=True)
    # A daily solve counts on the day's board only if it arrives that day.
    slot = DailyPuzzle.objects.filter(date=today(), code=code, size=size, engine=engine).first()
    try:
        solve = Solve.objects.create(user=request.user, puzzle=found, daily=slot, seconds=seconds)
    except IntegrityError:
        return _done(Solve.objects.select_related("puzzle", "daily").get(user=request.user, puzzle=found), already=True)
    record(request, "score_submitted", game="hashi", mode=str(size), daily=bool(slot))
    return _done(solve)

// The pencil-puzzle kit's referee: one entry for every puzzle on the kit,
// each run with its own engine (games/static/games/puzzles/engine/engines.js;
// docs/puzzles.md, ADR 0023). The input is JSON on stdin; the answer is JSON
// on stdout.
//
//   node referee/puzzles.mjs make  {"slug":"star-battle","code":"ABC234","size":"8","difficulty":"medium"}
//     → {"engine":2,"puzzle":{…as the engine made it},"solution":[3,13,…]}
//
// `make` may name an "engine": an earlier version the engine still makes
// (its VERSIONS), for a daily made under it; any other is refused.
//
//   node referee/puzzles.mjs check {"slug":"star-battle","puzzle":{…},"answer":[3,13,…]}
//     → {"engine":1,"ok":true}
//
// `make` is the puzzle the engine makes from its code, and its one answer
// in its written form; the server keeps both and compares a posted answer
// with it. `check` runs the engine's own rules on an answer, for a puzzle
// kept without its answer.
//
// A judged puzzle (its engine exports JUDGED: Chicago Traffic, where any
// legal answer solves it) has no one answer to compare: `make`'s solution
// is one of the shortest, and `check` is how a posted answer is judged,
// saying too how many moves it took, as the engine counts them:
//
//   node referee/puzzles.mjs check {"slug":"chicago-traffic","puzzle":{…},"answer":[["A",-1],…]}
//     → {"engine":1,"ok":true,"moves":23} A code the engine won't make exits with status 2
// (the player's message says so); anything else that goes wrong, status 1.
import { engine } from '../games/static/games/puzzles/engine/engines.js';

class Refused extends Error {}

const read = async () => {
  let text = '';
  for await (const chunk of process.stdin) text += chunk;
  return JSON.parse(text);
};

try {
  const [command] = process.argv.slice(2);
  const input = await read();
  let game;
  try {
    game = await engine(String(input.slug));
  } catch (e) {
    throw new Refused(e.message);
  }
  let out;
  if (command === 'make') {
    const version = input.engine ?? game.ENGINE_VERSION;
    let puzzle;
    try {
      if (!(game.VERSIONS || [game.ENGINE_VERSION]).includes(version)) throw new Error(`This engine doesn't make version ${version}.`);
      const args = [String(input.code), String(input.size), String(input.difficulty)];
      puzzle = await (version === game.ENGINE_VERSION ? game.generate(...args) : game.generate(...args, {}, version));
    } catch (e) {
      throw new Refused(e.message);
    }
    out = { engine: version, puzzle, solution: game.solution(puzzle) };
  } else if (command === 'check') {
    out = { ok: game.check(input.puzzle, input.answer) === true };
    if (game.JUDGED && out.ok) out.moves = game.movesOf(input.answer);
  } else {
    throw new Error('Usage: puzzles.mjs make|check < input.json');
  }
  process.stdout.write(JSON.stringify({ engine: game.ENGINE_VERSION, ...out }));
} catch (e) {
  process.stderr.write(String(e.message || e));
  process.exit(e instanceof Refused ? 2 : 1);
}

def run(command, payload):
    try:
        done = node.run([SCRIPT, command], input=json.dumps(payload), timeout=TIMEOUT)
    except subprocess.TimeoutExpired as e:
        raise RefereeDown("The referee took too long with this puzzle. Try posting again in a moment.") from e
    except OSError as e:
        raise RefereeDown("The referee isn’t working just now. Try posting again later.") from e
    if done.returncode == REFUSED:
        log.warning("The referee wouldn't %s %s: %s", command, payload.get("slug"), done.stderr.strip()[:200])
        raise RefereeError("The referee couldn’t make this puzzle, so it can’t be checked.")
    if done.returncode:
        log.warning("The puzzle referee failed on %s: %s", command, done.stderr.strip()[:200])
        raise RefereeDown("The referee isn’t working just now. Try posting again later.")
    try:
        return json.loads(done.stdout)
    except ValueError as e:
        raise RefereeDown("The referee isn’t working just now. Try posting again later.") from e

def puzzle(kind, code, size, difficulty, engine):
    """The puzzle, from the cache or made now. A puzzle kept under an older
    engine still checks, since it was kept; so does one of an earlier
    version the engine still makes (a daily made under it); any other the
    server's engine didn't make can't be."""
    found = cached(kind, code, size, difficulty, engine)
    if found:
        return found
    if engine not in kind.versions:
        raise RefereeError(ANOTHER_VERSION)
    built = build(kind, code, size, difficulty, engine)
    if built.get("engine") != engine:
        raise RefereeError(ANOTHER_VERSION)
    if built.get("solution") is None:
        # Every puzzle the engine makes has one answer its solver finds.
        log.error("The referee made %s %s %s %s without an answer", kind.slug, code, size, difficulty)
        raise RefereeDown("The referee isn’t working just now. Try posting again later.")
    made, _ = Puzzle.objects.get_or_create(
        kind=kind.slug, code=code, size=size, difficulty=difficulty, engine=engine,
        defaults={"data": built["puzzle"], "solution": built["solution"]},
    )
    return made

def solves(kind, found, answer):
    """Whether a cleaned answer solves a kept puzzle. Every pencil puzzle on
    the kit has exactly one answer (the engine proves it), so it's the kept
    answer or it's wrong; a puzzle kept without its answer asks the engine.
    (A brainteaser's answer is how it was played, and many solve it, so the
    engine judges every one: `judged`, above.)"""
    if found.solution is not None:
        return answer == found.solution
    return judge(kind, found.data, answer)

def clean(answer, size):
    """An answer is the cells holding stars (row * n + column): whole
    numbers on the grid, none twice, n × stars of them. Written increasing."""
    n, stars = GRIDS[size]
    if not isinstance(answer, list) or len(answer) != n * stars:
        raise ValueError("not the right number of stars")
    # Exactly integers: not a bool (an int to Python), a fraction or text.
    if not all(type(i) is int and 0 <= i < n * n for i in answer) or len(set(answer)) != len(answer):
        raise ValueError("not cells of the grid")
    return sorted(answer)

/**
 * The referee: deal the board's code and play `moves` through. A solve
 * counts only if every move is legal and the last one wins (nothing after
 * the win). A line is the player's whole play, undos included: "u3" takes
 * back the last three moves (an Undo press and the helpers' moves it
 * took with it), and costs one. The count that ranks is the moves still
 * standing plus one for every undo, so it's worked out here, from the
 * line, and never taken from the player.
 * Returns { ok: true, moves, kept, undos } or { ok: false, error, at }
 * where `at` is the index of the entry that failed.
 */
export function replay(boardKey, code, moves) {
  if (!BOARDS[boardKey]) return { ok: false, error: 'unknown board', at: -1 };
  if (!CODE_RE.test(code)) return { ok: false, error: 'bad code', at: -1 };
  if (!Array.isArray(moves)) return { ok: false, error: 'no moves', at: -1 };
  const state = deal(boardKey, code);
  const g = rules(state);
  const done = [];
  let undos = 0;
  for (let k = 0; k < moves.length; k++) {
    if (g.won(state)) return { ok: false, error: 'moves after the win', at: k };
    const back = typeof moves[k] === 'string' && UNDO_RE.exec(moves[k]);
    if (back) {
      const n = Number(back[1]);
      if (n > done.length) return { ok: false, error: 'nothing to undo', at: k };
      for (let i = 0; i < n; i++) g.revert(state, done.pop());
      undos++;
      continue;
    }
    const m = typeof moves[k] === 'string' && g.moves(state).find(x => x.s === moves[k]);
    if (!m) return { ok: false, error: 'illegal move', at: k };
    done.push(g.apply(state, m));
  }
  if (!g.won(state)) return { ok: false, error: 'not won', at: moves.length };
  return { ok: true, moves: done.length + undos, kept: done.length, undos };
}

# The engine's move strings (engine/solitaire.js, MOVE_RE), ASCII digits
# only, and "u3", an undo of the last three moves: a posted line is the
# whole of the play, undos included, and the referee counts them.
MOVE_RE = re.compile(r"[dnw]|[wr]>(?:f|t[0-9])|t[0-9]>f|t[0-9]:[0-9]{1,2}>t[0-9]|f[SHDC]>t[0-9]|p[0-9]{1,2}(?:\+(?:p[0-9]{1,2}|w))?|u[1-9][0-9]{0,2}")

def run(command, payload):
    try:
        done = node.run([SCRIPT, command], input=json.dumps(payload), timeout=TIMEOUT)
    except subprocess.TimeoutExpired as e:
        raise RefereeDown("The referee took too long. Try again in a moment.") from e
    except OSError as e:
        raise RefereeDown("The referee isn’t working just now. Try again later.") from e
    if done.returncode:
        log.warning("The Solitaire referee failed on %s: %s", command, done.stderr.strip()[:200])
        raise RefereeDown("The referee isn’t working just now. Try again later.")
    try:
        return json.loads(done.stdout)
    except ValueError as e:
        raise RefereeDown("The referee isn’t working just now. Try again later.") from e

@property
def solution(self) -> list[str]:
    """The solver's moves: every other move of the line, from the second."""
    return list(self.line[1::2])

def needs_referee(puzzle, moves) -> bool:
    """A solve that follows the line but for its last move, which ends the
    puzzle early or differently: right only if that move mates."""
    line = puzzle.solution
    n = len(moves)
    return 0 < n <= len(line) and moves[:-1] == line[: n - 1] and moves[-1] != line[n - 1]

// Chess Puzzles' referee (docs/chess.md): replays a posted solve on the
// puzzle with the game's own rules (games/static/games/chess/engine/), for
// the one case the server can't settle by comparing moves itself, a mate
// other than the line's. The input is JSON on stdin; the answer is JSON on
// stdout.
//
//   node referee/chess.mjs solves {"puzzle":{"id":"0JMFA","fen":"…","line":["h4h5",…]},"moves":["c4f7","g3g6"]}
//     → {"ok":true}
//
// Anything that goes wrong exits with status 1.
import { solves } from '../games/static/games/chess/engine/index.js';

const read = async () => {
  let text = '';
  for await (const chunk of process.stdin) text += chunk;
  return JSON.parse(text);
};

try {
  const [command] = process.argv.slice(2);
  if (command !== 'solves') throw new Error('Usage: chess.mjs solves < input.json');
  const { puzzle, moves } = await read();
  const ok = solves({ id: String(puzzle.id), fen: String(puzzle.fen), line: puzzle.line.map(String) }, moves) === true;
  process.stdout.write(JSON.stringify({ ok }));
} catch (e) {
  process.stderr.write(String(e.message || e));
  process.exit(1);
}

/**
 * Replay a solve: the solver's moves, in order, on the puzzle. True if every
 * one is legal and right, the opponent's answers in between, and the last
 * either ends the line or mates. What the referee checks of a posted solve.
 */
export function solves(puzzle, moves) {
  if (!Array.isArray(moves) || !moves.length || moves.length > solverMoves(puzzle)) return false;
  const chess = positionAt(puzzle, 1);
  for (let k = 0; k < moves.length; k++) {
    const ply = 2 * k + 1;
    const uci = moves[k];
    if (typeof uci !== 'string' || !play(chess, uci)) return false;
    const verdict = judge(puzzle, ply, chess, uci);
    if (verdict === 'wrong') return false;
    const last = k === moves.length - 1;
    if (verdict === 'mate') return last;
    if (last) return ply === puzzle.line.length - 1;
    if (!play(chess, puzzle.line[ply + 1])) return false;
  }
  return false;
}

@require_POST
def submit(request):
    if not request.user.is_authenticated:
        return _fail(401, "Sign in to post your time.", login=reverse("accounts:login", args=["chess"]), signup=reverse("accounts:signup", args=["chess"]))
    try:
        body = json.loads(request.body)
        pid, band, moves = body["id"], body["band"], body["moves"]
        seconds = _count(body["seconds"], 2**31)
        mistakes, hints = _count(body.get("mistakes", 0), MAX_HELP), _count(body.get("hints", 0), MAX_HELP)
    except (ValueError, KeyError, TypeError, RecursionError):  # RecursionError: JSON nested a hundred thousand deep
        return _fail(400, "That submission was incomplete.")
    if not isinstance(pid, str) or not ID_RE.fullmatch(pid) or not isinstance(band, str) or band not in BANDS:
        return _fail(400, "That submission didn’t describe a puzzle.")
    if not isinstance(moves, list) or not 1 <= len(moves) <= 8 or not all(isinstance(m, str) and UCI_RE.fullmatch(m) for m in moves):
        return _fail(400, "That submission didn’t describe any moves.")
    puzzle = bundle.get(band, pid)
    if not puzzle:
        return _fail(422, "That puzzle isn’t in this game’s collection, so it can’t be checked.")
    if not min_seconds(moves) <= seconds <= MAX_SECONDS:
        return _fail(422, "That time doesn’t look like a real solve.")

    if not referee.follows_line(puzzle, moves):
        if not referee.needs_referee(puzzle, moves):
            return _fail(422, "Those moves don’t solve this puzzle.")
        if not _may_replay(request.user):
            return _fail(429, "That’s a lot of solves to check in an hour. Try posting again later.")
        try:
            if not referee.replay(puzzle, moves):
                return _fail(422, "Those moves don’t solve this puzzle.")
        except referee.RefereeDown as e:
            return _fail(503, str(e), retry=True)

    mine = Solve.objects.select_related("daily")
    existing = mine.filter(user=request.user, puzzle=pid).first()
    if existing:
        return _done(existing, already=True)
    # A daily solve counts on the day's board only if it arrives that day.
    slot = DailyChess.objects.filter(date=today(), band=band, puzzle=pid).first()
    # A puzzle already missed (a wrong move, or the solution shown) is never
    # clean, whatever this solve says (docs/ratings.md).
    if Miss.objects.filter(user=request.user, puzzle=pid).exists():
        mistakes = max(mistakes, 1)
    try:
        solve = Solve.objects.create(user=request.user, puzzle=pid, band=band, rating=puzzle.rating, daily=slot, seconds=seconds, mistakes=mistakes, hints=hints)
    except IntegrityError:
        return _done(mine.get(user=request.user, puzzle=pid), already=True)
    record(request, "score_submitted", game="chess", mode=band, daily=bool(slot))
    return _done(solve)

# The engine version of the hub's copy of Hashi, read from the game itself.
ENGINE = int(re.search(r"ENGINE_VERSION = (\d+)", _SOURCE).group(1))

def min_seconds(moves):
    """Faster than this isn't a real solve: a second a move (the clock
    starts once the opponent's first move has landed). The game posts
    whole seconds, one at least (play.js, `solved`), so a one-mover seen at
    a glance still posts."""
    return max(1, len(moves))