chatccc 0.2.176 → 0.2.178

package/src/__tests__/orchestrator.test.ts

@@ -6,8 +6,8 @@ import { join } from "node:path";
 import type { PlatformAdapter } from "../platform-adapter.ts";
 import type { SessionInfo, ToolAdapter } from "../adapters/adapter-interface.ts";
 
-const mockStreamStates = new Map<string, { status: "running" | "done" | "stopped"; finalReply: string }>();
-const mockGetCodexUsageSummary = vi.hoisted(() => vi.fn());
+const mockStreamStates = new Map<string, { status: "running" | "done" | "stopped"; finalReply: string }>();
+const mockGetCodexUsageSummary = vi.hoisted(() => vi.fn());
 
 vi.mock("../im-skills.ts", () => ({
   buildImSkillsPrompt: async () => "",
@@ -15,7 +15,7 @@ vi.mock("../im-skills.ts", () => ({
   exportSkillSubDocs: async () => {},
 }));
 
-vi.mock("../stream-state.ts", () => ({
+vi.mock("../stream-state.ts", () => ({
   readStreamState: async (sessionId: string) => {
     const state = mockStreamStates.get(sessionId);
     if (!state) return null;
@@ -50,14 +50,14 @@ vi.mock("../stream-state.ts", () => ({
     cwd,
     tool,
   }),
-  fixStaleStreamStates: async () => {},
-}));
-
-vi.mock("../feishu-platform.ts", () => ({
-  getCodexUsageSummary: mockGetCodexUsageSummary,
-  getTenantAccessToken: vi.fn(async () => "tenant-token"),
-  sendPostMessage: vi.fn(async () => true),
-}));
+  fixStaleStreamStates: async () => {},
+}));
+
+vi.mock("../feishu-platform.ts", () => ({
+  getCodexUsageSummary: mockGetCodexUsageSummary,
+  getTenantAccessToken: vi.fn(async () => "tenant-token"),
+  sendPostMessage: vi.fn(async () => true),
+}));
 
 import { handleCommand } from "../orchestrator.ts";
 import {
@@ -120,14 +120,14 @@ describe("handleCommand WeChat processing ack", () => {
     _setSessionToolsFileForTest(join(tempDir, "sessions.json"));
     resetState();
     resetBindingState();
-    mockStreamStates.clear();
-    mockGetCodexUsageSummary.mockReset();
-    mockGetCodexUsageSummary.mockResolvedValue({
-      fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
-      weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
-    });
-    _setAdapterForToolForTest("claude", mockAdapter());
-  });
+    mockStreamStates.clear();
+    mockGetCodexUsageSummary.mockReset();
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+      weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+    });
+    _setAdapterForToolForTest("claude", mockAdapter());
+  });
 
   afterEach(async () => {
     resetState();
@@ -249,7 +249,7 @@ describe("handleCommand WeChat processing ack", () => {
     expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-new");
   });
 
-  it("cleans stale Feishu p2p binding but keeps valid commands from auto-creating a group", async () => {
+  it("cleans stale Feishu p2p binding but keeps valid commands from auto-creating a group", async () => {
     const platform = mockPlatform("feishu");
     await recordSessionRegistry({
       chatId: "feishu-p2p",
@@ -264,76 +264,76 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.createGroup).not.toHaveBeenCalled();
     expect(platform.sendRawCard).toHaveBeenCalled();
     const registry = await loadSessionRegistryForBinding();
-    expect(registry["feishu-p2p"]).toBeUndefined();
-  });
-
-  it("handles /usage without creating a new Feishu group", async () => {
-    const platform = mockPlatform("feishu");
-    mockGetCodexUsageSummary.mockResolvedValue({
-      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
-      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
-    });
-
-    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    expect(platform.createGroup).not.toHaveBeenCalled();
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("**5h:** 已用 37%，剩余 63%，重置:"),
-      "blue",
-    );
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("约 2小时52分钟后"),
-      "blue",
-    );
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("[███████░░░░░░░░░░░░░]"),
-      "blue",
-    );
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("**周:** 已用 12%，剩余 88%，重置:"),
-      "blue",
-    );
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("约 3天18小时17分钟后"),
-      "blue",
-    );
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "feishu-p2p",
-      "Codex Usage",
-      expect.stringContaining("[██░░░░░░░░░░░░░░░░░░]"),
-      "blue",
-    );
-  });
-
-  it("only advertises /usage in new Codex session ready messages", async () => {
-    const codexPlatform = mockPlatform("feishu");
-    _setAdapterForToolForTest("codex", mockAdapter("sid-codex"));
-
-    await handleCommand(codexPlatform, "/new codex", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    expect(codexPlatform.sendCard).toHaveBeenCalledWith(
-      "feishu-group",
-      "Codex Session Ready",
-      expect.stringContaining("发送 **/usage** 查看 Codex 5h 和周用量。"),
-      "green",
-    );
-
-    const claudePlatform = mockPlatform("feishu");
-    await handleCommand(claudePlatform, "/new claude", "feishu-p2p-2", "ou-user", Date.now(), "p2p");
-
-    const claudeReadyCall = vi.mocked(claudePlatform.sendCard).mock.calls.find(
-      ([chatId, title]) => chatId === "feishu-group" && title === "Claude Code Session Ready",
-    );
-    expect(claudeReadyCall?.[2]).not.toContain("/usage");
-  });
-});
+    expect(registry["feishu-p2p"]).toBeUndefined();
+  });
+
+  it("handles /usage without creating a new Feishu group", async () => {
+    const platform = mockPlatform("feishu");
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
+      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
+    });
+
+    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "feishu-p2p",
+      "Codex Usage",
+      expect.stringContaining("**5h:** 已用 37%，剩余 63%，重置:"),
+      "blue",
+    );
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "feishu-p2p",
+      "Codex Usage",
+      expect.stringContaining("约 2小时52分钟后"),
+      "blue",
+    );
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "feishu-p2p",
+      "Codex Usage",
+      expect.stringContaining("[███████░░░░░░░░░░░░░]"),
+      "blue",
+    );
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "feishu-p2p",
+      "Codex Usage",
+      expect.stringContaining("**周:** 已用 12%，剩余 88%，重置:"),
+      "blue",
+    );
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "feishu-p2p",
+      "Codex Usage",
+      expect.stringContaining("约 3天18小时17分钟后"),
+      "blue",
+    );
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "feishu-p2p",
+      "Codex Usage",
+      expect.stringContaining("[██░░░░░░░░░░░░░░░░░░]"),
+      "blue",
+    );
+  });
+
+  it("only advertises /usage in new Codex session ready messages", async () => {
+    const codexPlatform = mockPlatform("feishu");
+    _setAdapterForToolForTest("codex", mockAdapter("sid-codex"));
+
+    await handleCommand(codexPlatform, "/new codex", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(codexPlatform.sendCard).toHaveBeenCalledWith(
+      "feishu-group",
+      "Codex Session Ready",
+      expect.stringContaining("发送 **/usage** 查看 Codex 5h 和周用量。"),
+      "green",
+    );
+
+    const claudePlatform = mockPlatform("feishu");
+    await handleCommand(claudePlatform, "/new claude", "feishu-p2p-2", "ou-user", Date.now(), "p2p");
+
+    const claudeReadyCall = vi.mocked(claudePlatform.sendCard).mock.calls.find(
+      ([chatId, title]) => chatId === "feishu-group" && title === "Claude Code Session Ready",
+    );
+    expect(claudeReadyCall?.[2]).not.toContain("/usage");
+  });
+});

