chatccc 0.2.252 → 0.2.254

package/src/trace.ts

@@ -1,51 +0,0 @@
-/**
- * 轻量级消息全链路 trace 工具。
- *
- * 每条消息生成唯一 traceId，在关键决策点、API 调用、消息发送时输出结构化日志。
- * grep traceId 即可看到该消息的完整 RECV → BRANCH → SEND → DONE 链路。
- *
- * 设计原则：trace 自身绝不能抛异常导致主流程中断——所有函数内都有 try/catch 兜底。
- */
-
-let _traceSeq = 0;
-
-/** 基于时间戳 + 递增序号生成短 trace ID（约 10 字符） */
-export function makeTraceId(): string {
-  try {
-    _traceSeq++;
-    const ts = Date.now().toString(36).slice(-6);
-    const seq = _traceSeq.toString(36).padStart(3, "0");
-    return `${ts}${seq}`;
-  } catch {
-    // 极端情况（计数器溢出等）降级为纯时间戳
-    return Date.now().toString(36);
-  }
-}
-
-/**
- * 输出一条 trace 日志。
- * detail 中的值做浅层截断（字符串 > 200 字符会截断），避免日志膨胀。
- */
-export function logTrace(traceId: string, step: string, detail?: Record<string, unknown>): void {
-  try {
-    const safe: Record<string, unknown> = {};
-    if (detail) {
-      for (const [k, v] of Object.entries(detail)) {
-        if (typeof v === "string" && v.length > 200) {
-          safe[k] = v.slice(0, 200) + "...(truncated)";
-        } else {
-          safe[k] = v;
-        }
-      }
-    }
-    const extra = Object.keys(safe).length > 0 ? " " + JSON.stringify(safe) : "";
-    console.log(`[TRACE ${traceId}] ${step}${extra}`);
-  } catch {
-    // trace 自身绝不能抛异常
-  }
-}
-
-/** 重置序号（仅单测使用，确保 trace ID 可预测） */
-export function _resetTraceSeqForTest(): void {
-  _traceSeq = 0;
-}

package/src/turn-cards.ts

