fix(panel): op-login 轮询按请求截止时间停止并显示倒计时，过期可一键重新发起，失败指数退避，服务端拒绝即停并提示

const LOGIN_HINT_SCRIPT = `

(() => {

  const id = "felis-mock-login-hint";

  const html = '<aside id="' + id + '" aria-label="Mock sign-in credentials"><strong>Mock sign-in (passwordless)</strong><div>Email OTP: any email / code <code>${MOCK_OTP_CODE}</code> (signs in as <code>owner</code>, admin)</div><div>Link code: <code>${MOCK_LINK_CODE}</code> (signs in as <code>linked</code>, user)</div><div>Passkey: any assertion is accepted (signs in as <code>owner</code>)</div></aside>';

  const html = '<aside id="' + id + '" aria-label="Mock sign-in credentials"><strong>Mock sign-in (passwordless)</strong><div>Email OTP: any email / code <code>${MOCK_OTP_CODE}</code> (signs in as <code>owner</code>, admin)</div><div>Link code: <code>${MOCK_LINK_CODE}</code> (signs in as <code>linked</code>, user)</div><div>Passkey: any assertion is accepted (signs in as <code>owner</code>)</div><div>Operator: any email / code <code>${MOCK_OTP_CODE}</code>, approved ~9s later; an address starting <code>expire</code> lapses in 20s</div></aside>';

  const sync = () => {

    const existing = document.getElementById(id);

    if (location.pathname === "/login") {

    `    Email OTP: any email / code ${MOCK_OTP_CODE}  → owner (admin, linked)`,

    `    Link code: ${MOCK_LINK_CODE}                  → linked (user, linked)`,

    "    Passkey:   any assertion accepted     → owner (admin, linked)",

    `    Op login:  any email / code ${MOCK_OTP_CODE}, approved ~9s later; an email starting "expire" lapses in 20s`,

    `  Reset state: curl -X POST http://127.0.0.1:5173${RESET_ROUTE}`,

    "",

  ].join("\n");

  sendError(res, status, code, code);

}

// Op-login requests the mock has handed out. Nobody is in-game to vouch, so each

// one approves itself a few seconds after start; an "expire…" address never does

// and lapses quickly, to show the page's expiry path.

const opLogins = new Map<string, { approveAt: number; expiresAt: number }>();

