chatccc 0.2.150 → 0.2.152

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.150",
+  "version": "0.2.152",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",
@@ -19,6 +19,7 @@
     "images/img_readme_*.png",
     "images/avatars/status_*.png",
     "images/avatars/badges/",
+    "images/avatars/combinations/",
     "package.json",
     "README.md",
     "config.sample.json"

package/src/__tests__/cards.test.ts

@@ -106,9 +106,11 @@ describe("buildProgressCard", () => {
     const card = buildProgressCard("hello");
     const parsed = JSON.parse(card);
     const buttons = parsed.body.elements.filter((e: any) => e.tag === "button");
-    expect(buttons).toHaveLength(2);
-    expect(buttons[0].text.content).toBe("查看状态（/state）");
-    expect(buttons[1].text.content).toBe("停止生成（/stop）");
+    expect(buttons).toHaveLength(2);
+    expect(buttons[0].text.content).toBe("查看状态（/state）");
+    expect(buttons[0].value).toEqual({ action: "state" });
+    expect(buttons[0].element_id).toBe("action_state");
+    expect(buttons[1].text.content).toBe("停止生成（/stop）");
   });
 
   it("hides stop button when showStop is false", () => {

package/src/__tests__/feishu-avatar.test.ts

@@ -0,0 +1,102 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+async function loadFeishuApiWithHome(homeDir: string, userDataDir: string) {
+  vi.resetModules();
+  vi.doMock("node:os", () => ({ homedir: () => homeDir }));
+  vi.doMock("../config.ts", () => ({
+    APP_ID: "app_id",
+    APP_SECRET: "app_secret",
+    BASE_URL: "https://open.feishu.test",
+    CHAT_LOGS_DIR: join(userDataDir, "logs"),
+    PROJECT_ROOT: process.cwd(),
+    USER_DATA_DIR: userDataDir,
+    CLAUDE_SESSION_PREFIX: "Claude Code Session:",
+    CURSOR_SESSION_PREFIX: "Cursor Session:",
+    CODEX_SESSION_PREFIX: "Codex Session:",
+    ts: () => "test-ts",
+    resolveDefaultAgentTool: () => "claude",
+    toolDisplayName: (tool: string) => tool,
+  }));
+  return import("../feishu-api.ts");
+}
+
+async function writeCodexAuth(homeDir: string): Promise<void> {
+  const codexDir = join(homeDir, ".codex");
+  await mkdir(codexDir, { recursive: true });
+  await writeFile(
+    join(codexDir, "auth.json"),
+    JSON.stringify({ tokens: { access_token: "codex-access-token" } }),
+    "utf-8",
+  );
+}
+
+function mockAvatarFetch(uploadedNames: string[], usageResponse: Response): void {
+  vi.stubGlobal("fetch", vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
+    const urlText = String(url);
+    if (urlText === "https://chatgpt.com/backend-api/wham/usage") {
+      return usageResponse.clone();
+    }
+    if (urlText === "https://open.feishu.test/im/v1/images") {
+      const form = init?.body as FormData;
+      const image = form.get("image") as File;
+      uploadedNames.push(image.name);
+      return new Response(JSON.stringify({ code: 0, data: { image_key: "img_test" } }), { status: 200 });
+    }
+    if (urlText === "https://open.feishu.test/im/v1/chats/chat_1") {
+      return new Response(JSON.stringify({ code: 0 }), { status: 200 });
+    }
+    throw new Error(`unexpected fetch: ${urlText}`);
+  }));
+}
+
+describe("Codex avatar usage battery", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.doUnmock("node:os");
+    vi.doUnmock("../config.ts");
+    vi.restoreAllMocks();
+  });
+
+  it("adds the 5h remaining percent to Codex avatar uploads when usage lookup succeeds", async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
+    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
+    const uploadedNames: string[] = [];
+    await writeCodexAuth(homeDir);
+    mockAvatarFetch(uploadedNames, new Response(JSON.stringify({
+      rate_limit: { primary_window: { used_percent: 37 } },
+    }), { status: 200 }));
+
+    try {
+      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
+      await setChatAvatar("tenant-token", "chat_1", "codex", "busy");
+
+      expect(uploadedNames).toEqual(["avatar_codex_busy_usage_63.jpg"]);
+    } finally {
+      await rm(homeDir, { recursive: true, force: true });
+      await rm(userDataDir, { recursive: true, force: true });
+    }
+  });
+
+  it("falls back to the pre-combined Codex avatar when usage lookup fails", async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
+    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
+    const uploadedNames: string[] = [];
+    await writeCodexAuth(homeDir);
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    mockAvatarFetch(uploadedNames, new Response("fail", { status: 500 }));
+
+    try {
+      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
+      await setChatAvatar("tenant-token", "chat_1", "codex", "idle");
+
+      expect(uploadedNames).toEqual(["avatar_codex_idle.jpg"]);
+    } finally {
+      await rm(homeDir, { recursive: true, force: true });
+      await rm(userDataDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/adapters/adapter-interface.ts

@@ -128,6 +128,10 @@ export interface ToolPromptOptions {
   onProcessStart?: (info: ToolProcessInfo) => void;
   /** Called when the adapter leaves the prompt process scope normally or by abort. */
   onProcessExit?: (info: ToolProcessInfo) => void;
+  /** Called when the adapter creates an SDK session internally.
+   *  The callback receives a close function that terminates the underlying
+   *  subprocess. Used by stop-stuck-loop to kill the CLI process immediately. */
+  onSessionCreated?: (closeSession: () => void) => void;
 }
 
 // ---------------------------------------------------------------------------

package/src/adapters/claude-adapter.ts

@@ -490,6 +490,8 @@ class ClaudeAdapter implements ToolAdapter {
       })),
     );
 
