后台新增游戏管理页与全量游戏列表接口

- SpacetimeDB 新增 list_admin_game_distribution_games_and_return：一个事务内返回全量游戏、版本数与最近 20 个版本，作者名/头像读时联 user_account
- SpacetimeDB 新增 restore_game_distribution_game_and_return：恢复管理员暂停的游戏时重新激活最近一次由管理员暂停撤回的公开版本，作者自行下架的版本不会被恢复
- 后台新增 GET /admin/api/game-distribution/games 与 POST /admin/api/game-distribution/games/{gameId}/restore，并新增 game-management Tab 权限，待审队列仍只属于 editor-showcase
- admin-web 新增 #game-management「游戏管理」页：标题/作者/gameId/状态/版本数/游玩数表格，行内下架、恢复与版本历史弹层，复用现有后台表格与二次确认
- 同步生成 spacetime 绑定并更新后端架构数据契约文档

apps/admin-web/src/api/adminApiClient.test.ts

@@ -8,10 +8,12 @@ import {
   getAdminUserDetail,
   importAdminAgcTemplates,
   listAdminAgcTrackingEvents,
+  listAdminGameDistributionGames,
   listAdminGameDistributionReviews,
   listAdminRechargeOrders,
   reconcileAdminUserConsumption,
   resolveAdminRechargeRefundManualReview,
+  restoreAdminGameDistributionGame,
   reviewAdminGameDistributionVersion,
   suspendAdminGameDistributionGame,
   updateAdminAccount,
@@ -525,6 +527,85 @@ test('游戏审核列表与审核动作使用约定的 URL、方法和幂等键'
   );
 });
 
