chatccc 0.2.252 → 0.2.254

package/dist/src/stream-state.js

@@ -0,0 +1,141 @@
+import { readFile, writeFile, mkdir, rename, unlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { USER_DATA_DIR, ts } from "./config.js";
+import { createAgentActivityTracker } from "./agent-activity.js";
+// ---------------------------------------------------------------------------
+// stream-state.json — 每个 session 的流式输出持久化文件
+// ---------------------------------------------------------------------------
+export const STREAMS_DIR = join(USER_DATA_DIR, "state", "streams");
+function getStreamStatePath(sessionId) {
+    return join(STREAMS_DIR, `${sessionId}.json`);
+}
+export async function readStreamState(sessionId) {
+    try {
+        const raw = await readFile(getStreamStatePath(sessionId), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.sessionId === "string")
+            return parsed;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// rename 的可注入实现——仅供测试模拟"Windows EPERM 降级"路径。
+// 生产代码使用 node:fs/promises.rename。
+let renameImpl = rename;
+/**
+ * 仅供单测：注入自定义 rename 实现以验证降级分支。
+ * 调用方负责测试结束后用 _resetRenameForTest 还原。
+ */
+export function _setRenameForTest(impl) {
+    renameImpl = impl;
+}
+export function _resetRenameForTest() {
+    renameImpl = rename;
+}
+/**
+ * 把 StreamState 持久化到磁盘——尽量原子地写。
+ *
+ * 为什么需要原子写：display loop 每 3 秒读一次 stream-state.json,而
+ * runAgentSession 每 2 秒写一次。如果用 `writeFile(filePath, ...)` 直接
+ * 覆盖,reader 在写入过程中读会拿到半截 JSON,JSON.parse 报错——虽然
+ * readStreamState 包了 try/catch 返回 null 不会崩,但相当于"丢一帧"。
+ *
+ * 实现：
+ *   1) 先把内容写到 `<filePath>.tmp`（reader 不会读 .tmp）
+ *   2) 再用 `rename` 把 .tmp 替换成正式文件——`rename` 在 POSIX 上是真原子
+ *      操作,reader 任何时刻读到的都是某个完整的旧/新版本
+ *
+ * Windows 兼容性：Windows 上 `rename` 偶尔会因为目标文件正被 reader 打开
+ * 抛 EPERM/EBUSY（实测罕见,但非零概率）。降级方案：直接 writeFile 覆盖
+ * 真文件,这一帧可能被 reader 读到半截,但 readStreamState 的 try/catch 兜底
+ * 会让 loop 跳过这一帧,2 秒后下次 write 大概率成功——比写盘失败丢数据好。
+ */
+export async function writeStreamState(state) {
+    const filePath = getStreamStatePath(state.sessionId);
+    const payload = JSON.stringify(state, null, 2);
+    try {
+        await mkdir(dirname(filePath), { recursive: true });
+        const tmpPath = filePath + ".tmp";
+        await writeFile(tmpPath, payload, "utf-8");
+        try {
+            await renameImpl(tmpPath, filePath);
+        }
+        catch (renameErr) {
+            // Windows 偶发 EPERM/EBUSY：rename 失败时降级为直接覆盖写。
+            // 此次写入失去原子性（reader 可能读到半截 JSON,但 readStreamState
+            // 的 try/catch 会兜底返回 null,只是丢一帧 display 更新）。
+            console.warn(`[${ts()}] [STREAM-STATE] rename failed for ${state.sessionId}, ` +
+                `fallback to overwrite: ${renameErr.message}`);
+            await writeFile(filePath, payload, "utf-8");
+            // 尽力清理 .tmp,失败也无所谓——下次 write 会覆盖它
+            await unlink(tmpPath).catch(() => { });
+        }
+    }
+    catch (err) {
+        console.error(`[${ts()}] Failed to write stream-state for ${state.sessionId}: ${err.message}`);
+    }
+}
+export function isFinalReplySentForTurn(state) {
+    return state.finalReplySentTurn === state.turnCount;
+}
+export async function markFinalReplySent(sessionId, turnCount, sentAt = Date.now()) {
+    const state = await readStreamState(sessionId);
+    if (!state)
+        return;
+    if (state.turnCount !== turnCount)
+        return;
+    if (state.status === "running")
+        return;
+    state.finalReplySentTurn = turnCount;
+    state.finalReplySentAt = sentAt;
+    state.updatedAt = Date.now();
+    await writeStreamState(state);
+}
+export function createEmptyStreamState(sessionId, cwd, tool, turnCount) {
+    const now = Date.now();
+    return {
+        sessionId,
+        status: "running",
+        accumulatedContent: "",
+        finalReply: "",
+        activity: createAgentActivityTracker(now).activity,
+        chunkCount: 0,
+        turnCount,
+        contextTokens: 0,
+        updatedAt: now,
+        cwd,
+        tool,
+    };
+}
+/** 进程重启时修正虚假的 "running" 状态 */
+export async function fixStaleStreamStates() {
+    // 启动时将残留的 running 标记为 error
+    // 实际 agent 进程已不存在，下次 prompt 时会自然覆盖
+    try {
+        const { readdir } = await import("node:fs/promises");
+        let entries;
+        try {
+            entries = await readdir(STREAMS_DIR);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.endsWith(".json"))
+                continue;
+            const state = await readStreamState(entry.replace(".json", ""));
+            if (state && state.status === "running") {
+                state.status = "error";
+                state.accumulatedContent += "\n\n⚠️ 进程重启，流式输出中断。";
+                state.updatedAt = Date.now();
+                await writeStreamState(state);
+                console.log(`[${ts()}] [STREAM-STATE] marked stale running as error: ${state.sessionId}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`[${ts()}] [STREAM-STATE] fixStaleStreamStates failed: ${err.message}`);
+    }
+}

package/dist/src/terminal-error.js

@@ -0,0 +1,100 @@
+const MAX_UNKNOWN_ERROR_LENGTH = 300;
+function errorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+/**
+ * 未分类错误仍应给出可诊断线索，但不能把常见凭据带进群聊或持久化状态。
+ * 已分类错误使用固定文案，不复述地址、请求体或 provider 原始响应。
+ */
+export function sanitizeTerminalErrorDetail(raw) {
+    return raw
+        .replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [已脱敏]")
+        .replace(/\b(api[_-]?key|access[_-]?token|token|secret)\s*[:=]\s*[^\s,;]+/gi, "$1=[已脱敏]")
+        .replace(/\bsk-[A-Za-z0-9._-]{6,}\b/g, "sk-[已脱敏]")
+        .replace(/([?&](?:api[_-]?key|access[_-]?token|token|secret)=)[^&\s]+/gi, "$1[已脱敏]")
+        .slice(0, MAX_UNKNOWN_ERROR_LENGTH);
+}
+function parsePositiveInt(message, pattern) {
+    const value = Number.parseInt(message.match(pattern)?.[1] ?? "", 10);
+    return Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function formatSeconds(milliseconds) {
+    if (milliseconds % 1000 === 0)
+        return `${milliseconds / 1000} 秒`;
+    return `${milliseconds} 毫秒`;
+}
+export function classifyTerminalError(error, occurredAt = Date.now()) {
+    const raw = errorMessage(error);
+    const lower = raw.toLowerCase();
+    const attempts = parsePositiveInt(raw, /\bafter\s+(\d+)\s+attempts?\b/i);
+    const timeoutMs = parsePositiveInt(raw, /\btimeout\s*:\s*(\d+)\s*ms\b/i);
+    if (/\b429\b|rate[ _-]?limit|too many requests/.test(lower)) {
+        return {
+            kind: "rate_limit",
+            title: "请求受到限流",
+            message: "模型服务请求受到限流，请稍后重试。",
+            occurredAt,
+        };
+    }
+    if (/\b401\b|\b403\b|unauthori[sz]ed|forbidden|invalid api key|authentication/.test(lower)) {
+        return {
+            kind: "authentication",
+            title: "模型服务鉴权失败",
+            message: "模型服务拒绝了当前凭据，请检查 API Key、账号权限或凭据是否过期。",
+            occurredAt,
+        };
+    }
+    if (/connect timeout|connection timed out|etimedout|und_err_connect_timeout/.test(lower)
+        || (lower.includes("cannot connect") && lower.includes("timeout"))) {
+        const retryText = attempts ? `，已重试 ${attempts} 次` : "";
+        const timeoutText = timeoutMs ? `，单次连接等待 ${formatSeconds(timeoutMs)}` : "";
+        return {
+            kind: "network_timeout",
+            title: "网络连接超时",
+            message: `连接模型服务失败${retryText}${timeoutText}。请检查网络、VPN或模型服务状态后重试。`,
+            occurredAt,
+        };
+    }
+    if (/econnrefused|econnreset|enotfound|eai_again|socket hang up|network error|cannot connect/.test(lower)) {
+        return {
+            kind: "network",
+            title: "无法连接模型服务",
+            message: "与模型服务的网络连接失败，请检查网络、VPN、DNS或服务状态后重试。",
+            occurredAt,
+        };
+    }
+    const httpStatus = raw.match(/\b(?:HTTP\s*)?(5\d\d)\b/i)?.[1];
+    if (httpStatus || /service unavailable|bad gateway|gateway timeout|provider error/.test(lower)) {
+        return {
+            kind: "provider",
+            title: "模型服务暂时不可用",
+            message: `模型服务返回异常${httpStatus ? `（HTTP ${httpStatus}）` : ""}，请稍后重试。`,
+            occurredAt,
+        };
+    }
+    const safeDetail = sanitizeTerminalErrorDetail(raw).trim() || "未提供错误详情";
+    return {
+        kind: "unknown",
+        title: "Agent 执行错误",
+        message: `发生未分类错误：${safeDetail}`,
+        occurredAt,
+    };
+}
+export function formatTerminalErrorReason(error) {
+    return `⚠️ 异常结束：${error.title}\n${error.message}`;
+}
+export function formatTerminalErrorNotice(error, finalReply = "") {
+    const reason = formatTerminalErrorReason(error);
+    return finalReply.trim()
+        ? `${reason}\n\n以下回复可能不完整：\n\n${finalReply.trim()}`
+        : reason;
+}

package/dist/src/trace.js

@@ -0,0 +1,50 @@
+/**
+ * 轻量级消息全链路 trace 工具。
+ *
+ * 每条消息生成唯一 traceId，在关键决策点、API 调用、消息发送时输出结构化日志。
+ * grep traceId 即可看到该消息的完整 RECV → BRANCH → SEND → DONE 链路。
+ *
+ * 设计原则：trace 自身绝不能抛异常导致主流程中断——所有函数内都有 try/catch 兜底。
+ */
+let _traceSeq = 0;
+/** 基于时间戳 + 递增序号生成短 trace ID（约 10 字符） */
+export function makeTraceId() {
+    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, step, detail) {
+    try {
+        const safe = {};
+        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() {
+    _traceSeq = 0;
+}

package/dist/src/turn-cards.js

@@ -0,0 +1,92 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { USER_DATA_DIR, ts } from "./config.js";
+// ---------------------------------------------------------------------------
+// turn-cards.json — 每个 session 的卡片归属持久化
+// 记录每个 turn 有哪些卡片（轮转会产生多张），以及每张卡片的状态
+// ---------------------------------------------------------------------------
+export const TURNS_DIR = join(USER_DATA_DIR, "state", "turns");
+function getTurnCardsPath(sessionId) {
+    return join(TURNS_DIR, `${sessionId}.json`);
+}
+export function createEmptyTurnCards(sessionId) {
+    return { sessionId, turns: [] };
+}
+export async function readTurnCards(sessionId) {
+    try {
+        const raw = await readFile(getTurnCardsPath(sessionId), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.sessionId === "string" && Array.isArray(parsed.turns)) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeTurnCards(sessionId, data) {
+    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.message}`);
+    }
+}
+/** 向指定 turn 追加一张卡片并持久化。若 turn 不存在则创建。 */
+export async function addCardToTurn(sessionId, turnCount, cardId) {
+    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, turnCount, finalStatus) {
+    const data = await readTurnCards(sessionId);
+    if (!data)
+        return [];
+    const turn = data.turns.find(t => t.turnCount === turnCount);
+    if (!turn)
+        return [];
+    const finalized = [];
+    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, turnCount, cardId) {
+    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) {
+    try {
+        const { unlink } = await import("node:fs/promises");
+        await unlink(getTurnCardsPath(sessionId));
+    }
+    catch {
+        // 文件不存在，忽略
+    }
+}

package/dist/src/update-command-guard.js

@@ -0,0 +1,114 @@
+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;
+function asRecord(value) {
+    return typeof value === "object" && value !== null
+        ? value
+        : undefined;
+}
+/** 从飞书事件信封中读取重投时保持不变的 event_id。 */
+export function extractFeishuEventId(data) {
+    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, id) {
+    const normalized = id?.trim();
+    return normalized ? `${source}:${normalized}` : undefined;
+}
+function emptyState() {
+    return { version: UPDATE_COMMAND_GUARD_VERSION, processed: [] };
+}
+function parseState(raw, maxEntries) {
+    const parsed = JSON.parse(raw);
+    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, maxEntries, warn) {
+    if (!existsSync(filePath))
+        return emptyState();
+    try {
+        return parseState(readFileSync(filePath, "utf8"), maxEntries);
+    }
+    catch (err) {
+        warn(`[UPDATE-GUARD] 状态文件损坏，将重建 ${filePath}: ${err.message}`);
+        return emptyState();
+    }
+}
+/**
+ * 原子写入更新命令 ID。写失败时调用方必须拒绝更新：只有先落盘，
+ * 新进程才能识别飞书在旧进程退出后重投的同一条 `/update`。
+ */
+function persistState(filePath, state) {
+    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 = {}) {
+    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) => 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.message}`);
+        return { allowed: false, reason: "state_write_failed" };
+    }
+    return { allowed: true, reason: "accepted" };
+}