refactor: 引入 Checker 统一接口与 Runner 抽象机制

定义 Checker 接口（resolve/execute/serialize）和 CheckerRegistry
注册中心，消除 engine/config-loader/store 中硬编码类型分支。
按 checker 类型分子包（runner/http/、runner/command/），提取
共享 expect 到 runner/shared/。超时控制通过引擎注入 AbortSignal。
CheckFailure.phase 从联合类型改为 string。配置校验下沉到各
Checker.resolve() 内部。

新增 checker-runner-abstraction spec，更新 DEVELOPMENT.md。

tests/server/checker/runner/command/expect.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import { checkExitCode } from "../../../../../src/server/checker/runner/command/expect";
+
+describe("checkExitCode", () => {
+  test("exitCode 在允许列表中匹配成功", () => {
+    const r = checkExitCode(0, [0]);
+    expect(r.matched).toBe(true);
+    expect(r.failure).toBeNull();
+  });
+
+  test("exitCode 不在允许列表中匹配失败", () => {
+    const r = checkExitCode(1, [0]);
+    expect(r.matched).toBe(false);
+    expect(r.failure!.phase).toBe("exitCode");
+    expect(r.failure!.kind).toBe("mismatch");
+    expect(r.failure!.expected).toEqual([0]);
+    expect(r.failure!.actual).toBe(1);
+  });
+
+  test("多个允许退出码", () => {
+    expect(checkExitCode(0, [0, 1]).matched).toBe(true);
+    expect(checkExitCode(1, [0, 1]).matched).toBe(true);
+    expect(checkExitCode(2, [0, 1]).matched).toBe(false);
+  });
+});

tests/server/checker/runner/command/runner.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, test } from "bun:test";
+import { CommandChecker } from "../../../../../src/server/checker/runner/command/runner";
+import type { CheckerContext } from "../../../../../src/server/checker/runner/types";
+import type { ResolvedCommandTarget } from "../../../../../src/server/checker/types";
+
+const checker = new CommandChecker();
+
+function makeTarget(
+  command: Partial<ResolvedCommandTarget["command"]>,
+  overrides?: Partial<ResolvedCommandTarget>,
+): ResolvedCommandTarget {
+  return {
+    type: "command",
+    name: "test-cmd",
+    group: "default",
+    command: {
+      exec: "echo",
+      args: ["hello"],
+      cwd: "/tmp",
+      env: {},
+      maxOutputBytes: 1024 * 1024,
+      ...command,
+    },
+    intervalMs: 60000,
+    timeoutMs: 5000,
+    ...overrides,
+  };
+}
+
+function makeCtx(timeoutMs = 5000): CheckerContext {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), timeoutMs);
+  return { signal: controller.signal };
+}
+
+describe("CommandChecker", () => {
+  test("exitCode=0 成功", async () => {
+    const result = await checker.execute(makeTarget({ exec: "true", args: [] }), makeCtx());
+    expect(result.matched).toBe(true);
+    expect(result.statusDetail).toBe("exitCode=0");
+    expect(result.failure).toBeNull();
+  });
+
+  test("exitCode=1 不匹配默认 [0]", async () => {
+    const result = await checker.execute(makeTarget({ exec: "false", args: [] }), makeCtx());
+    expect(result.matched).toBe(false);
+    expect(result.statusDetail).toBe("exitCode=1");
+    expect(result.failure!.phase).toBe("exitCode");
+  });
+
+  test("exitCode=1 匹配自定义 [1]", async () => {
+    const result = await checker.execute(makeTarget({ exec: "false", args: [] }, { expect: { exitCode: [1] } }), makeCtx());
+    expect(result.matched).toBe(true);
+    expect(result.statusDetail).toBe("exitCode=1");
+  });
+
+  test("命令不存在返回 spawn 错误", async () => {
+    const result = await checker.execute(makeTarget({ exec: "/nonexistent/command/xyz" }), makeCtx());
+    expect(result.matched).toBe(false);
+    expect(result.failure!.phase).toBe("exitCode");
+    expect(result.failure!.message).toBeTruthy();
+  });
+
+  test("超时返回错误", async () => {
+    const result = await checker.execute(makeTarget({ exec: "sleep", args: ["10"] }, { timeoutMs: 100 }), makeCtx(100));
+    expect(result.matched).toBe(false);
+    expect(result.failure!.message).toContain("超时");
+  });
+
+  test("stdout 输出捕获", async () => {
+    const result = await checker.execute(makeTarget({ exec: "echo", args: ["hello world"] }), makeCtx());
+    expect(result.matched).toBe(true);
+  });
+
+  test("stdout 匹配 expect", async () => {
+    const result = await checker.execute(makeTarget({ exec: "echo", args: ["hello"] }, { expect: { stdout: [{ contains: "hello" }] } }), makeCtx());
+    expect(result.matched).toBe(true);
+  });
+
+  test("stdout 不匹配 expect", async () => {
+    const result = await checker.execute(makeTarget({ exec: "echo", args: ["hello"] }, { expect: { stdout: [{ contains: "nonexistent" }] } }), makeCtx());
+    expect(result.matched).toBe(false);
+    expect(result.failure!.phase).toBe("stdout");
+  });
+
+  test("stderr 匹配 expect", async () => {
+    const result = await checker.execute(makeTarget({ exec: "bash", args: ["-c", "echo error >&2"] }, { expect: { stderr: [{ contains: "error" }] } }), makeCtx());
+    expect(result.matched).toBe(true);
+  });
+
+  test("输出超过 maxOutputBytes", async () => {
+    const result = await checker.execute(makeTarget({ exec: "bash", args: ["-c", "yes | head -1000"], maxOutputBytes: 10 }), makeCtx());
+    expect(result.matched).toBe(false);
+    expect(result.failure!.message).toContain("超过限制");
+  });
+
+  test("durationMs 非空", async () => {
+    const result = await checker.execute(makeTarget({ exec: "true", args: [] }), makeCtx());
+    expect(result.durationMs).not.toBeNull();
+    expect(result.durationMs!).toBeGreaterThanOrEqual(0);
+  });
+
+  test("不使用 shell，通配符不被展开", async () => {
+    const result = await checker.execute(makeTarget({ exec: "echo", args: ["*"] }, { expect: { stdout: [{ contains: "*" }] } }), makeCtx());
+    expect(result.matched).toBe(true);
+  });
+
+  test("serialize 返回命令摘要和 config JSON", () => {
+    const target = makeTarget({ exec: "echo", args: ["hello"] });
+    const s = checker.serialize(target);
+    expect(s.target).toBe("exec echo hello");
+    const config = JSON.parse(s.config);
+    expect(config.exec).toBe("echo");
+    expect(config.args).toEqual(["hello"]);
+  });
+});

