test: CI 工作流（Node 18/20/22 矩阵）+ 测试运行器修复

- 工作流：push master/release + PR + 手动触发；Node 18/20/22 矩阵；
  concurrency 取消同分支旧运行；timeout 10min
- 测试助手修复（两处，都会污染环境或造成偶发失败）：
  1. allocPort 原用 pid 派生端口区间，node --test 各文件并行时
     pid 取模会撞桶（如 pid 100 与 600 同桶）-> 偶发 EADDRINUSE。
     改为让内核分配（listen 0）后立刻释放。
  2. startProxy 用 mkdtempSync 建临时工作目录却从不删除 ->
     每次运行泄漏 N 个目录。改为在 kill() 的两条退出路径上递归删除。

Author: xelr233

.github/workflows/test.yml

@@ -2,18 +2,29 @@ name: Test
 
 on:
   push:
-    branches: ['**']
+    # 只在这些长期分支上跑 push；其余分支靠 pull_request 触发，避免同一提交跑两遍
+    branches: [master, release]
   pull_request:
   workflow_dispatch:
 
+# 同一分支的新推送取消旧运行，避免排队浪费
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
 jobs:
   test:
     runs-on: ubuntu-latest
+    timeout-minutes: 10
     strategy:
       fail-fast: false
       matrix:
-        # 覆盖 engines 下限与 Dockerfile 使用的版本
+        # engines 下限是 18；Dockerfile 用 22；中间放 20 覆盖 LTS 跨度
         node: ['18', '20', '22']
+    name: node ${{ matrix.node }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -23,20 +34,11 @@ jobs:
         with:
           node-version: ${{ matrix.node }}
 
-      - name: Show version
+      - name: Show Node version
         run: node --version
 
+      - name: Syntax check
+        run: node --check proxy.mjs
+
       - name: Run tests
         run: npm test
-
-  # 单独一条：确认 proxy.mjs 语法可被最低支持版本解析。
-  # setup-node 的解析失败会表现为进程启动即崩，与测试失败混淆，故单列出来。
-  syntax:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '18'
-      - name: node --check
-        run: node --check proxy.mjs

test/helpers.mjs

@@ -3,21 +3,32 @@
 import http from 'node:http';
 import { spawn } from 'node:child_process';
 import { setTimeout as sleep } from 'node:timers/promises';
-import { mkdtempSync, copyFileSync, existsSync } from 'node:fs';
+import { mkdtempSync, copyFileSync, existsSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 export const REPO = dirname(fileURLToPath(import.meta.url)).replace(/[/\\]test$/, '');
 
-// 每个用例拿到独立端口。node --test 每个文件一个进程，用 pid 派生基数，
-// 并用随机起点降低跨进程撞端口的概率。
-let nextPort = 40000 + (process.pid % 500) * 40 + Math.floor(Math.random() * 20);
-export const allocPort = () => nextPort++;
+// 取一个当前空闲的端口：让内核分配（listen 0）后立刻释放。
+// 不能用 pid 派生区间 —— node --test 各文件并行，pid 取模会在不同 pid 间
+// 映射到同一区间（如 pid 100 与 pid 600 同桶），进而偶发 EADDRINUSE。
+// 内核分配把冲突面缩到「释放到重新占用」之间的极小窗口，调用方另有重试兜底。
+import net from 'node:net';
+export async function allocPort() {
+  return await new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.once('error', reject);
+    srv.listen(0, '127.0.0.1', () => {
+      const { port } = srv.address();
+      srv.close(() => resolve(port));
+    });
+  });
+}
 
 /** 启动一个 mock 上游。ndjson 为要回给代理的 CC NDJSON 行数组。 */
 export async function startMockUpstream(opts = {}) {
-  const port = allocPort();
+  const port = await allocPort();
   const seen = [];
   const server = http.createServer((req, res) => {
     const chunks = [];
@@ -56,8 +67,10 @@ export async function startMockUpstream(opts = {}) {
 
 /** 在临时 cwd 中启动代理（复刻真实部署：proxy.mjs 与 config.json 同目录）。 */
 export async function startProxy({ upstreamPort, env = {}, cwd } = {}) {
-  const port = allocPort();
+  const port = await allocPort();
   const logs = [];
+  // 自建的临时工作目录用完必须删；调用方传了 cwd 则由调用方负责。
+  const ownWorkdir = cwd === undefined;
   const workdir = cwd ?? mkdtempSync(join(tmpdir(), 'ccp-test-'));
   copyFileSync(join(REPO, 'proxy.mjs'), join(workdir, 'proxy.mjs'));
   if (!existsSync(join(workdir, 'config.json'))) {
@@ -90,7 +103,17 @@ export async function startProxy({ upstreamPort, env = {}, cwd } = {}) {
       method: 'POST', headers: { 'Content-Type': 'application/json', ...headers },
       body: typeof body === 'string' ? body : JSON.stringify(body),
     }),
-    kill: () => new Promise(r => { child.once('exit', r); child.kill(); setTimeout(r, 2000); }),
+    kill: () => new Promise(r => {
+      child.once('exit', () => {
+        if (ownWorkdir) { try { rmSync(workdir, { recursive: true, force: true }); } catch {} }
+        r();
+      });
+      child.kill();
+      setTimeout(() => {
+        if (ownWorkdir) { try { rmSync(workdir, { recursive: true, force: true }); } catch {} }
+        r();
+      }, 2000);
+    }),
   };
 }