refactor(判题机): 换成 go-judge，空闲内存从几百 MB 降到 16 MB

原来的 JudgeServer 按核数起 gunicorn worker、每份提交再按核数开进程池，空闲内存跟着核数走（2 核 52MB、16 核 305MB）。换成 go-judge 后空闲 16MB，同一批提交判题中 80–100MB（原来约 370MB）。 go-judge 只管在沙箱里跑命令，编译、逐点运行、比对输出、定状态码搬到 judge/sandbox.ts，口径逐条照搬 JudgeServer，出参形状不变。拿生产库真实提交新旧逐点对比：C 2000 份 1989 一致、 C++ 891 份 890 一致、Python 2000 份全一致；不一致的是 system("pause")（现在不再判运行时错误）、未定义行为、endl 死循环打印（运行时错误变运行超时），见 docker/judge/README.md。 - 判题容器改成 privileged（go-judge 要自己建 cgroup），镜像 oj2-judge-3 - 心跳改由 worker 每 5 秒问判题机 /version 代记，删掉 /api/judge-server/heartbeat - 前端统一用 stripJudgePath 去掉判题机工作目录（新的 /w/ 和旧的 /judger/run/） - 提交前编译检查只编译不运行 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 15:03:57 +08:00
1 parent 8427475337
commit 37e971b6b4
@@ -53,10 +53,6 @@ DATA_DIR=
 # **NPM 的记录要打开 Websockets Support**，否则学生那边「判题中…」永远不动。
 WEB_PORT=

-# 判题机的运行状态目录（log/、run/），不设是 `$DATA_DIR/judge_server`。
-# 换目录记得先 `mkdir -p .../{log,run}`。
-JUDGE_STATE_DIR=
-
 # --- 只有机房那套需要 ---
 # 机房没有本地库，连服务器的 5445。不填时默认指向服务器（默认值在 compose.school.yml 里），
 # 换服务器才要填。服务器那套不读这两个。
@@ -36,9 +36,8 @@
 		}
 	}