tests/server/checker/runner/http/expect.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, test } from "bun:test";
+import { checkHttpExpect } from "../../../../../src/server/checker/runner/http/expect";
+
+function obs(overrides: { statusCode?: number; headers?: Record<string, string>; body?: string | null; durationMs?: number } = {}) {
+  return {
+    statusCode: overrides.statusCode ?? 200,
+    headers: overrides.headers ?? {},
+    body: overrides.body ?? "",
+    durationMs: overrides.durationMs ?? 100,
+  };
+}
+
+describe("checkHttpExpect", () => {
+  test("无 expect 配置时默认检查 status [200] 匹配成功", () => {
+    const r = checkHttpExpect(obs().statusCode, obs().headers, obs().body as string, obs().durationMs);
+    expect(r.matched).toBe(true);
+    expect(r.failure).toBeNull();
+  });
+
+  test("无 expect 配置时 status 非 200 匹配失败", () => {
+    const r = checkHttpExpect(500, {}, "", 100);
+    expect(r.matched).toBe(false);
+    expect(r.failure).not.toBeNull();
+    expect(r.failure!.phase).toBe("status");
+    expect(r.failure!.kind).toBe("mismatch");
+  });
+
+  test("status 匹配指定状态码", () => {
+    const cfg = { status: [200, 301] };
+    expect(checkHttpExpect(200, {}, "", 100, cfg).matched).toBe(true);
+    expect(checkHttpExpect(301, {}, "", 100, cfg).matched).toBe(true);
+    expect(checkHttpExpect(404, {}, "", 100, cfg).matched).toBe(false);
+  });
+
+  test("status 不匹配返回 phase=status 的失败", () => {
+    const r = checkHttpExpect(503, {}, "", 100, { status: [200] });
+    expect(r.matched).toBe(false);
+    expect(r.failure!.phase).toBe("status");
+    expect(r.failure!.expected).toEqual([200]);
+    expect(r.failure!.actual).toBe(503);
+  });
+
+  test("duration 在限制内匹配成功", () => {
+    const r = checkHttpExpect(200, {}, "", 50, { maxDurationMs: 100 });
+    expect(r.matched).toBe(true);
+  });
+
+  test("duration 超过限制匹配失败", () => {
+    const r = checkHttpExpect(200, {}, "", 200, { maxDurationMs: 100 });
+    expect(r.matched).toBe(false);
+    expect(r.failure!.phase).toBe("duration");
+  });
+
+  test("duration 恰好等于限制匹配成功", () => {
+    const r = checkHttpExpect(200, {}, "", 100, { maxDurationMs: 100 });
+    expect(r.matched).toBe(true);
+  });
+
+  test("headers 字符串格式检查（等于）", () => {
+    const h = { "content-type": "application/json", "x-api": "v1" };
+    expect(checkHttpExpect(200, h, "", 100, { headers: { "content-type": "application/json" } }).matched).toBe(true);
+    expect(checkHttpExpect(200, h, "", 100, { headers: { "content-type": "text/html" } }).matched).toBe(false);
+  });
+
+  test("headers 操作符格式检查", () => {
+    const h = { "content-type": "application/json" };
+    expect(checkHttpExpect(200, h, "", 100, { headers: { "content-type": { contains: "json" } } }).matched).toBe(true);
+    expect(checkHttpExpect(200, h, "", 100, { headers: { "content-type": { match: "^application/" } } }).matched).toBe(true);
+    expect(checkHttpExpect(200, h, "", 100, { headers: { "content-type": { contains: "xml" } } }).matched).toBe(false);
+  });
+
+  test("headers 大小写不敏感匹配", () => {
+    const h = { "content-type": "application/json" };
+    expect(checkHttpExpect(200, h, "", 100, { headers: { "Content-Type": "application/json" } }).matched).toBe(true);
+  });
+
+  test("headers 不存在时返回失败", () => {
+    const r = checkHttpExpect(200, {}, "", 100, { headers: { "x-missing": "value" } });
+    expect(r.matched).toBe(false);
+    expect(r.failure!.phase).toBe("headers");
+  });
+
+  test("body 规则数组按顺序检查", () => {
+    const body = JSON.stringify({ status: "ok", count: 5 });
+    const r = checkHttpExpect(200, {}, body, 100, {
+      body: [{ contains: "ok" }, { json: { path: "$.count", gte: 1 } }],
+    });
+    expect(r.matched).toBe(true);
+  });
+
+  test("body 第一条规则失败立即返回", () => {
+    const r = checkHttpExpect(200, {}, "hello world", 100, {
+      body: [{ contains: "missing" }, { contains: "hello" }],
+    });
+    expect(r.matched).toBe(false);
+    expect(r.failure!.path).toBe("body[0]");
+  });
+
+  test("body 为 null 但有 body 规则时报错", () => {
+    const r = checkHttpExpect(200, {}, null, 100, { body: [{ contains: "test" }] });
+    expect(r.matched).toBe(false);
+    expect(r.failure!.kind).toBe("error");
+  });
+
+  test("完整流水线 status->duration->headers->body 全部通过", () => {
+    const r = checkHttpExpect(200, { "content-type": "application/json" }, JSON.stringify({ status: "healthy" }), 50, {
+      status: [200],
+      maxDurationMs: 100,
+      headers: { "content-type": { contains: "json" } },
+      body: [{ json: { path: "$.status", equals: "healthy" } }],
+    });
+    expect(r.matched).toBe(true);
+    expect(r.failure).toBeNull();
+  });
+
+  test("完整流水线 status 通过但 duration 失败", () => {
+    const r = checkHttpExpect(200, {}, "", 500, { status: [200], maxDurationMs: 100 });
+    expect(r.matched).toBe(false);
+    expect(r.failure!.phase).toBe("duration");
+  });
+
+  test("完整流水线 status 和 duration 通过但 headers 失败", () => {
+    const r = checkHttpExpect(200, { "x-api": "v1" }, "", 50, {
+      status: [200],
+      maxDurationMs: 100,
+      headers: { "x-api": "v2" },
+    });
+    expect(r.matched).toBe(false);
+    expect(r.failure!.phase).toBe("headers");
+  });
+
+  test("完整流水线 status/duration/headers 通过但 body 失败", () => {
+    const r = checkHttpExpect(200, { "content-type": "text/plain" }, "error occurred", 50, {
+      status: [200],
+      maxDurationMs: 100,
+      headers: { "content-type": "text/plain" },
+      body: [{ contains: "success" }],
+    });
+    expect(r.matched).toBe(false);
+    expect(r.failure!.phase).toBe("body");
+  });
+});

