chatccc 0.2.18 → 0.2.20

package/src/feishu-api.ts

@@ -1,6 +1,6 @@
-import { readdir, stat, readFile } from "node:fs/promises";
+import { readdir, stat, readFile, mkdir, writeFile } from "node:fs/promises";
 import { resolve as resolvePath } from "node:path";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import sharp from "sharp";
 
 import {
@@ -261,19 +261,79 @@ 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_KEY_CACHE_FILE = resolvePath(PROJECT_ROOT, "state", "avatar-image-keys.json");
 const AVATAR_SOURCES: Record<string, string> = {
   new: resolvePath(AVATAR_DIR, "status_new.png"),
   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 BADGE_SIZE = 92;
+const BADGE_MARGIN = 10;
 
 const avatarKeyCache = new Map<string, string>();
+let avatarKeyCacheLoaded = false;
+
+function normalizeAvatarTool(tool: string): string {
+  return AVATAR_BADGES[tool] ? tool : "claude";
+}
+
+function normalizeAvatarStatus(status: string): string {
+  return AVATAR_SOURCES[status] ? status : "idle";
+}
+
+function avatarCacheKey(tool: string, status: string): string {
+  return `${normalizeAvatarTool(tool)}:${normalizeAvatarStatus(status)}`;
+}
+
+async function loadAvatarKeyCache(): Promise<void> {
+  if (avatarKeyCacheLoaded) return;
+  avatarKeyCacheLoaded = true;
+  try {
+    const raw = await readFile(AVATAR_KEY_CACHE_FILE, "utf-8");
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    for (const [key, value] of Object.entries(parsed)) {
+      if (typeof value === "string" && value.trim()) avatarKeyCache.set(key, value);
+    }
+  } catch {
+    // Missing or malformed cache should not block avatar updates.
+  }
+}
+
+async function persistAvatarKeyCache(): Promise<void> {
+  await mkdir(dirname(AVATAR_KEY_CACHE_FILE), { recursive: true });
+  await writeFile(
+    AVATAR_KEY_CACHE_FILE,
+    JSON.stringify(Object.fromEntries(avatarKeyCache.entries()), null, 2),
+    "utf-8",
+  );
+}
 
-async function loadAvatarSource(source: string): Promise<{ buffer: Buffer; contentType: string; filename: string }> {
-  const input = await readFile(source);
+async function renderAvatar(tool: string, status: string): 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 jpeg = await sharp(input)
-    .resize(256, 256, { fit: "cover", position: "center" })
+  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,
+    }])
     .flatten({ background: "#ffffff" })
     .removeAlpha()
     .jpeg({ quality: 95, progressive: false })
@@ -282,12 +342,12 @@ async function loadAvatarSource(source: string): Promise<{ buffer: Buffer; conte
   return {
     buffer: jpeg,
     contentType: "image/jpeg",
-    filename: "avatar.jpg",
+    filename: `avatar_${normalizedTool}_${normalizedStatus}.jpg`,
   };
 }
 
