chatccc 0.2.10 → 0.2.12

package/src/feishu-api.ts

@@ -1,5 +1,7 @@
-import { readdir, stat } from "node:fs/promises";
+import { readdir, stat, readFile } from "node:fs/promises";
+import { resolve as resolvePath } from "node:path";
 import { join } from "node:path";
+import sharp from "sharp";
 
 import {
   APP_ID,
@@ -9,9 +11,10 @@ import {
   PROJECT_ROOT,
   CLAUDE_SESSION_PREFIX,
   CURSOR_SESSION_PREFIX,
+  CODEX_SESSION_PREFIX,
   ts,
 } from "./config.ts";
-import { buildButtons } from "./cards.ts";
+import { buildHelpCard } from "./cards.ts";
 
 // ---------------------------------------------------------------------------
 // Auth
@@ -78,6 +81,18 @@ const REQUIRED_PERMISSIONS: PermissionDef[] = [
     path: "/im/v1/messages/om_000000000000000000000000",
     body: JSON.stringify({ content: JSON.stringify({ elements: [{ tag: "markdown", content: " " }] }) }),
   },
+  {
+    scope: "cardkit:card",
+    description: "创建/更新群卡片（流式进度卡片、状态卡片等）",
+    method: "POST",
+    path: "/cardkit/v1/cards",
+    body: JSON.stringify({
+      schema: "2.0",
+      config: { update_multi: true },
+      header: { template: "blue", title: { tag: "plain_text", content: "permcheck" } },
+      body: { direction: "vertical", elements: [{ tag: "markdown", content: " " }] },
+    }),
+  },
 ];
 
 interface PermissionResult {
@@ -224,6 +239,7 @@ export function extractSessionInfo(description: string): { sessionId: string; to
   const PREFIXES: Array<{ prefix: string; tool: string }> = [
     { prefix: CLAUDE_SESSION_PREFIX, tool: "claude" },
     { prefix: CURSOR_SESSION_PREFIX, tool: "cursor" },
+    { prefix: CODEX_SESSION_PREFIX, tool: "codex" },
   ];
   for (const { prefix, tool } of PREFIXES) {
     const idx = description.indexOf(prefix);
@@ -240,6 +256,101 @@ export function extractSessionId(description: string): string | null {
   return extractSessionInfo(description)?.sessionId ?? null;
 }
 
+// ---------------------------------------------------------------------------
+// Avatar
+// ---------------------------------------------------------------------------
+
+const AVATAR_DIR = resolvePath(PROJECT_ROOT, "images", "avatars");
+const AVATAR_SOURCES: Record<string, string> = {
+  new: process.env.CHATCCC_AVATAR_NEW_URL?.trim() || resolvePath(AVATAR_DIR, "status_new.png"),
+  busy: process.env.CHATCCC_AVATAR_BUSY_URL?.trim() || resolvePath(AVATAR_DIR, "status_busy.png"),
+  idle: process.env.CHATCCC_AVATAR_IDLE_URL?.trim() || resolvePath(AVATAR_DIR, "status_idle.png"),
+};
+
+const avatarKeyCache = new Map<string, string>();
+
+function isHttpUrl(source: string): boolean {
+  return /^https?:\/\//i.test(source);
+}
+
+async function loadAvatarSource(source: string): Promise<{ buffer: Buffer; contentType: string; filename: string }> {
+  let input: Buffer;
+  if (isHttpUrl(source)) {
+    const resp = await fetch(source);
+    if (!resp.ok) throw new Error(`download avatar url failed: status=${resp.status}`);
+    input = Buffer.from(await resp.arrayBuffer());
+  } else {
+    input = await readFile(source);
+  }
+
+  const jpeg = await sharp(input)
+    .resize(256, 256, { fit: "cover", position: "center" })
+    .flatten({ background: "#ffffff" })
+    .removeAlpha()
+    .jpeg({ quality: 95, progressive: false })
+    .toBuffer();
+
+  return {
+    buffer: jpeg,
+    contentType: "image/jpeg",
+    filename: "avatar.jpg",
+  };
+}
+
+async function uploadImage(token: string, source: string): Promise<string> {
+  const image = await loadAvatarSource(source);
+  const blob = new Blob([new Uint8Array(image.buffer)], { type: image.contentType });
+  const form = new FormData();
+  form.append("image_type", "avatar");
+  form.append("image", blob, image.filename);
+
+  // Group avatars need an im/v1 image_key uploaded with image_type=avatar.
+  const resp = await fetch(`${BASE_URL}/im/v1/images`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}` },
+    body: form,
+  });
+  const text = await resp.text();
+  let data: { code: number; msg?: string; data?: { image_key?: string } };
+  try { data = JSON.parse(text); } catch {
+    throw new Error(`uploadImage non-JSON response: ${text.slice(0, 200)}`);
+  }
+  if (data.code !== 0) throw new Error(`[${data.code}] ${data.msg}`);
+  return data.data!.image_key!;
+}
+
+async function getOrUploadAvatarKey(token: string, status: string): Promise<string> {
+  const cached = avatarKeyCache.get(status);
+  if (cached) return cached;
+  const key = await uploadImage(token, AVATAR_SOURCES[status]);
+  avatarKeyCache.set(status, key);
+  console.log(`[${ts()}] [AVATAR] Uploaded "${status}" → image_key=${key}`);
+  return key;
+}
+
+export async function setChatAvatar(token: string, chatId: string, status: string): Promise<void> {
+  try {
+    const avatarKey = await getOrUploadAvatarKey(token, status);
+    const resp = await fetch(`${BASE_URL}/im/v1/chats/${chatId}`, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ avatar: avatarKey }),
+    });
+    const text = await resp.text();
+    let data: { code: number; msg?: string };
+    try { data = JSON.parse(text); } catch {
+      if (resp.ok) return;
+      throw new Error(`setChatAvatar non-JSON response (status=${resp.status}): ${text.slice(0, 200)}`);
+    }
+    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}`);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Messaging
 // ---------------------------------------------------------------------------
@@ -334,19 +445,7 @@ export async function sendRestartCard(token: string): Promise<void> {
 
     console.log(`[${ts()}] [RESTART] Latest active chat: ${latestChatId} (mtime=${new Date(latestTime).toISOString()})`);
 
-    const restartCard = JSON.stringify({
-      config: { wide_screen_mode: true },
-      header: { template: "green", title: { content: "ChatCCC Started", tag: "plain_text" } },
-      elements: [
-        { tag: "div", text: { tag: "lark_md", content: "Bot 已启动完成，可以继续使用。\n\n发送 **/new** 创建新会话（默认 Claude Code）\n发送 **/new claude** 创建新 Claude 对话\n发送 **/new cursor** 创建新 Cursor 会话（启动需要多等几秒）" } },
-        buildButtons([
-          { text: "新建 Claude Code 会话（/new claude）", value: JSON.stringify({ cmd: "new" }), type: "primary" },
-          { text: "新建 Cursor 会话（/new cursor）", value: JSON.stringify({ cmd: "new cursor" }), type: "primary" },
-          { text: "重启Chat CCC（/restart）", value: JSON.stringify({ cmd: "restart" }), type: "danger" },
-          { text: "切换工作路径（/cd）", value: JSON.stringify({ cmd: "cd" }), type: "default" },
-        ]),
-      ],
-    });
+    const restartCard = buildHelpCard("", { greeting: "Bot 已启动完成，可以继续使用。" });
     await fetch(`${BASE_URL}/im/v1/messages?receive_id_type=chat_id`, {
       method: "POST",
       headers: {
@@ -388,4 +487,4 @@ export async function updateCardMessage(token: string, messageId: string, conten
     return false;
   }
   return true;
-}
+}

package/src/index.ts

@@ -1,16 +1,17 @@
 /**
- * ChatCCC — Feishu Bot Bridge for Claude Code (TypeScript)
+ * ChatCCC — Feishu Bot Bridge for AI Coding Tools (TypeScript)
  * =================================================================
- * When a user sends "/new" to the bot:
- *   1. Create a Claude session via Agent SDK, get session ID from init event
+ * Supported tools: Claude Code, Cursor, Codex (OpenAI).
+ *
+ * When a user sends "/new [tool]" to the bot:
+ *   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
- *   4. Stream SDK output to logs/session-<session-id>.jsonl
- *   5. Reply to the new group with session info and welcome message
+ *   4. Reply to the new group with session info and welcome message
  *
- * Auto-resume: when any message is received in a Claude session group
- * (group description contains "Claude Session:"), the bot extracts the
- * session ID, resumes the session via SDK, sends the user's text, and
+ * Auto-resume: when any message is received in a session group
+ * (group description contains a tool-specific prefix), the bot extracts the
+ * session ID, resumes the session, sends the user's text, and
  * streams the response to the session's jsonl file.
  *
  * Buttons: progress cards have a 停止 button; help messages have /new and /restart buttons.
@@ -23,7 +24,7 @@
 
 import { spawn } from "node:child_process";
 import { readdir, stat } from "node:fs/promises";
-import { resolve, dirname, basename } from "node:path";
+import { resolve, dirname } from "node:path";
 
 import { WSClient, EventDispatcher } from "@larksuiteoapi/node-sdk";
 import WebSocket from "ws";
@@ -65,6 +66,7 @@ import {
   recallMessage,
   sendCardReply,
   sendTextReply,
+  setChatAvatar,
   updateCardMessage,
   updateChatInfo,
   sendRestartCard,
@@ -87,6 +89,19 @@ import {
   getAdapterForTool,
 } from "./session.ts";
 
+export function cwdDisplayName(cwd: string): string {
+  const trimmed = cwd.trim().replace(/[\\/]+$/, "");
+  return trimmed.split(/[\\/]/).filter(Boolean).pop() || trimmed || "cwd";
+}
+
+export function sessionChatName(left: string, cwd: string): string {
+  return `${left}-${cwdDisplayName(cwd)}`;
+}
+
+function isUntitledSessionChatName(name: string): boolean {
+  return name === "新会话" || name.startsWith("新会话-");
+}
+
 // ---------------------------------------------------------------------------
 // Event types
 // ---------------------------------------------------------------------------
@@ -177,7 +192,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", restart: "/restart", status: "/status", cd: "/cd", sessions: "/sessions" };
+  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" };
   let text = CMD_MAP[cmd] ?? "";
   if (cmd === "cd" && typeof action.value === "object" && action.value !== null) {
     const path = (action.value as Record<string, string>).path;
@@ -317,10 +332,10 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
   if (text === "/new" || text.startsWith("/new ")) {
     const toolArg = text.slice(5).trim();
     const tool = toolArg || "claude";
-    const validTools = ["claude", "cursor"];
+    const validTools = ["claude", "cursor", "codex"];
     if (!validTools.includes(tool)) {
       const warnToken = await getTenantAccessToken();
-      await sendCardReply(warnToken, chatId, "Error", `未知的工具类型: "${toolArg}"。支持: claude (Claude Code), cursor (Cursor)。`, "red");
+      await sendCardReply(warnToken, chatId, "Error", `未知的工具类型: "${toolArg}"。支持: claude (Claude Code), cursor (Cursor), codex (Codex)。`, "red");
       return;
     }
     const toolLabel = toolDisplayName(tool);
@@ -335,8 +350,11 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
     const freshToken = await getTenantAccessToken();
 
     let sessionId: string;
+    let sessionCwd: string;
     try {
-      sessionId = await initClaudeSession(tool);
+      const init = await initClaudeSession(tool);
+      sessionId = init.sessionId;
+      sessionCwd = init.cwd;
       console.log(`[${ts()}] [STEP 1/4] ${toolLabel} session created: ${sessionId} → OK`);
     } catch (err) {
       console.error(`[${ts()}] [STEP 1/4] FAIL: ${(err as Error).message}`);
@@ -348,9 +366,12 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
       return;
     }
 
+    const cwd = sessionCwd;
+    const initialName = sessionChatName("新会话", cwd);
+
     let newChatId: string;
     try {
-      newChatId = await createGroupChat(freshToken, `新会话-${sessionId}`, [openId]);
+      newChatId = await createGroupChat(freshToken, initialName, [openId]);
       console.log(`[${ts()}] [STEP 2/4] Created Feishu group: ${newChatId}  → OK`);
     } catch (err) {
       console.error(`[${ts()}] [STEP 2/4] FAIL: ${(err as Error).message}`);
@@ -359,7 +380,6 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
     }
 
     try {
-      const initialName = `新会话-${sessionId}`;
       const descPrefix = sessionPrefixForTool(tool);
       await updateChatInfo(freshToken, newChatId, initialName, `${descPrefix} ${sessionId}`);
       console.log(`[${ts()}] [STEP 3/4] Renamed group → name="${initialName}" (${toolLabel}) → OK`);
@@ -369,7 +389,6 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
       return;
     }
 
-    const cwd = await getDefaultCwd();
     const adapter = getAdapterForTool(tool);
     await sendCardReply(
       freshToken, newChatId, `${toolLabel} Session Ready`,
@@ -383,6 +402,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(() => {});
     console.log(`${"=".repeat(60)}`);
     return;
   }
@@ -401,10 +421,13 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
 
       const freshToken = await getTenantAccessToken();
 
-      if (chatInfo.name === `新会话-${sessionId}`) {
-        const MAX_PREFIX = 20;
+      if (isUntitledSessionChatName(chatInfo.name)) {
+        const MAX_PREFIX = 10;
         const prefix = text.slice(0, MAX_PREFIX);
-        const newName = `${prefix} ${sessionId}`;
+        const adapter = getAdapterForTool(descriptionTool);
+        const info = await adapter.getSessionInfo(sessionId).catch(() => undefined);
+        const sessionCwd = info?.cwd ?? (await getDefaultCwd());
+        const newName = sessionChatName(prefix, sessionCwd);
         try {
           await updateChatInfo(freshToken, chatId, newName, description);
           console.log(`[${ts()}] [RENAME] First message → group renamed to "${newName}"`);
@@ -492,6 +515,61 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
         return;
       }
 
+      if (text === "/forget") {
+        const adapter = getAdapterForTool(descriptionTool);
+        let cwd: string;
+        try {
+          const info = await adapter.getSessionInfo(sessionId);
+          cwd = info?.cwd ?? (await getDefaultCwd());
+        } catch {
+          cwd = await getDefaultCwd();
+        }
+
+        const existing = chatSessionMap.get(chatId);
+        if (existing) {
+          existing.stopped = true;
+          if (existing.spinnerTimer) { clearInterval(existing.spinnerTimer); existing.spinnerTimer = null; }
+          existing.close();
+          chatSessionMap.delete(chatId);
+        }
+
+        let newSessionId: string;
+        try {
+          const init = await initClaudeSession(descriptionTool, cwd);
+          newSessionId = init.sessionId;
+        } catch (err) {
+          await sendCardReply(freshToken, chatId, "Error", `Failed to create new session:\n${(err as Error).message}`, "red");
+          return;
+        }
+
+        const descPrefix = sessionPrefixForTool(descriptionTool);
+        const initialName = sessionChatName("新会话", cwd);
+        await updateChatInfo(freshToken, chatId, initialName, `${descPrefix} ${newSessionId}`);
+        console.log(`[${ts()}] [FORGET] Group updated: name="${initialName}" desc="${descPrefix} ${newSessionId}"`);
+
+        sessionInfoMap.set(chatId, {
+          sessionId: newSessionId,
+          turnCount: 0,
+          lastContextTokens: 0,
+          startTime: Date.now(),
+          tool: descriptionTool,
+        });
+
+        setChatAvatar(freshToken, chatId, "new").catch(() => {});
+
+        await sendCardReply(
+          freshToken, chatId, `${toolLabel} Session Reset`,
+          `会话已重置为新的 **${toolLabel}** 会话。\n\n` +
+            `**Session ID:** ${newSessionId}\n` +
+            `**工作目录:** \`${cwd}\`\n\n` +
+            `直接在这里发消息即可继续对话。`,
+          "green"
+        );
+
+        console.log(`[${ts()}] [FORGET] Session ${sessionId} → ${newSessionId} (same cwd=${cwd})`);
+        return;
+      }
+
       // /git <args>：在「当前会话工作目录」执行 git 命令，把输出回发到群里。
       // 注意 cwd 必须取自 adapter.getSessionInfo（会话真实 cwd），而非
       // getDefaultCwd（下一次 /new 才会使用的默认路径）。
@@ -873,4 +951,4 @@ main().catch((err: Error) => {
   if (err.stack) console.error(err.stack);
   printServiceDidNotStart(`main() 异常: ${err.message}`);
   process.exit(1);
-});
+});

package/src/session.ts

@@ -19,11 +19,12 @@ import {
   sendCardKitMessage,
   updateCardKitCard,
 } from "./cardkit.ts";
-import { sendTextReply } from "./feishu-api.ts";
+import { sendTextReply, setChatAvatar } from "./feishu-api.ts";
 import type { UnifiedBlock } from "./adapters/adapter-interface.ts";
 import type { ToolAdapter } from "./adapters/adapter-interface.ts";
 import { createClaudeAdapter } from "./adapters/claude-adapter.ts";
 import { createCursorAdapter } from "./adapters/cursor-adapter.ts";
+import { createCodexAdapter } from "./adapters/codex-adapter.ts";
 
 // ---------------------------------------------------------------------------
 // Shared state (imported by index.ts)
@@ -91,6 +92,8 @@ export function getAdapterForTool(tool: string): ToolAdapter {
   let adapter: ToolAdapter;
   if (tool === "cursor") {
     adapter = createCursorAdapter();
+  } else if (tool === "codex") {
+    adapter = createCodexAdapter();
   } else {
     adapter = createClaudeAdapter({
       model: CLAUDE_MODEL,
@@ -255,11 +258,20 @@ function formatToolConfigForLog(tool: string, sessionModel?: string): string {
   if (tool === "cursor") {
     return `model=${sessionModel ?? "(由 cursor-agent 决定，init 事件后学习)"}`;
   }
+  if (tool === "codex") {
+    const m = process.env.CHATCCC_CODEX_MODEL?.trim();
+    const e = process.env.CHATCCC_CODEX_EFFORT?.trim();
+    const modelStr = m && m !== "default" ? m : "(由 codex config.toml 决定)";
+    const effortStr = e && e !== "default"
+      ? `effort=${e}`
+      : "effort=(由 codex config.toml 决定)";
+    return `model=${modelStr}, ${effortStr}`;
+  }
   return `model=${anthropicConfigDisplay(CLAUDE_MODEL)}, effort=${anthropicConfigDisplay(CLAUDE_EFFORT)}`;
 }
 
-export async function initClaudeSession(tool: string): Promise<string> {
-  const cwd = await getDefaultCwd();
+export async function initClaudeSession(tool: string, overrideCwd?: string): Promise<{ sessionId: string; cwd: string }> {
+  const cwd = overrideCwd ?? (await getDefaultCwd());
   const adapter = getAdapterForTool(tool);
   console.log(
     `[${ts()}] [STEP 1/5] Creating ${adapter.displayName} session (${formatToolConfigForLog(tool)}, cwd=${cwd})`
@@ -273,7 +285,7 @@ export async function initClaudeSession(tool: string): Promise<string> {
 
   await addRecentDir(cwd);
 
-  return sessionId;
+  return { sessionId, cwd };
 }
 
 export async function resumeAndPrompt(
@@ -307,6 +319,8 @@ export async function resumeAndPrompt(
   });
   const myGen = sessionGen;
 
+  setChatAvatar(token, chatId, "busy").catch(() => {});
+
   const now = Date.now();
   const existingInfo = sessionInfoMap.get(chatId);
   sessionInfoMap.set(chatId, {
@@ -437,6 +451,7 @@ export async function resumeAndPrompt(
   if (!cEntry || cEntry.gen !== myGen) return;
   const wasStopped = cEntry.stopped;
   chatSessionMap.delete(chatId);
+  setChatAvatar(token, chatId, "idle").catch(() => {});
 
   const finalCardContent = state.accumulatedContent || " ";
   if (cardId) {
@@ -547,6 +562,14 @@ async function resolveModelEffort(
     }
     return { model, effort: null };
   }
+  if (tool === "codex") {
+    const m = process.env.CHATCCC_CODEX_MODEL?.trim();
+    const e = process.env.CHATCCC_CODEX_EFFORT?.trim();
+    return {
+      model: m && m !== "default" ? m : UNKNOWN_MODEL_PLACEHOLDER,
+      effort: e && e !== "default" ? e : UNKNOWN_MODEL_PLACEHOLDER,
+    };
+  }
   return {
     model: anthropicConfigDisplay(CLAUDE_MODEL),
     effort: anthropicConfigDisplay(CLAUDE_EFFORT),
@@ -618,4 +641,4 @@ export function _setAdapterForToolForTest(tool: string, adapter: ToolAdapter): v
 
 export function _clearAdapterCacheForTest(): void {
   adapterCache.clear();
-}
+}