chatccc 0.2.231 → 0.2.233

package/src/stream-state.ts

@@ -1,10 +1,10 @@
 import { readFile, writeFile, mkdir, rename, unlink } from "node:fs/promises";
 import { dirname, join } from "node:path";
 
-import { USER_DATA_DIR, ts } from "./config.ts";
-import { createAgentActivityTracker } from "./agent-activity.ts";
-import type { AgentActivity } from "./agent-activity.ts";
-import type { TerminalErrorInfo } from "./terminal-error.ts";
+import { USER_DATA_DIR, ts } from "./config.ts";
+import { createAgentActivityTracker } from "./agent-activity.ts";
+import type { AgentActivity } from "./agent-activity.ts";
+import type { TerminalErrorInfo } from "./terminal-error.ts";
 
 // ---------------------------------------------------------------------------
 // stream-state.json — 每个 session 的流式输出持久化文件
@@ -14,14 +14,14 @@ export const STREAMS_DIR = join(USER_DATA_DIR, "state", "streams");
 
 export interface StreamState {
   sessionId: string;
-  status: "running" | "done" | "stopped" | "error" | "auto_ended";
+  status: "running" | "done" | "stopped" | "error" | "auto_ended";
   accumulatedContent: string;
   /** 本轮会话中 LLM 输出的全部文本内容（所有 text block 的累加）。
    *  命名含 "final" 但实为"全部累积文本"，并非仅"最终一段回复"。
    *  参见 session.ts 的 AccumulatorState 注释。 */
-  finalReply: string;
-  /** Current user-visible work phase for running progress cards. */
-  activity?: AgentActivity;
+  finalReply: string;
+  /** Current user-visible work phase for running progress cards. */
+  activity?: AgentActivity;
   /** The turn whose terminal text reply has already been delivered to IM. */
   finalReplySentTurn?: number;
   finalReplySentAt?: number;
@@ -33,12 +33,12 @@ export interface StreamState {
   tool: string;
   /** Set by stop-stuck-loop to prevent the session from being resumed.
    *  The orchestrator checks this before resuming and creates a new session instead. */
-  stuckAt?: number;
-  /** Set when the shared response watchdog ends a turn after three minutes without new characters. */
-  autoEndedAt?: number;
-  /** 脱敏后的用户可见根因；完整原始异常只保留在运行日志中。 */
-  terminalError?: TerminalErrorInfo;
-}
+  stuckAt?: number;
+  /** Set when the shared response watchdog ends a turn after three minutes without new characters. */
+  autoEndedAt?: number;
+  /** 脱敏后的用户可见根因；完整原始异常只保留在运行日志中。 */
+  terminalError?: TerminalErrorInfo;
+}
 
 function getStreamStatePath(sessionId: string): string {
   return join(STREAMS_DIR, `${sessionId}.json`);
@@ -131,18 +131,18 @@ export async function markFinalReplySent(sessionId: string, turnCount: number, s
   await writeStreamState(state);
 }
 
-export function createEmptyStreamState(sessionId: string, cwd: string, tool: string, turnCount: number): StreamState {
-  const now = Date.now();
-  return {
+export function createEmptyStreamState(sessionId: string, cwd: string, tool: string, turnCount: number): StreamState {
+  const now = Date.now();
+  return {
     sessionId,
     status: "running",
-    accumulatedContent: "",
-    finalReply: "",
-    activity: createAgentActivityTracker(now).activity,
+    accumulatedContent: "",
+    finalReply: "",
+    activity: createAgentActivityTracker(now).activity,
     chunkCount: 0,
     turnCount,
     contextTokens: 0,
-    updatedAt: now,
+    updatedAt: now,
     cwd,
     tool,
   };

package/src/terminal-error.ts

@@ -1,129 +1,129 @@
-/** 用户可见的终态错误。这里只保存脱敏摘要；完整原始异常继续只写运行日志。 */
-export type TerminalErrorKind =
-  | "network_timeout"
-  | "network"
-  | "authentication"
-  | "rate_limit"
-  | "provider"
-  | "process"
-  | "resource"
-  | "unknown";
-
-export interface TerminalErrorInfo {
-  kind: TerminalErrorKind;
-  title: string;
-  message: string;
-  occurredAt: number;
-}
-
-const MAX_UNKNOWN_ERROR_LENGTH = 300;
-
-function errorMessage(error: unknown): string {
-  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: string): string {
-  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: string, pattern: RegExp): number | undefined {
-  const value = Number.parseInt(message.match(pattern)?.[1] ?? "", 10);
-  return Number.isFinite(value) && value > 0 ? value : undefined;
-}
-
-function formatSeconds(milliseconds: number): string {
-  if (milliseconds % 1000 === 0) return `${milliseconds / 1000} 秒`;
-  return `${milliseconds} 毫秒`;
-}
-
-export function classifyTerminalError(error: unknown, occurredAt = Date.now()): TerminalErrorInfo {
-  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: TerminalErrorInfo): string {
-  return `⚠️ 异常结束：${error.title}\n${error.message}`;
-}
-
-export function formatTerminalErrorNotice(error: TerminalErrorInfo, finalReply = ""): string {
-  const reason = formatTerminalErrorReason(error);
-  return finalReply.trim()
-    ? `${reason}\n\n以下回复可能不完整：\n\n${finalReply.trim()}`
-    : reason;
-}
+/** 用户可见的终态错误。这里只保存脱敏摘要；完整原始异常继续只写运行日志。 */
+export type TerminalErrorKind =
+  | "network_timeout"
+  | "network"
+  | "authentication"
+  | "rate_limit"
+  | "provider"
+  | "process"
+  | "resource"
+  | "unknown";
+
+export interface TerminalErrorInfo {
+  kind: TerminalErrorKind;
+  title: string;
+  message: string;
+  occurredAt: number;
+}
+
+const MAX_UNKNOWN_ERROR_LENGTH = 300;
+
+function errorMessage(error: unknown): string {
+  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: string): string {
+  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: string, pattern: RegExp): number | undefined {
+  const value = Number.parseInt(message.match(pattern)?.[1] ?? "", 10);
+  return Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
+function formatSeconds(milliseconds: number): string {
+  if (milliseconds % 1000 === 0) return `${milliseconds / 1000} 秒`;
+  return `${milliseconds} 毫秒`;
+}
+
+export function classifyTerminalError(error: unknown, occurredAt = Date.now()): TerminalErrorInfo {
+  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: TerminalErrorInfo): string {
+  return `⚠️ 异常结束：${error.title}\n${error.message}`;
+}
+
+export function formatTerminalErrorNotice(error: TerminalErrorInfo, finalReply = ""): string {
+  const reason = formatTerminalErrorReason(error);
+  return finalReply.trim()
+    ? `${reason}\n\n以下回复可能不完整：\n\n${finalReply.trim()}`
+    : reason;
+}

package/src/turn-cards.ts

@@ -1,118 +1,118 @@
-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 {
-    // 文件不存在，忽略
-  }
+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 {
+    // 文件不存在，忽略
+  }
 }