chatccc 0.2.175 → 0.2.177

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.175",
+  "version": "0.2.177",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",

package/src/__tests__/privacy.test.ts

@@ -1,143 +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";
-
-// 在 import privacy 之前 mock config，让 USER_DATA_DIR 指向临时目录
-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>;
-
-beforeEach(async () => {
-  vi.resetModules();
-  // 清理临时目录中的 privacy.json
-  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;
-});
-
-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("无 privacy.json 时返回原文", () => {
-    reloadPrivacyRules();
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("privacy.json 存在时按规则替换", 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("多规则替换多次出现", 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("空文本直接返回", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ x: "y" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("")).toBe("");
-  });
-
-  it("规则中的特殊字符不会被当作正则", 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 强制重新加载", 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" });
-
-    // 变更磁盘内容后 reload
-    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("格式错误的 JSON 不抛异常，返回原文", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      "not json",
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello")).toBe("hello");
-  });
-
-  it("数组格式的 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");
+  });
+});

package/src/feishu-api.ts

@@ -307,30 +307,30 @@ const AVATAR_SOURCES: Record<string, string> = {
   busy: resolvePath(AVATAR_DIR, "status_busy.png"),
   idle: resolvePath(AVATAR_DIR, "status_idle.png"),
 };
-const AVATAR_BADGES: Record<string, string> = {
-  claude: resolvePath(AVATAR_BADGE_DIR, "badge_claude.png"),
-  cursor: resolvePath(AVATAR_BADGE_DIR, "badge_cursor.png"),
-  codex: resolvePath(AVATAR_BADGE_DIR, "badge_codex.png"),
-};
-const AVATAR_SIZE = 256;
-const AVATAR_BADGE_SIZE = 92;
-const AVATAR_BADGE_MARGIN = 10;
-const CODEX_AVATAR_USAGE_STYLE_VERSION = "usage-ring-gray-consumed-v5";
-
-export interface CodexUsageBalance {
-  usedPercent: number;
-  remainingPercent: number;
-  resetAtEpochSeconds: number | null;
-  resetAfterSeconds: number | null;
-}
-
-export interface CodexUsageSummary {
-  fiveHour: CodexUsageBalance;
-  weekly: CodexUsageBalance | null;
-}
-
-const avatarKeyCache = new Map<string, string>();
-let avatarKeyCacheLoaded = false;
+const AVATAR_BADGES: Record<string, string> = {
+  claude: resolvePath(AVATAR_BADGE_DIR, "badge_claude.png"),
+  cursor: resolvePath(AVATAR_BADGE_DIR, "badge_cursor.png"),
+  codex: resolvePath(AVATAR_BADGE_DIR, "badge_codex.png"),
+};
+const AVATAR_SIZE = 256;
+const AVATAR_BADGE_SIZE = 92;
+const AVATAR_BADGE_MARGIN = 10;
+const CODEX_AVATAR_USAGE_STYLE_VERSION = "usage-ring-gray-consumed-v8";
+
+export interface CodexUsageBalance {
+  usedPercent: number;
+  remainingPercent: number;
+  resetAtEpochSeconds: number | null;
+  resetAfterSeconds: number | null;
+}
+
+export interface CodexUsageSummary {
+  fiveHour: CodexUsageBalance;
+  weekly: CodexUsageBalance | null;
+}
+
+const avatarKeyCache = new Map<string, string>();
+let avatarKeyCacheLoaded = false;
 
 function normalizeAvatarTool(tool: string): string {
   return AVATAR_BADGES[tool] ? tool : "claude";
@@ -344,16 +344,16 @@ function avatarCombinationPath(tool: string, status: string): string {
   return resolvePath(AVATAR_COMBINATIONS_DIR, `avatar_${normalizeAvatarTool(tool)}_${normalizeAvatarStatus(status)}.png`);
 }
 
-function avatarCacheKey(tool: string, status: string, codexUsage: CodexUsageSummary | null = null): string {
-  const normalizedTool = normalizeAvatarTool(tool);
-  const normalizedStatus = normalizeAvatarStatus(status);
-  if (normalizedTool === "codex") {
-    return codexUsage
-      ? `${normalizedTool}:${normalizedStatus}:${CODEX_AVATAR_USAGE_STYLE_VERSION}:week-battery:${codexUsage.weekly?.remainingPercent}:5h-ring:${codexUsage.fiveHour.remainingPercent}`
-      : `${normalizedTool}:${normalizedStatus}:plain`;
-  }
-  return `${normalizedTool}:${normalizedStatus}`;
-}
+function avatarCacheKey(tool: string, status: string, codexUsage: CodexUsageSummary | null = null): string {
+  const normalizedTool = normalizeAvatarTool(tool);
+  const normalizedStatus = normalizeAvatarStatus(status);
+  if (normalizedTool === "codex") {
+    return codexUsage
+      ? `${normalizedTool}:${normalizedStatus}:${CODEX_AVATAR_USAGE_STYLE_VERSION}:week-battery:${codexUsage.weekly?.remainingPercent}:5h-ring:${codexUsage.fiveHour.remainingPercent}`
+      : `${normalizedTool}:${normalizedStatus}:plain`;
+  }
+  return `${normalizedTool}:${normalizedStatus}`;
+}
 
 async function loadAvatarKeyCache(): Promise<void> {
   if (avatarKeyCacheLoaded) return;
@@ -378,37 +378,37 @@ async function persistAvatarKeyCache(): Promise<void> {
   );
 }
 
-function clampPercent(value: number): number {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(100, Math.round(value)));
-}
-
-function usageBalanceFromWindow(raw: Record<string, unknown>, fieldName: string): CodexUsageBalance {
-  const value = raw.used_percent;
-  const usedPercent = Number(value);
-  if (!Number.isFinite(usedPercent)) throw new Error(`missing ${fieldName}.used_percent`);
-  const used = clampPercent(usedPercent);
-  const resetAt = Number(raw.reset_at);
-  const resetAfter = Number(raw.reset_after_seconds);
-  return {
-    usedPercent: used,
-    remainingPercent: clampPercent(100 - used),
-    resetAtEpochSeconds: Number.isFinite(resetAt) ? resetAt : null,
-    resetAfterSeconds: Number.isFinite(resetAfter) ? resetAfter : null,
-  };
-}
-
-function parseOptionalUsageWindow(rateLimit: Record<string, unknown>, keys: string[]): CodexUsageBalance | null {
-  for (const key of keys) {
-    const raw = rateLimit[key];
-    if (!raw || typeof raw !== "object") continue;
-    if ((raw as { used_percent?: unknown }).used_percent === undefined) continue;
-    return usageBalanceFromWindow(raw as Record<string, unknown>, `rate_limit.${key}`);
-  }
-  return null;
-}
-
-async function getCodexAccessToken(): Promise<string | null> {
+function clampPercent(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(100, Math.round(value)));
+}
+
+function usageBalanceFromWindow(raw: Record<string, unknown>, fieldName: string): CodexUsageBalance {
+  const value = raw.used_percent;
+  const usedPercent = Number(value);
+  if (!Number.isFinite(usedPercent)) throw new Error(`missing ${fieldName}.used_percent`);
+  const used = clampPercent(usedPercent);
+  const resetAt = Number(raw.reset_at);
+  const resetAfter = Number(raw.reset_after_seconds);
+  return {
+    usedPercent: used,
+    remainingPercent: clampPercent(100 - used),
+    resetAtEpochSeconds: Number.isFinite(resetAt) ? resetAt : null,
+    resetAfterSeconds: Number.isFinite(resetAfter) ? resetAfter : null,
+  };
+}
+
+function parseOptionalUsageWindow(rateLimit: Record<string, unknown>, keys: string[]): CodexUsageBalance | null {
+  for (const key of keys) {
+    const raw = rateLimit[key];
+    if (!raw || typeof raw !== "object") continue;
+    if ((raw as { used_percent?: unknown }).used_percent === undefined) continue;
+    return usageBalanceFromWindow(raw as Record<string, unknown>, `rate_limit.${key}`);
+  }
+  return null;
+}
+
+async function getCodexAccessToken(): Promise<string | null> {
   try {
     const raw = await readFile(CODEX_AUTH_FILE, "utf-8");
     const parsed = JSON.parse(raw) as { tokens?: { access_token?: unknown } };
@@ -416,49 +416,49 @@ async function getCodexAccessToken(): Promise<string | null> {
     return typeof token === "string" && token.trim() ? token : null;
   } catch {
     return null;
-  }
-}
-
-export async function getCodexUsageSummary(): Promise<CodexUsageSummary> {
-  const token = await getCodexAccessToken();
-  if (!token) throw new Error("missing ~/.codex/auth.json access token");
-
-  const resp = await fetch(CODEX_USAGE_URL, {
-    headers: { Authorization: `Bearer ${token}` },
-  });
-  const text = await resp.text();
-  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
-
-  const data = JSON.parse(text) as {
-    rate_limit?: Record<string, unknown>;
-  };
-  const rateLimit = data.rate_limit;
-  if (!rateLimit || typeof rateLimit !== "object") throw new Error("missing rate_limit");
-
-  const fiveHour = parseOptionalUsageWindow(rateLimit, ["primary_window"]);
-  if (!fiveHour) throw new Error("missing rate_limit.primary_window.used_percent");
-
-  return {
-    fiveHour,
-    weekly: parseOptionalUsageWindow(rateLimit, [
-      "secondary_window",
-      "weekly_window",
-      "week_window",
-      "long_window",
-    ]),
-  };
-}
-
-async function fetchCodexAvatarUsage(): Promise<CodexUsageSummary | null> {
-  try {
-    const summary = await getCodexUsageSummary();
-    if (!summary.weekly) throw new Error("missing weekly usage window");
-    return summary;
-  } catch (err) {
-    console.warn(`[${ts()}] [AVATAR] Codex usage unavailable, using plain avatar: ${(err as Error).message}`);
-    return null;
-  }
-}
+  }
+}
+
+export async function getCodexUsageSummary(): Promise<CodexUsageSummary> {
+  const token = await getCodexAccessToken();
+  if (!token) throw new Error("missing ~/.codex/auth.json access token");
+
+  const resp = await fetch(CODEX_USAGE_URL, {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  const text = await resp.text();
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 160)}`);
+
+  const data = JSON.parse(text) as {
+    rate_limit?: Record<string, unknown>;
+  };
+  const rateLimit = data.rate_limit;
+  if (!rateLimit || typeof rateLimit !== "object") throw new Error("missing rate_limit");
+
+  const fiveHour = parseOptionalUsageWindow(rateLimit, ["primary_window"]);
+  if (!fiveHour) throw new Error("missing rate_limit.primary_window.used_percent");
+
+  return {
+    fiveHour,
+    weekly: parseOptionalUsageWindow(rateLimit, [
+      "secondary_window",
+      "weekly_window",
+      "week_window",
+      "long_window",
+    ]),
+  };
+}
+
+async function fetchCodexAvatarUsage(): Promise<CodexUsageSummary | null> {
+  try {
+    const summary = await getCodexUsageSummary();
+    if (!summary.weekly) throw new Error("missing weekly usage window");
+    return summary;
+  } catch (err) {
+    console.warn(`[${ts()}] [AVATAR] Codex usage unavailable, using plain avatar: ${(err as Error).message}`);
+    return null;
+  }
+}
 
 function codexUsagePalette(remainingPercent: number): { start: string; end: string; glow: string } {
   if (remainingPercent <= 25) return { start: "#ef4444", end: "#fb923c", glow: "#fed7aa" };
@@ -466,26 +466,26 @@ function codexUsagePalette(remainingPercent: number): { start: string; end: stri
   return { start: "#16a34a", end: "#34d399", glow: "#bbf7d0" };
 }
 
-function buildCodexUsageBatterySvg(remainingPercent: number): Buffer {
-  const remaining = clampPercent(remainingPercent);
-  const label = String(remaining);
-  const palette = codexUsagePalette(remaining);
-
-  const bodyX = 28;
-  const bodyY = 38;
-  const bodyW = 109;
-  const bodyH = 56;
-  const capW = 12;
-  const capH = 22;
-  const capX = bodyX + bodyW;
-  const capY = bodyY + Math.round((bodyH - capH) / 2);
-  const pad = 6;
-  const fillMaxW = bodyW - pad * 2;
-  const fillWidth = Math.round((fillMaxW * remaining) / 100);
-  const labelFontSize = label.length >= 3 ? 49 : 51;
-
-  return Buffer.from(`
-<svg width="256" height="256" xmlns="http://www.w3.org/2000/svg">
+function buildCodexUsageBatterySvg(remainingPercent: number): Buffer {
+  const remaining = clampPercent(remainingPercent);
+  const label = String(remaining);
+  const palette = codexUsagePalette(remaining);
+
+  const bodyX = 28;
+  const bodyY = 38;
+  const bodyW = 109;
+  const bodyH = 56;
+  const capW = 12;
+  const capH = 22;
+  const capX = bodyX + bodyW;
+  const capY = bodyY + Math.round((bodyH - capH) / 2);
+  const pad = 6;
+  const fillMaxW = bodyW - pad * 2;
+  const fillWidth = Math.round((fillMaxW * remaining) / 100);
+  const labelFontSize = label.length >= 3 ? 49 : 51;
+
+  return Buffer.from(`
+<svg width="256" height="256" xmlns="http://www.w3.org/2000/svg">
   <defs>
     <filter id="shadow" x="-35%" y="-35%" width="170%" height="170%">
       <feDropShadow dx="0" dy="4" stdDeviation="4" flood-color="#4a2712" flood-opacity="0.30"/>
@@ -501,100 +501,100 @@ function buildCodexUsageBatterySvg(remainingPercent: number): Buffer {
     <clipPath id="batteryInnerClip">
       <rect x="${bodyX + pad}" y="${bodyY + pad}" width="${fillMaxW}" height="${bodyH - pad * 2}" rx="10"/>
     </clipPath>
-  </defs>
-  <g filter="url(#shadow)">
-    <rect x="${bodyX}" y="${bodyY}" width="${bodyW}" height="${bodyH}" rx="18" fill="#0f172a"/>
-    <rect x="${bodyX + pad}" y="${bodyY + pad}" width="${fillMaxW}" height="${bodyH - pad * 2}" rx="12" fill="url(#well)"/>
-    <rect x="${bodyX + pad}" y="${bodyY + pad}" width="${fillWidth}" height="${bodyH - pad * 2}" fill="url(#fill)" clip-path="url(#batteryInnerClip)"/>
-    <rect x="${bodyX + pad + 4}" y="${bodyY + pad + 5}" width="${Math.max(0, fillWidth - 8)}" height="8" rx="4" fill="${palette.glow}" fill-opacity="0.42" clip-path="url(#batteryInnerClip)"/>
-    <rect x="${capX}" y="${capY}" width="${capW}" height="${capH}" rx="6" fill="#0f172a"/>
-    <rect x="${bodyX}" y="${bodyY}" width="${bodyW}" height="${bodyH}" rx="18" fill="none" stroke="#f8fafc" stroke-opacity="0.82" stroke-width="3.8"/>
-    <text x="${bodyX + bodyW / 2}" y="${bodyY + bodyH / 2 + 3}" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" font-family="Arial, Helvetica, sans-serif" font-size="${labelFontSize}" font-weight="700" letter-spacing="0" stroke="#0b1220" stroke-width="2.6" paint-order="stroke" stroke-linejoin="round" fill="#ffffff">${label}</text>
-  </g>
-</svg>`);
-}
-
-function buildCodexUsageRingSvg(remainingPercent: number): Buffer {
-  const remaining = clampPercent(remainingPercent);
-  const palette = codexUsagePalette(remaining);
-  const cx = 128;
-  const cy = 128;
-  const r = 118;
-  const strokeWidth = 13;
-  const used = clampPercent(100 - remaining);
-  const polar = (angleDegrees: number) => {
-    const angle = (angleDegrees * Math.PI) / 180;
-    return {
-      x: cx + r * Math.cos(angle),
-      y: cy + r * Math.sin(angle),
-    };
-  };
-  const startAngle = -90 + (used / 100) * 360;
-  const sweepAngle = (remaining / 100) * 360;
-  const start = polar(startAngle);
-  const end = polar(startAngle + Math.min(sweepAngle, 359.99));
-  const largeArcFlag = sweepAngle > 180 ? 1 : 0;
-  const progressPath = remaining >= 100
-    ? `<circle cx="${cx}" cy="${cy}" r="${r}" fill="none" stroke="url(#ring)" stroke-width="${strokeWidth}" stroke-linecap="round" filter="url(#ringShadow)"/>`
-    : remaining <= 0
-      ? ""
-      : `<path d="M ${start.x.toFixed(3)} ${start.y.toFixed(3)} A ${r} ${r} 0 ${largeArcFlag} 1 ${end.x.toFixed(3)} ${end.y.toFixed(3)}" fill="none" stroke="url(#ring)" stroke-width="${strokeWidth}" stroke-linecap="round" filter="url(#ringShadow)"/>`;
-
-  return Buffer.from(`
-<svg width="256" height="256" xmlns="http://www.w3.org/2000/svg">
-  <defs>
-    <linearGradient id="ring" x1="0" y1="0" x2="1" y2="1">
-      <stop offset="0" stop-color="${palette.start}"/>
-      <stop offset="1" stop-color="${palette.end}"/>
-    </linearGradient>
-    <filter id="ringShadow" x="-10%" y="-10%" width="120%" height="120%">
-      <feDropShadow dx="0" dy="2" stdDeviation="2.4" flood-color="#0f172a" flood-opacity="0.25"/>
-    </filter>
-  </defs>
-  <circle cx="${cx}" cy="${cy}" r="${r}" fill="none" stroke="#cbd5e1" stroke-width="${strokeWidth}"/>
-  ${progressPath}
-</svg>`);
-}
-
-async function buildAgentBadgeOverlay(tool: string): Promise<sharp.OverlayOptions> {
-  const badge = await sharp(AVATAR_BADGES[tool])
-    .resize(AVATAR_BADGE_SIZE, AVATAR_BADGE_SIZE, {
-      fit: "contain",
-      kernel: sharp.kernel.lanczos3,
-      background: { r: 0, g: 0, b: 0, alpha: 0 },
-    })
-    .png()
-    .toBuffer();
-  return {
-    input: badge,
-    left: AVATAR_SIZE - AVATAR_BADGE_SIZE - AVATAR_BADGE_MARGIN,
-    top: AVATAR_SIZE - AVATAR_BADGE_SIZE - AVATAR_BADGE_MARGIN,
-  };
-}
-
-async function renderAvatar(tool: string, status: string, codexUsage: CodexUsageSummary | null = null): Promise<{ buffer: Buffer; contentType: string; filename: string }> {
-  const normalizedTool = normalizeAvatarTool(tool);
-  const normalizedStatus = normalizeAvatarStatus(status);
-  const composites: sharp.OverlayOptions[] = [];
-
-  const useDynamicCodexAvatar = normalizedTool === "codex" && codexUsage?.weekly;
-  const basePath = useDynamicCodexAvatar
-    ? AVATAR_SOURCES[normalizedStatus]
-    : avatarCombinationPath(normalizedTool, normalizedStatus);
-
-  if (useDynamicCodexAvatar) {
-    composites.push(
-      { input: buildCodexUsageRingSvg(codexUsage.fiveHour.remainingPercent), left: 0, top: 0 },
-      { input: buildCodexUsageBatterySvg(codexUsage.weekly.remainingPercent), left: 0, top: 0 },
-      await buildAgentBadgeOverlay(normalizedTool),
-    );
-  }
-
-  let pipeline = sharp(await readFile(basePath))
-    .resize(AVATAR_SIZE, AVATAR_SIZE, { fit: "cover", position: "center" });
-  if (composites.length > 0) {
-    pipeline = pipeline.composite(composites);
-  }
+  </defs>
+  <g filter="url(#shadow)">
+    <rect x="${bodyX}" y="${bodyY}" width="${bodyW}" height="${bodyH}" rx="18" fill="#0f172a"/>
+    <rect x="${bodyX + pad}" y="${bodyY + pad}" width="${fillMaxW}" height="${bodyH - pad * 2}" rx="12" fill="url(#well)"/>
+    <rect x="${bodyX + pad}" y="${bodyY + pad}" width="${fillWidth}" height="${bodyH - pad * 2}" fill="url(#fill)" clip-path="url(#batteryInnerClip)"/>
+    <rect x="${bodyX + pad + 4}" y="${bodyY + pad + 5}" width="${Math.max(0, fillWidth - 8)}" height="8" rx="4" fill="${palette.glow}" fill-opacity="0.42" clip-path="url(#batteryInnerClip)"/>
+    <rect x="${capX}" y="${capY}" width="${capW}" height="${capH}" rx="6" fill="#0f172a"/>
+    <rect x="${bodyX}" y="${bodyY}" width="${bodyW}" height="${bodyH}" rx="18" fill="none" stroke="#f8fafc" stroke-opacity="0.82" stroke-width="3.8"/>
+    <text x="${bodyX + bodyW / 2}" y="${bodyY + bodyH / 2 + 3}" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" font-family="Arial, Helvetica, sans-serif" font-size="${labelFontSize}" font-weight="600" letter-spacing="0" stroke="#0b1220" stroke-width="4.6" paint-order="stroke" stroke-linejoin="round" fill="#ffffff">${label}</text>
+  </g>
+</svg>`);
+}
+
+function buildCodexUsageRingSvg(remainingPercent: number): Buffer {
+  const remaining = clampPercent(remainingPercent);
+  const palette = codexUsagePalette(remaining);
+  const cx = 128;
+  const cy = 128;
+  const r = 118;
+  const strokeWidth = 13;
+  const used = clampPercent(100 - remaining);
+  const polar = (angleDegrees: number) => {
+    const angle = (angleDegrees * Math.PI) / 180;
+    return {
+      x: cx + r * Math.cos(angle),
+      y: cy + r * Math.sin(angle),
+    };
+  };
+  const startAngle = -90 + (used / 100) * 360;
+  const sweepAngle = (remaining / 100) * 360;
+  const start = polar(startAngle);
+  const end = polar(startAngle + Math.min(sweepAngle, 359.99));
+  const largeArcFlag = sweepAngle > 180 ? 1 : 0;
+  const progressPath = remaining >= 100
+    ? `<circle cx="${cx}" cy="${cy}" r="${r}" fill="none" stroke="url(#ring)" stroke-width="${strokeWidth}" stroke-linecap="round" filter="url(#ringShadow)"/>`
+    : remaining <= 0
+      ? ""
+      : `<path d="M ${start.x.toFixed(3)} ${start.y.toFixed(3)} A ${r} ${r} 0 ${largeArcFlag} 1 ${end.x.toFixed(3)} ${end.y.toFixed(3)}" fill="none" stroke="url(#ring)" stroke-width="${strokeWidth}" stroke-linecap="round" filter="url(#ringShadow)"/>`;
+
+  return Buffer.from(`
+<svg width="256" height="256" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="ring" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="${palette.start}"/>
+      <stop offset="1" stop-color="${palette.end}"/>
+    </linearGradient>
+    <filter id="ringShadow" x="-10%" y="-10%" width="120%" height="120%">
+      <feDropShadow dx="0" dy="2" stdDeviation="2.4" flood-color="#0f172a" flood-opacity="0.25"/>
+    </filter>
+  </defs>
+  <circle cx="${cx}" cy="${cy}" r="${r}" fill="none" stroke="#cbd5e1" stroke-width="${strokeWidth}"/>
+  ${progressPath}
+</svg>`);
+}
+
+async function buildAgentBadgeOverlay(tool: string): Promise<sharp.OverlayOptions> {
+  const badge = await sharp(AVATAR_BADGES[tool])
+    .resize(AVATAR_BADGE_SIZE, AVATAR_BADGE_SIZE, {
+      fit: "contain",
+      kernel: sharp.kernel.lanczos3,
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+    .png()
+    .toBuffer();
+  return {
+    input: badge,
+    left: AVATAR_SIZE - AVATAR_BADGE_SIZE - AVATAR_BADGE_MARGIN,
+    top: AVATAR_SIZE - AVATAR_BADGE_SIZE - AVATAR_BADGE_MARGIN,
+  };
+}
+
+async function renderAvatar(tool: string, status: string, codexUsage: CodexUsageSummary | null = null): Promise<{ buffer: Buffer; contentType: string; filename: string }> {
+  const normalizedTool = normalizeAvatarTool(tool);
+  const normalizedStatus = normalizeAvatarStatus(status);
+  const composites: sharp.OverlayOptions[] = [];
+
+  const useDynamicCodexAvatar = normalizedTool === "codex" && codexUsage?.weekly;
+  const basePath = useDynamicCodexAvatar
+    ? AVATAR_SOURCES[normalizedStatus]
+    : avatarCombinationPath(normalizedTool, normalizedStatus);
+
+  if (useDynamicCodexAvatar) {
+    composites.push(
+      { input: buildCodexUsageRingSvg(codexUsage.fiveHour.remainingPercent), left: 0, top: 0 },
+      { input: buildCodexUsageBatterySvg(codexUsage.weekly.remainingPercent), left: 0, top: 0 },
+      await buildAgentBadgeOverlay(normalizedTool),
+    );
+  }
+
+  let pipeline = sharp(await readFile(basePath))
+    .resize(AVATAR_SIZE, AVATAR_SIZE, { fit: "cover", position: "center" });
+  if (composites.length > 0) {
+    pipeline = pipeline.composite(composites);
+  }
 
   const jpeg = await pipeline
     .flatten({ background: "#ffffff" })
@@ -602,16 +602,16 @@ async function renderAvatar(tool: string, status: string, codexUsage: CodexUsage
     .jpeg({ quality: 95, progressive: false })
     .toBuffer();
 
-  return {
-    buffer: jpeg,
-    contentType: "image/jpeg",
-    filename: codexUsage?.weekly
-      ? `avatar_${normalizedTool}_${normalizedStatus}_week_${codexUsage.weekly.remainingPercent}_5h_${codexUsage.fiveHour.remainingPercent}.jpg`
-      : `avatar_${normalizedTool}_${normalizedStatus}.jpg`,
-  };
-}
-
-async function uploadImage(token: string, tool: string, status: string, codexUsage: CodexUsageSummary | null = null): Promise<string> {
+  return {
+    buffer: jpeg,
+    contentType: "image/jpeg",
+    filename: codexUsage?.weekly
+      ? `avatar_${normalizedTool}_${normalizedStatus}_week_${codexUsage.weekly.remainingPercent}_5h_${codexUsage.fiveHour.remainingPercent}.jpg`
+      : `avatar_${normalizedTool}_${normalizedStatus}.jpg`,
+  };
+}
+
+async function uploadImage(token: string, tool: string, status: string, codexUsage: CodexUsageSummary | null = null): Promise<string> {
   const image = await renderAvatar(tool, status, codexUsage);
   const blob = new Blob([new Uint8Array(image.buffer)], { type: image.contentType });
   const form = new FormData();
@@ -634,10 +634,10 @@ async function uploadImage(token: string, tool: string, status: string, codexUsa
 }
 
 async function getOrUploadAvatarKey(token: string, tool: string, status: string): Promise<string> {
-  await loadAvatarKeyCache();
-  const normalizedTool = normalizeAvatarTool(tool);
-  const normalizedStatus = normalizeAvatarStatus(status);
-  const codexUsage = normalizedTool === "codex" ? await fetchCodexAvatarUsage() : null;
+  await loadAvatarKeyCache();
+  const normalizedTool = normalizeAvatarTool(tool);
+  const normalizedStatus = normalizeAvatarStatus(status);
+  const codexUsage = normalizedTool === "codex" ? await fetchCodexAvatarUsage() : null;
   const keyName = avatarCacheKey(normalizedTool, normalizedStatus, codexUsage);
   const cached = avatarKeyCache.get(keyName);
   if (cached) return cached;

package/src/privacy.ts

@@ -1,68 +1,118 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { USER_DATA_DIR } from "./config.ts";
-
-// ---------------------------------------------------------------------------
-// 隐私替换规则
-// ---------------------------------------------------------------------------
-
-interface PrivacyRules {
-  [key: string]: string;
-}
-
-let rules: PrivacyRules | null = null;
-let loaded = false;
-
-function loadRules(): PrivacyRules {
-  const filePath = join(USER_DATA_DIR, "privacy.json");
-  if (!existsSync(filePath)) {
-    return {};
-  }
-  try {
-    const raw = readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      console.error(`[PRIVACY] privacy.json 格式错误：应为对象`);
-      return {};
-    }
-    for (const [k, v] of Object.entries(parsed)) {
-      if (typeof v !== "string") {
-        console.error(`[PRIVACY] privacy.json 值必须为字符串，跳过 "${k}"`);
-        delete (parsed as Record<string, unknown>)[k];
-      }
-    }
-    return parsed as PrivacyRules;
-  } catch (err) {
-    console.error(`[PRIVACY] 读取 privacy.json 失败: ${(err as Error).message}`);
-    return {};
-  }
-}
-
-export function getPrivacyRules(): PrivacyRules {
-  if (!loaded) {
-    rules = loadRules();
-    loaded = true;
-  }
-  return rules!;
-}
-
-/** 重新加载规则（热更新用） */
-export function reloadPrivacyRules(): void {
-  loaded = false;
-  rules = null;
-}
-
-/**
- * 对文本应用隐私替换规则。
- * 若无规则或文本为空，直接返回原文。
- */
-export function applyPrivacy(text: string): string {
-  const r = getPrivacyRules();
-  if (Object.keys(r).length === 0 || !text) return text;
-  let result = text;
-  for (const [from, to] of Object.entries(r)) {
-    // 用 split+join 替代 replaceAll，避免正则特殊字符问题
-    result = result.split(from).join(to);
-  }
-  return result;
-}
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { USER_DATA_DIR } from "./config.ts";
+
+interface PrivacyRules {
+  [key: string]: string;
+}
+
+interface PrivacyConfig {
+  enabled: boolean;
+  rules: PrivacyRules;
+}
+
+let config: PrivacyConfig | null = null;
+let loadedStamp: string | null | undefined;
+
+function privacyFilePath(): string {
+  return join(USER_DATA_DIR, "privacy.json");
+}
+
+function privacyFileStamp(): string | null {
+  const filePath = privacyFilePath();
+  if (!existsSync(filePath)) return null;
+  try {
+    const s = statSync(filePath);
+    return `${s.mtimeMs}:${s.size}`;
+  } catch {
+    return null;
+  }
+}
+
+function sanitizeRules(raw: Record<string, unknown>): PrivacyRules {
+  const result: PrivacyRules = {};
+  for (const [from, to] of Object.entries(raw)) {
+    if (!from) {
+      console.error("[PRIVACY] privacy.json rule key cannot be empty, skipped");
+      continue;
+    }
+    if (typeof to !== "string") {
+      console.error(`[PRIVACY] privacy.json value must be a string, skipped "${from}"`);
+      continue;
+    }
+    result[from] = to;
+  }
+  return result;
+}
+
+function normalizeConfig(parsed: Record<string, unknown>): PrivacyConfig {
+  const hasNewSchema = Object.prototype.hasOwnProperty.call(parsed, "enabled") ||
+    Object.prototype.hasOwnProperty.call(parsed, "rules");
+
+  if (!hasNewSchema) {
+    return { enabled: true, rules: sanitizeRules(parsed) };
+  }
+
+  const enabledRaw = parsed.enabled;
+  const enabled = enabledRaw === undefined ? true : enabledRaw !== false;
+  if (enabledRaw !== undefined && typeof enabledRaw !== "boolean") {
+    console.error("[PRIVACY] privacy.json enabled must be a boolean, using true");
+  }
+
+  const rulesRaw = parsed.rules;
+  if (rulesRaw === undefined) return { enabled, rules: {} };
+  if (typeof rulesRaw !== "object" || rulesRaw === null || Array.isArray(rulesRaw)) {
+    console.error("[PRIVACY] privacy.json rules must be an object");
+    return { enabled, rules: {} };
+  }
+  return { enabled, rules: sanitizeRules(rulesRaw as Record<string, unknown>) };
+}
+
+function loadConfig(): PrivacyConfig {
+  const filePath = privacyFilePath();
+  if (!existsSync(filePath)) {
+    return { enabled: true, rules: {} };
+  }
+  try {
+    const raw = readFileSync(filePath, "utf-8").replace(/^\uFEFF/, "");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      console.error("[PRIVACY] privacy.json must be an object");
+      return { enabled: true, rules: {} };
+    }
+    return normalizeConfig(parsed as Record<string, unknown>);
+  } catch (err) {
+    console.error(`[PRIVACY] failed to read privacy.json: ${(err as Error).message}`);
+    return { enabled: true, rules: {} };
+  }
+}
+
+export function getPrivacyConfig(): PrivacyConfig {
+  const stamp = privacyFileStamp();
+  if (!config || stamp !== loadedStamp) {
+    config = loadConfig();
+    loadedStamp = stamp;
+  }
+  return config;
+}
+
+export function getPrivacyRules(): PrivacyRules {
+  return getPrivacyConfig().rules;
+}
+
+export function reloadPrivacyRules(): void {
+  config = null;
+  loadedStamp = undefined;
+}
+
+export function applyPrivacy(text: string): string {
+  const { enabled, rules } = getPrivacyConfig();
+  if (!enabled || Object.keys(rules).length === 0 || !text) return text;
+
+  let result = text;
+  for (const [from, to] of Object.entries(rules)) {
+    // Use split+join instead of regex replacement so rule keys stay literal.
+    result = result.split(from).join(to);
+  }
+  return result;
+}