feat(判题机): 自建镜像升级工具链，语言收敛到 C / C++ / Python

上游 QingdaoU/JudgeServer 停更在 2024-04（registry 上的 latest 和 1.6.1 是同一份
镜像，编译器停在 gcc-13），没有新版可拉，所以自己重编。docker/judge/ 是只改工具链
的 Dockerfile 分叉，server/ 和 Judger/ 从上游固定 commit b28aa56 拉，一行没动。

镜像 oj2-judge-2（不在任何 registry 上：本机 build.sh --save → scp → docker load）
- gcc/g++ 13 → 14.2，Python 3.12 → 3.13.5，都是 trixie 默认
- Go / JDK / Node 整套删掉：前端的题目语言复选框从来只给 C / C++ / Python / SQL，
  12 万条提交里 Java 44 条、Golang 15、JavaScript 3，全是很早以前的
- 体积 1.1GB → 433MB；默认走清华源，构建 12 分钟 → 40 秒（--no-mirror 换回官方）
- deploy.sh 加一道自检：镜像不在本机就中止，并打印该跑的三条命令

C 的编译参数加三个 -Wno-error（implicit-function-declaration / int-conversion /
incompatible-pointer-types）：gcc-14 把它们从 warning 提成了 error，而 -w 压不住。

语言值统一成 Python（迁移 0019 / 0020）
- 0019：Python3（104527 条提交）与 Python2（3 条）并成 Python，一并改掉 937 道题的
  languages、75 个 template 键、15 个 ast_rules 键、257 条 answers、1235 个用户的
  成就指标 _languages（languages_used 重算，总和 1928 → 1925，少的 3 个是同时用过
  两种 Python 的人）
- 0020：把 Java / JavaScript / Golang 从 84 道题的可选语言里摘掉 —— 不摘的话那些题
  的语言下拉还能选 Java，提交必 SYSTEM_ERROR
- 契约新增 normalizeLanguage() 别名表，判题侧一律走 judgeConfigFor()：旧客户端
  localStorage 里的 Python3、迁移前排进队列的任务都还能判；协作的语言归一也走它，
  否则上线那一刻学生页面里的 Python3 会静默落到 C
- 回滚要连数据一起回，只滚代码会让所有 Python 提交变 SYSTEM_ERROR

实跑
- 判题冒烟 docker/judge/smoke.ts 13 条全过：三种语言、六种状态码、gcc 宽松度
- 拿备份里的真实代码逐文件比对新旧镜像的编译结果，0 差异：C 提交 1951 份
  （1725 过 / 226 CE）、C++ 882 份、Python 2000 份、20 篇 C 教程的 93 个代码块。
  不加那三个 -Wno-error 的话，C 有 26 份会从能过变成 CE
- 迁移在灌了 12.4 万行真实数据的一次性库里跑过：0 残留、没有题目被清空；
  dev 库用真正的执行器跑通
- check:ast 56 个 target 全过，前后端 typecheck 均 0

顺带记下一个升级之前就有的坑（现在随 Go 一起消失，写在 README 里）：GOCACHE 指向
容器的 tmpfs，判题机重启后第一次 Go 提交是冷构建，Go 1.22 要 5.6 秒 CPU、超过 3 秒
的编译预算，于是重启后第一个交 Go 的学生必吃一次 CE，后面的人缓存热了又都正常。

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

apps/api/src/collab/handler.ts