tests/server/checker/runner/http/runner.test.ts

@@ -0,0 +1,180 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { HttpChecker } from "../../../../../src/server/checker/runner/http/runner";
+import type { CheckerContext } from "../../../../../src/server/checker/runner/types";
+import type { ResolvedHttpTarget } from "../../../../../src/server/checker/types";
+
+const checker = new HttpChecker();
+
+describe("HttpChecker", () => {
+  let server: ReturnType<typeof Bun.serve>;
+  let baseUrl: string;
+
+  beforeAll(() => {
+    server = Bun.serve({
+      port: 0,
+      fetch(req) {
+        const url = new URL(req.url);
+        switch (url.pathname) {
+          case "/ok":
+            return new Response("hello world", {
+              headers: { "content-type": "text/plain", "x-custom": "test-value" },
+            });
+          case "/json":
+            return new Response(JSON.stringify({ status: "ok" }), {
+              headers: { "content-type": "application/json" },
+            });
+          case "/echo":
+            return new Response(JSON.stringify({ method: req.method, body: req.body ? "present" : "empty" }), {
+              headers: { "content-type": "application/json" },
+            });
+          case "/large":
+            return new Response("x".repeat(2000));
+          case "/notfound":
+            return new Response("not found", { status: 404 });
+          default:
+            return new Response("ok");
+        }
+      },
+    });
+    baseUrl = `http://localhost:${server.port}`;
+  });
+
+  afterAll(() => {
+    server.stop();
+  });
+
+  function makeTarget(overrides: {
+    url?: string;
+    method?: string;
+    body?: string;
+    headers?: Record<string, string>;
+    expect?: Record<string, unknown>;
+    maxBodyBytes?: number;
+    timeoutMs?: number;
+  }): ResolvedHttpTarget {
+    return {
+      type: "http",
+      name: "test-http",
+      group: "default",
+      http: {
+        url: overrides.url ?? `${baseUrl}/ok`,
+        method: overrides.method ?? "GET",
+        headers: overrides.headers ?? {},
+        body: overrides.body,
+        maxBodyBytes: overrides.maxBodyBytes ?? 1024 * 1024,
+      },
+      intervalMs: 60000,
+      timeoutMs: overrides.timeoutMs ?? 5000,
+      expect: overrides.expect as ResolvedHttpTarget["expect"],
+    };
+  }
+
+  function makeCtx(timeoutMs = 5000): CheckerContext {
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), timeoutMs);
+    return { signal: controller.signal };
+  }
+
+  test("成功请求 200", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/ok` }), makeCtx());
+    expect(result.matched).toBe(true);
+    expect(result.statusDetail).toBe("HTTP 200");
+    expect(result.durationMs).not.toBeNull();
+    expect(result.failure).toBeNull();
+  });
+
+  test("404 不匹配默认 status [200]", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/notfound` }), makeCtx());
+    expect(result.matched).toBe(false);
+    expect(result.statusDetail).toBe("HTTP 404");
+    expect(result.failure!.phase).toBe("status");
+  });
+
+  test("404 匹配自定义 status [404]", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/notfound`, expect: { status: [404] } }), makeCtx());
+    expect(result.matched).toBe(true);
+  });
+
+  test("headers 检查通过", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/ok`, expect: { headers: { "x-custom": "test-value" } } }), makeCtx());
+    expect(result.matched).toBe(true);
+  });
+
+  test("headers 检查失败", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/ok`, expect: { headers: { "x-custom": "wrong-value" } } }), makeCtx());
+    expect(result.matched).toBe(false);
+    expect(result.failure!.phase).toBe("headers");
+  });
+
+  test("body contains 检查", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/ok`, expect: { body: [{ contains: "hello" }] } }), makeCtx());
+    expect(result.matched).toBe(true);
+  });
+
+  test("body contains 失败", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/ok`, expect: { body: [{ contains: "nonexistent" }] } }), makeCtx());
+    expect(result.matched).toBe(false);
+    expect(result.failure!.phase).toBe("body");
+  });
+
+  test("body json 检查", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/json`, expect: { body: [{ json: { path: "$.status", equals: "ok" } }] } }), makeCtx());
+    expect(result.matched).toBe(true);
+  });
+
+  test("响应体超过 maxBodyBytes", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/large`, maxBodyBytes: 100, expect: { body: [{ contains: "x" }] } }), makeCtx());
+    expect(result.matched).toBe(false);
+    expect(result.failure!.phase).toBe("body");
+    expect(result.failure!.message).toContain("超过限制");
+  });
+
+  test("请求超时", async () => {
+    const timeoutServer = Bun.serve({
+      port: 0,
+      async fetch() {
+        await new Promise((resolve) => setTimeout(resolve, 10000));
+        return new Response("late");
+      },
+    });
+
+    try {
+      const result = await checker.execute(makeTarget({ url: `http://localhost:${timeoutServer.port}/`, timeoutMs: 100 }), makeCtx(100));
+      expect(result.matched).toBe(false);
+      expect(result.failure!.message).toContain("超时");
+    } finally {
+      timeoutServer.stop();
+    }
+  });
+
+  test("快速失败：status 失败时不读取 body", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/notfound`, expect: { status: [200], body: [{ contains: "something" }] } }), makeCtx());
+    expect(result.matched).toBe(false);
+    expect(result.failure!.phase).toBe("status");
+  });
+
+  test("status 通过但 body 失败", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/ok`, expect: { status: [200], body: [{ contains: "not-in-body" }] } }), makeCtx());
+    expect(result.matched).toBe(false);
+    expect(result.failure!.phase).toBe("body");
+  });
+
+  test("无 expect 时默认检查 status 200", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/ok`, expect: undefined }), makeCtx());
+    expect(result.matched).toBe(true);
+  });
+
+  test("POST 请求携带 body", async () => {
+    const result = await checker.execute(makeTarget({ url: `${baseUrl}/echo`, method: "POST", body: "test-body", headers: { "content-type": "text/plain" }, expect: { status: [200], body: [{ json: { path: "$.body", equals: "present" } }] } }), makeCtx());
+    expect(result.matched).toBe(true);
+  });
+
+  test("serialize 返回 URL 和 config JSON", () => {
+    const target = makeTarget({});
+    const s = checker.serialize(target);
+    expect(s.target).toBe(target.http.url);
+    const config = JSON.parse(s.config);
+    expect(config.url).toBe(target.http.url);
+    expect(config.method).toBe("GET");
+  });
+});

tests/server/checker/runner/registry.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "bun:test";
+import { CheckerRegistry } from "../../../../src/server/checker/runner/registry";
+import type { Checker } from "../../../../src/server/checker/runner/types";
+
+function createChecker(type: string): Checker {
+  return {
+    type,
+    resolve: () => ({}) as any,
+    execute: () => Promise.resolve({} as any),
+    serialize: () => ({ target: "", config: "" }),
+  };
+}
+
+describe("CheckerRegistry", () => {
+  test("注册并获取 Checker", () => {
+    const registry = new CheckerRegistry();
+    const checker = createChecker("http");
+    registry.register(checker);
+    expect(registry.get("http")).toBe(checker);
+  });
+
+  test("获取未注册的 type 抛出错误", () => {
+    const registry = new CheckerRegistry();
+    expect(() => registry.get("unknown")).toThrow("不支持的 probe type");
+  });
+
+  test("重复注册同一 type 抛出错误", () => {
+    const registry = new CheckerRegistry();
+    registry.register(createChecker("http"));
+    expect(() => registry.register(createChecker("http"))).toThrow("已注册");
+  });
+
+  test("查询支持的 type 列表", () => {
+    const registry = new CheckerRegistry();
+    registry.register(createChecker("http"));
+    registry.register(createChecker("command"));
+    expect(registry.supportedTypes).toEqual(["http", "command"]);
+  });
+});

tests/server/checker/runner/shared/body.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, test } from "bun:test";
+import { checkBodyExpect } from "../../../../../src/server/checker/runner/shared/body";
+
+describe("checkBodyExpect (BodyRule[])", () => {
+  test("无规则返回匹配成功", () => {
+    const r = checkBodyExpect("anything");
+    expect(r.matched).toBe(true);
+    expect(r.failure).toBeNull();
+  });
+
+  test("空规则数组返回匹配成功", () => {
+    const r = checkBodyExpect("anything", []);
+    expect(r.matched).toBe(true);
+    expect(r.failure).toBeNull();
+  });
+
+  test("contains 规则匹配成功", () => {
+    const r = checkBodyExpect("hello world", [{ contains: "hello" }]);
+    expect(r.matched).toBe(true);
+    expect(r.failure).toBeNull();
+  });
+
+  test("contains 规则匹配失败", () => {
+    const r = checkBodyExpect("hello world", [{ contains: "missing" }]);
+    expect(r.matched).toBe(false);
+    expect(r.failure).not.toBeNull();
+    expect(r.failure!.kind).toBe("mismatch");
+    expect(r.failure!.phase).toBe("body");
+    expect(r.failure!.path).toBe("body[0]");
+  });
+
+  test("regex 规则匹配成功", () => {
+    const r = checkBodyExpect("status: ok", [{ regex: "ok" }]);
+    expect(r.matched).toBe(true);
+  });
+
+  test("regex 规则匹配失败", () => {
+    const r = checkBodyExpect("status: error", [{ regex: "^ok$" }]);
+    expect(r.matched).toBe(false);
+    expect(r.failure!.path).toBe("body[0]");
+  });
+
+  test("json 等值匹配成功", () => {
+    const body = JSON.stringify({ status: "ok", code: 0 });
+    const r = checkBodyExpect(body, [{ json: { path: "$.status", equals: "ok" } }]);
+    expect(r.matched).toBe(true);
+  });
+
+  test("json 等值匹配失败", () => {
+    const body = JSON.stringify({ status: "ok" });
+    const r = checkBodyExpect(body, [{ json: { path: "$.status", equals: "error" } }]);
+    expect(r.matched).toBe(false);
+    expect(r.failure!.kind).toBe("mismatch");
+  });
+
+  test("json 操作符匹配", () => {
+    const body = JSON.stringify({ count: 42, version: "v2.1.0" });
+    expect(checkBodyExpect(body, [{ json: { path: "$.count", gte: 10 } }]).matched).toBe(true);
+    expect(checkBodyExpect(body, [{ json: { path: "$.version", match: "\\d+\\.\\d+\\.\\d+" } }]).matched).toBe(true);
+    expect(checkBodyExpect(body, [{ json: { path: "$.count", gte: 100 } }]).matched).toBe(false);
+  });
+
+  test("json 路径不存在", () => {
+    const body = JSON.stringify({ status: "ok" });
+    const r = checkBodyExpect(body, [{ json: { path: "$.notExist", equals: "value" } }]);
+    expect(r.matched).toBe(false);
+  });
+
+  test("json 解析失败", () => {
+    const r = checkBodyExpect("not json", [{ json: { path: "$.status", equals: "ok" } }]);
+    expect(r.matched).toBe(false);
+    expect(r.failure!.kind).toBe("error");
+  });
+
+  test("css 文本内容匹配", () => {
+    const html = "<div id='health'>OK</div><span class='ver'>1.0</span>";
+    expect(checkBodyExpect(html, [{ css: { selector: "div#health", equals: "OK" } }]).matched).toBe(true);
+    expect(checkBodyExpect(html, [{ css: { selector: "span.ver", equals: "1.0" } }]).matched).toBe(true);
+    expect(checkBodyExpect(html, [{ css: { selector: "div#health", equals: "ERROR" } }]).matched).toBe(false);
+  });
+
+  test("css 选择器无匹配元素", () => {
+    const html = "<div>OK</div>";
+    const r = checkBodyExpect(html, [{ css: { selector: "span.missing", equals: "OK" } }]);
+    expect(r.matched).toBe(false);
+  });
+
+  test("css attr 提取", () => {
+    const html = '<meta name="version" content="2.0.1">';
+    expect(
+      checkBodyExpect(html, [{ css: { selector: 'meta[name="version"]', attr: "content", equals: "2.0.1" } }]).matched,
+    ).toBe(true);
+  });
+
+  test("css exists 检查", () => {
+    const html = "<div id='test'>OK</div>";
+    expect(checkBodyExpect(html, [{ css: { selector: "div#test", exists: true } }]).matched).toBe(true);
+    expect(checkBodyExpect(html, [{ css: { selector: "span#missing", exists: false } }]).matched).toBe(true);
+    expect(checkBodyExpect(html, [{ css: { selector: "div#test", exists: false } }]).matched).toBe(false);
+  });
+
+  test("xpath 节点文本匹配", () => {
+    const xml = "<root><status>ok</status><code>200</code></root>";
+    expect(checkBodyExpect(xml, [{ xpath: { path: "/root/status/text()", equals: "ok" } }]).matched).toBe(true);
+    expect(checkBodyExpect(xml, [{ xpath: { path: "/root/status/text()", equals: "error" } }]).matched).toBe(false);
+  });
+
+  test("xpath 无匹配节点", () => {
+    const xml = "<root><status>ok</status></root>";
+    const r = checkBodyExpect(xml, [{ xpath: { path: "/root/missing/text()", equals: "ok" } }]);
+    expect(r.matched).toBe(false);
+  });
+
+  test("规则数组按顺序检查，第一条失败立即返回", () => {
+    const body = JSON.stringify({ status: "error" });
+    const r = checkBodyExpect(body, [{ contains: "healthy" }, { json: { path: "$.status", equals: "error" } }]);
+    expect(r.matched).toBe(false);
+    expect(r.failure!.path).toBe("body[0]");
+  });
+
+  test("多条规则全部通过", () => {
+    const body = JSON.stringify({ status: "healthy", count: 5 });
+    const r = checkBodyExpect(body, [
+      { contains: "healthy" },
+      { json: { path: "$.status", equals: "healthy" } },
+      { json: { path: "$.count", gte: 1 } },
+    ]);
+    expect(r.matched).toBe(true);
+    expect(r.failure).toBeNull();
+  });
+
+  test("第二条规则失败返回正确索引", () => {
+    const body = JSON.stringify({ status: "ok" });
+    const r = checkBodyExpect(body, [{ contains: "ok" }, { json: { path: "$.status", equals: "error" } }]);
+    expect(r.matched).toBe(false);
+    expect(r.failure!.path).toContain("body[1]");
+  });
+});

tests/server/checker/runner/shared/duration.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "bun:test";
+import { checkDuration } from "../../../../../src/server/checker/runner/shared/duration";
+
+describe("checkDuration", () => {
+  test("未配置 maxDurationMs 返回匹配成功", () => {
+    const r = checkDuration(100);
+    expect(r.matched).toBe(true);
+    expect(r.failure).toBeNull();
+  });
+
+  test("duration 在限制内匹配成功", () => {
+    const r = checkDuration(50, 100);
+    expect(r.matched).toBe(true);
+    expect(r.failure).toBeNull();
+  });
+
+  test("duration 等于限制匹配成功", () => {
+    const r = checkDuration(100, 100);
+    expect(r.matched).toBe(true);
+  });
+
+  test("duration 超过限制匹配失败", () => {
+    const r = checkDuration(200, 100);
+    expect(r.matched).toBe(false);
+    expect(r.failure).not.toBeNull();
+    expect(r.failure!.phase).toBe("duration");
+    expect(r.failure!.kind).toBe("mismatch");
+  });
+});

tests/server/checker/runner/shared/failure.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from "bun:test";
+import { truncateActual, mismatchFailure, errorFailure } from "../../../../../src/server/checker/runner/shared/failure";
+
+describe("truncateActual", () => {
+  test("短字符串不截断", () => {
+    expect(truncateActual("hello")).toBe("hello");
+  });
+
+  test("恰好等于限制长度不截断", () => {
+    const str = "a".repeat(200);
+    expect(truncateActual(str)).toBe(str);
+  });
+
+  test("超过限制长度截断并加省略号", () => {
+    const str = "a".repeat(300);
+    const result = truncateActual(str) as string;
+    expect(result.length).toBe(203);
+    expect(result.endsWith("...")).toBe(true);
+    expect(result.startsWith("a".repeat(200))).toBe(true);
+  });
+
+  test("自定义最大长度", () => {
+    const str = "abcdefghij";
+    const result = truncateActual(str, 5) as string;
+    expect(result).toBe("abcde...");
+  });
+
+  test("null 不截断", () => {
+    expect(truncateActual(null)).toBe(null);
+  });
+
+  test("undefined 不截断", () => {
+    expect(truncateActual(undefined)).toBe(undefined);
+  });
+
+  test("数字转换为字符串后判断", () => {
+    expect(truncateActual(42)).toBe(42);
+    expect(truncateActual(123456789, 3) as string).toBe("123...");
+  });
+});
+
+describe("mismatchFailure", () => {
+  test("返回正确的 mismatch 结构", () => {
+    const f = mismatchFailure("status", "status", [200], 500, "status mismatch");
+    expect(f).toEqual({
+      kind: "mismatch",
+      phase: "status",
+      path: "status",
+      expected: [200],
+      actual: 500,
+      message: "status mismatch",
+    });
+  });
+
+  test("自动截断过长的 actual", () => {
+    const longStr = "x".repeat(300);
+    const f = mismatchFailure("body", "body[0]", "short", longStr, "too long");
+    expect((f.actual as string).endsWith("...")).toBe(true);
+    expect((f.actual as string).length).toBe(203);
+  });
+});
+
+describe("errorFailure", () => {
+  test("返回正确的 error 结构", () => {
+    const f = errorFailure("body", "body[0].json($.x)", "body is not valid JSON");
+    expect(f).toEqual({
+      kind: "error",
+      phase: "body",
+      path: "body[0].json($.x)",
+      message: "body is not valid JSON",
+    });
+  });
+
+  test("不含 expected 和 actual 字段", () => {
+    const f = errorFailure("headers", "headers.x", "header missing");
+    expect(f).not.toHaveProperty("expected");
+    expect(f).not.toHaveProperty("actual");
+  });
+});

tests/server/checker/runner/shared/operator.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "bun:test";
+import { applyOperator, checkExpectValue, evaluateJsonPath } from "../../../../../src/server/checker/runner/shared/operator";
+
+describe("evaluateJsonPath", () => {
+  const obj = {
+    status: "ok",
+    code: 0,
+    active: true,
+    error: null,
+    data: {
+      count: 42,
+      items: [{ name: "a" }, { name: "b" }],
+      nested: { deep: "value" },
+    },
+    emptyObj: {},
+    emptyArr: [],
+  };
+
+  test("简单字段访问", () => {
+    expect(evaluateJsonPath(obj, "$.status")).toBe("ok");
+    expect(evaluateJsonPath(obj, "$.code")).toBe(0);
+    expect(evaluateJsonPath(obj, "$.active")).toBe(true);
+    expect(evaluateJsonPath(obj, "$.error")).toBeNull();
+  });
+
+  test("嵌套对象访问", () => {
+    expect(evaluateJsonPath(obj, "$.data.count")).toBe(42);
+    expect(evaluateJsonPath(obj, "$.data.nested.deep")).toBe("value");
+  });
+
+  test("数组索引访问", () => {
+    expect(evaluateJsonPath(obj, "$.data.items[0].name")).toBe("a");
+    expect(evaluateJsonPath(obj, "$.data.items[1].name")).toBe("b");
+  });
+
+  test("路径不存在返回 undefined", () => {
+    expect(evaluateJsonPath(obj, "$.notExist")).toBeUndefined();
+    expect(evaluateJsonPath(obj, "$.data.notExist")).toBeUndefined();
+    expect(evaluateJsonPath(obj, "$.data.items[99]")).toBeUndefined();
+  });
+
+  test("空对象和空数组", () => {
+    expect(evaluateJsonPath(obj, "$.emptyObj")).toEqual({});
+    expect(evaluateJsonPath(obj, "$.emptyArr")).toEqual([]);
+  });
+
+  test("非 $ 开头路径返回 undefined", () => {
+    expect(evaluateJsonPath(obj, "status")).toBeUndefined();
+    expect(evaluateJsonPath(obj, ".status")).toBeUndefined();
+  });
+
+  test("null 对象上访问", () => {
+    expect(evaluateJsonPath(null, "$.any")).toBeUndefined();
+  });
+});
+
+describe("applyOperator", () => {
+  test("equals 操作符", () => {
+    expect(applyOperator("ok", { equals: "ok" })).toBe(true);
+    expect(applyOperator("ok", { equals: "error" })).toBe(false);
+    expect(applyOperator(42, { equals: 42 })).toBe(true);
+    expect(applyOperator(42, { equals: 41 })).toBe(false);
+    expect(applyOperator(null, { equals: null })).toBe(true);
+    expect(applyOperator(true, { equals: true })).toBe(true);
+  });
+
+  test("contains 操作符", () => {
+    expect(applyOperator("hello world", { contains: "hello" })).toBe(true);
+    expect(applyOperator("hello world", { contains: "missing" })).toBe(false);
+    expect(applyOperator(12345, { contains: "23" })).toBe(true);
+  });
+
+  test("match 操作符", () => {
+    expect(applyOperator("v2.1.0", { match: "\\d+\\.\\d+\\.\\d+" })).toBe(true);
+    expect(applyOperator("v2.1", { match: "\\d+\\.\\d+\\.\\d+" })).toBe(false);
+    expect(applyOperator("abc123", { match: "^\\w+\\d+$" })).toBe(true);
+  });
+
+  test("empty 操作符", () => {
+    expect(applyOperator("", { empty: true })).toBe(true);
+    expect(applyOperator(null, { empty: true })).toBe(true);
+    expect(applyOperator(undefined, { empty: true })).toBe(true);
+    expect(applyOperator([], { empty: true })).toBe(true);
+    expect(applyOperator({}, { empty: true })).toBe(true);
+    expect(applyOperator("ok", { empty: true })).toBe(false);
+    expect(applyOperator([1, 2], { empty: false })).toBe(true);
+    expect(applyOperator([], { empty: false })).toBe(false);
+  });
+
+  test("exists 操作符", () => {
+    expect(applyOperator("ok", { exists: true })).toBe(true);
+    expect(applyOperator(null, { exists: true })).toBe(true);
+    expect(applyOperator(undefined, { exists: true })).toBe(false);
+    expect(applyOperator(undefined, { exists: false })).toBe(true);
+    expect(applyOperator("ok", { exists: false })).toBe(false);
+  });
+
+  test("gte 操作符", () => {
+    expect(applyOperator(10, { gte: 5 })).toBe(true);
+    expect(applyOperator(5, { gte: 5 })).toBe(true);
+    expect(applyOperator(3, { gte: 5 })).toBe(false);
+    expect(applyOperator("10", { gte: 5 })).toBe(true);
+  });
+
+  test("lte 操作符", () => {
+    expect(applyOperator(3, { lte: 5 })).toBe(true);
+    expect(applyOperator(5, { lte: 5 })).toBe(true);
+    expect(applyOperator(10, { lte: 5 })).toBe(false);
+  });
+
+  test("gt 操作符", () => {
+    expect(applyOperator(10, { gt: 5 })).toBe(true);
+    expect(applyOperator(5, { gt: 5 })).toBe(false);
+  });
+
+  test("lt 操作符", () => {
+    expect(applyOperator(3, { lt: 5 })).toBe(true);
+    expect(applyOperator(5, { lt: 5 })).toBe(false);
+  });
+
+  test("多操作符 AND 组合", () => {
+    expect(applyOperator(7, { gte: 5, lte: 10 })).toBe(true);
+    expect(applyOperator(3, { gte: 5, lte: 10 })).toBe(false);
+    expect(applyOperator(15, { gte: 5, lte: 10 })).toBe(false);
+  });
+});
+
+describe("checkExpectValue", () => {
+  test("原始值直接比较", () => {
+    expect(checkExpectValue("ok", "ok")).toBe(true);
+    expect(checkExpectValue("ok", "error")).toBe(false);
+    expect(checkExpectValue(42, 42)).toBe(true);
+    expect(checkExpectValue(null, null)).toBe(true);
+  });
+
+  test("对象作为操作符", () => {
+    expect(checkExpectValue(42, { gte: 10 })).toBe(true);
+    expect(checkExpectValue(42, { gte: 100 })).toBe(false);
+    expect(checkExpectValue("hello", { contains: "ell" })).toBe(true);
+  });
+});

tests/server/checker/runner/shared/text.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test";
+import { checkTextRules } from "../../../../../src/server/checker/runner/shared/text";
+
+describe("checkTextRules", () => {
+  test("无规则返回匹配成功", () => {
+    const r = checkTextRules("hello", [], "stdout");
+    expect(r.matched).toBe(true);
+    expect(r.failure).toBeNull();
+  });
+
+  test("单条 contains 规则匹配成功", () => {
+    const r = checkTextRules("build completed successfully", [{ contains: "completed" }], "stdout");
+    expect(r.matched).toBe(true);
+  });
+
+  test("单条 contains 规则匹配失败", () => {
+    const r = checkTextRules("build completed successfully", [{ contains: "failed" }], "stdout");
+    expect(r.matched).toBe(false);
+    expect(r.failure!.phase).toBe("stdout");
+    expect(r.failure!.path).toBe("stdout[0]");
+  });
+
+  test("多条规则全部通过", () => {
+    const r = checkTextRules("version: 3.2.1, build: ok", [{ contains: "version" }, { match: "\\d+\\.\\d+\\.\\d+" }], "stdout");
+    expect(r.matched).toBe(true);
+  });
+
+  test("第一条规则失败立即返回", () => {
+    const r = checkTextRules("error occurred", [{ contains: "success" }, { contains: "error" }], "stdout");
+    expect(r.matched).toBe(false);
+    expect(r.failure!.phase).toBe("stdout");
+    expect(r.failure!.path).toBe("stdout[0]");
+  });
+
+  test("stderr phase", () => {
+    const r = checkTextRules("warning: deprecated", [{ contains: "warning" }], "stderr");
+    expect(r.matched).toBe(true);
+    expect(r.failure).toBeNull();
+  });
+
+  test("empty 操作符", () => {
+    const r = checkTextRules("", [{ empty: true }], "stderr");
+    expect(r.matched).toBe(true);
+  });
+});