async function handlePublic(ctx: RequestContext): Promise<boolean> {

  const opStatus = route(ctx).match(/^GET auth\/op-login\/status\/(.+)$/);

  if (opStatus) {

    const req = opLogins.get(opStatus[1]);

    const now = Date.now();

    sendJSON(ctx.res, 200, { approved: !!req && now >= req.approveAt && now < req.expiresAt });

    return true;

  }

  switch (route(ctx)) {

    case "POST auth/op-login/start": {

      const body = await readJSON<{ email?: string }>(ctx.req);

      if (!body.email || !body.email.includes("@")) {

        sendError(ctx.res, 400, "bad_request", "email is required");

        return true;

      }

      const lapses = body.email.startsWith("expire");

      const id = `op-${opLogins.size + 1}`;

      const now = Date.now();

      const expiresAt = now + (lapses ? 20_000 : 600_000);

      opLogins.set(id, { approveAt: lapses ? Infinity : now + 9_000, expiresAt });

      sendJSON(ctx.res, 202, { request_id: id, expires_at: new Date(expiresAt).toISOString() });

      return true;

    }

    case "POST auth/op-login/finish": {

      const body = await readJSON<{ request_id?: string; code?: string }>(ctx.req);

      const req = body.request_id ? opLogins.get(body.request_id) : undefined;

      const now = Date.now();

      if (!req || now < req.approveAt || now >= req.expiresAt || body.code !== MOCK_OTP_CODE) {

        sendError(ctx.res, 400, "op_login_invalid", "operator login could not be completed");

        return true;

      }

      opLogins.delete(body.request_id!);

      setSessionCookie(ctx.res, "owner");

      sendJSON(ctx.res, 200, { user_id: "mock-owner", role: "owner" });

      return true;

    }

    case "POST auth/bind": {

      const body = await readJSON<{ code?: string }>(ctx.req);

      const code = body.code?.trim().toUpperCase();

  "op_waiting": "Waiting for in-game approval…",

  "op_approved": "Approved — enter the code from your email.",

  "op_restart": "Start over",

  "op_expires_in": "This request expires in {{time}}.",

  "op_expired": "This request expired before it was used. Request a new one to sign in.",

  "op_request_again": "Request again",

  "op_poll_retrying": "Can't reach Felis right now. Still waiting, checking less often…",

  "saving": "Saving…",

  "setup_title": "Set up your account",

  "setup_welcome": "Welcome, {{name}}",

  "op_waiting": "等待游戏内批准…",

  "op_approved": "已批准——请输入邮件中的验证码。",

  "op_restart": "重新开始",

  "op_expires_in": "此请求将在 {{time}} 后过期。",

  "op_expired": "此请求在使用前已过期，请重新发起登录。",

  "op_request_again": "重新发起",

  "op_poll_retrying": "暂时连不上 Felis，仍在等待，查询会放慢…",

  "saving": "保存中…",

  "setup_title": "初始化你的账户",

  "setup_welcome": "欢迎，{{name}}",

import { describe, it, expect } from "vitest";

import { OP_LOGIN_TTL_MS, formatCountdown, opLoginDeadline, opPollDelay } from "./opLoginPoll";

const NOW = Date.parse("2026-09-25T12:00:00Z");

describe("opLoginDeadline", () => {

  it("counts down to the server's expires_at when the clocks agree", () => {

    expect(opLoginDeadline("2026-09-25T12:09:30Z", NOW)).toBe(NOW + 570_000);

  });

  it("falls back to the TTL from now when the clocks disagree", () => {

    // The browser runs 20 minutes fast: taken literally the request died before it was shown.

    expect(opLoginDeadline("2026-09-25T11:50:00Z", NOW)).toBe(NOW + OP_LOGIN_TTL_MS);

    // The browser runs an hour slow: no request lives that long.

    expect(opLoginDeadline("2026-09-25T13:10:00Z", NOW)).toBe(NOW + OP_LOGIN_TTL_MS);

    expect(opLoginDeadline("not a time", NOW)).toBe(NOW + OP_LOGIN_TTL_MS);

  });

});

describe("opPollDelay", () => {

  it("asks every 3s while calls succeed and doubles per failure up to 30s", () => {

    expect([0, 1, 2, 3, 4, 10].map(opPollDelay)).toEqual([3000, 6000, 12000, 24000, 30000, 30000]);

  });

});

describe("formatCountdown", () => {

  it("writes minutes and zero-padded seconds, rounding a started second up", () => {

    expect(formatCountdown(600_000)).toBe("10:00");

    expect(formatCountdown(65_001)).toBe("1:06");

    expect(formatCountdown(9_000)).toBe("0:09");

    expect(formatCountdown(-5)).toBe("0:00");

  });

});

import { useEffect, useState } from "react";

import { api } from "@/lib/api";

import type { ApiError } from "@/lib/types";

// The op-login status endpoint answers approved:false for an unknown, expired or

// used request alike (it must not tell a stranger which staff addresses exist), so

// it never says a request died. The expires_at that start returned is the only

// end the page gets.

/** OP_LOGIN_TTL_MS mirrors otpTTL in handlers_email_otp.go: how long a request lives. */

export const OP_LOGIN_TTL_MS = 10 * 60 * 1000;

export const OP_POLL_BASE_MS = 3000;

export const OP_POLL_MAX_MS = 30000;

/**

 * opLoginDeadline turns start's expires_at into a deadline on this browser's

 * clock. One already past, or further off than a request can live, means the two

 * clocks disagree; the request was minted just now, so the TTL from now is the

 * better estimate then.

 */

export function opLoginDeadline(expiresAt: string, now: number): number {

  const remaining = Date.parse(expiresAt) - now;

  if (!Number.isFinite(remaining) || remaining <= 0 || remaining > OP_LOGIN_TTL_MS) {

    return now + OP_LOGIN_TTL_MS;

  }

  return now + remaining;

}

/** opPollDelay doubles the wait after each consecutive failure, capped at OP_POLL_MAX_MS. */

export function opPollDelay(failures: number): number {

  return Math.min(OP_POLL_BASE_MS * 2 ** failures, OP_POLL_MAX_MS);

}

/** formatCountdown writes a remaining time as m:ss. */

export function formatCountdown(ms: number): string {

  const total = Math.ceil(Math.max(0, ms) / 1000);

  return `${Math.floor(total / 60)}:${String(total % 60).padStart(2, "0")}`;

}

// A failure worth asking again after: no answer at all, a rate limit, or the server

// side. Anything else (local sessions switched off, a malformed id) answers the

// same way every time.

function retryable(e: unknown): boolean {

  const status = (e as Partial<ApiError> | null)?.status;

  return status === undefined || status === 0 || status === 429 || status >= 500;

}

export interface OpLoginPoll {

  approved: boolean;

  expired: boolean;

  remainingMs: number;

  /** The last status call failed and the next one waits longer. */

  retrying: boolean;

  /** A refusal that asking again will not change; polling has stopped. */

  error: unknown;

}

/**

 * useOpLoginPoll asks whether the request was approved in-game until it is, until

 * the deadline passes, or until the server refuses outright, backing off while the

 * calls fail. The countdown keeps running after approval: the code has to be

 * redeemed before the same deadline.

 */

export function useOpLoginPoll(requestId: string | null, deadline: number | null): OpLoginPoll {

  const [approved, setApproved] = useState(false);

  const [retrying, setRetrying] = useState(false);

  const [error, setError] = useState<unknown>(null);

  const [now, setNow] = useState(() => Date.now());

  useEffect(() => {

    setApproved(false);

    setRetrying(false);

    setError(null);

    if (!requestId || deadline === null) return;

    let cancelled = false;

    let failures = 0;

    let timer: ReturnType<typeof setTimeout> | undefined;

    const poll = async () => {

      if (Date.now() >= deadline) return;

      try {

        const s = await api.opLoginStatus(requestId);

        if (cancelled) return;

        failures = 0;

        setRetrying(false);

        if (s.approved) {

          setApproved(true);

          return;

        }

      } catch (e) {

        if (cancelled) return;

        if (!retryable(e)) {

          setRetrying(false);

          setError(e);

          return;

        }

        failures += 1;

        setRetrying(true);

      }

      timer = setTimeout(poll, opPollDelay(failures));

    };

    timer = setTimeout(poll, OP_POLL_BASE_MS);

    return () => {

      cancelled = true;

      clearTimeout(timer);

    };

  }, [requestId, deadline]);

  useEffect(() => {

    if (deadline === null) return;

    setNow(Date.now());

    const tick = setInterval(() => {

      const n = Date.now();

      setNow(n);

      if (n >= deadline) clearInterval(tick);

    }, 1000);

    return () => clearInterval(tick);

  }, [deadline]);

  const remainingMs = deadline === null ? 0 : Math.max(0, deadline - now);

  return { approved, expired: deadline !== null && remainingMs === 0, remainingMs, retrying, error };

}