@@ -13,7 +13,7 @@ import {
   getRoom,
   hasTeacherOnline,
   listRequests,
-  normalizeLanguage,
+  normalizeCollabLanguage,
   openRoom,
   queueAheadOf,
   removeRequest,
@@ -307,7 +307,7 @@ async function handleHelpRequest(
     className: student?.className ?? null,
     problemId,
     problemTitle: problem.title,
-    language: normalizeLanguage(language),
+    language: normalizeCollabLanguage(language),
     createdAt: Date.now(),
     status: "pending",
     socket: ws,
@@ -327,7 +327,7 @@ function handleHelpLanguage(ws: CollabSocket, language: unknown) {
   const request = getRequest(ws.data.userId)
   // 比对 socket 归属：同账号的另一个标签页停在别的题上切语言，不该改这条求助
   if (!request || request.socket !== ws) return
-  const next = normalizeLanguage(language)
+  const next = normalizeCollabLanguage(language)
   if (request.language === next) return
   request.language = next
 

apps/api/src/collab/state.ts

@@ -6,6 +6,8 @@
  * 所以内存态够用，不需要 Redis 同步。进程重启丢掉全部状态，两端重连后回到干净状态。
  */
 
+import { normalizeLanguage } from "@oj2/contract"
+
 export type CollabSocket = Bun.ServerWebSocket<
   import("../websocket").SubmissionSocketData
 >
@@ -17,8 +19,7 @@ export type CollabSocket = Bun.ServerWebSocket<
 export const COLLAB_LANGUAGES = [
   "C",
   "C++",
-  "Python2",
-  "Python3",
+  "Python",
   "Java",
   "JavaScript",
   "Golang",
@@ -27,10 +28,16 @@ export const COLLAB_LANGUAGES = [
 
 export type CollabLanguage = (typeof COLLAB_LANGUAGES)[number]
 
-/** 认不出来的一律当 C：老客户端不带这个字段，而它以前就是写死 C 的 */
-export function normalizeLanguage(value: unknown): CollabLanguage {
-  return (COLLAB_LANGUAGES as readonly string[]).includes(value as string)
-    ? (value as CollabLanguage)
+/**
+ * 认不出来的一律当 C：老客户端不带这个字段，而它以前就是写死 C 的。
+ *
+ * 先过契约的别名表 —— 上线那一刻学生页面里还揣着 `Python3`，不翻译的话会**静默**
+ * 落到 C，求助窗口里的代码高亮和同步编辑都按 C 走，没人会报错。
+ */
+export function normalizeCollabLanguage(value: unknown): CollabLanguage {
+  const normalized = normalizeLanguage(value) ?? value
+  return (COLLAB_LANGUAGES as readonly string[]).includes(normalized as string)
+    ? (normalized as CollabLanguage)
     : "C"
 }
 

apps/api/src/db/0019_unify_python_language.sql

@@ -0,0 +1,77 @@
+-- 语言值统一成 `Python`：库里原来有 `Python3`（104527 条提交）和 `Python2`（3 条，
+-- 全是 2022 年的），界面上两个都显示成「Python」，内部却是两个值。判题沙箱早就只剩
+-- 一个 Python 了，这里把落库的值也并成一个。
+--
+-- 语言名不是判题状态码那种「判题机也认得的编码」—— 它只是我们自己的键（语言配置是
+-- 整个对象发给判题机的），所以可以改。但它确实是**落库的值**，改完再回滚到旧版后端，
+-- 旧代码查 languageConfigs["Python"] 会查不到 → 所有 Python 提交变 SYSTEM_ERROR。
+-- 为此后端保留了 Python2/Python3 → Python 的别名（见 judge/languages.ts），
+-- 新旧代码读哪一种数据都不会炸。
+--
+-- 涉及的四张表是全量扫备份确认过的（submission / problem / user_stat /
+-- options_sysoptions）。options_sysoptions 里那行 `languages` 是 Django 时代的判题
+-- 配置，OJ2 只读 website_* 几个键，不碰它，所以这里**故意不动**。
+
+-- ① 提交记录。12 万条里 8 成是 Python，走一次全表 UPDATE。
+UPDATE "submission" SET "language" = 'Python'
+WHERE "language" IN ('Python2', 'Python3');--> statement-breakpoint
+
+-- ② 题目的可选语言。用 WITH ORDINALITY 保住原来的顺序 —— 题目页的语言下拉和默认
+--    选中项就是按这个数组的顺序来的，打乱了学生打开题目看到的默认语言会变。
+UPDATE "problem" p SET "languages" = (
+  SELECT COALESCE(jsonb_agg(
+    CASE WHEN v IN ('Python2', 'Python3') THEN 'Python' ELSE v END ORDER BY ord
+  ), '[]'::jsonb)
+  FROM jsonb_array_elements_text(p."languages") WITH ORDINALITY AS t(v, ord)
+)
+WHERE EXISTS (
+  SELECT 1 FROM jsonb_array_elements_text(p."languages") x(v)
+  WHERE x.v IN ('Python2', 'Python3')
+);--> statement-breakpoint
+
+-- ③ 预制代码，键是语言名（75 道题有 Python3 的模板）。
+UPDATE "problem"
+SET "template" = ("template" - 'Python3') || jsonb_build_object('Python', "template" -> 'Python3')
+WHERE jsonb_exists("template", 'Python3');--> statement-breakpoint
+
+-- ④ AST 代码规则，键就是语言名（15 道题）。
+UPDATE "problem"
+SET "ast_rules" = ("ast_rules" - 'Python3') || jsonb_build_object('Python', "ast_rules" -> 'Python3')
+WHERE "ast_rules" IS NOT NULL AND jsonb_exists("ast_rules", 'Python3');--> statement-breakpoint
+
+-- ⑤ 参考答案，形如 [{"language": "...", "code": "..."}]（257 条 Python3 答案）。
+UPDATE "problem" p SET "answers" = (
+  SELECT jsonb_agg(
+    CASE WHEN a ->> 'language' IN ('Python2', 'Python3')
+      THEN jsonb_set(a, '{language}', '"Python"')
+      ELSE a END ORDER BY ord
+  )
+  FROM jsonb_array_elements(p."answers") WITH ORDINALITY AS t(a, ord)
+)
+WHERE p."answers" IS NOT NULL AND jsonb_typeof(p."answers") = 'array' AND EXISTS (
+  SELECT 1 FROM jsonb_array_elements(p."answers") x(a)
+  WHERE x.a ->> 'language' IN ('Python2', 'Python3')
+);--> statement-breakpoint
+
+-- ⑥ 成就指标里的「用过哪些语言」（1235 个用户）。_languages 去重之后重算
+--    languages_used —— 同时用过 Python2 和 Python3 的那 3 个用户，数字会从 n 掉到
+--    n-1，这是**对的**：那本来就是同一种语言。已经发出去的成就不回收。
+WITH mapped AS (
+  SELECT s."id", jsonb_agg(d.v ORDER BY d.ord) AS arr
+  FROM "user_stat" s, LATERAL (
+    SELECT DISTINCT ON (val) val AS v, ord FROM (
+      SELECT CASE WHEN e IN ('Python2', 'Python3') THEN 'Python' ELSE e END AS val, ord
+      FROM jsonb_array_elements_text(s."metrics" -> '_languages') WITH ORDINALITY AS t(e, ord)
+    ) m ORDER BY val, ord
+  ) d
+  WHERE jsonb_typeof(s."metrics" -> '_languages') = 'array' AND EXISTS (
+    SELECT 1 FROM jsonb_array_elements_text(s."metrics" -> '_languages') x(e)
+    WHERE x.e IN ('Python2', 'Python3')
+  )
+  GROUP BY s."id"
+)
+UPDATE "user_stat" s SET "metrics" = jsonb_set(
+  jsonb_set(s."metrics", '{_languages}', mapped.arr),
+  '{languages_used}', to_jsonb(jsonb_array_length(mapped.arr))
+)
+FROM mapped WHERE mapped."id" = s."id";

apps/api/src/db/0020_drop_unsupported_languages.sql

@@ -0,0 +1,41 @@
+-- 把 Java / JavaScript / Golang 从题目的可选语言里摘掉。
+--
+-- 这三种语言的判题配置和判题镜像里的 JDK / Node / Go 已经一起删了（见
+-- judge/languages.ts 和 docker/judge/）。但生产库里有 84 道题的 `languages` 还留着
+-- 它们，而题目页的语言下拉就是按这个数组渲染的 —— 不摘掉的话，学生能在那 84 道题上
+-- 选 Java 提交，判题时 languageConfigs 查不到就抛 Unsupported judge language，
+-- 结果是 SYSTEM_ERROR。**这道迁移是那次删语言的收尾，不能只删代码不清数据。**
+--
+-- 备份实测：84 道题受影响，其中**没有**任何一道只有这三种语言，所以不会有题目被清空。
+-- 保险起见加了 jsonb_array_length > 0 的条件：真要出现这种题，宁可留着不动、让它
+-- 在后台显形，也不要把语言清空（题目页会渲染出一个空的语言下拉）。
+--
+-- 历史提交里那 62 条 Java/JS/Golang 记录**不动**，语言名留在契约里就是为了渲染它们。
+
+UPDATE "problem" p SET "languages" = (
+  SELECT jsonb_agg(v ORDER BY ord)
+  FROM jsonb_array_elements_text(p."languages") WITH ORDINALITY AS t(v, ord)
+  WHERE v NOT IN ('Java', 'JavaScript', 'Golang')
+)
+WHERE EXISTS (
+  SELECT 1 FROM jsonb_array_elements_text(p."languages") x(v)
+  WHERE x.v IN ('Java', 'JavaScript', 'Golang')
+) AND (
+  SELECT count(*) FROM jsonb_array_elements_text(p."languages") y(v)
+  WHERE y.v NOT IN ('Java', 'JavaScript', 'Golang')
+) > 0;--> statement-breakpoint
+
+-- 预制代码和参考答案里对应的条目一并清掉（生产库里是空的，防后台以后写进去）。
+UPDATE "problem"
+SET "template" = "template" - 'Java' - 'JavaScript' - 'Golang'
+WHERE jsonb_exists_any("template", ARRAY['Java', 'JavaScript', 'Golang']);--> statement-breakpoint
+
+UPDATE "problem" p SET "answers" = (
+  SELECT COALESCE(jsonb_agg(a ORDER BY ord), '[]'::jsonb)
+  FROM jsonb_array_elements(p."answers") WITH ORDINALITY AS t(a, ord)
+  WHERE a ->> 'language' NOT IN ('Java', 'JavaScript', 'Golang')
+)
+WHERE p."answers" IS NOT NULL AND jsonb_typeof(p."answers") = 'array' AND EXISTS (
+  SELECT 1 FROM jsonb_array_elements(p."answers") x(a)
+  WHERE x.a ->> 'language' IN ('Java', 'JavaScript', 'Golang')
+);

apps/api/src/db/meta/_journal.json

@@ -134,6 +134,20 @@
       "when": 1789822227451,
       "tag": "0018_ai_hint_diagnosis",
       "breakpoints": true
+    },
+    {
+      "idx": 19,
+      "version": "7",
+      "when": 1789906464541,
+      "tag": "0019_unify_python_language",
+      "breakpoints": true
+    },
+    {
+      "idx": 20,
+      "version": "7",
+      "when": 1789906612433,
+      "tag": "0020_drop_unsupported_languages",
+      "breakpoints": true
     }
   ]
 }

apps/api/src/db/schema.ts

@@ -858,11 +858,12 @@ export const submission = pgTable(
      * 提交列表的「语言」和「结果」两个下拉筛选。原来这两列上要么没索引、要么只有
      * 不带 `contest_id IS NULL` 的单列索引，翻页那条靠 submission_public_create_time_id_idx
      * 边扫边滤还能对付，**count 那条只能全表扫**（快照实测固定 75~82ms / 18448 buffers，
-     * 筛什么值都一样）。加完：语言 count 80ms → 11ms（Python3，占 8 成）/ 1.6ms（C），
+     * 筛什么值都一样）。加完：语言 count 80ms → 11ms（Python，占 8 成）/ 1.6ms（C），
      * 结果 count 75ms → 2.0ms。
      *
-     * 更要命的是冷门语言的**翻页**：Python2 只有 3 条、全是 2022 年的，分页索引得从
-     * 最新一路倒扫到底才凑够一页，43ms 全表扫；走这条索引是 0.02ms。
+     * 更要命的是冷门语言的**翻页**：JavaScript 只有 3 条、全是很早以前的，分页索引得从
+     * 最新一路倒扫到底才凑够一页，43ms 全表扫；走这条索引是 0.02ms。（这个实测当年用的
+     * 是 Python2，那 3 条 2026-09 已被 0019 迁移并进 Python，换了个同样冷门的值举例。）
      *
      * 两列都 ASC NULLS LAST，理由同上面 submission_public_create_time_id_idx ——
      * 靠 Index Scan **Backward** 出 `ORDER BY create_time DESC`。这里再实测了一遍：

apps/api/src/judge/ast.ts

@@ -236,7 +236,7 @@ function rangePassed(count: number, rule: AstRule) {
 const CALL_NODE_TYPES: Record<string, string> = {
   C: "call_expression",
   "C++": "call_expression",
-  Python3: "call",
+  Python: "call",
 }
 
 function functionCalls(root: Node, target: string, language: string) {
@@ -267,7 +267,7 @@ function methodCalls(root: Node, target: string, language: string) {
       )
     })
   }
-  if (language !== "Python3") return []
+  if (language !== "Python") return []
   return collectNodes(root, "call").filter((call) => {
     const fn = call.childForFieldName("function")
     return (

apps/api/src/judge/languages.ts

@@ -1,9 +1,40 @@
+import { normalizeLanguage } from "@oj2/contract"
+
+/**
+ * 判题沙箱认得的语言，**只有 C / C++ / Python 这三种**。
+ *
+ * Java / Golang / JavaScript 在 2026-09 连同镜像里的 JDK、Go、Node 工具链一起砍掉了：
+ * 前端从来没给过它们入口（后台题目的语言复选框只有 Python / C / C++ / SQL），
+ * 生产库 12 万条提交里它们一共 62 条，全是很早以前的。砍掉之后判题镜像小了一半多。
+ *
+ * 契约 `judgeLanguageSchema` 里那几个键**故意留着** —— 那是渲染历史提交要用的。
+ * 想恢复某种语言，得同时改这里和 `docker/judge/Dockerfile` 的工具链，再重建镜像。
+ *
+ * `Python` 这个键 2026-09 之前叫 `Python3`（库里还有 3 条更老的 `Python2`），
+ * 0019 迁移把数据并成了一个值。查配置一律走 `judgeConfigFor()`，别直接下标 ——
+ * 那里带着旧值的别名，迁移之前排进队列的任务、旧客户端传上来的值都还能判。
+ *
+ * SQL 题不走这里，走 `judge/sql/`；流程图题走 AI 评分。
+ */
 const defaultEnv = [
   "LANG=en_US.UTF-8",
   "LANGUAGE=en_US:en",
   "LC_ALL=en_US.UTF-8",
 ]
 
+/**
+ * gcc-14 起这三类老写法从 warning 提成了 error，而 `-w` 只关警告、压不住 error：
+ * 隐式函数声明（忘了 `#include <stdio.h>` 就用 printf）、int 与指针互赋、
+ * 不兼容的指针类型。判题机镜像 2026-09 从 gcc-13 升到 14（见 docker/judge/），
+ * 不加这三个开关的话，**一批历史题解和 20 篇 C 教程的示例会突然全部 CE**。
+ *
+ * 只给 C 加：C++ 那边这些本来就是 error，g++ 升版不改判定。
+ * 哪天决定「就是要学生写规范」，是删掉这三行，不是改镜像 —— 删之前先拿
+ * docs/c-tutorials/verify-code.sh 全量过一遍教程。
+ */
+const cLooseErrors =
+  "-Wno-error=implicit-function-declaration -Wno-error=int-conversion -Wno-error=incompatible-pointer-types"
+
 export const languageConfigs: Record<string, Record<string, unknown>> = {
   C: {
     template: "",
@@ -13,8 +44,7 @@ export const languageConfigs: Record<string, Record<string, unknown>> = {
       max_cpu_time: 3000,
       max_real_time: 10000,
       max_memory: 256 * 1024 * 1024,
-      compile_command:
-        "/usr/bin/gcc -DONLINE_JUDGE -O2 -w -fmax-errors=3 -std=c17 {src_path} -lm -o {exe_path}",
+      compile_command: `/usr/bin/gcc -DONLINE_JUDGE -O2 -w -fmax-errors=3 -std=c17 ${cLooseErrors} {src_path} -lm -o {exe_path}`,
     },
     run: {
       command: "{exe_path}",
@@ -39,24 +69,7 @@ export const languageConfigs: Record<string, Record<string, unknown>> = {
       env: defaultEnv,
     },
   },
-  Java: {
-    template: "",
-    compile: {
-      src_name: "Main.java",
-      exe_name: "Main",
-      max_cpu_time: 5000,
-      max_real_time: 10000,
-      max_memory: -1,
-      compile_command: "/usr/bin/javac {src_path} -d {exe_dir}",
-    },
-    run: {
-      command: "/usr/bin/java -cp {exe_dir} -XX:MaxRAM={max_memory}k Main",
-      seccomp_rule: null,
-      env: defaultEnv,
-      memory_limit_check_only: 1,
-    },
-  },
-  Python3: {
+  Python: {
     template: "",
     compile: {
       src_name: "solution.py",
@@ -72,40 +85,16 @@ export const languageConfigs: Record<string, Record<string, unknown>> = {
       env: defaultEnv,
     },
   },
-  Golang: {
-    template: "",
-    compile: {
-      src_name: "main.go",
-      exe_name: "main",
-      max_cpu_time: 3000,
-      max_real_time: 5000,
-      max_memory: 1024 * 1024 * 1024,
-      compile_command: "/usr/bin/go build -o {exe_path} {src_path}",
-      env: ["GOCACHE=/tmp", "GOPATH=/tmp", "GOMAXPROCS=1", ...defaultEnv],
-    },
-    run: {
-      command: "{exe_path}",
-      seccomp_rule: "golang",
-      env: ["GOMAXPROCS=1", ...defaultEnv],
-      memory_limit_check_only: 1,
-    },
-  },
-  JavaScript: {
-    template: "",
-    compile: {
-      src_name: "main.js",
-      exe_name: "main.js",
-      max_cpu_time: 3000,
-      max_real_time: 5000,
-      max_memory: 1024 * 1024 * 1024,
-      compile_command: "/usr/bin/node --check {src_path}",
-      env: defaultEnv,
-    },
-    run: {
-      command: "/usr/bin/node {exe_path}",
-      seccomp_rule: "node",
-      env: defaultEnv,
-      memory_limit_check_only: 1,
-    },
-  },
+}
+
+/**
+ * 按语言取判题配置。**判题侧一律走这个函数**，不要直接 `languageConfigs[x]`：
+ * 它先过 `normalizeLanguage()`，所以 `Python3` / `Python2` 这类旧值也能命中。
+ */
+export function judgeConfigFor(language: string) {
+  return (
+    languageConfigs[language] ??
+    languageConfigs[normalizeLanguage(language) ?? ""] ??
+    null
+  )
 }

apps/api/src/judge/run.ts

@@ -14,7 +14,7 @@ import { recordSolvedProblem } from "../services/problemset"
 import { checkAst, type AstRule } from "./ast"
 import { publishSubmissionUpdate } from "./events"
 import type { JudgeJobData } from "./job"
-import { languageConfigs } from "./languages"
+import { judgeConfigFor } from "./languages"
 import { isAccepted, JudgeStatus, type JudgeStatusValue } from "./status"
 import { parseProblemTemplate } from "./template"
 import { runSqlCase } from "./sql"
@@ -77,7 +77,7 @@ async function requestJudge(
   memoryLimit: number,
   testCaseId: string,
 ) {
-  const languageConfig = languageConfigs[language]
+  const languageConfig = judgeConfigFor(language)
   if (!languageConfig)
     throw new Error(`Unsupported judge language: ${language}`)
 

apps/api/src/scripts/check-ast-targets.ts

@@ -31,7 +31,7 @@ import treeSitterWasmPath from "web-tree-sitter/web-tree-sitter.wasm" with { typ
 const WASM_BY_LANGUAGE: Record<string, string> = {
   C: cWasmPath,
   "C++": cppWasmPath,
-  Python3: pythonWasmPath,
+  Python: pythonWasmPath,
 }
 
 await Parser.init({ locateFile: () => treeSitterWasmPath })