-	# 判题机心跳每秒一次；静态资源量大且带永久缓存。两者都不记访问日志。
-	# 路径跟着新后端改了：judge_server_heartbeat → judge-server/heartbeat
-	@nolog path /api/judge-server/heartbeat /api/judge-server/heartbeat/ /assets/* /emoji/*
+	# 静态资源量大且带永久缓存，不记访问日志
+	@nolog path /assets/* /emoji/*
 	log_skip @nolog

 	handle /api/* {
@@ -87,33 +87,21 @@ services:
      retries: 10

  oj-judge:
-    # 自己构建的判题沙箱（上游 JudgeServer 1.6.1 + 新工具链，见 docker/judge/）。
-    # 上游停更在 2024-04，registry 上的 1.6.1 == latest，没有新版可拉。
+    # 自己构建的判题沙箱（go-judge + gcc / python，见 docker/judge/）。
    # ⚠️ 这个 tag 不在任何 registry 上：本机 docker/judge/build.sh 构建，
    #    服务器/机房用 docker load 装。镜像不在本地时 compose 会去 pull 然后报找不到。
-    image: oj2-judge-2
+    image: oj2-judge-3
    container_name: oj-judge
    restart: always
-    read_only: true
-    cap_drop:
-      - SETPCAP
-      - MKNOD
-      - NET_BIND_SERVICE
-      - SYS_CHROOT
-      - SETFCAP
-      - FSETID
+    # go-judge 要自己建 namespace 和 cgroup 来关学生程序，只能给特权，理由见 docker/judge/README.md
+    privileged: true
+    # go-judge 的文件存储（编译产物、程序输出）放这里，见 docker/judge/Dockerfile 的 -dir
    tmpfs:
      - /tmp
    volumes:
      - ${DATA_DIR:-../data}/backend/test_case:/test_case:ro
-      # 判题机的运行状态目录，默认跟着 DATA_DIR 走
-      - ${JUDGE_STATE_DIR:-${DATA_DIR:-../data}/judge_server}/log:/log
-      - ${JUDGE_STATE_DIR:-${DATA_DIR:-../data}/judge_server}/run:/judger
    environment:
-      SERVICE_URL: http://oj-judge:8080
-      # 心跳路径跟着新后端改了：judge_server_heartbeat/ → judge-server/heartbeat
-      BACKEND_URL: http://oj-api:3000/api/judge-server/heartbeat
-      TOKEN: ${OJ2_JUDGE_TOKEN:?请在 docker/.env 里设置 OJ2_JUDGE_TOKEN}
+      ES_AUTH_TOKEN: ${OJ2_JUDGE_TOKEN:?请在 docker/.env 里设置 OJ2_JUDGE_TOKEN}
    # 同一时刻最多六份在编译（正式判题 2、试运行 2、提交前编译检查 2），g++ 编一份 iostream
    # 峰值约 70MB、bits/stdc++.h 约 195MB，再加学生程序本身。512m 不够撑满，超了是容器里
    # 随机杀进程、学生看到系统错误
@@ -144,6 +132,8 @@ services:
      REDIS_URL: redis://:${REDIS_PASSWORD:?请在 docker/.env 里设置 REDIS_PASSWORD}@oj-redis:6379
      JUDGE_SERVER_URL: http://oj-judge:8080
      JUDGE_SERVER_TOKEN: ${OJ2_JUDGE_TOKEN:?}
+      # 后台「判题机列表」里这一台的名字（worker 替判题机记心跳，见 judge/heartbeat.ts）
+      JUDGE_SERVER_NAME: 服务器
      JUDGE_CONCURRENCY: ${JUDGE_CONCURRENCY:-2}
      TRIAL_CONCURRENCY: ${TRIAL_CONCURRENCY:-2}
      AI_KEY: ${AI_KEY:-}
@@ -21,9 +21,9 @@
 #   echo "OJ2_JUDGE_TOKEN=$TOKEN"    >> docker/.env   # docker compose 读这里
 #   echo "JUDGE_SERVER_TOKEN=$TOKEN" >> .env          # 后端读这里，两边必须一致
 #
-# 两个变量名不同但值必须相同：TOKEN 是判题机镜像认的名字，JUDGE_SERVER_TOKEN 是后端认的名字。
-# 忘了设 OJ2_JUDGE_TOKEN 的话 docker compose 会直接报错退出；忘了设 JUDGE_SERVER_TOKEN
-# 的话后端会随机生成一个并在启动日志里告警，判题机心跳会被 403 挡掉。
+# 两个变量名不同但值必须相同：ES_AUTH_TOKEN 是判题机（go-judge）认的名字，JUDGE_SERVER_TOKEN
+# 是后端认的名字。忘了设 OJ2_JUDGE_TOKEN 的话 docker compose 会直接报错退出；忘了设
+# JUDGE_SERVER_TOKEN 的话后端会随机生成一个并在启动日志里告警，判题请求会被 401 挡掉。

 services:
  postgres:
@@ -60,37 +60,25 @@ services:
      retries: 10

  judge:
-    # 自己构建的判题沙箱（上游 JudgeServer 1.6.1 + 新工具链，见 docker/judge/）。
-    # 上游停更在 2024-04，registry 上的 1.6.1 == latest，没有新版可拉。
+    # 自己构建的判题沙箱（go-judge + gcc / python，见 docker/judge/）。
    # ⚠️ 这个 tag 不在任何 registry 上：本机 docker/judge/build.sh 构建，
    #    服务器/机房用 docker load 装。镜像不在本地时 compose 会去 pull 然后报找不到。
-    image: oj2-judge-2
+    image: oj2-judge-3
    container_name: oj2-judge
    restart: unless-stopped
-    read_only: true
-    cap_drop:
-      - SETPCAP
-      - MKNOD
-      - NET_BIND_SERVICE
-      - SYS_CHROOT
-      - SETFCAP
-      - FSETID
+    # go-judge 要自己建 namespace 和 cgroup 来关学生程序，只能给特权，理由见 docker/judge/README.md
+    privileged: true
+    # go-judge 的文件存储（编译产物、程序输出）放这里，见 Dockerfile 的 -dir
    tmpfs:
      - /tmp
    ports:
      - "127.0.0.1:8081:8080"
    volumes:
      - ../data/test_case:/test_case:ro
-      - ../data/judge_server/log:/log
-      - ../data/judge_server/run:/judger
    environment:
-      SERVICE_URL: http://oj2-judge:8080
-      BACKEND_URL: http://host.docker.internal:3000/api/judge-server/heartbeat
      # 没有默认值是故意的：写死在仓库里的弱 token 等于没有 token。
      # 未设置时 docker compose 直接报错，不会静默起一个人人可连的判题机。
-      TOKEN: ${OJ2_JUDGE_TOKEN:?请先设置 OJ2_JUDGE_TOKEN，见本文件顶部注释}
-    extra_hosts:
-      - "host.docker.internal:host-gateway"
+      ES_AUTH_TOKEN: ${OJ2_JUDGE_TOKEN:?请先设置 OJ2_JUDGE_TOKEN，见本文件顶部注释}
    mem_limit: 512m

 volumes:
@@ -29,32 +29,21 @@ services:
      retries: 10

  oj-judge:
-    # 自己构建的判题沙箱（上游 JudgeServer 1.6.1 + 新工具链，见 docker/judge/）。
-    # 上游停更在 2024-04，registry 上的 1.6.1 == latest，没有新版可拉。
+    # 自己构建的判题沙箱（go-judge + gcc / python，见 docker/judge/）。
    # ⚠️ 这个 tag 不在任何 registry 上：本机 docker/judge/build.sh 构建，
    #    服务器/机房用 docker load 装。镜像不在本地时 compose 会去 pull 然后报找不到。
-    image: oj2-judge-2
+    image: oj2-judge-3
    container_name: oj-judge
    restart: always
-    read_only: true
-    cap_drop:
-      - SETPCAP
-      - MKNOD
-      - NET_BIND_SERVICE
-      - SYS_CHROOT
-      - SETFCAP
-      - FSETID
+    # go-judge 要自己建 namespace 和 cgroup 来关学生程序，只能给特权，理由见 docker/judge/README.md
+    privileged: true
+    # go-judge 的文件存储（编译产物、程序输出）放这里，见 docker/judge/Dockerfile 的 -dir
    tmpfs:
      - /tmp
    volumes:
      - ${DATA_DIR:-../data}/backend/test_case:/test_case:ro
-      # 判题机的运行状态目录，默认跟着 DATA_DIR 走
-      - ${JUDGE_STATE_DIR:-${DATA_DIR:-../data}/judge_server}/log:/log
-      - ${JUDGE_STATE_DIR:-${DATA_DIR:-../data}/judge_server}/run:/judger
    environment:
-      SERVICE_URL: http://oj-judge:8080
-      BACKEND_URL: http://oj-api:3000/api/judge-server/heartbeat
-      TOKEN: ${OJ2_JUDGE_TOKEN:?请在 env 文件里设置 OJ2_JUDGE_TOKEN}
+      ES_AUTH_TOKEN: ${OJ2_JUDGE_TOKEN:?请在 env 文件里设置 OJ2_JUDGE_TOKEN}
    # 机房机器内存宽裕，判题给足
    mem_limit: 2g

@@ -81,6 +70,8 @@ services:
      REDIS_URL: redis://oj-redis:6379
      JUDGE_SERVER_URL: http://oj-judge:8080
      JUDGE_SERVER_TOKEN: ${OJ2_JUDGE_TOKEN:?}
+      # 后台「判题机列表」里这一台的名字（worker 替判题机记心跳，见 judge/heartbeat.ts）
+      JUDGE_SERVER_NAME: 机房
      JUDGE_CONCURRENCY: ${JUDGE_CONCURRENCY:-4}
      TRIAL_CONCURRENCY: ${TRIAL_CONCURRENCY:-4}
      AI_KEY: ${AI_KEY:-}
@@ -108,14 +108,9 @@ pgver=$(cat "$pgver_file")
 [ "$pgver" = 18 ] || die "$data_dir/postgresql 是 PostgreSQL $pgver 的数据目录，但 compose 里是 postgres:18-alpine，起不来。"
 ok "数据目录 $data_dir/postgresql（PostgreSQL $pgver）"

-# ③ 判题机运行目录：不设就是 $DATA_DIR/judge_server
-judge_dir=$(grep -E '^JUDGE_STATE_DIR=' docker/.env | tail -1 | cut -d= -f2- || true)
-ok "判题机运行目录 ${judge_dir:-$data_dir/judge_server}"
-
-# ④ 判题镜像是自建的（上游 JudgeServer 停更，官方镜像的编译器停在 gcc-13），
+# ③ 判题镜像是自建的（go-judge 的二进制 + 我们要的 gcc / python），
 #    registry 上没有这个 tag。忘了 docker load 的话，要到「起栈」那步 compose 去 pull
 #    才失败 —— 不如在这里就把该跑的三条命令说清楚。
-#    回滚到官方镜像时这段自动跳过：那个 tag 是 pull 得到的。
 judge_image=$(grep -m1 -E '^[[:space:]]*image: oj2-judge' <<<"$cfg" | awk '{print $2}' || true)
 if [ -n "$judge_image" ]; then
  docker image inspect "$judge_image" >/dev/null 2>&1 \
@@ -134,7 +129,6 @@ ok "对外端口 $port"
 [ "$CHECK_ONLY" -eq 0 ] || { printf '\n\033[1;32m✅ 自检通过（--check，没动容器）\033[0m\n'; exit 0; }

 # ---------------------------------------------------------------- 起栈
-mkdir -p "$judge_dir/log" "$judge_dir/run"

 if [ "$BUILD" -eq 1 ]; then
  say "构建镜像（首次约 5 分钟，之后走缓存很快）"
@@ -1,86 +1,41 @@
-# 判题沙箱镜像。**这是 QingdaoU/JudgeServer 官方 Dockerfile 的分叉**，
-# 只改工具链版本，server/ 和 Judger/ 的代码一行都没动（构建时从上游仓库
-# 的固定 commit 拉，见 build.sh）。
+# 判题沙箱镜像：go-judge（https://github.com/criyle/go-judge）+ 我们要的工具链。
 #
-# 为什么要分叉：上游停更在 2024-04-05（b28aa56，也就是 1.6.1 这个 tag），
-# registry 上的 `latest` 和 `1.6.1` 是同一份镜像，没有新版可升。想要新编译器
-# 只能自己构建。
+# go-judge 只管「在沙箱里跑一条命令」：编译、逐个测试点运行、比对输出、算状态码
+# 都在 api 那边（apps/api/src/judge/sandbox.ts）。所以这个镜像里只有两样东西：
+# go-judge 的单个二进制，和学生程序要用的编译器 / 解释器。
 #
-# 相对上游的全部改动：
-#   gcc/g++  13      → 14      (trixie 默认)
-#   Python   3.12    → 3.13    (trixie 默认)
-#   Go / JDK / Node  → **整套删掉**（见下）
+# 2026-10 从 QingdaoU/JudgeServer 换过来的（那边停更在 2024-04，而且 gunicorn 按
+# 核数起 worker，16 核的机器空闲就占 300MB）。换的原因和逐份对比的结论见 README.md。
 #
-# 只留 C / C++ / Python3 的工具链：前端的语言复选框从来只给这三种加 SQL，
-# 生产库 12 万条提交里 Java/Golang/JavaScript 一共 62 条、全是很早以前的。
-# 删掉 golang-1.24-go、temurin-25-jdk、nodejs 之后镜像从 1.16GB 掉到 ~500MB，
-# 构建也少了 NodeSource 那个 39MB 的 deb（它没有可用的国内镜像，最慢的一块）。
-# 想恢复某种语言：这里加回包 + alternatives，同时改 apps/api/src/judge/languages.ts。
+#   gcc / g++  14     (trixie 默认)
+#   Python     3.13   (trixie 默认)
 #
 # ⚠️ 语言的编译/运行命令**不在这个文件里**，在 apps/api/src/judge/languages.ts。
 #    升 gcc 大版本要同步看那边的开关（gcc-14 把 implicit-function-declaration
 #    等提成了 error，languages.ts 里有几个 -Wno-error 把它压回去）。
+# ⚠️ 换 Python 大版本时，api 镜像（docker/Dockerfile 的 python3-minimal）要一起换，
+#    理由见 README.md。

-# 镜像源。默认走国内镜像 —— 官方源在这边实测 197 KB/s，清华 3.9 MB/s，
-# 整个构建从 12 分钟掉到 2 分钟出头。出国内网络环境用 build.sh --no-mirror 关掉。
+# go-judge 的版本。升级前看一眼它的 release notes 里有没有改 /run 的出入参。
+ARG GO_JUDGE_VERSION=v1.13.3
+
+# 镜像源。默认走国内镜像 —— 官方源在这边实测 197 KB/s，清华 3.9 MB/s。
+# 出国内网络环境用 build.sh --no-mirror 关掉。
 #
-# ⚠️ debian 这两个只能用 **http**：改 sources 这一步发生在装 ca-certificates 之前，
+# ⚠️ 只能用 **http**：改 sources 这一步发生在装 ca-certificates 之前，
 #    base 镜像里没有 CA 根证书，https 一律 `certificate verify failed`。
-#    PyPI 那条是 pip 自己请求的，pip 内置 certifi，不依赖系统 CA。
 ARG APT_MIRROR=http://mirrors.tuna.tsinghua.edu.cn/debian
 ARG APT_SECURITY_MIRROR=http://mirrors.tuna.tsinghua.edu.cn/debian-security
-ARG PIP_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple

-FROM debian:trixie-slim AS builder
-ARG TARGETARCH
-ARG TARGETVARIANT
-ARG APT_MIRROR
-ARG APT_SECURITY_MIRROR
-ARG PIP_INDEX_URL
-
-ENV DEBIAN_FRONTEND=noninteractive
-WORKDIR /app
-
-RUN --mount=type=cache,target=/var/cache/apt,id=apt-cahce-1-$TARGETARCH$TARGETVARIANT-builder,sharing=locked \
-    --mount=type=cache,target=/var/lib/apt,id=apt-cahce-2-$TARGETARCH$TARGETVARIANT-builder,sharing=locked \
-    <<EOS
-set -ex
-rm -f /etc/apt/apt.conf.d/docker-clean
-echo 'Binary::apt::APT::Keep-Downloaded-Packages "1";' > /etc/apt/apt.conf.d/keep-cache
-echo 'APT::Install-Recommends "0";' > /etc/apt/apt.conf.d/no-recommends
-echo 'APT::AutoRemove::RecommendsImportant "0";' >> /etc/apt/apt.conf.d/no-recommends
-# 换镜像源。debian-security 必须先换：它的 URI 以 debian 的 URI 为前缀，
-# 反过来的话第二条 sed 会把它改成 <镜像>/debian-security，路径不存在。
-sed -i "s|http://deb.debian.org/debian-security|$APT_SECURITY_MIRROR|; s|http://deb.debian.org/debian|$APT_MIRROR|" /etc/apt/sources.list.d/debian.sources
-apt-get update
-apt-get install -y libtool make cmake libseccomp-dev gcc python3 python3-venv
-EOS
-
-COPY Judger/ /app/
-RUN <<EOS
-set -ex
-mkdir /app/build
-cmake -S . -B build
-cmake --build build --parallel $(nproc)
-EOS
-
-RUN <<EOS
-set -ex
-cd bindings/Python
-python3 -m venv .venv
-.venv/bin/pip3 install -i "$PIP_INDEX_URL" build
-.venv/bin/python3 -m build -w
-EOS
+FROM criyle/go-judge:${GO_JUDGE_VERSION} AS go-judge

 FROM debian:trixie-slim
 ARG TARGETARCH
 ARG TARGETVARIANT
 ARG APT_MIRROR
 ARG APT_SECURITY_MIRROR
-ARG PIP_INDEX_URL

 ENV DEBIAN_FRONTEND=noninteractive
-WORKDIR /app

 RUN --mount=type=cache,target=/var/cache/apt,id=apt-cahce-1-$TARGETARCH$TARGETVARIANT-final,sharing=locked \
    --mount=type=cache,target=/var/lib/apt,id=apt-cahce-2-$TARGETARCH$TARGETVARIANT-final,sharing=locked \
@@ -90,59 +45,39 @@ rm -f /etc/apt/apt.conf.d/docker-clean
 echo 'Binary::apt::APT::Keep-Downloaded-Packages "1";' > /etc/apt/apt.conf.d/keep-cache
 echo 'APT::Install-Recommends "0";' > /etc/apt/apt.conf.d/no-recommends
 echo 'APT::AutoRemove::RecommendsImportant "0";' >> /etc/apt/apt.conf.d/no-recommends
-needed="python3.13-minimal \
-    python3.13-venv \
-    libpython3.13-stdlib \
-    libpython3.13-dev \
-    gcc-14 \
-    g++-14 \
-    strace"
-savedAptMark="$(apt-mark showmanual) $needed"
-# 换镜像源。debian-security 必须先换：它的 URI 以 debian 的 URI 为前缀，
+# debian-security 必须先换：它的 URI 以 debian 的 URI 为前缀，
 # 反过来的话第二条 sed 会把它改成 <镜像>/debian-security，路径不存在。
 sed -i "s|http://deb.debian.org/debian-security|$APT_SECURITY_MIRROR|; s|http://deb.debian.org/debian|$APT_MIRROR|" /etc/apt/sources.list.d/debian.sources
 apt-get update
-apt-get install -y $needed
+# 和换掉的 JudgeServer 镜像同一组包（去掉了它自己要的 venv / dev / strace），
+# 学生程序能 import 的标准库模块因此一个不少
+apt-get install -y python3.13-minimal libpython3.13-stdlib gcc-14 g++-14
 # languages.ts 里的编译/运行命令写的是绝对路径（/usr/bin/gcc、/usr/bin/python3 …），
 # 全靠下面这几条 alternatives 挂出来。换包名必须同步改，漏一条的表现是 CE 而不是报错。
 update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-14 14
 update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-14 14
 update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.13 13
-apt-mark auto '.*' > /dev/null
-apt-mark manual $savedAptMark
-apt-get purge -y --auto-remove
 EOS

-COPY --from=builder --chmod=755 --link /app/output/libjudger.so /usr/lib/judger/libjudger.so
-COPY --from=builder /app/bindings/Python/dist/ /app/
-RUN --mount=type=cache,target=/root/.cache/pip,id=pip-cahce-$TARGETARCH$TARGETVARIANT-final \
-    <<EOS
-set -ex
-python3 -m venv .venv
-CC=gcc .venv/bin/pip3 install -i "$PIP_INDEX_URL" --compile --no-cache-dir flask gunicorn idna psutil requests
-.venv/bin/pip3 install *.whl
-EOS
+COPY --from=go-judge /opt/go-judge /usr/local/bin/go-judge
+COPY mount.yaml /etc/go-judge/mount.yaml

-COPY server/ /app/
-RUN <<EOS
-set -ex
-chmod -R u=rwX,go=rX /app/
-chmod +x /app/entrypoint.sh
-gcc -shared -fPIC -o unbuffer.so unbuffer.c
-useradd -u 901 -r -s /sbin/nologin -M compiler
-useradd -u 902 -r -s /sbin/nologin -M code
-useradd -u 903 -r -s /sbin/nologin -M -G code spj
-mkdir -p /usr/lib/judger
-EOS
-
-# 构建期自检：这五行任何一个不是预期版本，说明上面的包名或 alternatives 配错了。
+# 构建期自检：任何一个不是预期版本，说明上面的包名或 alternatives 配错了。
 RUN <<EOS
 set -ex
 gcc --version
 g++ --version
 python3 --version
+go-judge -version
 EOS

-HEALTHCHECK --interval=5s CMD [ "/app/.venv/bin/python3", "/app/service.py" ]
+# 参数也能用环境变量覆盖（ES_ 前缀，比如 ES_PARALLELISM=4），compose 里就是这么传 token 的。
+#   -http-addr        端口沿用 JudgeServer 的 8080，compose 和 JUDGE_SERVER_URL 不用改
+#   -mount-conf       沙箱里能看到哪些目录，见 mount.yaml
+#   -src-prefix       学生程序的 stdin 直接从 /test_case 里开，不经 api 中转；别的路径一律拒
+#   -output-limit     每条命令写文件的上限（RLIMIT_FSIZE）。16MB 是 JudgeServer 的口径：
+#                     死循环打印写到 16MB 吃 SIGXFSZ，判运行时错误，前端有对应的中文说明
+#   -file-timeout     编译产物和输出由 api 用完就删，这是 api 半路崩掉时的兜底
+#   -dir              文件存储默认在 /dev/shm，docker 默认只给 64MB，放到 /tmp（compose 里的 tmpfs）
+ENTRYPOINT [ "go-judge", "-http-addr=:8080", "-mount-conf=/etc/go-judge/mount.yaml", "-src-prefix=/test_case", "-output-limit=16m", "-file-timeout=10m", "-dir=/tmp/go-judge" ]
 EXPOSE 8080
-ENTRYPOINT [ "/app/entrypoint.sh" ]
@@ -1,109 +1,148 @@
 # 判题沙箱镜像

-判题机跑的是 [QingdaoU/JudgeServer](https://github.com/QingdaoU/JudgeServer)。
-**上游已经停更**：master 最后一次提交是 2024-04-05（`b28aa56`，即 tag `v1.6.1`），
-registry 上的 `oj-image/judge:latest` 和 `:1.6.1` 是同一份镜像（config digest 都是
-`221bf4c0e730`）。所以想换新编译器，只能自己构建。
+判题机跑的是 [go-judge](https://github.com/criyle/go-judge)：一个 Go 写的沙箱服务，
+只管「在沙箱里跑一条命令、量出用了多少时间和内存」。**编译、逐个测试点运行、比对输出、
+定状态码都在后端** `apps/api/src/judge/sandbox.ts`。

-这里放的是**只改工具链的分叉**：`server/`（Flask + `_judger` 那套判题逻辑）和
-`Judger/`（libjudger.so 沙箱内核）一行都没动，构建时从上游那个固定 commit 拉。
+这个镜像里只有两样东西：go-judge 的单个二进制（从官方镜像 `criyle/go-judge` 里拷出来），
+和学生程序要用的工具链。

-## 工具链
-
-2026-09 从上游镜像升级，同时把用不上的三种语言整套砍掉：
-
-| | 上游 1.6.1 | 现在 |
-|---|---|---|
-| gcc / g++ | 13 | **14.2**（trixie 默认） |
-| Python | 3.12 | **3.13.5**（trixie 默认） |
-| Go | 1.22 | **删掉** |
-| Node | 20.x | **删掉** |
-| JDK | temurin-21 | **删掉** |
-| base | debian:trixie-slim（2024 年的） | debian:trixie-slim（当前） |
-| 镜像体积 | 1.1 GB | **433 MB** |
+| | 版本 |
+|---|---|
+| go-judge | **v1.13.3**（`Dockerfile` 的 `GO_JUDGE_VERSION`） |
+| gcc / g++ | **14.2**（trixie 默认） |
+| Python | **3.13.5**（trixie 默认） |
+| base | debian:trixie-slim |
+| 镜像体积 | 384 MB |

 ⚠️ **换 Python 大版本时，api 镜像（`docker/Dockerfile` 的 `python3-minimal`）要一起换。**
 提交前的语法检查在 api 那边用 CPython 编译一遍，前端再按报错原文翻成中文（翻译表在
-`apps/web/src/oj/problem/utils/pythonError.ts`）。两边版本不一致的话，同一份代码
+`apps/web/src/utils/pythonError.ts`）。两边版本不一致的话，同一份代码
 在提交前和判题时报的句式可能不同，翻译表只能对上其中一边。

-砍语言的依据：前端的题目语言复选框从来只给 Python / C / C++ / SQL，
-生产库 12 万条提交里 Java 44 条、Golang 15 条、JavaScript 3 条，全是很早以前的。
-契约 `judgeLanguageSchema` 里那几个键留着（渲染历史提交要用），只是判题机不再认。
-要恢复某种语言：Dockerfile 里加回包和 `update-alternatives`，同时改
-`apps/api/src/judge/languages.ts`，两边缺一个都是静默失败。
+## 为什么从 JudgeServer 换过来（2026-10）
+
+之前跑的是 QingdaoU/JudgeServer（上游停更在 2024-04，我们自己重编过工具链，那是 `oj2-judge-2`）。
+它的 gunicorn 按核数起 worker、每份提交再按核数开进程池，**空闲内存跟着机器核数走**：
+
+| | 空闲 | 判题中（同一批提交） |
+|---|---|---|
+| JudgeServer，2 核（= 服务器） | 52 MB | — |
+| JudgeServer，16 核 | 305 MB | 约 370 MB |
+| go-judge | **16 MB** | **80–100 MB** |
+
+判题中那一列是在 16 核的开发机上、两边同时跑同一批真实提交时量的。go-judge 同时跑几个
+程序由 `-parallelism` 管（默认等于核数），不再随提交数翻倍。
+
+## 判定和原来一样吗
+
+后端逐条照搬了 JudgeServer 的口径（输出 rstrip 后比 md5、stdout 和 stderr 合在一起比、
+地址空间限两倍内存、16MB 输出上限、墙钟是 CPU 时限的 3 倍、libjudger 的状态码顺序），
+细节见 `sandbox.ts` 顶部。换之前拿**生产库里的真实提交**，同一份代码同时送进新旧两台判题机，
+逐个测试点比状态码：
+
+| 语料 | 份数 | 一模一样 | 不一样 |
+|---|---|---|---|
+| C 提交（共 19757，随机抽样） | 2000 | 1989 | 11 |
+| C++ 提交（全量） | 891 | 890 | 1 |
+| Python 提交（共 115492，随机抽样） | 2000 | 2000 | 0 |
+
+不一样的全部是下面三种，都是有意接受的：
+
+- **`system("pause")`**（Dev-C++ 留下的习惯）：原来 seccomp 直接杀，运行时错误、信号 31；
+  现在学生程序开不了子进程，`system()` 返回 -1，程序照常往下跑、按输出判。全库这样判成
+  运行时错误的一共 63 条，2026-09 以后一条没有。
+- **未定义行为**：读越界的数组元素（`max = num[10]`）、没读进值的变量。读到的垃圾值取决于
+  栈上原来有什么，换了沙箱就换了一批垃圾。库里存的结果本来就和旧判题机现在重跑的对不上。
+- **死循环里用 `endl` 打印**（C++ 那 1 条）：原来 CPU 时间只算用户态，先写满 16MB 判运行时错误；
+  现在内核态也算（每次 `endl` 刷新都是一次系统调用），先到 1 秒判运行超时。都是错，说法不同。
+
+另外几处数字会变，不影响判定：
+
+- **内存读数变小**：现在是 cgroup 的峰值，原来是 ru_maxrss。C 的空程序 0.25 MB（原来
+  1.5 MB），Python 2–5 MB（原来 8 MB）。程序打印的输出也算在内存里（写在 tmpfs 上）。
+- **CPU 时间含内核态**，原来只算用户态。读大输入的程序会多出几毫秒。
+- **Python 的回溯路径**是 `/w/solution.py`，原来是 `/judger/run/<随机串>/solution.py`。
+  前端显示前两种都会去掉（`apps/web/src/utils/judge.ts` 的 `stripJudgePath`）。
+  编译错误是相对路径（`main.c:3:5`、`File "solution.py"`），不受影响。
+
+## 判题机容器为什么是 privileged
+
+go-judge 要给每个学生程序建 namespace（看不到网络、别的进程、宿主的文件）和 cgroup（限内存、
+数进程），这些在普通容器里做不了。试过不给特权：要同时加 `SYS_ADMIN`、关掉 Docker 的
+seccomp 和 AppArmor、去掉 `/proc` `/sys` 的遮罩、再在容器里把 cgroup 重新挂成可写 ——
+那几乎就是特权了，还更脆，换台宿主机就可能起不来。所以照 go-judge 官方的做法给 `privileged: true`。
+
+学生程序本身是关在 go-judge 自己的沙箱里的（独立的 mount / pid / net / ipc / uts / user
+namespace、cgroup、seccomp），比原来 libjudger 只有 seccomp + setuid 关得更严。
+
+**宿主机要求**：cgroup v2（Debian 12 起默认就是），内核 ≥ 5.19 时内存峰值用 `memory.peak`，
+更老的内核退回 maxrss（读数偏大一点）。起不来时 `docker logs oj-judge` 里会有
+`create environment builder failed`。

 ## 镜像源

-默认走清华源（`Dockerfile` 顶部三个 ARG）。官方源在这边实测 **197 KB/s**，清华
-**3.9 MB/s**，整个构建从 12 分钟掉到 1 分钟以内。
+默认走清华源（`Dockerfile` 顶部两个 ARG）。官方源在这边实测 **197 KB/s**，清华
+**3.9 MB/s**。

 `build.sh --no-mirror` 换回官方源。debian 那两个只能用 http —— 改 sources 发生在
 装 ca-certificates 之前，base 镜像里没有 CA 根证书，https 一律
 `certificate verify failed`（这个坑踩过）。

+go-judge 那层是从 Docker Hub 拉 `criyle/go-judge:<版本>`，构建机要能拉到它。
+
 ## 构建与分发

 ```bash
-docker/judge/build.sh --save      # 本机构建 + 导出 dist/oj2-judge-2.tar
-scp dist/oj2-judge-2.tar root@服务器:/root/OJDeploy/
-ssh root@服务器 'docker load -i /root/OJDeploy/oj2-judge-2.tar'
+docker/judge/build.sh --save      # 本机构建 + 导出 dist/oj2-judge-3.tar
+scp dist/oj2-judge-3.tar root@服务器:/root/OJDeploy/
+ssh root@服务器 'docker load -i /root/OJDeploy/oj2-judge-3.tar'
 # 机房那台同样来一遍 —— 两个站点各有各的判题沙箱
 ```

-之后正常 `docker/deploy.sh` 即可。
+之后正常 `docker/deploy.sh` 即可。**判题机和 api / worker 要一起换**：新后端只会说
+go-judge 的话，旧判题机只认旧后端。

-⚠️ **这个名字不在任何 registry 上。** 服务器上忘了 `docker load`，compose 会去
-pull 然后报找不到镜像（好在是响亮地失败，不是静默降级）。
+⚠️ **这个名字不在任何 registry 上。** 服务器上忘了 `docker load`，`deploy.sh` 的自检会拦下。

-⚠️ **改工具链就把末尾的序号 +1**（下一版叫 `oj2-judge-3`：`build.sh` 里的 `IMAGE`、
-compose 里三处，一起改）。`docker compose up -d` 不带 `--pull`，名字没变会静默用机器上
-的旧镜像。官方镜像算第 1 版，所以我们自己重编的从 `-2` 起。
+⚠️ **改工具链或升 go-judge 就把末尾的序号 +1**（下一版叫 `oj2-judge-4`：`build.sh` 里的
+`IMAGE`、三个 compose 里的 image，一起改）。`docker compose up -d` 不带 `--pull`，名字没变会静默
+用机器上的旧镜像。

-回滚：把三个 compose 的 image 改回
-`registry.cn-hongkong.aliyuncs.com/oj-image/judge:1.6.1`，重新 `up -d`。别在服务器上
-`docker image prune` 把那份旧镜像清掉。
+回滚：JudgeServer 那版（`oj2-judge-2`）只认 2026-10 之前的后端，要连代码一起回退到换判题机之前
+的提交再部署。别在服务器上 `docker image prune` 把 `oj2-judge-2` 清掉。

-## 和 `languages.ts` 的关系
+## 和后端的分工

-**编译和运行命令不在镜像里**，在 `apps/api/src/judge/languages.ts`。镜像只负责把
-`/usr/bin/gcc`、`/usr/bin/python3`、`/usr/bin/go`、`/usr/bin/node`、`/usr/bin/java`
-这些绝对路径挂到正确的版本上（Dockerfile 末尾的 `update-alternatives`）。
+- **编译和运行命令在 `apps/api/src/judge/languages.ts`**，不在镜像里。镜像只负责把
+  `/usr/bin/gcc`、`/usr/bin/g++`、`/usr/bin/python3` 这些绝对路径挂到正确的版本上
+  （Dockerfile 里的 `update-alternatives`）。恢复一种语言要两边一起改，缺一个都是静默失败。
+- **沙箱里能看到哪些目录在 `mount.yaml`**：`/usr`、`/lib` 这些只读，工作目录 `/w` 和 `/tmp`
+  各是一块 128MB 的 tmpfs。
+- **测试点不经过 api**：学生程序的 stdin 直接从判题机容器里的 `/test_case/<id>/N.in` 开
+  （镜像的 `-src-prefix=/test_case`，别的路径一律拒）。比对用的 `stripped_output_md5` 由 api
+  从同一个目录的 `info` 里读。所以 compose 里判题机和 api 挂的必须是同一个测试点目录。
+- **程序输出不内联回传**：每个测试点的输出（最多 16MB）留在判题机的文件存储里，api 用
+  `GET /file/:id` 按原始字节取回来比 md5，然后删掉。直接塞在 JSON 里的话，死循环打印的
+  16MB 会在 worker 里膨胀成几倍。api 半路崩了没删的，判题机 10 分钟后自己清（`-file-timeout`）。
+- **心跳**：go-judge 不主动报，worker 每 5 秒问一次 `/version`，替它在 `judge_server` 表里记一笔
+  （`apps/api/src/judge/heartbeat.ts`）。后台列表里两台分别叫「服务器」「机房」（compose 的
+  `JUDGE_SERVER_NAME`）。
+- **鉴权**：`Authorization: Bearer <OJ2_JUDGE_TOKEN>`，go-judge 从 `ES_AUTH_TOKEN` 读。原来
+  JudgeServer 收的是 token 的 sha256，现在是原文。

 gcc-14 把隐式函数声明、int↔指针互赋、不兼容指针类型从 warning 提成了 error，`-w`
 压不住。`languages.ts` 里的 `cLooseErrors` 里的 `-Wno-error=` 就是为此加的 ——
-实测 1951 份历史 C 提交和 20 篇 C 教程的 93 个代码块，加了之后与 gcc-13 逐个文件
-结果完全一致；不加的话有一批会从能过变成 CE。
-
-## 这次升级是怎么验的
-
-不写测试，全是实跑。除了 `smoke.ts` 的 13 条，还拿**生产库备份里的真实代码**逐个
-文件对比了新旧镜像的编译结果（脚本是一次性的，结论记在这里）：
-
-| 语料 | 份数 | 老镜像 (gcc-13 / py3.12) | 新镜像 (gcc-14 / py3.13) | 差异 |
-|---|---|---|---|---|
-| 历史 C 提交（共 19262，随机抽样） | 1951 | 1725 过 / 226 CE | 一模一样 | **0** |
-| 历史 C++ 提交（全量） | 882 | 603 过 / 279 CE | 一模一样 | **0** |
-| 历史 Python 提交（共 104527，随机抽样） | 2000 | 1833 过 / 167 CE | 一模一样 | **0** |
-| 20 篇 C 教程里含 `int main` 的代码块 | 93 | 93 全过 | 一模一样 | **0** |
-
-**不加 `cLooseErrors` 那三个开关的话，1951 份 C 提交里有 26 份会从「能过」变成 CE**
-（按比例算全库约 260 条），全是忘了 `#include <string.h>` 之类的隐式函数声明。
-教程那 93 块本身写得规范，加不加都全过。
+2026-09 升 gcc-14 时实测 1951 份历史 C 提交和 20 篇 C 教程的 93 个代码块，加了之后与
+gcc-13 逐个文件结果完全一致；不加的话有 26 份会从「能过」变成 CE（按比例算全库约 260 条），
+全是忘了 `#include <string.h>` 之类的隐式函数声明。

 ## 换镜像后怎么验

 ```bash
-bun docker/judge/smoke.ts          # 六种语言 + 六种状态码 + gcc 宽松度
+bun docker/judge/smoke.ts          # 三种语言 + 六种状态码 + gcc 宽松度 + 几条照搬的口径
 ```

-它直接打判题机的 `/judge`，不需要起后端、不需要库里有题。用的 `languageConfigs`
-就是线上那份，所以配置和镜像对不上会当场暴露。
+它走的就是线上那份 `sandbox.ts`，不需要起后端、不需要库里有题，测试点内联传。

-**Go 那条坑记一下**（升级时发现的，升级之前就有）：`GOCACHE` 指向容器的 tmpfs
-`/tmp`，判题机重启后第一次 Go 提交是冷构建，Go 1.22 要 5.6 秒 CPU、超过 3 秒的编译
-预算 —— 重启后第一个交 Go 的学生必吃一次 CE，后面的人缓存热了又都正常。Go 现在整个
-删掉了，但**以后加回任何需要编译缓存的语言，记得把编译预算放宽**。
-
-判题机装好之后，后台「判题机列表」应该能看到它上线（心跳走
-`POST /api/judge-server/heartbeat`，5 秒一次）。
+判题机装好之后，后台「判题机列表」应该能看到它上线（worker 起来 5 秒内）。
@@ -7,9 +7,8 @@
 #   docker/judge/build.sh --no-cache      # 不吃构建缓存
 #   docker/judge/build.sh --no-mirror     # 不走国内镜像源（默认走）
 #
-# 上游 JudgeServer 停更在 2024-04-05，registry 上的 1.6.1 == latest，没有新版
-# 可拉。这个脚本从上游那个固定 commit 拉源码（server/ 和 Judger/ 一行不改），
-# 只把 Dockerfile 换成 docker/judge/Dockerfile —— 新工具链的全部改动都在那里。
+# 镜像 = go-judge 官方镜像里的那个二进制 + debian 的 gcc / python。构建上下文就是
+# docker/judge/ 这个目录（Dockerfile + mount.yaml）。
 #
 # 上传和切换见 docker/judge/README.md。

@@ -18,15 +17,11 @@ set -euo pipefail

 cd "$(dirname "${BASH_SOURCE[0]}")/../.."

-# 上游 master HEAD（= tag v1.6.1+judgeserver.1.6.1）。Judger 子模块的版本由这个
-# commit 自己钉住（d19a6dc），不用在这里再写一遍。
-UPSTREAM_REPO=https://github.com/QingdaoU/JudgeServer.git
-UPSTREAM_COMMIT=b28aa56d60fed7358a29d9bdeb9d86fcc06e41a7
-
-# 我们自己重编的第几版判题镜像（官方那个算第 1 版，这是第 2 版）。
-# **改工具链就把末尾的序号 +1**（下一版叫 oj2-judge-3），别在同一个名字上重建 ——
+# 我们自己构建的第几版判题镜像（官方 JudgeServer 算第 1 版，自己重编的 JudgeServer
+# 是第 2 版，换成 go-judge 是第 3 版）。
+# **改工具链就把末尾的序号 +1**（下一版叫 oj2-judge-4），别在同一个名字上重建 ——
 # compose 的 `up -d` 不带 --pull，名字没变就会静默用机器上的旧镜像。
-IMAGE=oj2-judge-2
+IMAGE=oj2-judge-3

 SAVE=0
 BUILD_ARGS=()
@@ -34,13 +29,12 @@ for arg in "$@"; do
  case "$arg" in
    --save)     SAVE=1 ;;
    --no-cache) BUILD_ARGS+=(--no-cache) ;;
-    # 默认用国内镜像源（Dockerfile 顶部的四个 ARG）。在能直连的网络里用这个关掉，
-    # 换回 deb.debian.org / pypi.org。
+    # 默认用国内镜像源（Dockerfile 顶部的 ARG）。在能直连的网络里用这个关掉，
+    # 换回 deb.debian.org。
    --no-mirror)
      BUILD_ARGS+=(
        --build-arg APT_MIRROR=http://deb.debian.org/debian
        --build-arg APT_SECURITY_MIRROR=http://deb.debian.org/debian-security
-        --build-arg PIP_INDEX_URL=https://pypi.org/simple
      ) ;;
    *) echo "未知参数：$arg（可用：--save、--no-cache、--no-mirror）" >&2; exit 2 ;;
  esac
@@ -53,25 +47,16 @@ die()  { printf '\n\033[1;31m❌ %s\033[0m\n\n' "$*" >&2; exit 1; }
 command -v docker >/dev/null || die "没装 docker"
 [ -f docker/judge/Dockerfile ] || die "docker/judge/Dockerfile 不见了，当前目录：$PWD"

-src=$(mktemp -d)
-trap 'rm -rf "$src"' EXIT
-
-say "拉上游源码 $UPSTREAM_COMMIT"
-git -c advice.detachedHead=false clone --quiet "$UPSTREAM_REPO" "$src"
-git -C "$src" -c advice.detachedHead=false checkout --quiet "$UPSTREAM_COMMIT"
-git -C "$src" submodule update --quiet --init --recursive
-ok "server/ 和 Judger/ 就位"
-
 say "构建 $IMAGE"
-# 上下文是上游源码，Dockerfile 用我们自己的那份。
-docker build "${BUILD_ARGS[@]}" -f docker/judge/Dockerfile -t "$IMAGE" "$src"
+docker build "${BUILD_ARGS[@]}" -t "$IMAGE" docker/judge
 ok "$IMAGE"

 say "镜像里的工具链"
 docker run --rm --entrypoint sh "$IMAGE" -c '
-  printf "gcc     %s\n" "$(gcc -dumpfullversion)"
-  printf "g++     %s\n" "$(g++ -dumpfullversion)"
-  printf "python3 %s\n" "$(python3 -V | cut -d" " -f2)"
+  printf "gcc      %s\n" "$(gcc -dumpfullversion)"
+  printf "g++      %s\n" "$(g++ -dumpfullversion)"
+  printf "python3  %s\n" "$(python3 -V | cut -d" " -f2)"
+  printf "go-judge %s\n" "$(go-judge -version | head -1)"
 '

 if [ "$SAVE" = 1 ]; then
@@ -0,0 +1,81 @@
+# go-judge 沙箱里的文件系统：学生程序和编译器只看得到这些。
+# 照 go-judge 自带的 mount.yaml 删减的：只留 gcc / g++ / python3 要的，
+# fpc、mono、ghc、java 那几条（还有 MPI 的 /sys、/dev/shm）都去掉了。
+mount:
+  # 编译器、解释器和它们的库
+  - type: bind
+    source: /bin
+    target: /bin
+    readonly: true
+  - type: bind
+    source: /lib
+    target: /lib
+    readonly: true
+  - type: bind
+    source: /lib64
+    target: /lib64
+    readonly: true
+  - type: bind
+    source: /usr
+    target: /usr
+    readonly: true
+  - type: bind
+    source: /etc/ld.so.cache
+    target: /etc/ld.so.cache
+    readonly: true
+  # /usr/bin/gcc → /etc/alternatives/gcc → /usr/bin/gcc-14，少了这条编译器就找不到
+  - type: bind
+    source: /etc/alternatives
+    target: /etc/alternatives
+    readonly: true
+  - type: bind
+    source: /dev/null
+    target: /dev/null
+  - type: bind
+    source: /dev/urandom
+    target: /dev/urandom
+  - type: bind
+    source: /dev/random
+    target: /dev/random
+  - type: bind
+    source: /dev/zero
+    target: /dev/zero
+  - type: bind
+    source: /dev/full
+    target: /dev/full
+  # 工作目录：源码、编译产物、程序输出都在这里。输出上限 16MB（-output-limit），
+  # 加上可执行文件，128MB 绰绰有余
+  - type: tmpfs
+    target: /w
+    data: size=128m,nr_inodes=4k
+  # g++ 的中间文件写在 /tmp
+  - type: tmpfs
+    target: /tmp
+    data: size=128m,nr_inodes=4k
+proc: true
+symLink:
+  - linkPath: /dev/fd
+    target: /proc/self/fd
+  - linkPath: /dev/stdin
+    target: /proc/self/fd/0
+  - linkPath: /dev/stdout
+    target: /proc/self/fd/1
+  - linkPath: /dev/stderr
+    target: /proc/self/fd/2
+maskPath:
+  - /sys/firmware
+  - /sys/devices/virtual/powercap
+  - /proc/acpi
+  - /proc/asound
+  - /proc/kcore
+  - /proc/keys
+  - /proc/latency_stats
+  - /proc/timer_list
+  - /proc/timer_stats
+  - /proc/sched_debug
+  - /proc/scsi
+workDir: /w
+hostName: go-judge
+domainName: go-judge
+uid: 1536
+gid: 1536
@@ -4,27 +4,24 @@
 *   bun docker/judge/smoke.ts                                   # 打 .env 里的 JUDGE_SERVER_URL
 *   JUDGE_SERVER_URL=http://localhost:8082 bun docker/judge/smoke.ts
 *
- * 直接打判题机的 /judge，不经过 api / worker / 队列，所以不需要起后端，也不需要
- * 库里有题 —— 测试点用 `test_case` 内联传进去，判题机会当场写进临时目录。
+ * 走的是线上那份判题代码（apps/api/src/judge/sandbox.ts 的 judge()），不经过 api / worker /
+ * 队列，所以不需要起后端，也不需要库里有题 —— 测试点内联传进去。
 *
- * 它核的是三件事：
+ * 它核的是四件事：
 *   1. 三种语言都能编译、运行、判对（languageConfigs 就是线上那份，不是另抄的）
 *   2. 六种结果状态的**整数值**没变（落库的值，见 packages/contract/src/judge-status.ts）
 *   3. gcc 的宽松度没变 —— 忘了 #include 的老代码照样能过（gcc-14 默认会把它判 CE）
+ *   4. 从 JudgeServer 照搬过来的几条口径：stderr 算进输出、死循环打印判运行时错误（信号 25）
 */
