chatccc 0.2.214 → 0.2.216

package/src/cards.ts

@@ -553,8 +553,12 @@ export function buildModelCard(
     lines.push("", "没有可切换的模型。请在 config.json 中配置模型字段。");
   }
 
-  const buttons: ButtonDef[] = [];
-  for (const m of models.slice(0, 20)) {
+  if (tool === "codex") {
+    lines.push("输入 `/fast` 查看或切换当前会话的 Fast 模式");
+  }
+
+  const buttons: ButtonDef[] = [];
+  for (const m of models.slice(0, 20)) {
     const shortName = m.includes("/") ? m.slice(m.lastIndexOf("/") + 1) : m;
     buttons.push({
       text: `/model ${shortName}`,
@@ -574,6 +578,43 @@ export function buildModelCard(
   });
 }
 
+export function buildFastModeCard(enabled: boolean): string {
+  const mode = enabled ? "ON (Fast)" : "OFF (Standard)";
+  return JSON.stringify({
+    config: { wide_screen_mode: true },
+    header: {
+      template: enabled ? "green" : "blue",
+      title: { content: "Codex Fast 模式", tag: "plain_text" },
+    },
+    elements: [
+      {
+        tag: "div",
+        text: {
+          tag: "lark_md",
+          content: [
+            `**当前模式:** ${mode}`,
+            "",
+            "切换将在下一条消息生效，当前生成不中断。",
+          ].join("\n"),
+        },
+      },
+      { tag: "hr" },
+      buildButtons([
+        {
+          text: "ON",
+          value: JSON.stringify({ cmd: "/fast on" }),
+          type: enabled ? "primary" : "default",
+        },
+        {
+          text: "OFF",
+          value: JSON.stringify({ cmd: "/fast off" }),
+          type: enabled ? "default" : "primary",
+        },
+      ]),
+    ],
+  });
+}
+
 export function buildEffortCard(
   currentEffort: string,
   efforts: string[],

package/src/config.ts

@@ -97,8 +97,10 @@ export interface CodexConfig {
   path: string;
   model: string;
   /** /model 可切换的单个备选模型；留空则不加入候选列表 */
-  alternativeModel: string;
+  alternativeModel: string;
   effort: string;
+  /** Codex Priority service tier. False explicitly forces the standard tier. */
+  fastMode: boolean;
 }
 
 export interface CccConfig {
@@ -442,7 +444,7 @@ function loadConfig(): AppConfig {
       avatarBatteryMode: "apiPercent",
       onDemandMonthlyBudget: 1000,
     },
-    codex: { enabled: false, defaultAgent: false, path: "", model: "", alternativeModel: "", effort: "" },
+    codex: { enabled: false, defaultAgent: false, path: "", model: "", alternativeModel: "", effort: "", fastMode: false },
     ccc: { DEEPSEEK_API_KEY: "", DEEPSEEK_BASE_URL: DEFAULT_CCC_DEEPSEEK_BASE_URL, model: DEFAULT_CCC_MODEL },
   };
 
@@ -495,7 +497,7 @@ function loadConfig(): AppConfig {
       avatarBatteryMode?: unknown;
       onDemandMonthlyBudget?: unknown;
     };
-    codex?: { enabled?: unknown; defaultAgent?: unknown; path?: unknown; command?: unknown; model?: unknown; alternativeModel?: unknown; effort?: unknown };
+    codex?: { enabled?: unknown; defaultAgent?: unknown; path?: unknown; command?: unknown; model?: unknown; alternativeModel?: unknown; effort?: unknown; fastMode?: unknown };
     ccc?: { DEEPSEEK_API_KEY?: unknown; DEEPSEEK_BASE_URL?: unknown; model?: unknown };
     webUi?: { openOnStart?: unknown };
     chromeDevtools?: { enabled?: unknown; port?: unknown; chromePath?: unknown };
@@ -555,9 +557,10 @@ function loadConfig(): AppConfig {
     Boolean(
       (typeof codexRaw.path === "string" && codexRaw.path.trim()) ||
       (typeof codexRaw.command === "string" && (codexRaw.command as string).trim()) ||
-      (typeof codexRaw.model === "string" && (codexRaw.model as string).trim()) ||
-      (typeof codexRaw.alternativeModel === "string" && (codexRaw.alternativeModel as string).trim()) ||
-      (typeof codexRaw.effort === "string" && (codexRaw.effort as string).trim()),
+      (typeof codexRaw.model === "string" && (codexRaw.model as string).trim()) ||
+      (typeof codexRaw.alternativeModel === "string" && (codexRaw.alternativeModel as string).trim()) ||
+      (typeof codexRaw.effort === "string" && (codexRaw.effort as string).trim()) ||
+      codexRaw.fastMode === true,
     );
 
   const claudeEnabled = resolveEnabled(claude.enabled, claudeNonEmpty);
@@ -649,6 +652,7 @@ function loadConfig(): AppConfig {
       model: normalizeOptionalConfigField(codexRaw.model, { label: "codex.model" }),
       alternativeModel: normalizeOptionalConfigField(codexRaw.alternativeModel, { label: "codex.alternativeModel" }),
       effort: normalizeOptionalConfigField(codexRaw.effort, { label: "codex.effort" }),
+      fastMode: codexRaw.fastMode === true,
     },
     ccc: {
       DEEPSEEK_API_KEY: normalizeOptionalConfigField(cccRaw.DEEPSEEK_API_KEY, { label: "ccc.DEEPSEEK_API_KEY" }),

package/src/feishu-api.ts

@@ -1023,7 +1023,7 @@ export function formatDelayNotice(createTimeMs: number, messageText?: string, no
   }
 
   const contentLine = messageText ? `\n> 原始内容：${messageText.slice(0, 200)}` : "";
-  return `> ⚠️ 延迟送达提醒：此消息于 ${sendTimeStr} 发送，因服务离线，延迟约 ${delayStr}后送达${contentLine}`;
+  return `> ⚠️ 延迟送达提醒：此消息于 ${sendTimeStr} 发送，现延迟约 ${delayStr}后送达${contentLine}`;
 }
 
 /**

package/src/feishu-message-ingress.ts

@@ -0,0 +1,195 @@
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+
+export const MAX_PROCESSED = 5000;
+
+export type FeishuMessageDisposition = "accepted" | "duplicate" | "stale";
+
+export interface FeishuMessageIdentity {
+  messageId?: string;
+  chatId: string;
+  createTime: number;
+}
+
+interface PersistedMessageEntry {
+  messageId: string;
+  chatId: string;
+  createTime: number;
+}
+
+interface PersistedMessageLedger {
+  version: 1;
+  entries: PersistedMessageEntry[];
+}
+
+type ScheduleTask = (task: () => void) => void;
+
+const defaultSchedule: ScheduleTask = (task) => {
+  setImmediate(task);
+};
+
+/**
+ * The Feishu SDK waits for an event handler's return value before sending its
+ * WebSocket response. Schedule the real work for the next event-loop turn so
+ * the SDK callback can return and acknowledge the event immediately.
+ */
+export function createAckFirstEventHandler<T>(
+  worker: (data: T) => Promise<void>,
+  onError: (error: unknown) => void,
+  schedule: ScheduleTask = defaultSchedule,
+): (data: T) => Promise<void> {
+  return async (data) => {
+    schedule(() => {
+      void worker(data).catch(onError);
+    });
+  };
+}
+
+function isPersistedEntry(value: unknown): value is PersistedMessageEntry {
+  if (!value || typeof value !== "object") return false;
+  const entry = value as Record<string, unknown>;
+  return typeof entry.messageId === "string"
+    && entry.messageId.length > 0
+    && typeof entry.chatId === "string"
+    && typeof entry.createTime === "number"
+    && Number.isFinite(entry.createTime);
+}
+
+export class FeishuMessageLedger {
+  private readonly messageIds: Set<string>;
+  private entries: PersistedMessageEntry[] = [];
+  private latestCreateTimeByChat = new Map<string, number>();
+  private persistTail: Promise<void> = Promise.resolve();
+
+  constructor(
+    public readonly filePath: string,
+    private readonly maxEntries = MAX_PROCESSED,
+    messageIds?: Set<string>,
+  ) {
+    this.messageIds = messageIds ?? new Set<string>();
+  }
+
+  async load(): Promise<void> {
+    this.clearMemory();
+
+    try {
+      const raw = await readFile(this.filePath, "utf-8");
+      const parsed = JSON.parse(raw) as Partial<PersistedMessageLedger>;
+      const entries = Array.isArray(parsed.entries)
+        ? parsed.entries.filter(isPersistedEntry)
+        : [];
+      this.entries = entries.slice(-this.maxEntries);
+      this.rebuildIndexes();
+
+      if (entries.length > this.maxEntries) {
+        await this.persist();
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+        console.error(
+          `[FEISHU-DEDUP] Failed to load ${this.filePath}: ${(error as Error).message}`,
+        );
+      }
+    }
+  }
+
+  async accept(identity: FeishuMessageIdentity): Promise<FeishuMessageDisposition> {
+    const { messageId, chatId, createTime } = identity;
+
+    if (messageId && this.messageIds.has(messageId)) {
+      return "duplicate";
+    }
+
+    const latestCreateTime = this.latestCreateTimeByChat.get(chatId);
+    if (latestCreateTime !== undefined && createTime < latestCreateTime) {
+      return "stale";
+    }
+
+    if (!messageId) {
+      this.recordLatestCreateTime(chatId, createTime);
+      return "accepted";
+    }
+
+    this.entries.push({ messageId, chatId, createTime });
+    this.messageIds.add(messageId);
+    this.recordLatestCreateTime(chatId, createTime);
+
+    if (this.entries.length > this.maxEntries) {
+      this.entries = this.entries.slice(-this.maxEntries);
+      this.rebuildIndexes();
+    }
+
+    try {
+      await this.persist();
+    } catch (error) {
+      console.error(
+        `[FEISHU-DEDUP] Failed to persist ${this.filePath}: ${(error as Error).message}`,
+      );
+    }
+    return "accepted";
+  }
+
+  clearMemory(): void {
+    this.entries = [];
+    this.messageIds.clear();
+    this.latestCreateTimeByChat.clear();
+    this.persistTail = Promise.resolve();
+  }
+
+  private recordLatestCreateTime(chatId: string, createTime: number): void {
+    const current = this.latestCreateTimeByChat.get(chatId);
+    if (current === undefined || createTime > current) {
+      this.latestCreateTimeByChat.set(chatId, createTime);
+    }
+  }
+
+  private rebuildIndexes(): void {
+    this.messageIds.clear();
+    this.latestCreateTimeByChat.clear();
+    for (const entry of this.entries) {
+      this.messageIds.add(entry.messageId);
+      this.recordLatestCreateTime(entry.chatId, entry.createTime);
+    }
+  }
+
+  private persist(): Promise<void> {
+    const snapshot: PersistedMessageLedger = {
+      version: 1,
+      entries: this.entries.map((entry) => ({ ...entry })),
+    };
+
+    const nextPersist = this.persistTail
+      .catch(() => {})
+      .then(async () => {
+        await mkdir(dirname(this.filePath), { recursive: true });
+        const tempPath = `${this.filePath}.${process.pid}.tmp`;
+        try {
+          await writeFile(tempPath, JSON.stringify(snapshot), "utf-8");
+          await rename(tempPath, this.filePath);
+        } finally {
+          await rm(tempPath, { force: true }).catch(() => {});
+        }
+      });
+    this.persistTail = nextPersist;
+    return nextPersist;
+  }
+}
+
+const defaultLedgerPath = join(
+  homedir(),
+  ".chatccc",
+  "state",
+  "feishu-message-ledger.json",
+);
+
+export const processedMessages = new Set<string>();
+export const feishuMessageLedger = new FeishuMessageLedger(
+  defaultLedgerPath,
+  MAX_PROCESSED,
+  processedMessages,
+);
+
+export function clearFeishuMessageLedgerMemory(): void {
+  feishuMessageLedger.clearMemory();
+}

package/src/index.ts

@@ -96,11 +96,9 @@ import {
   sendCardKitMessage,
   updateCardKitCard,
 } from "./cardkit.ts";
-import {
-  MAX_PROCESSED,
-  loadSessionRegistryForBinding,
-  processedMessages,
-  rebuildBindingsFromRegistry,
+import {
+  loadSessionRegistryForBinding,
+  rebuildBindingsFromRegistry,
   resetState,
   setSessionPlatform,
   startUnifiedDisplayLoop,
@@ -115,7 +113,11 @@ import { handleCommand, type PlatformAdapter } from "./orchestrator.ts";
 import { createWechatAdapter, startWechatPlatform } from "./wechat-platform.ts";
 import { handleCodexResetCardAction } from "./codex-reset-actions.ts";
 import { resolveFeishuCardActionChatType } from "./card-action-routing.ts";
-import { reloadRuntimeConfig } from "./runtime-reload.ts";
+import { reloadRuntimeConfig } from "./runtime-reload.ts";
+import {
+  createAckFirstEventHandler,
+  feishuMessageLedger,
+} from "./feishu-message-ingress.ts";
 
 // ---------------------------------------------------------------------------
 // Feishu 平台适配器
@@ -262,12 +264,105 @@ function parseCardAction(data: unknown): CardActionResult | null {
 // WebSocket relay broadcast
 // ---------------------------------------------------------------------------
 
-let broadcastToRelay: (data: unknown) => void = () => {};
-const wechatSignal = { stopped: false };
-
-// ---------------------------------------------------------------------------
-// Simulate mode: inject message via HTTP
-// ---------------------------------------------------------------------------
+let broadcastToRelay: (data: unknown) => void = () => {};
+const wechatSignal = { stopped: false };
+
+async function processFeishuMessageEvent(data: Evt): Promise<void> {
+  const traceId = makeTraceId();
+  try {
+    broadcastToRelay(data);
+
+    const event = getInnerEvent(data);
+    const message = event.message;
+    if (!message) return;
+
+    const messageId = message.message_id;
+    const chatId = message.chat_id ?? "";
+    const chatType = message.chat_type ?? "group";
+    const msgTimestamp = parseInt(message.create_time ?? "0", 10) || Date.now();
+    const disposition = await feishuMessageLedger.accept({
+      messageId,
+      chatId,
+      createTime: msgTimestamp,
+    });
+
+    if (disposition === "duplicate") {
+      console.log(`[MSG] Duplicate message ignored: ${messageId ?? "(missing id)"}`);
+      return;
+    }
+    if (disposition === "stale") {
+      logTrace(traceId, "DONE", {
+        outcome: "skip_stale_feishu_message",
+        messageId,
+        chatId,
+        msgTimestamp,
+      });
+      console.log(
+        `[${ts()}] [SKIP] Stale Feishu message ignored: messageId=${messageId ?? "(missing id)"} chatId=${chatId} createTime=${msgTimestamp}`,
+      );
+      return;
+    }
+
+    const text = await formatMessageContent(message);
+    const openId = event.sender?.sender_id?.open_id ?? "";
+
+    console.log(
+      `[MSG] id=${messageId ?? "(missing)"} sender=${openId} chat=${chatId} type=${chatType} text="${text}"`,
+    );
+    appendChatLog(chatId, openId, text);
+
+    if (messageId) {
+      getTenantAccessToken().then((freshToken) =>
+        addReaction(freshToken, messageId).catch((err) =>
+          console.error(`[${ts()}] Reaction failed: ${(err as Error).message}`)
+        )
+      ).catch((err) =>
+        console.error(`[${ts()}] Reaction token failed: ${(err as Error).message}`)
+      );
+    }
+
+    if (!text) return;
+    logTrace(traceId, "RECV", {
+      messageId,
+      chatId,
+      chatType,
+      text: text.slice(0, 100),
+    });
+
+    const delayNotice = formatDelayNotice(msgTimestamp, text);
+    if (delayNotice) {
+      const delayToken = await getTenantAccessToken();
+      await sendCardReply(delayToken, chatId, "延迟送达", delayNotice, "yellow").catch(() => {});
+    }
+
+    await handleCommand(
+      feishuPlatform,
+      text,
+      chatId,
+      openId,
+      msgTimestamp,
+      chatType,
+      traceId,
+      buildUpdateCommandId("message", messageId),
+    );
+  } catch (err) {
+    logTrace(traceId, "ERROR", { message: (err as Error).message });
+    console.error(
+      `[${ts()}] [FATAL] im.message.receive_v1 worker crashed: ${(err as Error).message}`,
+    );
+  }
+}
+
+const handleFeishuMessageEventAckFirst = createAckFirstEventHandler(
+  processFeishuMessageEvent,
+  (err) => console.error(
+    `[${ts()}] [FATAL] Detached Feishu event worker failed: ${(err as Error).message}`,
+  ),
+);
+
+// ---------------------------------------------------------------------------
+// Simulate mode: inject message via HTTP
+// ---------------------------------------------------------------------------
 
 async function handleSimInjectMessage(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
   const url = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -399,74 +494,9 @@ async function startBotServiceCore(): Promise<void> {
 
   console.log(`[${ts()}] [AUTH] Token obtained`);
 
-  const eventDispatcher = new EventDispatcher({});
-  eventDispatcher.register({
-    "im.message.receive_v1": async (data: Evt) => {
-      const traceId = makeTraceId();
-      try {
-      broadcastToRelay(data);
-
-      const event = getInnerEvent(data);
-      const message = event.message;
-      if (!message) return;
-
-      const messageId = message.message_id;
-      if (messageId) {
-        if (processedMessages.has(messageId)) {
-          console.log(`[MSG] Duplicate message ignored: ${messageId}`);
-          return;
-        }
-        processedMessages.add(messageId);
-        if (processedMessages.size > MAX_PROCESSED) {
-          const it = processedMessages.values();
-          for (let i = 0; i < 1000; i++) processedMessages.delete(it.next().value as string);
-        }
-      }
-
-      const text = await formatMessageContent(message);
-      const sender = event.sender;
-      const openId = sender?.sender_id?.open_id ?? "";
-      const chatId = message.chat_id ?? "";
-      const chatType = message.chat_type ?? "group";
-
-      console.log(`[MSG] sender=${openId} chat=${chatId} type=${chatType} text="${text}"`);
-      appendChatLog(chatId, openId, text);
-
-      if (messageId) {
-        getTenantAccessToken().then((freshToken) =>
-          addReaction(freshToken, messageId).catch((err) =>
-            console.error(`[${ts()}] Reaction failed: ${(err as Error).message}`)
-          )
-        ).catch((err) =>
-          console.error(`[${ts()}] Reaction token failed: ${(err as Error).message}`)
-        );
-      }
-
-      if (!text) return;
-      const msgTimestamp = parseInt(message.create_time ?? "0", 10) || Date.now();
-      logTrace(traceId, "RECV", { chatId, chatType, text: text.slice(0, 100) });
-      const delayNotice = formatDelayNotice(msgTimestamp, text);
-      if (delayNotice) {
-        const delayToken = await getTenantAccessToken();
-        await sendCardReply(delayToken, chatId, "延迟送达", delayNotice, "yellow").catch(() => {});
-      }
-      // 仅 `/update` 会使用这个稳定 ID 做跨重启幂等；其他命令仍沿用
-      // processedMessages 的进程内去重。
-      await handleCommand(
-        feishuPlatform,
-        text,
-        chatId,
-        openId,
-        msgTimestamp,
-        chatType,
-        traceId,
-        buildUpdateCommandId("message", messageId),
-      );
-      } catch (err) {
-        logTrace(traceId, "ERROR", { message: (err as Error).message });
-        console.error(`[${ts()}] [FATAL] im.message.receive_v1 handler crashed: ${(err as Error).message}`);
-      }
-    },
+  const eventDispatcher = new EventDispatcher({});
+  eventDispatcher.register({
+    "im.message.receive_v1": handleFeishuMessageEventAckFirst,
 
     "card.action.trigger": async (data: Evt) => {
       try {
@@ -593,7 +623,8 @@ async function startBotServiceCore(): Promise<void> {
   } else {
     // 进程首次启动:此时所有 Map 都是空的,resetState 主要是打个 LOG 标识"开始
     // 干净状态"。修正残留的 running stream-state 并重建 session→chat 映射。
-    resetState();
+    resetState();
+    await feishuMessageLedger.load();
     startUnifiedDisplayLoop();
     fixStaleStreamStates().then(async () => {
       const registry = await loadSessionRegistryForBinding();