-async function uploadImage(token: string, source: string): Promise<string> {
-  const image = await loadAvatarSource(source);
+async function uploadImage(token: string, tool: string, status: string): Promise<string> {
+  const image = await renderAvatar(tool, status);
   const blob = new Blob([new Uint8Array(image.buffer)], { type: image.contentType });
   const form = new FormData();
   form.append("image_type", "avatar");
@@ -308,18 +368,23 @@ async function uploadImage(token: string, source: string): Promise<string> {
   return data.data!.image_key!;
 }
 
-async function getOrUploadAvatarKey(token: string, status: string): Promise<string> {
-  const cached = avatarKeyCache.get(status);
+async function getOrUploadAvatarKey(token: string, tool: string, status: string): Promise<string> {
+  await loadAvatarKeyCache();
+  const keyName = avatarCacheKey(tool, status);
+  const cached = avatarKeyCache.get(keyName);
   if (cached) return cached;
-  const key = await uploadImage(token, AVATAR_SOURCES[status]);
-  avatarKeyCache.set(status, key);
+  const key = await uploadImage(token, tool, status);
+  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}`);
   return key;
 }
 
-export async function setChatAvatar(token: string, chatId: string, status: string): Promise<void> {
+export async function setChatAvatar(token: string, chatId: string, tool: string, status: string): Promise<void> {
   try {
-    const avatarKey = await getOrUploadAvatarKey(token, status);
+    const avatarKey = await getOrUploadAvatarKey(token, tool, status);
     const resp = await fetch(`${BASE_URL}/im/v1/chats/${chatId}`, {
       method: "PUT",
       headers: {
@@ -336,7 +401,7 @@ export async function setChatAvatar(token: string, chatId: string, status: strin
     }
     if (data.code !== 0) throw new Error(`[${data.code}] ${data.msg}`);
   } catch (err) {
-    console.error(`[${ts()}] [AVATAR] setChatAvatar FAIL: chatId=${chatId} status=${status} ${(err as Error).message}`);
+    console.error(`[${ts()}] [AVATAR] setChatAvatar FAIL: chatId=${chatId} tool=${tool} status=${status} ${(err as Error).message}`);
   }
 }
 
@@ -344,6 +409,40 @@ export async function setChatAvatar(token: string, chatId: string, status: strin
 // Messaging
 // ---------------------------------------------------------------------------
 
+const DELAY_NOTICE_THRESHOLD_MS = 15 * 60 * 1000; // 15 分钟
+
+/** 消息延迟超过阈值时生成提醒文本，否则返回 null */
+export function formatDelayNotice(createTimeMs: number, nowMs?: number): string | null {
+  const now = nowMs ?? Date.now();
+  const delayMs = now - createTimeMs;
+  if (delayMs < DELAY_NOTICE_THRESHOLD_MS) return null;
+
+  const sendDate = new Date(createTimeMs);
+  const month = sendDate.getMonth() + 1;
+  const day = sendDate.getDate();
+  const hour = String(sendDate.getHours()).padStart(2, "0");
+  const min = String(sendDate.getMinutes()).padStart(2, "0");
+  const sendTimeStr = `${month}月${day}日 ${hour}:${min}`;
+
+  const totalMinutes = Math.floor(delayMs / 60000);
+  let delayStr: string;
+  if (totalMinutes < 60) {
+    delayStr = `${totalMinutes} 分钟`;
+  } else {
+    const hours = Math.floor(totalMinutes / 60);
+    const mins = totalMinutes % 60;
+    if (hours < 24) {
+      delayStr = mins > 0 ? `${hours} 小时 ${mins} 分钟` : `${hours} 小时`;
+    } else {
+      const days = Math.floor(hours / 24);
+      const remainHours = hours % 24;
+      delayStr = remainHours > 0 ? `${days} 天 ${remainHours} 小时` : `${days} 天`;
+    }
+  }
+
+  return `> ⚠️ 延迟送达提醒：此消息于 ${sendTimeStr} 发送，因服务离线，延迟约 ${delayStr}后送达`;
+}
+
 export async function sendTextReply(
   token: string,
   chatId: string,

package/src/index.ts

@@ -3,7 +3,7 @@
  * =================================================================
  * Supported tools: Claude Code, Cursor, Codex (OpenAI).
  *
- * When a user sends "/new [tool]" to the bot:
+ * When a user sends "/new [tool]" to the bot (omitting tool uses the configured default Agent):
  *   1. Create an AI tool session via the corresponding adapter, get session ID
  *   2. Create a new Feishu group chat and add the user
  *   3. Rename the group (name + description) to the session ID
@@ -54,16 +54,18 @@ import {
   maskAppId,
   setDefaultCwd,
   getRecentDirs,
-  addRecentDir,
-  sessionPrefixForTool,
-  toolDisplayName,
-  ts,
-} from "./config.ts";
+  addRecentDir,
+  sessionPrefixForTool,
+  resolveDefaultAgentTool,
+  toolDisplayName,
+  ts,
+} from "./config.ts";
 import { printServiceDidNotStart, printServiceRunningHint } from "./exit-banner.ts";
 import {
   addReaction,
   createGroupChat,
   extractSessionInfo,
+  formatDelayNotice,
   getChatInfo,
   getTenantAccessToken,
   recallMessage,
@@ -195,7 +197,7 @@ function parseCardAction(data: unknown): CardActionResult | null {
   }
   if (!cmd) return null;
 
-  const CMD_MAP: Record<string, string> = { stop: "/stop", new: "/new", "new cursor": "/new cursor", "new codex": "/new codex", restart: "/restart", status: "/status", cd: "/cd", sessions: "/sessions", forget: "/forget" };
+  const CMD_MAP: Record<string, string> = { stop: "/stop", new: "/new", "new claude": "/new claude", "new cursor": "/new cursor", "new codex": "/new codex", restart: "/restart", status: "/status", cd: "/cd", sessions: "/sessions", forget: "/forget" };
   let text = CMD_MAP[cmd] ?? "";
   if (cmd === "cd" && typeof action.value === "object" && action.value !== null) {
     const path = (action.value as Record<string, string>).path;
@@ -405,7 +407,7 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
     );
 
     console.log(`[${ts()}] [STEP 4/4] Replied to new group → OK`);
-    setChatAvatar(freshToken, newChatId, "new").catch(() => {});
+    setChatAvatar(freshToken, newChatId, tool, "new").catch(() => {});
     console.log(`${"=".repeat(60)}`);
     return;
   }
@@ -558,7 +560,7 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
           tool: descriptionTool,
         });
 
-        setChatAvatar(freshToken, chatId, "new").catch(() => {});
+        setChatAvatar(freshToken, chatId, descriptionTool, "new").catch(() => {});
 
         await sendCardReply(
           freshToken, chatId, `${toolLabel} Session Reset`,
@@ -721,8 +723,8 @@ async function startBotServiceCore(): Promise<void> {
   console.log(`${"=".repeat(60)}`);
   console.log(`  ChatCCC — Feishu Bot Bridge for Claude Code${modeTag}`);
   console.log(`${"=".repeat(60)}`);
-  console.log(`  Send "/new" to the bot to create a new group + Claude session.`);
-  console.log(`  In a Claude session group, send any message to resume & prompt.`);
+  console.log(`  Send "/new" to the bot to create a new group + ${toolDisplayName(resolveDefaultAgentTool())} session.`);
+  console.log(`  In a session group, send any message to resume & prompt.`);
   console.log(`${"=".repeat(60)}`);
 
   console.log(`\n[启动 4/7] 向飞书开放平台申请 tenant_access_token …`);
@@ -802,6 +804,11 @@ async function startBotServiceCore(): Promise<void> {
 
       if (!text) return;
       const msgTimestamp = parseInt(message.create_time ?? "0", 10) || Date.now();
+      const delayNotice = formatDelayNotice(msgTimestamp);
+      if (delayNotice) {
+        const delayToken = await getTenantAccessToken();
+        await sendCardReply(delayToken, chatId, "延迟送达", delayNotice, "yellow").catch(() => {});
+      }
       await handleCommand(text, chatId, openId, msgTimestamp);
       } catch (err) {
         console.error(`[${ts()}] [FATAL] im.message.receive_v1 handler crashed: ${(err as Error).message}`);

package/src/session.ts

@@ -251,7 +251,7 @@ export function accumulateBlockContent(
 }
 
 // ---------------------------------------------------------------------------
-// Claude session management
+// AI tool session management
 // ---------------------------------------------------------------------------
 
 /**
@@ -324,7 +324,7 @@ export async function resumeAndPrompt(
   });
   const myGen = sessionGen;
 
-  setChatAvatar(token, chatId, "busy").catch(() => {});
+  setChatAvatar(token, chatId, tool, "busy").catch(() => {});
 
   const now = Date.now();
   const existingInfo = sessionInfoMap.get(chatId);
@@ -466,7 +466,7 @@ export async function resumeAndPrompt(
   if (!cEntry || cEntry.gen !== myGen) return;
   const wasStopped = cEntry.stopped;
   chatSessionMap.delete(chatId);
-  setChatAvatar(token, chatId, "idle").catch(() => {});
+  setChatAvatar(token, chatId, tool, "idle").catch(() => {});
 
   const finalCardContent = state.accumulatedContent || " ";
   if (cardId) {