package/src/__tests__/privacy.test.ts

@@ -1,198 +1,198 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from "vitest";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-const TEST_DATA_DIR = await mkdtemp(join(tmpdir(), "chatccc-privacy-test-"));
-vi.mock("../config.ts", async () => {
-  const actual = await vi.importActual<typeof import("../config.ts")>("../config.ts");
-  return {
-    ...actual,
-    USER_DATA_DIR: TEST_DATA_DIR,
-    ts: () => "test-ts",
-  };
-});
-
-let applyPrivacy: (text: string) => string;
-let reloadPrivacyRules: () => void;
-let getPrivacyRules: () => Record<string, string>;
-let getPrivacyConfig: () => { enabled: boolean; rules: Record<string, string> };
-
-beforeEach(async () => {
-  vi.resetModules();
-  try {
-    await rm(join(TEST_DATA_DIR, "privacy.json"), { force: true });
-  } catch {}
-  const mod = await import("../privacy.ts");
-  applyPrivacy = mod.applyPrivacy;
-  reloadPrivacyRules = mod.reloadPrivacyRules;
-  getPrivacyRules = mod.getPrivacyRules;
-  getPrivacyConfig = mod.getPrivacyConfig;
-});
-
-afterEach(async () => {
-  try {
-    await rm(join(TEST_DATA_DIR, "privacy.json"), { force: true });
-  } catch {}
-});
-
-afterAll(async () => {
-  try {
-    await rm(TEST_DATA_DIR, { recursive: true, force: true });
-  } catch {}
-});
-
-describe("applyPrivacy", () => {
-  it("returns original text when privacy.json is missing", () => {
-    reloadPrivacyRules();
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("supports legacy flat privacy rules", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ weizhangjian: "wzj", secret: "***" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-    expect(applyPrivacy("my secret is safe")).toBe("my *** is safe");
-    expect(applyPrivacy("weizhangjian and secret")).toBe("wzj and ***");
-  });
-
-  it("supports privacy.json schema with enabled=false", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
-    expect(getPrivacyRules()).toEqual({ weizhangjian: "wzj" });
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("supports privacy.json schema with enabled=true", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ enabled: true, rules: { weizhangjian: "wzj" } }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-  });
-
-  it("accepts UTF-8 BOM in privacy.json", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      `\uFEFF${JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } })}`,
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("auto reloads privacy.json changes without explicit reload", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ weizhangjian: "wzj" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj-disabled" } }),
-      "utf-8",
-    );
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj-disabled" } });
-  });
-
-  it("replaces multiple rules and repeated occurrences", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ a: "A", b: "B" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("a b a b")).toBe("A B A B");
-  });
-
-  it("returns empty text directly", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ x: "y" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("")).toBe("");
-  });
-
-  it("treats special characters in rule keys literally", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ "a.b": "X", "(test)": "Y", "*star": "Z" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello a.b world")).toBe("hello X world");
-    expect(applyPrivacy("text (test) here")).toBe("text Y here");
-    expect(applyPrivacy("a *star shines")).toBe("a Z shines");
-  });
-
-  it("reloadPrivacyRules forces a reload", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ old: "OLD" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("old")).toBe("OLD");
-    expect(getPrivacyRules()).toEqual({ old: "OLD" });
-
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ new: "NEW" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("new")).toBe("NEW");
-    expect(getPrivacyRules()).toEqual({ new: "NEW" });
-  });
-
-  it("returns original text for malformed JSON", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      "not json",
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello")).toBe("hello");
-  });
-
-  it("returns original text for array JSON", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify(["a", "b"]),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello")).toBe("hello");
-  });
-});
+import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from "vitest";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const TEST_DATA_DIR = await mkdtemp(join(tmpdir(), "chatccc-privacy-test-"));
+vi.mock("../config.ts", async () => {
+  const actual = await vi.importActual<typeof import("../config.ts")>("../config.ts");
+  return {
+    ...actual,
+    USER_DATA_DIR: TEST_DATA_DIR,
+    ts: () => "test-ts",
+  };
+});
+
+let applyPrivacy: (text: string) => string;
+let reloadPrivacyRules: () => void;
+let getPrivacyRules: () => Record<string, string>;
+let getPrivacyConfig: () => { enabled: boolean; rules: Record<string, string> };
+
+beforeEach(async () => {
+  vi.resetModules();
+  try {
+    await rm(join(TEST_DATA_DIR, "privacy.json"), { force: true });
+  } catch {}
+  const mod = await import("../privacy.ts");
+  applyPrivacy = mod.applyPrivacy;
+  reloadPrivacyRules = mod.reloadPrivacyRules;
+  getPrivacyRules = mod.getPrivacyRules;
+  getPrivacyConfig = mod.getPrivacyConfig;
+});
+
+afterEach(async () => {
+  try {
+    await rm(join(TEST_DATA_DIR, "privacy.json"), { force: true });
+  } catch {}
+});
+
+afterAll(async () => {
+  try {
+    await rm(TEST_DATA_DIR, { recursive: true, force: true });
+  } catch {}
+});
+
+describe("applyPrivacy", () => {
+  it("returns original text when privacy.json is missing", () => {
+    reloadPrivacyRules();
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
+  });
+
+  it("supports legacy flat privacy rules", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ weizhangjian: "wzj", secret: "***" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
+    expect(applyPrivacy("my secret is safe")).toBe("my *** is safe");
+    expect(applyPrivacy("weizhangjian and secret")).toBe("wzj and ***");
+  });
+
+  it("supports privacy.json schema with enabled=false", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
+    expect(getPrivacyRules()).toEqual({ weizhangjian: "wzj" });
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
+  });
+
+  it("supports privacy.json schema with enabled=true", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ enabled: true, rules: { weizhangjian: "wzj" } }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
+  });
+
+  it("accepts UTF-8 BOM in privacy.json", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      `\uFEFF${JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } })}`,
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
+  });
+
+  it("auto reloads privacy.json changes without explicit reload", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ weizhangjian: "wzj" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
+
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj-disabled" } }),
+      "utf-8",
+    );
+
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
+    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj-disabled" } });
+  });
+
+  it("replaces multiple rules and repeated occurrences", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ a: "A", b: "B" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("a b a b")).toBe("A B A B");
+  });
+
+  it("returns empty text directly", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ x: "y" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("")).toBe("");
+  });
+
+  it("treats special characters in rule keys literally", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ "a.b": "X", "(test)": "Y", "*star": "Z" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello a.b world")).toBe("hello X world");
+    expect(applyPrivacy("text (test) here")).toBe("text Y here");
+    expect(applyPrivacy("a *star shines")).toBe("a Z shines");
+  });
+
+  it("reloadPrivacyRules forces a reload", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ old: "OLD" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("old")).toBe("OLD");
+    expect(getPrivacyRules()).toEqual({ old: "OLD" });
+
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ new: "NEW" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("new")).toBe("NEW");
+    expect(getPrivacyRules()).toEqual({ new: "NEW" });
+  });
+
+  it("returns original text for malformed JSON", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      "not json",
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello")).toBe("hello");
+  });
+
+  it("returns original text for array JSON", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify(["a", "b"]),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello")).toBe("hello");
+  });
+});