@@ -1,118 +0,0 @@
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
-import { USER_DATA_DIR, ts } from "./config.ts";
-
-// ---------------------------------------------------------------------------
-// turn-cards.json — 每个 session 的卡片归属持久化
-// 记录每个 turn 有哪些卡片（轮转会产生多张），以及每张卡片的状态
-// ---------------------------------------------------------------------------
-
-export const TURNS_DIR = join(USER_DATA_DIR, "state", "turns");
-
-export interface TurnCardEntry {
-  cardId: string;
-  status: "active" | "done" | "stopped";
-  createdAt: number;
-}
-
-export interface TurnCardsFile {
-  sessionId: string;
-  turns: { turnCount: number; cards: TurnCardEntry[] }[];
-}
-
-function getTurnCardsPath(sessionId: string): string {
-  return join(TURNS_DIR, `${sessionId}.json`);
-}
-
-export function createEmptyTurnCards(sessionId: string): TurnCardsFile {
-  return { sessionId, turns: [] };
-}
-
-export async function readTurnCards(sessionId: string): Promise<TurnCardsFile | null> {
-  try {
-    const raw = await readFile(getTurnCardsPath(sessionId), "utf-8");
-    const parsed = JSON.parse(raw) as TurnCardsFile;
-    if (parsed && typeof parsed.sessionId === "string" && Array.isArray(parsed.turns)) {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-export async function writeTurnCards(sessionId: string, data: TurnCardsFile): Promise<void> {
-  try {
-    const filePath = getTurnCardsPath(sessionId);
-    await mkdir(dirname(filePath), { recursive: true });
-    await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
-  } catch (err) {
-    console.error(`[${ts()}] Failed to write turn-cards for ${sessionId}: ${(err as Error).message}`);
-  }
-}
-
-/** 向指定 turn 追加一张卡片并持久化。若 turn 不存在则创建。 */
-export async function addCardToTurn(
-  sessionId: string,
-  turnCount: number,
-  cardId: string,
-): Promise<void> {
-  const data = (await readTurnCards(sessionId)) ?? createEmptyTurnCards(sessionId);
-  let turn = data.turns.find(t => t.turnCount === turnCount);
-  if (!turn) {
-    turn = { turnCount, cards: [] };
-    data.turns.push(turn);
-  }
-  turn.cards.push({ cardId, status: "active", createdAt: Date.now() });
-  await writeTurnCards(sessionId, data);
-}
-
-/** 将指定 turn 的所有 active 卡片标记为终态并持久化。返回被标记的 cardId 列表。 */
-export async function finalizeTurnCards(
-  sessionId: string,
-  turnCount: number,
-  finalStatus: "done" | "stopped",
-): Promise<string[]> {
-  const data = await readTurnCards(sessionId);
-  if (!data) return [];
-  const turn = data.turns.find(t => t.turnCount === turnCount);
-  if (!turn) return [];
-  const finalized: string[] = [];
-  for (const card of turn.cards) {
-    if (card.status === "active") {
-      card.status = finalStatus;
-      finalized.push(card.cardId);
-    }
-  }
-  if (finalized.length > 0) {
-    await writeTurnCards(sessionId, data);
-  }
-  return finalized;
-}
-
-/** 将指定 turn 中的一张 active 卡片标记为 done（轮转时用），并持久化。 */
-export async function markCardDone(
-  sessionId: string,
-  turnCount: number,
-  cardId: string,
-): Promise<void> {
-  const data = await readTurnCards(sessionId);
-  if (!data) return;
-  const turn = data.turns.find(t => t.turnCount === turnCount);
-  if (!turn) return;
-  const card = turn.cards.find(c => c.cardId === cardId && c.status === "active");
-  if (!card) return;
-  card.status = "done";
-  await writeTurnCards(sessionId, data);
-}
-
-/** 清理 session 的 turn-cards 文件 */
-export async function removeTurnCards(sessionId: string): Promise<void> {
-  try {
-    const { unlink } = await import("node:fs/promises");
-    await unlink(getTurnCardsPath(sessionId));
-  } catch {
-    // 文件不存在，忽略
-  }
-}

package/src/update-command-guard.ts

@@ -1,165 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-export const UPDATE_COMMAND_GUARD_FILE = join(
-  homedir(),
-  ".chatccc",
-  "state",
-  "update-command-guard.json",
-);
-
-const UPDATE_COMMAND_GUARD_VERSION = 1;
-const DEFAULT_MAX_PROCESSED_IDS = 100;
-
-interface ProcessedUpdateCommand {
-  id: string;
-  recordedAt: number;
-}
-
-interface UpdateCommandGuardState {
-  version: 1;
-  processed: ProcessedUpdateCommand[];
-}
-
-export type UpdateCommandGuardResult =
-  | { allowed: true; reason: "accepted" | "missing_id" }
-  | { allowed: false; reason: "duplicate_id" | "state_write_failed" };
-
-export interface AcquireUpdateCommandGuardOptions {
-  filePath?: string;
-  commandId?: string;
-  now?: number;
-  maxEntries?: number;
-  warn?: (message: string) => void;
-}
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-  return typeof value === "object" && value !== null
-    ? value as Record<string, unknown>
-    : undefined;
-}
-
-/** 从飞书事件信封中读取重投时保持不变的 event_id。 */
-export function extractFeishuEventId(data: unknown): string | undefined {
-  const envelope = asRecord(data);
-  const event = asRecord(envelope?.event);
-  const header = asRecord(envelope?.header) ?? asRecord(event?.header);
-  const context = asRecord(event?.context);
-  const candidates = [header?.event_id, envelope?.event_id, event?.event_id, context?.event_id];
-  for (const candidate of candidates) {
-    if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
-  }
-  return undefined;
-}
-
-/** 分隔文字消息和卡片回调 ID 的命名空间。 */
-export function buildUpdateCommandId(
-  source: "message" | "card",
-  id: string | undefined,
-): string | undefined {
-  const normalized = id?.trim();
-  return normalized ? `${source}:${normalized}` : undefined;
-}
-
-function emptyState(): UpdateCommandGuardState {
-  return { version: UPDATE_COMMAND_GUARD_VERSION, processed: [] };
-}
-
-function parseState(raw: string, maxEntries: number): UpdateCommandGuardState {
-  const parsed = JSON.parse(raw) as Partial<UpdateCommandGuardState>;
-  if (parsed.version !== UPDATE_COMMAND_GUARD_VERSION || !Array.isArray(parsed.processed)) {
-    throw new Error("invalid update command guard schema");
-  }
-
-  const processed = parsed.processed.map((entry) => {
-    if (
-      typeof entry !== "object"
-      || entry === null
-      || typeof entry.id !== "string"
-      || entry.id.length === 0
-      || typeof entry.recordedAt !== "number"
-      || !Number.isFinite(entry.recordedAt)
-      || entry.recordedAt < 0
-    ) {
-      throw new Error("invalid processed update command entry");
-    }
-    return { id: entry.id, recordedAt: entry.recordedAt };
-  });
-
-  return {
-    version: UPDATE_COMMAND_GUARD_VERSION,
-    processed: processed.slice(-maxEntries),
-  };
-}
-
-function loadState(
-  filePath: string,
-  maxEntries: number,
-  warn: (message: string) => void,
-): UpdateCommandGuardState {
-  if (!existsSync(filePath)) return emptyState();
-  try {
-    return parseState(readFileSync(filePath, "utf8"), maxEntries);
-  } catch (err) {
-    warn(`[UPDATE-GUARD] 状态文件损坏，将重建 ${filePath}: ${(err as Error).message}`);
-    return emptyState();
-  }
-}
-
-/**
- * 原子写入更新命令 ID。写失败时调用方必须拒绝更新：只有先落盘，
- * 新进程才能识别飞书在旧进程退出后重投的同一条 `/update`。
- */
-function persistState(filePath: string, state: UpdateCommandGuardState): void {
-  mkdirSync(dirname(filePath), { recursive: true });
-  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  try {
-    writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
-    renameSync(tempPath, filePath);
-  } catch (err) {
-    try { rmSync(tempPath, { force: true }); } catch {}
-    throw err;
-  }
-}
-
-/**
- * 获取 `/update` 执行资格。只比较稳定消息/事件 ID，因此用户主动发送的
- * 不同 `/update` 消息仍可立即执行。
- */
-export function acquireUpdateCommandGuard(
-  options: AcquireUpdateCommandGuardOptions = {},
-): UpdateCommandGuardResult {
-  const filePath = options.filePath ?? UPDATE_COMMAND_GUARD_FILE;
-  const commandId = options.commandId?.trim() || undefined;
-  const now = options.now ?? Date.now();
-  const maxEntries = Number.isInteger(options.maxEntries) && (options.maxEntries ?? 0) > 0
-    ? options.maxEntries!
-    : DEFAULT_MAX_PROCESSED_IDS;
-  const warn = options.warn ?? ((message: string) => console.warn(message));
-
-  // 模拟注入等没有稳定事件 ID 的入口无法做跨重启判断，保持原有行为。
-  if (!commandId) return { allowed: true, reason: "missing_id" };
-
-  const state = loadState(filePath, maxEntries, warn);
-  if (state.processed.some((entry) => entry.id === commandId)) {
-    return { allowed: false, reason: "duplicate_id" };
-  }
-
-  state.processed.push({ id: commandId, recordedAt: now });
-  state.processed = state.processed.slice(-maxEntries);
-  try {
-    persistState(filePath, state);
-  } catch (err) {
-    warn(`[UPDATE-GUARD] 无法写入状态文件 ${filePath}: ${(err as Error).message}`);
-    return { allowed: false, reason: "state_write_failed" };
-  }
-  return { allowed: true, reason: "accepted" };
-}