+test('游戏管理列表与恢复动作使用约定的 URL、方法和幂等键', async () => {
+  const fetchMock = vi
+    .fn()
+    .mockResolvedValueOnce(
+      new Response(JSON.stringify({ ok: true, data: { games: [] } }), {
+        status: 200,
+      }),
+    )
+    .mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          ok: true,
+          data: {
+            game: {
+              id: 'game/1',
+              title: '测试游戏',
+              status: 'published',
+              publicationRevision: 10,
+            },
+            replayed: false,
+          },
+        }),
+        { status: 200 },
+      ),
+    );
+  vi.stubGlobal('fetch', fetchMock);
+  const controller = new AbortController();
+
+  await listAdminGameDistributionGames(
+    'admin-token',
+    { limit: 80 },
+    controller.signal,
+  );
+  await restoreAdminGameDistributionGame(
+    'admin-token',
+    ' game/1 ',
+    ' game-restore-key-1 ',
+    { expectedPublicationRevision: 9 },
+  );
+
+  expect(fetchMock.mock.calls[0]?.[0]).toBe(
+    '/admin/api/game-distribution/games?limit=50',
+  );
+  expect(fetchMock.mock.calls[0]?.[1]).toEqual(
+    expect.objectContaining({
+      method: 'GET',
+      signal: controller.signal,
+      headers: expect.objectContaining({
+        Authorization: 'Bearer admin-token',
+      }),
+    }),
+  );
+  expect(fetchMock.mock.calls[1]?.[0]).toBe(
+    '/admin/api/game-distribution/games/game%2F1/restore',
+  );
+  expect(fetchMock.mock.calls[1]?.[1]).toEqual(
+    expect.objectContaining({
+      method: 'POST',
+      headers: expect.objectContaining({
+        Authorization: 'Bearer admin-token',
+        'Idempotency-Key': 'game-restore-key-1',
+      }),
+      body: JSON.stringify({ expectedPublicationRevision: 9 }),
+    }),
+  );
+
+  expect(() =>
+    restoreAdminGameDistributionGame('admin-token', '  ', 'key', {
+      expectedPublicationRevision: 9,
+    }),
+  ).toThrow('缺少游戏 ID');
+  expect(() =>
+    restoreAdminGameDistributionGame('admin-token', 'game-1', '  ', {
+      expectedPublicationRevision: 9,
+    }),
+  ).toThrow('恢复幂等键必须是 1 到 128 个字符');
+  expect(fetchMock).toHaveBeenCalledTimes(2);
+});
+
 test('安全下架请求携带公开修订号、原因与幂等键', async () => {
   const fetchMock = vi.fn().mockImplementation(() =>
     Promise.resolve(

apps/admin-web/src/api/adminApiClient.ts

@@ -32,6 +32,9 @@ import type {
   AdminExternalApiKeyListQuery,
   AdminExternalApiKeyListResponse,
   AdminFeatureGateConfigResponse,
+  AdminGameDistributionGameListResponse,
+  AdminGameDistributionRestoreRequest,
+  AdminGameDistributionRestoreResponse,
   AdminGameDistributionReviewListResponse,
   AdminGameDistributionReviewRequest,
   AdminGameDistributionReviewResponse,
@@ -1240,6 +1243,46 @@ export function listAdminGameDistributionReviews(token: string, limit = 48) {
   );
 }
 
+export function listAdminGameDistributionGames(
+  token: string,
+  options: { limit?: number } = {},
+  signal?: AbortSignal,
+) {
+  const requestedLimit = options.limit ?? 50;
+  const normalizedLimit = Number.isFinite(requestedLimit)
+    ? Math.min(Math.max(Math.trunc(requestedLimit), 1), 50)
+    : 50;
+  return request<AdminGameDistributionGameListResponse>(
+    `/admin/api/game-distribution/games?limit=${normalizedLimit}`,
+    { token, signal },
+  );
+}
+
+export function restoreAdminGameDistributionGame(
+  token: string,
+  gameId: string,
+  idempotencyKey: string,
+  payload: AdminGameDistributionRestoreRequest,
+) {
+  const normalizedGameId = gameId.trim();
+  const normalizedKey = idempotencyKey.trim();
+  if (!normalizedGameId) {
+    throw new Error('缺少游戏 ID');
+  }
+  if (!normalizedKey || normalizedKey.length > 128) {
+    throw new Error('恢复幂等键必须是 1 到 128 个字符');
+  }
+  return request<AdminGameDistributionRestoreResponse>(
+    `/admin/api/game-distribution/games/${encodeURIComponent(normalizedGameId)}/restore`,
+    {
+      method: 'POST',
+      token,
+      headers: { 'Idempotency-Key': normalizedKey },
+      body: payload,
+    },
+  );
+}
+
 /**
  * 审核游戏发行版本。幂等键由调用方生成并在同一次提交内复用，避免重复点击产生
  * 两条审核结论。

apps/admin-web/src/api/adminApiTypes.ts

@@ -1132,6 +1132,57 @@ export interface AdminGameDistributionSuspendResponse {
   replayed: boolean;
 }
 
+export interface AdminGameDistributionGameVersionEntry {
+  versionId: string;
+  gameId: string;
+  versionNumber: number;
+  status: string;
+  reviewReason: string | null;
+  packageBytes: number;
+  packageSha256: string;
+  createdAt: string;
+  updatedAt: string;
+  reviewedAt: string | null;
+  publishedAt: string | null;
+  entryUrl: string | null;
+}
+
+export interface AdminGameDistributionGameEntry {
+  gameId: string;
+  title: string;
+  author: {
+    id: string;
+    name: string;
+    avatarUrl: string | null;
+  };
+  status: string;
+  versionCount: number;
+  playCount: number;
+  activeVersionId: string | null;
+  publicationRevision: number;
+  createdAt: string;
+  updatedAt: string;
+  versions: AdminGameDistributionGameVersionEntry[];
+}
+
+export interface AdminGameDistributionGameListResponse {
+  games: AdminGameDistributionGameEntry[];
+}
+
+export interface AdminGameDistributionRestoreRequest {
+  expectedPublicationRevision: number;
+}
+
+export interface AdminGameDistributionRestoreResponse {
+  game: {
+    id: string;
+    title: string;
+    status: string;
+    publicationRevision: number;
+  };
+  replayed: boolean;
+}
+
 export interface AdminAgcTemplatePayload {
   id: string;
   title: string;

apps/admin-web/src/app/AdminApp.tsx

@@ -29,6 +29,7 @@ import { AdminEditorGenerationPricingPage } from '../pages/AdminEditorGeneration
 import { AdminEditorShowcaseReviewPage } from '../pages/AdminEditorShowcaseReviewPage';
 import { AdminErrorReportsPage } from '../pages/AdminErrorReportsPage';
 import { AdminGameDistributionReviewPage } from '../pages/AdminGameDistributionReviewPage';
+import { AdminGameManagementPage } from '../pages/AdminGameManagementPage';
 import { AdminGrayReleaseConfigPage } from '../pages/AdminGrayReleaseConfigPage';
 import { AdminInviteCodePage } from '../pages/AdminInviteCodePage';
 import { AdminLoginPage } from '../pages/AdminLoginPage';
@@ -321,6 +322,12 @@ export function AdminApp() {
           onUnauthorized={handleUnauthorized}
         />
       ) : null}
+      {activeRouteId === 'game-management' ? (
+        <AdminGameManagementPage
+          token={token}
+          onUnauthorized={handleUnauthorized}
+        />
+      ) : null}
       {activeRouteId === 'editor-assets' ? (
         <AdminEditorAssetQueryPage
           token={token}

apps/admin-web/src/app/AdminShell.tsx

@@ -14,6 +14,7 @@ import {
   ReceiptText,
   ShieldCheck,
   Star,
+  Swords,
   Table2,
   TicketCheck,
   TicketPercent,
@@ -52,6 +53,7 @@ const routeIcons = {
   'editor-generation-pricing': Coins,
   'editor-showcase': Star,
   'game-distribution': Gamepad2,
+  'game-management': Swords,
   'editor-assets': Images,
   'project-snapshots': FolderArchive,
   accounts: Users,

apps/admin-web/src/app/adminRoutes.test.ts

@@ -168,6 +168,16 @@ test('后台游戏审核路由可通过导航和 hash 访问', () => {
   expect(routeHash('game-distribution')).toBe('#game-distribution');
 });
 
+test('后台游戏管理路由可通过导航和 hash 访问', () => {
+  expect(adminRoutes).toContainEqual({
+    id: 'game-management',
+    label: '游戏管理',
+    hash: '#game-management',
+  });
+  expect(resolveAdminRoute('#game-management')).toBe('game-management');
+  expect(routeHash('game-management')).toBe('#game-management');
+});
+
 test('member 可单独获得游戏审核 Tab 权限', () => {
   const routes = getAccessibleAdminRoutes({
     accountRole: 'member',

apps/admin-web/src/app/adminRoutes.ts

@@ -17,6 +17,7 @@ export type AdminRouteId =
   | 'editor-generation-pricing'
   | 'editor-showcase'
   | 'game-distribution'
+  | 'game-management'
   | 'editor-assets'
   | 'project-snapshots'
   | 'agc-models'
@@ -60,6 +61,7 @@ export const adminRoutes: AdminRouteDefinition[] = [
   { id: 'agc-templates', label: '模板管理', hash: '#agc-templates' },
   { id: 'editor-showcase', label: '精选审核', hash: '#editor-showcase' },
   { id: 'game-distribution', label: '游戏审核', hash: '#game-distribution' },
+  { id: 'game-management', label: '游戏管理', hash: '#game-management' },
   { id: 'editor-assets', label: '素材查询', hash: '#editor-assets' },
   { id: 'project-snapshots', label: '项目工程', hash: '#project-snapshots' },
   { id: 'accounts', label: '账号管理', hash: '#accounts', ownerOnly: true },

apps/admin-web/src/pages/AdminGameManagementPage.test.tsx

@@ -0,0 +1,265 @@
+/* @vitest-environment jsdom */
+
+import {
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from '@testing-library/react';
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
+
+import {
+  listAdminGameDistributionGames,
+  restoreAdminGameDistributionGame,
+  suspendAdminGameDistributionGame,
+} from '../api/adminApiClient';
+import type {
+  AdminGameDistributionGameEntry,
+  AdminGameDistributionGameVersionEntry,
+} from '../api/adminApiTypes';
+import { AdminGameManagementPage } from './AdminGameManagementPage';
+
+vi.mock('../api/adminApiClient', () => ({
+  isAdminApiError: vi.fn(
+    (error: unknown) =>
+      typeof error === 'object' &&
+      error !== null &&
+      'status' in error &&
+      typeof error.status === 'number',
+  ),
+  formatAdminApiError: vi.fn((error: unknown) =>
+    error instanceof Error ? error.message : '请求失败',
+  ),
+  listAdminGameDistributionGames: vi.fn(),
+  restoreAdminGameDistributionGame: vi.fn(),
+  suspendAdminGameDistributionGame: vi.fn(),
+}));
+
+const version: AdminGameDistributionGameVersionEntry = {
+  versionId: 'version-3',
+  gameId: 'game_1',
+  versionNumber: 3,
+  status: 'published',
+  reviewReason: '测试原因',
+  packageBytes: 2048,
+  packageSha256:
+    'abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789',
+  createdAt: '2026-09-20T08:00:00Z',
+  updatedAt: '2026-09-20T08:00:00Z',
+  reviewedAt: '2026-09-20T09:00:00Z',
+  publishedAt: '2026-09-20T10:00:00Z',
+  entryUrl: 'https://game.example.com/game_1',
+};
+
+const publishedGame: AdminGameDistributionGameEntry = {
+  gameId: 'game_1',
+  title: '测试游戏',
+  author: {
+    id: 'user_1',
+    name: '作者甲',
+    avatarUrl: 'https://example.com/avatar.png',
+  },
+  status: 'published',
+  versionCount: 21,
+  playCount: 345,
+  activeVersionId: 'version-3',
+  publicationRevision: 4,
+  createdAt: '2026-09-18T08:00:00Z',
+  updatedAt: '2026-09-20T10:00:00Z',
+  versions: [version],
+};
+
+const suspendedGame: AdminGameDistributionGameEntry = {
+  gameId: 'game_2',
+  title: '下架游戏',
+  author: {
+    id: 'user_2',
+    name: '作者乙',
+    avatarUrl: null,
+  },
+  status: 'suspended',
+  versionCount: 2,
+  playCount: 8,
+  activeVersionId: null,
+  publicationRevision: 7,
+  createdAt: '2026-09-19T08:00:00Z',
+  updatedAt: '2026-09-21T08:00:00Z',
+  versions: [],
+};
+
+beforeEach(() => {
+  vi.mocked(listAdminGameDistributionGames)
+    .mockReset()
+    .mockResolvedValue({ games: [publishedGame] });
+  vi.mocked(restoreAdminGameDistributionGame)
+    .mockReset()
+    .mockResolvedValue({
+      game: {
+        id: suspendedGame.gameId,
+        title: suspendedGame.title,
+        status: 'published',
+        publicationRevision: 8,
+      },
+      replayed: false,
+    });
+  vi.mocked(suspendAdminGameDistributionGame)
+    .mockReset()
+    .mockResolvedValue({
+      game: {
+        id: publishedGame.gameId,
+        title: publishedGame.title,
+        status: 'suspended',
+        publicationRevision: 5,
+      },
+      replayed: false,
+    });
+});
+
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+test('列表展示作者头像、状态、版本数和游玩数', async () => {
+  vi.mocked(listAdminGameDistributionGames).mockResolvedValue({
+    games: [publishedGame, suspendedGame],
+  });
+
+  render(
+    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  const publishedRow = (await screen.findByText('测试游戏')).closest('tr')!;
+  expect(within(publishedRow).getByText('作者甲')).toBeTruthy();
+  const avatar = within(publishedRow).getByRole('img', {
+    name: '作者甲 头像',
+  });
+  expect(avatar.getAttribute('src')).toBe('https://example.com/avatar.png');
+  expect(within(publishedRow).getByText('已公开')).toBeTruthy();
+  expect(within(publishedRow).getByText('21')).toBeTruthy();
+  expect(within(publishedRow).getByText('345')).toBeTruthy();
+
+  const suspendedRow = (await screen.findByText('下架游戏')).closest('tr')!;
+  expect(within(suspendedRow).getByText('作者乙')).toBeTruthy();
+  expect(suspendedRow.querySelector('.admin-user-avatar')?.textContent).toBe(
+    '作',
+  );
+  expect(within(suspendedRow).getByText('已下架')).toBeTruthy();
+});
+
+test('恢复按钮只在下架态出现，成功后携带幂等键并刷新列表', async () => {
+  vi.mocked(listAdminGameDistributionGames)
+    .mockResolvedValueOnce({ games: [suspendedGame] })
+    .mockResolvedValueOnce({
+      games: [{ ...suspendedGame, status: 'published' }],
+    });
+
+  render(
+    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('下架游戏');
+  expect(screen.queryByRole('button', { name: '下架' })).toBeNull();
+  fireEvent.click(screen.getByRole('button', { name: '恢复' }));
+
+  expect(restoreAdminGameDistributionGame).not.toHaveBeenCalled();
+  await screen.findByRole('dialog');
+  fireEvent.click(screen.getByRole('button', { name: '确认' }));
+
+  await waitFor(() =>
+    expect(restoreAdminGameDistributionGame).toHaveBeenCalledTimes(1),
+  );
+  const [token, gameId, idempotencyKey, payload] =
+    vi.mocked(restoreAdminGameDistributionGame).mock.calls[0] ?? [];
+  expect(token).toBe('admin-token');
+  expect(gameId).toBe('game_2');
+  expect(String(idempotencyKey)).toContain('game_2');
+  expect(payload).toEqual({ expectedPublicationRevision: 7 });
+  await waitFor(() =>
+    expect(listAdminGameDistributionGames).toHaveBeenCalledTimes(2),
+  );
+  expect(await screen.findByText('游戏《下架游戏》已恢复')).toBeTruthy();
+});
+
+test('下架需要原因和二次确认，提交原因与当前公开修订号', async () => {
+  render(
+    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('测试游戏');
+  fireEvent.change(screen.getByLabelText('下架原因'), {
+    target: { value: '违规内容' },
+  });
+  fireEvent.click(screen.getByRole('button', { name: '下架' }));
+
+  expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();
+  await screen.findByRole('dialog');
+  fireEvent.click(screen.getByRole('button', { name: '确认' }));
+
+  await waitFor(() =>
+    expect(suspendAdminGameDistributionGame).toHaveBeenCalledTimes(1),
+  );
+  const [token, gameId, idempotencyKey, payload] =
+    vi.mocked(suspendAdminGameDistributionGame).mock.calls[0] ?? [];
+  expect(token).toBe('admin-token');
+  expect(gameId).toBe('game_1');
+  expect(String(idempotencyKey)).toContain('game_1');
+  expect(payload).toEqual({
+    expectedPublicationRevision: 4,
+    reason: '违规内容',
+  });
+  expect(await screen.findByText('游戏《测试游戏》已下架')).toBeTruthy();
+});
+
+test('版本历史弹层展示版本条目与统计信息', async () => {
+  render(
+    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('测试游戏');
+  fireEvent.click(screen.getByRole('button', { name: '版本历史' }));
+  const dialog = await screen.findByRole('dialog');
+
+  expect(within(dialog).getByText('共 21 个版本，展示最近 20 个')).toBeTruthy();
+  expect(within(dialog).getByText('v3')).toBeTruthy();
+  expect(within(dialog).getByText('published')).toBeTruthy();
+  expect(within(dialog).getByText('2.0 KiB')).toBeTruthy();
+  expect(within(dialog).getByText('abcdef012345')).toBeTruthy();
+  expect(within(dialog).getByText('测试原因')).toBeTruthy();
+  expect(
+    within(dialog).getByText('https://game.example.com/game_1'),
+  ).toBeTruthy();
+});
+
+test('接口失败显示错误文案', async () => {
+  vi.mocked(listAdminGameDistributionGames).mockRejectedValue(
+    new Error('游戏列表读取失败'),
+  );
+
+  render(
+    <AdminGameManagementPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  expect(await screen.findByText('游戏列表读取失败')).toBeTruthy();
+});
+
+test('401 交给 onUnauthorized 处理', async () => {
+  const onUnauthorized = vi.fn();
+  vi.mocked(listAdminGameDistributionGames).mockRejectedValue(
+    Object.assign(new Error('未授权'), { status: 401 }),
+  );
+
+  render(
+    <AdminGameManagementPage
+      token="admin-token"
+      onUnauthorized={onUnauthorized}
+    />,
+  );
+
+  await waitFor(() =>
+    expect(onUnauthorized).toHaveBeenCalledWith('登录状态已失效'),
+  );
+  expect(screen.queryByRole('alert')).toBeNull();
+});

apps/admin-web/src/pages/AdminGameManagementPage.tsx

@@ -0,0 +1,456 @@
+import { RefreshCcw, X } from 'lucide-react';
+import { useCallback, useEffect, useState } from 'react';
+
+import {
+  listAdminGameDistributionGames,
+  restoreAdminGameDistributionGame,
+  suspendAdminGameDistributionGame,
+} from '../api/adminApiClient';
+import type {
+  AdminGameDistributionGameEntry,
+  AdminGameDistributionGameVersionEntry,
+} from '../api/adminApiTypes';
+import { useAdminWriteConfirm } from '../components/useAdminWriteConfirm';
+import { handlePageError } from './pageUtils';
+
+interface AdminGameManagementPageProps {
+  token: string;
+  onUnauthorized: (message?: string) => void;
+}
+
+const GAME_STATUS_META: Record<string, { label: string; className: string }> = {
+  published: { label: '已公开', className: 'admin-status-ok' },
+  suspended: { label: '已下架', className: 'admin-status-error' },
+  unpublished: { label: '未公开', className: 'admin-status-pending' },
+};
+
+function gameStatusMeta(status: string) {
+  return (
+    GAME_STATUS_META[status] ?? {
+      label: status || '—',
+      className: 'admin-status-pending',
+    }
+  );
+}
+
+function formatBytes(value: number) {
+  if (value >= 1024 * 1024) {
+    return `${(value / (1024 * 1024)).toFixed(1)} MiB`;
+  }
+  if (value >= 1024) {
+    return `${(value / 1024).toFixed(1)} KiB`;
+  }
+  return `${value} B`;
+}
+
+function formatTime(value: string) {
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return value;
+  return parsed.toLocaleString('zh-CN', { hour12: false });
+}
+
+function formatOptionalTime(value: string | null) {
+  return value ? formatTime(value) : '—';
+}
+
+function authorName(entry: AdminGameDistributionGameEntry) {
+  return entry.author?.name?.trim() || '—';
+}
+
+function authorInitial(entry: AdminGameDistributionGameEntry) {
+  const name = authorName(entry);
+  return name === '—' ? '—' : (Array.from(name)[0] ?? '—');
+}
+
+function createGameActionIdempotencyKey(
+  action: 'suspend' | 'restore',
+  gameId: string,
+) {
+  const random =
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+      ? crypto.randomUUID()
+      : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const prefix = action === 'suspend' ? 'game-suspend' : 'game-restore';
+  return `${prefix}-${gameId}-${random}`.slice(0, 128);
+}
+
+export function AdminGameManagementPage({
+  token,
+  onUnauthorized,
+}: AdminGameManagementPageProps) {
+  const [games, setGames] = useState<AdminGameDistributionGameEntry[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [busyGameId, setBusyGameId] = useState('');
+  const [errorMessage, setErrorMessage] = useState('');
+  const [statusMessage, setStatusMessage] = useState('');
+  const [suspendReasonByGame, setSuspendReasonByGame] = useState<
+    Record<string, string>
+  >({});
+  const [versionGame, setVersionGame] =
+    useState<AdminGameDistributionGameEntry | null>(null);
+  const writeConfirm = useAdminWriteConfirm();
+
+  const loadGames = useCallback(async () => {
+    setIsLoading(true);
+    setErrorMessage('');
+    try {
+      const response = await listAdminGameDistributionGames(token, {
+        limit: 50,
+      });
+      setGames(response.games);
+    } catch (error) {
+      handlePageError(error, onUnauthorized, setErrorMessage);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [token, onUnauthorized]);
+
+  useEffect(() => {
+    void loadGames();
+  }, [loadGames]);
+
+  useEffect(() => {
+    if (!versionGame) return undefined;
+
+    const handleKeyDown = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        setVersionGame(null);
+      }
+    };
+    window.addEventListener('keydown', handleKeyDown);
+    return () => window.removeEventListener('keydown', handleKeyDown);
+  }, [versionGame]);
+
+  async function suspendGame(entry: AdminGameDistributionGameEntry) {
+    const reason = (suspendReasonByGame[entry.gameId] ?? '').trim();
+    if (!reason) {
+      setErrorMessage('下架原因不能为空');
+      setStatusMessage('');
+      return;
+    }
+
+    const confirmed = await writeConfirm.confirmWrite({
+      action: '下架游戏',
+      target: `${entry.title || entry.gameId}（${entry.gameId}）`,
+    });
+    if (!confirmed) return;
+
+    setBusyGameId(entry.gameId);
+    setErrorMessage('');
+    setStatusMessage('');
+    try {
+      await suspendAdminGameDistributionGame(
+        token,
+        entry.gameId,
+        createGameActionIdempotencyKey('suspend', entry.gameId),
+        {
+          expectedPublicationRevision: entry.publicationRevision,
+          reason,
+        },
+      );
+      setStatusMessage(`游戏《${entry.title || entry.gameId}》已下架`);
+      setSuspendReasonByGame((current) => ({
+        ...current,
+        [entry.gameId]: '',
+      }));
+      await loadGames();
+    } catch (error) {
+      handlePageError(error, onUnauthorized, setErrorMessage);
+    } finally {
+      setBusyGameId('');
+    }
+  }
+
+  async function restoreGame(entry: AdminGameDistributionGameEntry) {
+    const confirmed = await writeConfirm.confirmWrite({
+      action: '恢复游戏',
+      target: `${entry.title || entry.gameId}（${entry.gameId}）`,
+    });
+    if (!confirmed) return;
+
+    setBusyGameId(entry.gameId);
+    setErrorMessage('');
+    setStatusMessage('');
+    try {
+      await restoreAdminGameDistributionGame(
+        token,
+        entry.gameId,
+        createGameActionIdempotencyKey('restore', entry.gameId),
+        { expectedPublicationRevision: entry.publicationRevision },
+      );
+      setStatusMessage(`游戏《${entry.title || entry.gameId}》已恢复`);
+      await loadGames();
+    } catch (error) {
+      handlePageError(error, onUnauthorized, setErrorMessage);
+    } finally {
+      setBusyGameId('');
+    }
+  }
+
+  return (
+    <section className="admin-page admin-page-wide">
+      <div className="admin-page-heading">
+        <h1>游戏管理</h1>
+        <button
+          type="button"
+          className="admin-secondary-button"
+          onClick={() => void loadGames()}
+          disabled={isLoading}
+        >
+          <RefreshCcw aria-hidden="true" />
+          刷新
+        </button>
+      </div>
+
+      {errorMessage ? (
+        <div className="admin-alert admin-alert-warning" role="alert">
+          {errorMessage}
+        </div>
+      ) : null}
+      {statusMessage ? (
+        <div className="admin-alert admin-alert-success" role="status">
+          {statusMessage}
+        </div>
+      ) : null}
+
+      <div className="admin-panel">
+        <div className="admin-panel-heading">
+          <h2>游戏列表</h2>
+          <span className="admin-muted-text">共 {games.length} 条</span>
+        </div>
+
+        {isLoading ? (
+          <p className="admin-muted-text">正在加载游戏列表…</p>
+        ) : null}
+
+        {!isLoading && games.length === 0 ? (
+          <p className="admin-muted-text">暂无游戏。</p>
+        ) : null}
+
+        {!isLoading && games.length > 0 ? (
+          <div className="admin-table-wrap">
+            <table className="admin-table admin-table-wide">
+              <thead>
+                <tr>
+                  <th>标题</th>
+                  <th>作者</th>
+                  <th>gameId</th>
+                  <th>状态</th>
+                  <th>版本数</th>
+                  <th>游玩数</th>
+                  <th>操作</th>
+                </tr>
+              </thead>
+              <tbody>
+                {games.map((entry) => {
+                  const status = gameStatusMeta(entry.status);
+                  const isSuspended = entry.status === 'suspended';
+                  const busy = busyGameId === entry.gameId;
+                  return (
+                    <tr key={entry.gameId}>
+                      <td>
+                        <strong>{entry.title?.trim() || '—'}</strong>
+                      </td>
+                      <td>
+                        <div
+                          className="admin-database-user-cell"
+                          style={{ justifyContent: 'flex-start' }}
+                        >
+                          <div
+                            className="admin-user-avatar"
+                            style={{
+                              width: 32,
+                              height: 32,
+                              flex: '0 0 32px',
+                              fontSize: 13,
+                            }}
+                          >
+                            {entry.author?.avatarUrl ? (
+                              <img
+                                alt={`${authorName(entry)} 头像`}
+                                src={entry.author.avatarUrl}
+                              />
+                            ) : (
+                              authorInitial(entry)
+                            )}
+                          </div>
+                          <div>
+                            <span>{authorName(entry)}</span>
+                            <small>{entry.author?.id?.trim() || '—'}</small>
+                          </div>
+                        </div>
+                      </td>
+                      <td>
+                        <code>{entry.gameId}</code>
+                      </td>
+                      <td>
+                        <span className={`admin-status ${status.className}`}>
+                          {status.label}
+                        </span>
+                      </td>
+                      <td>{entry.versionCount}</td>
+                      <td>{entry.playCount}</td>
+                      <td>
+                        <div className="admin-action-row">
+                          {!isSuspended ? (
+                            <>
+                              <div className="admin-field">
+                                <label
+                                  htmlFor={`game-suspend-reason-${entry.gameId}`}
+                                >
+                                  下架原因
+                                </label>
+                                <input
+                                  id={`game-suspend-reason-${entry.gameId}`}
+                                  value={
+                                    suspendReasonByGame[entry.gameId] ?? ''
+                                  }
+                                  onChange={(event) =>
+                                    setSuspendReasonByGame((current) => ({
+                                      ...current,
+                                      [entry.gameId]: event.target.value,
+                                    }))
+                                  }
+                                  disabled={busy}
+                                />
+                              </div>
+                              <button
+                                type="button"
+                                className="admin-danger-button"
+                                disabled={busy}
+                                onClick={() => void suspendGame(entry)}
+                              >
+                                {busy ? '处理中…' : '下架'}
+                              </button>
+                            </>
+                          ) : (
+                            <button
+                              type="button"
+                              className="admin-primary-button"
+                              disabled={busy}
+                              onClick={() => void restoreGame(entry)}
+                            >
+                              {busy ? '处理中…' : '恢复'}
+                            </button>
+                          )}
+                          <button
+                            type="button"
+                            className="admin-secondary-button"
+                            disabled={busy}
+                            onClick={() => setVersionGame(entry)}
+                          >
+                            版本历史
+                          </button>
+                        </div>
+                      </td>
+                    </tr>
+                  );
+                })}
+              </tbody>
+            </table>
+          </div>
+        ) : null}
+      </div>
+
+      {versionGame ? (
+        <div
+          className="admin-confirm-backdrop"
+          role="presentation"
+          onMouseDown={(event) => {
+            if (event.target === event.currentTarget) {
+              setVersionGame(null);
+            }
+          }}
+        >
+          <section
+            aria-labelledby="admin-game-version-history-title"
+            aria-modal="true"
+            className="admin-detail-panel"
+            role="dialog"
+          >
+            <div className="admin-panel-heading">
+              <div>
+                <h2 id="admin-game-version-history-title">版本历史</h2>
+                <span>
+                  {versionGame.title?.trim() || '—'}（{versionGame.gameId}）
+                </span>
+              </div>
+              <button
+                aria-label="关闭版本历史"
+                className="admin-ghost-button"
+                type="button"
+                onClick={() => setVersionGame(null)}
+              >
+                <X size={17} aria-hidden="true" />
+              </button>
+            </div>
+            <p className="admin-muted-text">
+              共 {versionGame.versionCount} 个版本，展示最近 20 个
+            </p>
+            {versionGame.versions.length === 0 ? (
+              <p className="admin-muted-text">暂无版本记录。</p>
+            ) : (
+              <div className="admin-table-wrap">
+                <table className="admin-table admin-table-wide">
+                  <thead>
+                    <tr>
+                      <th>版本</th>
+                      <th>状态</th>
+                      <th>包大小</th>
+                      <th>SHA</th>
+                      <th>创建时间</th>
+                      <th>审核时间</th>
+                      <th>公开时间</th>
+                      <th>审核原因</th>
+                      <th>发行入口</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {versionGame.versions.map((version) => (
+                      <GameVersionRow
+                        key={version.versionId}
+                        version={version}
+                      />
+                    ))}
+                  </tbody>
+                </table>
+              </div>
+            )}
+          </section>
+        </div>
+      ) : null}
+
+      {writeConfirm.confirmDialog}
+    </section>
+  );
+}
+
+function GameVersionRow({
+  version,
+}: {
+  version: AdminGameDistributionGameVersionEntry;
+}) {
+  return (
+    <tr>
+      <td>v{version.versionNumber}</td>
+      <td>{version.status || '—'}</td>
+      <td>{formatBytes(version.packageBytes)}</td>
+      <td>
+        <code>{version.packageSha256?.slice(0, 12) || '—'}</code>
+      </td>
+      <td>{formatOptionalTime(version.createdAt)}</td>
+      <td>{formatOptionalTime(version.reviewedAt)}</td>
+      <td>{formatOptionalTime(version.publishedAt)}</td>
+      <td>{version.reviewReason?.trim() || '—'}</td>
+      <td>
+        {version.entryUrl ? (
+          <a href={version.entryUrl} rel="noreferrer" target="_blank">
+            {version.entryUrl}
+          </a>
+        ) : (
+          '—'
+        )}
+      </td>
+    </tr>
+  );
+}