+    options?.onSessionCreated?.(() => session.close());
+
     try {
       await session.send(buildClaudePromptText(userText, undefined, sessionId));
       for await (const raw of session.stream()) {

package/src/agent-stop-stuck.ts

@@ -116,6 +116,8 @@ export async function handleAgentStopStuckRequest(
     }
   })();
 
+  // 先关闭底层 SDK session，终止 CLI 子进程，然后再 abort 清理 adapter 层
+  prompt.closeSession?.();
   // 不设 stopped 标记 → finally block 写 "done" → 卡片正常结束
   prompt.controller.abort();
 

package/src/cards.ts

@@ -91,8 +91,8 @@ export function buildProgressCard(
       tag: "button",
       text: { tag: "plain_text", content: "查看状态（/state）" },
       type: "default",
-      value: { action: "status" },
-      element_id: "action_status",
+      value: { action: "state" },
+      element_id: "action_state",
     });
     elements.push({
       tag: "button",

package/src/feishu-api.ts

@@ -1,4 +1,5 @@
 import { readdir, stat, readFile, mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import { extname, resolve as resolvePath } from "node:path";
 import { dirname, join } from "node:path";
 import sharp from "sharp";
@@ -297,7 +298,10 @@ export function extractSessionId(description: string): string | null {
 
 const AVATAR_DIR = resolvePath(PROJECT_ROOT, "images", "avatars");
 const AVATAR_BADGE_DIR = resolvePath(AVATAR_DIR, "badges");
+const AVATAR_COMBINATIONS_DIR = resolvePath(AVATAR_DIR, "combinations");
 const AVATAR_KEY_CACHE_FILE = resolvePath(USER_DATA_DIR, "state", "avatar-image-keys.json");
+const CODEX_AUTH_FILE = resolvePath(homedir(), ".codex", "auth.json");
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const AVATAR_SOURCES: Record<string, string> = {
   new: resolvePath(AVATAR_DIR, "status_new.png"),
   busy: resolvePath(AVATAR_DIR, "status_busy.png"),
@@ -309,8 +313,11 @@ const AVATAR_BADGES: Record<string, string> = {
   codex: resolvePath(AVATAR_BADGE_DIR, "badge_codex.png"),
 };
 const AVATAR_SIZE = 256;
-const BADGE_SIZE = 92;
-const BADGE_MARGIN = 10;
+
+interface CodexUsageBalance {
+  usedPercent: number;
+  remainingPercent: number;
+}
 
 const avatarKeyCache = new Map<string, string>();
 let avatarKeyCacheLoaded = false;
@@ -323,8 +330,19 @@ function normalizeAvatarStatus(status: string): string {
   return AVATAR_SOURCES[status] ? status : "idle";
 }
 
-function avatarCacheKey(tool: string, status: string): string {
-  return `${normalizeAvatarTool(tool)}:${normalizeAvatarStatus(status)}`;
+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: CodexUsageBalance | null = null): string {
+  const normalizedTool = normalizeAvatarTool(tool);
+  const normalizedStatus = normalizeAvatarStatus(status);
+  if (normalizedTool === "codex") {
+    return codexUsage
+      ? `${normalizedTool}:${normalizedStatus}:battery:${codexUsage.remainingPercent}`
+      : `${normalizedTool}:${normalizedStatus}:plain`;
+  }
+  return `${normalizedTool}:${normalizedStatus}`;
 }
 
 async function loadAvatarKeyCache(): Promise<void> {
@@ -350,25 +368,119 @@ async function persistAvatarKeyCache(): Promise<void> {
   );
 }
 
-async function renderAvatar(tool: string, status: string): Promise<{ buffer: Buffer; contentType: string; filename: string }> {
+function clampPercent(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(100, Math.round(value)));
+}
+
+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 } };
+    const token = parsed.tokens?.access_token;
+    return typeof token === "string" && token.trim() ? token : null;
+  } catch {
+    return null;
+  }
+}
+
+async function fetchCodexUsageBalance(): Promise<CodexUsageBalance | null> {
+  try {
+    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?: { primary_window?: { used_percent?: unknown } };
+    };
+    const usedPercent = Number(data.rate_limit?.primary_window?.used_percent);
+    if (!Number.isFinite(usedPercent)) throw new Error("missing rate_limit.primary_window.used_percent");
+
+    const used = clampPercent(usedPercent);
+    return {
+      usedPercent: used,
+      remainingPercent: clampPercent(100 - used),
+    };
+  } 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" };
+  if (remainingPercent <= 60) return { start: "#eab308", end: "#facc15", glow: "#fef3c7" };
+  return { start: "#16a34a", end: "#34d399", glow: "#bbf7d0" };
+}
+
+function buildCodexUsageBatterySvg(remainingPercent: number): Buffer {
+  const remaining = clampPercent(remainingPercent);
+  const label = `${remaining}%`;
+  const palette = codexUsagePalette(remaining);
+
+  const bodyX = 28;
+  const bodyY = 38;
+  const bodyW = 91;
+  const bodyH = 47;
+  const capW = 10;
+  const capH = 18;
+  const capX = bodyX + bodyW;
+  const capY = bodyY + Math.round((bodyH - capH) / 2);
+  const pad = 5;
+  const fillMaxW = bodyW - pad * 2;
+  const fillWidth = Math.round((fillMaxW * remaining) / 100);
+
+  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"/>
+    </filter>
+    <linearGradient id="fill" x1="0" y1="0" x2="1" y2="0">
+      <stop offset="0" stop-color="${palette.start}"/>
+      <stop offset="1" stop-color="${palette.end}"/>
+    </linearGradient>
+    <linearGradient id="well" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#334155"/>
+      <stop offset="1" stop-color="#111827"/>
+    </linearGradient>
+    <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="15" fill="#0f172a"/>
+    <rect x="${bodyX + pad}" y="${bodyY + pad}" width="${fillMaxW}" height="${bodyH - pad * 2}" rx="10" 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 + 3}" y="${bodyY + pad + 4}" width="${Math.max(0, fillWidth - 6)}" height="7" rx="3.5" fill="${palette.glow}" fill-opacity="0.42" clip-path="url(#batteryInnerClip)"/>
+    <rect x="${capX}" y="${capY}" width="${capW}" height="${capH}" rx="5" fill="#0f172a"/>
+    <rect x="${bodyX}" y="${bodyY}" width="${bodyW}" height="${bodyH}" rx="15" fill="none" stroke="#f8fafc" stroke-opacity="0.82" stroke-width="3.2"/>
+    <text x="${bodyX + bodyW / 2}" y="${bodyY + 32}" text-anchor="middle" font-family="Arial, Helvetica, sans-serif" font-size="27" font-weight="900" letter-spacing="0" stroke="#0b1220" stroke-width="5" paint-order="stroke" stroke-linejoin="round" fill="#ffffff">${label}</text>
+  </g>
+</svg>`);
+}
+
+async function renderAvatar(tool: string, status: string, codexUsage: CodexUsageBalance | null = null): Promise<{ buffer: Buffer; contentType: string; filename: string }> {
   const normalizedTool = normalizeAvatarTool(tool);
   const normalizedStatus = normalizeAvatarStatus(status);
-  const badge = await sharp(await readFile(AVATAR_BADGES[normalizedTool]))
-    .resize(BADGE_SIZE, BADGE_SIZE, {
-      fit: "contain",
-      kernel: sharp.kernel.lanczos3,
-      background: { r: 0, g: 0, b: 0, alpha: 0 },
-    })
-    .png()
-    .toBuffer();
+  const composites: sharp.OverlayOptions[] = [];
+
+  if (normalizedTool === "codex" && codexUsage) {
+    composites.push({ input: buildCodexUsageBatterySvg(codexUsage.remainingPercent), left: 0, top: 0 });
+  }
 
-  const jpeg = await sharp(await readFile(AVATAR_SOURCES[normalizedStatus]))
-    .resize(AVATAR_SIZE, AVATAR_SIZE, { fit: "cover", position: "center" })
-    .composite([{
-      input: badge,
-      left: AVATAR_SIZE - BADGE_SIZE - BADGE_MARGIN,
-      top: AVATAR_SIZE - BADGE_SIZE - BADGE_MARGIN,
-    }])
+  let pipeline = sharp(await readFile(avatarCombinationPath(normalizedTool, normalizedStatus)))
+    .resize(AVATAR_SIZE, AVATAR_SIZE, { fit: "cover", position: "center" });
+  if (composites.length > 0) {
+    pipeline = pipeline.composite(composites);
+  }
+
+  const jpeg = await pipeline
     .flatten({ background: "#ffffff" })
     .removeAlpha()
     .jpeg({ quality: 95, progressive: false })
@@ -377,12 +489,14 @@ async function renderAvatar(tool: string, status: string): Promise<{ buffer: Buf
   return {
     buffer: jpeg,
     contentType: "image/jpeg",
-    filename: `avatar_${normalizedTool}_${normalizedStatus}.jpg`,
+    filename: codexUsage
+      ? `avatar_${normalizedTool}_${normalizedStatus}_usage_${codexUsage.remainingPercent}.jpg`
+      : `avatar_${normalizedTool}_${normalizedStatus}.jpg`,
   };
 }
 
-async function uploadImage(token: string, tool: string, status: string): Promise<string> {
-  const image = await renderAvatar(tool, status);
+async function uploadImage(token: string, tool: string, status: string, codexUsage: CodexUsageBalance | 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();
   form.append("image_type", "avatar");
@@ -405,15 +519,18 @@ async function uploadImage(token: string, tool: string, status: string): Promise
 
 async function getOrUploadAvatarKey(token: string, tool: string, status: string): Promise<string> {
   await loadAvatarKeyCache();
-  const keyName = avatarCacheKey(tool, status);
+  const normalizedTool = normalizeAvatarTool(tool);
+  const normalizedStatus = normalizeAvatarStatus(status);
+  const codexUsage = normalizedTool === "codex" ? await fetchCodexUsageBalance() : null;
+  const keyName = avatarCacheKey(normalizedTool, normalizedStatus, codexUsage);
   const cached = avatarKeyCache.get(keyName);
   if (cached) return cached;
-  const key = await uploadImage(token, tool, status);
+  const key = await uploadImage(token, normalizedTool, normalizedStatus, codexUsage);
   avatarKeyCache.set(keyName, key);
   await persistAvatarKeyCache().catch((err) => {
     console.error(`[${ts()}] [AVATAR] persist cache FAIL: ${(err as Error).message}`);
   });
-  console.log(`[${ts()}] [AVATAR] Uploaded "${status}" → image_key=${key}`);
+  console.log(`[${ts()}] [AVATAR] Uploaded "${keyName}" → image_key=${key}`);
   return key;
 }
 

package/src/index.ts

@@ -212,7 +212,7 @@ function parseCardAction(data: unknown): CardActionResult | null {
   }
   if (!cmd) return null;
 
-  const CMD_MAP: Record<string, string> = { stop: "/stop", cancel: "/cancel", new: "/new", "new claude": "/new claude", "new cursor": "/new cursor", "new codex": "/new codex", restart: "/restart", status: "/state", cd: "/cd", sessions: "/sessions", newh: "/newh" };
+  const CMD_MAP: Record<string, string> = { stop: "/stop", cancel: "/cancel", new: "/new", "new claude": "/new claude", "new cursor": "/new cursor", "new codex": "/new codex", restart: "/restart", state: "/state", cd: "/cd", sessions: "/sessions", newh: "/newh" };
   let text = CMD_MAP[cmd] ?? "";
   if (cmd === "cd" && typeof action.value === "object" && action.value !== null) {
     const path = (action.value as Record<string, string>).path;

package/src/session-chat-binding.ts

@@ -73,6 +73,10 @@ export interface ActivePrompt {
   abnormalExitNotified?: boolean;
   /** Set when the resource monitor detects CPU + memory unchanged for 3 minutes. */
   resourceStuck?: boolean;
+  /** Adapter-provided callback to close the underlying SDK session / subprocess.
+   *  Called by stop-stuck-loop before controller.abort() to terminate the CLI
+   *  process immediately, rather than waiting for the async generator to unblock. */
+  closeSession?: () => void;
 }
 
 export const activePrompts = new Map<string, ActivePrompt>();

package/src/session.ts

@@ -1110,6 +1110,10 @@ export async function runAgentSession(
         clearPromptProcessMonitor(sessionId);
         if (exitInfo.pid !== undefined) unregisterProcess(exitInfo.pid);
       },
+      onSessionCreated: (closeSession) => {
+        const prompt = activePrompts.get(sessionId);
+        if (prompt) prompt.closeSession = closeSession;
+      },
     })) {
       for (const block of unifiedMsg.blocks) {
         accumulateBlockContent(block, state, toolCallMap);