-import { createHash } from 'node:crypto'
-
 import { JudgeStatus } from '@oj2/contract'

-import { languageConfigs } from '../../apps/api/src/judge/languages'
+import { judge, sandboxVersion, type JudgeCase } from '../../apps/api/src/judge/sandbox'

 const url = process.env.JUDGE_SERVER_URL ?? 'http://localhost:8081'
-const rawToken = process.env.JUDGE_SERVER_TOKEN
-if (!rawToken) {
+if (!process.env.JUDGE_SERVER_TOKEN) {
  console.error('JUDGE_SERVER_TOKEN 没设 —— 在 OJ2 根目录跑，bun 会自己读 .env')
  process.exit(2)
 }
-const token = createHash('sha256').update(rawToken).digest('hex')

 interface Case {
  language: string
@@ -34,6 +31,8 @@ interface Case {
  /** 默认 3000ms / 128MB，跑得慢或要撑爆内存的用例自己改 */
  cpu?: number
  memory?: number
+  /** 再核一下第一个测试点的信号 */
+  signal?: number
 }

 const sumTestCase = [{ input: '1 2\n', output: '3\n' }]
@@ -114,12 +113,12 @@ int main(void) {
 }`,
  },
  {
-    // RLIMIT_AS 是 max_memory 的两倍，所以 malloc 会先成功一阵子再失败，
-    // 退出时 ru_maxrss 已经超过 max_memory → judger 判 MLE 而不是 RE。
+    // 地址空间限在内存限制的两倍，所以 malloc 会先成功一阵子再失败，
+    // 退出时峰值已经超过内存限制 → 判 MLE 而不是 RE（sandbox.ts 的 verdict）。
    language: 'C',
    name: 'C 内存超限',
    expect: JudgeStatus.MEMORY_LIMIT_EXCEEDED,
-    memory: 64 * 1024 * 1024,
+    memory: 64,
    code: `#include <stdlib.h>
 #include <string.h>
 int main(void) {
@@ -134,10 +133,36 @@ int main(void) {
    language: 'C',
    name: 'C 运行时错误',
    expect: JudgeStatus.RUNTIME_ERROR,
+    signal: 11,
    code: `int main(void) {
  int *p = 0;
  *p = 1;
  return 0;
+}`,
+  },
+  {
+    // 写满 16MB 吃 SIGXFSZ。前端按信号 25 给「循环停不下来」的说明
+    language: 'C',
+    name: 'C 死循环打印判运行时错误',
+    expect: JudgeStatus.RUNTIME_ERROR,
+    signal: 25,
+    code: `#include <stdio.h>
+int main(void) {
+  for (;;) printf("hello world\\n");
+}`,
+  },
+  {
+    // JudgeServer 把 stdout 和 stderr 写进同一个文件再比，往 stderr 打东西就是答案错误
+    language: 'C',
+    name: 'C 往 stderr 打的也算输出',
+    expect: JudgeStatus.WRONG_ANSWER,
+    code: `#include <stdio.h>
+int main(void) {
+  int a, b;
+  scanf("%d %d", &a, &b);
+  fprintf(stderr, "debug\\n");
+  printf("%d\\n", a + b);
+  return 0;
 }`,
  },
  // ---------------------------------------------------------------- Python
@@ -168,6 +193,14 @@ print(a + b)`,
    expect: JudgeStatus.RUNTIME_ERROR,
    code: `print(1 / 0)`,
  },
+  {
+    // 学生程序开不了进程（procLimit 1），subprocess 抛 OSError
+    language: 'Python',
+    name: 'Python 开不了子进程',
+    expect: JudgeStatus.RUNTIME_ERROR,
+    code: `import subprocess
+subprocess.run(['true'])`,
+  },
  // ---------------------------------------------------------------- C++
  {
    language: 'C++',
@@ -202,51 +235,22 @@ const names: Record<number, string> = {
 const label = (code: number) => `${names[code] ?? '?'}(${code})`

 async function runCase(item: Case) {
-  const response = await fetch(new URL('/judge', url), {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-      'X-Judge-Server-Token': token,
-    },
-    body: JSON.stringify({
-      language_config: languageConfigs[item.language],
-      src: item.code,
-      max_cpu_time: item.cpu ?? 3000,
-      max_memory: item.memory ?? 128 * 1024 * 1024,
-      test_case: sumTestCase,
-      output: false,
-      io_mode: {
-        io_mode: 'Standard IO',
-        input: 'input.txt',
-        output: 'output.txt',
-      },
-    }),
-  })
-  if (!response.ok) throw new Error(`HTTP ${response.status}`)
-
-  const body = (await response.json()) as {
-    err: string | null
-    data: unknown
-  }
+  const body = await judge(item.language, item.code, item.cpu ?? 3000, item.memory ?? 128, sumTestCase)
  // 编译失败走 err 通道，不会有逐测试点的结果
  if (body.err === 'CompileError') return { result: JudgeStatus.COMPILE_ERROR }
  if (body.err) throw new Error(`${body.err}: ${JSON.stringify(body.data)}`)

-  const results = body.data as { result: number; cpu_time: number }[]
+  const results = body.data as JudgeCase[]
  // 多个测试点取最坏的那个，和 run.ts 的口径一致
  const failed = results.find((r) => r.result !== JudgeStatus.ACCEPTED)
  return failed ?? results[0]!
 }

-/** 判题机刚重建时 gunicorn 还没起来，先等它 —— 否则整屏都是连接被关。 */
+/** 判题机刚重建时还没起来，先等它 —— 否则整屏都是连接被拒。 */
 async function waitReady() {
  for (let i = 0; i < 60; i++) {
    try {
-      const response = await fetch(new URL('/ping', url), {
-        method: 'POST',
-        headers: { 'X-Judge-Server-Token': token },
-      })
-      if (response.ok) return
+      return await sandboxVersion()
    } catch {
      // 还没起来，接着等
    }
@@ -256,18 +260,20 @@ async function waitReady() {
  process.exit(2)
 }

-await waitReady()
+const version = await waitReady()

 let failures = 0
-console.log(`判题机 ${url}\n`)
+console.log(`判题机 ${url}（go-judge ${version}）\n`)
 for (const item of cases) {
  try {
    const got = await runCase(item)
-    const pass = got.result === item.expect
+    const pass = got.result === item.expect && (item.signal === undefined || ('signal' in got && got.signal === item.signal))
    if (!pass) failures++
    const time = 'cpu_time' in got ? ` ${got.cpu_time}ms` : ''
+    const signal = item.signal !== undefined && 'signal' in got ? ` 信号 ${got.signal}` : ''
    console.log(
-      `${pass ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m'} ${item.name.padEnd(32)}` + ` 期望 ${label(item.expect).padEnd(10)} 实得 ${label(got.result)}${time}`,
+      `${pass ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m'} ${item.name.padEnd(32)}` +
+        ` 期望 ${label(item.expect).padEnd(10)} 实得 ${label(got.result)}${signal}${time}`,
    )
  } catch (error) {
    failures++