chatccc 0.2.94 → 0.2.96

package/src/session.ts

@@ -25,6 +25,7 @@ import { simplifyToolUse, simplifyToolResult } from "./simplify.ts";
 import { logTrace } from "./trace.ts";
 import type { UnifiedBlock } from "./adapters/adapter-interface.ts";
 import type { ToolAdapter } from "./adapters/adapter-interface.ts";
+import type { ToolProcessInfo } 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";
@@ -114,6 +115,110 @@ function platformForChat(chatId: string): PlatformAdapter | null {
   return chatPlatformMap.get(chatId) ?? platformRef;
 }
 
+const DEFAULT_PROCESS_MONITOR_INTERVAL_MS = 5000;
+let processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
+let isProcessAliveImpl = (pid: number): boolean => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export function _setProcessAliveForTest(impl: (pid: number) => boolean): void {
+  isProcessAliveImpl = impl;
+}
+
+export function _resetProcessAliveForTest(): void {
+  isProcessAliveImpl = (pid: number): boolean => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+}
+
+export function _setProcessMonitorIntervalForTest(ms: number): void {
+  processMonitorIntervalMs = ms;
+}
+
+export function _resetProcessMonitorIntervalForTest(): void {
+  processMonitorIntervalMs = DEFAULT_PROCESS_MONITOR_INTERVAL_MS;
+}
+
+function clearPromptProcessMonitor(sessionId: string): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt?.processMonitor) return;
+  clearInterval(prompt.processMonitor);
+  prompt.processMonitor = undefined;
+}
+
+function formatTerminalHeader(status: "running" | "done" | "stopped" | "error"): {
+  title: string;
+  template?: string;
+} {
+  if (status === "stopped") return { title: "已停止", template: "red" };
+  if (status === "error") return { title: "异常结束", template: "red" };
+  return { title: "完成" };
+}
+
+function turnFinalStatus(status: "running" | "done" | "stopped" | "error"): "done" | "stopped" {
+  return status === "stopped" || status === "error" ? "stopped" : "done";
+}
+
+function startPromptProcessMonitor(sessionId: string, info: ToolProcessInfo): void {
+  const prompt = activePrompts.get(sessionId);
+  if (!prompt) return;
+  prompt.processPid = info.pid;
+  clearPromptProcessMonitor(sessionId);
+
+  const check = async () => {
+    const current = activePrompts.get(sessionId);
+    if (!current || current !== prompt) {
+      clearPromptProcessMonitor(sessionId);
+      return;
+    }
+    if (current.stopped || current.abnormalExit) return;
+    if (isProcessAliveImpl(info.pid)) return;
+
+    current.abnormalExit = true;
+    clearPromptProcessMonitor(sessionId);
+
+    const state = await readStreamState(sessionId);
+    if (state?.status === "running") {
+      await writeStreamState({
+        ...state,
+        status: "error",
+        updatedAt: Date.now(),
+      });
+    }
+
+    const chatId = pickDisplayChat(sessionId) ?? getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
+    const p = chatId ? platformForChat(chatId) : null;
+    if (chatId && p && !current.abnormalExitNotified) {
+      current.abnormalExitNotified = true;
+      await p.sendText(
+        chatId,
+        `⚠️ 进程异常结束：session ${sessionId} 对应的 CLI 进程 PID ${info.pid} 已不存在，已按完成处理。若回复不完整，请重新发送上一条指令。`,
+      ).catch(() => {});
+    }
+
+    // 主动关闭 readline，让 runAgentSession 的 finally 落盘 error 终态并清理 activePrompts。
+    current.controller.abort();
+  };
+
+  const handle = setInterval(() => {
+    void check().catch((err) => {
+      console.warn(`[${ts()}] [PROCESS-MONITOR] check failed for ${sessionId}: ${(err as Error).message}`);
+    });
+  }, processMonitorIntervalMs);
+  handle.unref?.();
+  prompt.processMonitor = handle;
+}
+
 export function _getPlatformForChatForTest(chatId: string): PlatformAdapter | null {
   return platformForChat(chatId);
 }
@@ -189,6 +294,9 @@ export function resetState(): void {
   processedMessages.clear();
   lastMsgTimestamps.clear();
   chatPlatformMap.clear();
+  for (const prompt of activePrompts.values()) {
+    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
+  }
   activePrompts.clear();
   displayCards.clear();
   stopUnifiedDisplayLoop();
@@ -199,13 +307,39 @@ export function resetState(): void {
 // 是 onReady/onReconnected 取代 resetState 的正确入口。
 
 // ---------------------------------------------------------------------------
-// Adapter: 按 tool 创建并缓存
+// Adapter: 按 tool + effectiveModel 创建并缓存
 // ---------------------------------------------------------------------------
 
 const adapterCache = new Map<string, ToolAdapter>();
 
-export function getAdapterForTool(tool: string): ToolAdapter {
-  const cached = adapterCache.get(tool);
+// Per-session 模型覆盖（/model 命令设置，不持久化）
+const sessionModelOverrides = new Map<string, string>();
+
+/** 返回 session 的生效模型：优先 per-session 覆盖，其次全局配置 */
+function getModelForSession(sessionId?: string): string {
+  if (sessionId) {
+    const override = sessionModelOverrides.get(sessionId);
+    if (override) return override;
+  }
+  return CLAUDE_MODEL;
+}
+
+/** 为指定 session 设置模型覆盖（/model pro、/model flash） */
+export function setSessionModelOverride(sessionId: string, model: string): void {
+  sessionModelOverrides.set(sessionId, model);
+  adapterCache.clear();
+}
+
+/** 清除指定 session 的模型覆盖（/model clear） */
+export function clearSessionModelOverride(sessionId: string): void {
+  sessionModelOverrides.delete(sessionId);
+  adapterCache.clear();
+}
+
+export function getAdapterForTool(tool: string, sessionId?: string): ToolAdapter {
+  const effectiveModel = tool === "claude" ? getModelForSession(sessionId) : "";
+  const cacheKey = tool === "claude" ? `${tool}:${effectiveModel}` : tool;
+  const cached = adapterCache.get(cacheKey);
   if (cached) return cached;
 
   let adapter: ToolAdapter;
@@ -215,7 +349,7 @@ export function getAdapterForTool(tool: string): ToolAdapter {
     adapter = createCodexAdapter();
   } else {
     adapter = createClaudeAdapter({
-      model: CLAUDE_MODEL,
+      model: effectiveModel,
       subagentModel: CLAUDE_SUBAGENT_MODEL,
       effort: CLAUDE_EFFORT,
       isEmpty: isAnthropicConfigEmpty,
@@ -223,7 +357,7 @@ export function getAdapterForTool(tool: string): ToolAdapter {
       baseUrl: CLAUDE_BASE_URL,
     });
   }
-  adapterCache.set(tool, adapter);
+  adapterCache.set(cacheKey, adapter);
   return adapter;
 }
 
@@ -640,7 +774,7 @@ export async function switchChatBinding(args: SwitchChatBindingArgs): Promise<Sw
  * Claude 显示 model/effort（来自环境变量）；Cursor 显示 model（运行时由
  * cursor-agent 决定，初次创建时尚未学习到，故显示占位）。
  */
-function formatToolConfigForLog(tool: string, sessionModel?: string): string {
+function formatToolConfigForLog(tool: string, sessionModel?: string, sessionId?: string): string {
   if (tool === "cursor") {
     return `model=${sessionModel ?? "(由 cursor-agent 决定，init 事件后学习)"}`;
   }
@@ -653,7 +787,7 @@ function formatToolConfigForLog(tool: string, sessionModel?: string): string {
       : "effort=(由 codex config.toml 决定)";
     return `model=${modelStr}, ${effortStr}`;
   }
-  return `model=${anthropicConfigDisplay(CLAUDE_MODEL)}, subagentModel=${anthropicConfigDisplay(CLAUDE_SUBAGENT_MODEL)}, effort=${anthropicConfigDisplay(CLAUDE_EFFORT)}`;
+  return `model=${anthropicConfigDisplay(getModelForSession(sessionId))}, subagentModel=${anthropicConfigDisplay(CLAUDE_SUBAGENT_MODEL)}, effort=${anthropicConfigDisplay(CLAUDE_EFFORT)}`;
 }
 
 export async function initClaudeSession(tool: string, overrideCwd?: string, chatId?: string): Promise<{ sessionId: string; cwd: string }> {
@@ -733,12 +867,12 @@ export async function runAgentSession(
   let info: Awaited<ReturnType<ToolAdapter["getSessionInfo"]>>;
   let cwd: string;
   try {
-    adapter = getAdapterForTool(tool);
+    adapter = getAdapterForTool(tool, sessionId);
     info = await adapter.getSessionInfo(sessionId);
     cwd = info?.cwd ?? (await getDefaultCwd(_chatId));
     if (tid) logTrace(tid, "SESSION_START", { sessionId, tool, cwd, turn: (sessionInfoMap.get(_chatId)?.turnCount ?? 0) + 1 });
     console.log(
-      `[${ts()}] Running ${adapter.displayName} session: ${sessionId} (${formatToolConfigForLog(tool, info?.model)}, cwd=${cwd})`
+      `[${ts()}] Running ${adapter.displayName} session: ${sessionId} (${formatToolConfigForLog(tool, info?.model, sessionId)}, cwd=${cwd})`
     );
 
     // 构建 IM skills prompt（sessionId 方式，无 token）
@@ -833,13 +967,12 @@ export async function runAgentSession(
         // terminal state，发送了 finalReply 并删除/替换了 displayCards 条目。
         // 通过引用比较检测——若统一 loop 已处理则只补持久化和头像，不重复发。
         if (displayCards.get(displayChatId) !== display) {
-          const finalStatus = prevState.status === "stopped" ? "stopped" : "done";
+          const finalStatus = turnFinalStatus(prevState.status);
           finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
           pp.setChatAvatar(displayChatId, prevState.tool, "idle").catch(() => {});
         } else {
           const nextSeq = display.sequence + 1;
-          const headerTitle = prevState.status === "stopped" ? "已停止" : "完成";
-          const headerTemplate = prevState.status === "stopped" ? "red" : undefined;
+          const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(prevState.status);
           const cardContent = truncateContent(prevState.accumulatedContent + prevState.finalReply) || " ";
           const doneCard = buildProgressCard(cardContent, { showStop: false, headerTitle, headerTemplate });
           await pp.cardUpdate(display.cardId, doneCard, nextSeq).catch(() => {});
@@ -848,7 +981,7 @@ export async function runAgentSession(
           displayCards.delete(displayChatId);
 
           // 持久化：标记上一轮所有卡片为终态
-          const finalStatus = prevState.status === "stopped" ? "stopped" : "done";
+          const finalStatus = turnFinalStatus(prevState.status);
           finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
 
           if (prevState.finalReply && stillOursAfterUpdate && !isFinalReplySentForTurn(prevState)) {
@@ -858,7 +991,7 @@ export async function runAgentSession(
         }
       } else if (pp && prevState.finalReply && !isFinalReplySentForTurn(prevState)) {
         // 无 display 记录但上一轮有 finalReply（极快轮次），至少发送
-        const finalStatus = prevState.status === "stopped" ? "stopped" : "done";
+        const finalStatus = turnFinalStatus(prevState.status);
         finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
         await sendFinalReplyTextOnce(pp, displayChatId, sessionId, prevState.turnCount, prevState.finalReply);
       }
@@ -928,7 +1061,14 @@ export async function runAgentSession(
   const toolCallMap = new Map<string, { name: string; input: unknown }>();
 
   try {
-    for await (const unifiedMsg of adapter.prompt(sessionId, userTextWithCapabilities, cwd, controller.signal)) {
+    for await (const unifiedMsg of adapter.prompt(sessionId, userTextWithCapabilities, cwd, controller.signal, {
+      onProcessStart: (processInfo) => {
+        startPromptProcessMonitor(sessionId, processInfo);
+      },
+      onProcessExit: () => {
+        clearPromptProcessMonitor(sessionId);
+      },
+    })) {
       for (const block of unifiedMsg.blocks) {
         accumulateBlockContent(block, state, toolCallMap);
 
@@ -971,13 +1111,15 @@ export async function runAgentSession(
     // 标记 prompt 结束
     const prompt = activePrompts.get(sessionId);
     const wasStopped = prompt?.stopped ?? false;
+    const wasAbnormalExit = prompt?.abnormalExit ?? false;
+    clearPromptProcessMonitor(sessionId);
     activePrompts.delete(sessionId);
 
     // 先写最终状态（done/stopped），确保 display loop 在下一轮消费前
     // 读到新状态并终结旧卡片。否则 setImmediate 在 CHECK 阶段先于
     // writeFile I/O（POLL 阶段）执行，display loop 会误以为旧轮仍在
     // 运行中并更新旧卡片，而不是新建卡片。
-    const finalStatus = wasStopped ? "stopped" : "done";
+    const finalStatus = wasAbnormalExit ? "error" : wasStopped ? "stopped" : "done";
     const finalReply = pickFinalReply(state).trim();
     await writeStreamState({
       sessionId,
@@ -1039,6 +1181,23 @@ export async function runAgentSession(
       if (active1) platform.setChatAvatar(active1, tool, "idle").catch(() => {});
       console.log(`[${ts()}] Session ${sessionId} stopped (content chunks: ${state.chunkCount})`);
       if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "stopped", chunks: state.chunkCount });
+    } else if (wasAbnormalExit) {
+      for (const cid of getChatsForSession(sessionId)) {
+        const finfo = sessionInfoMap.get(cid);
+        await recordSessionRegistry({
+          chatId: cid,
+          sessionId,
+          tool,
+          turnCount: finfo?.turnCount ?? nextTurnCount,
+          lastContextTokens: finfo?.lastContextTokens ?? nextContextTokens,
+          startTime: finfo?.startTime ?? now,
+          running: false,
+        });
+      }
+      const activeErr = getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
+      if (activeErr) platform.setChatAvatar(activeErr, tool, "idle").catch(() => {});
+      console.log(`[${ts()}] Session ${sessionId} process exited unexpectedly (content chunks: ${state.chunkCount})`);
+      if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "process_missing", chunks: state.chunkCount });
     } else {
       for (const cid of getChatsForSession(sessionId)) {
         const finfo = sessionInfoMap.get(cid);
@@ -1140,8 +1299,7 @@ export function startUnifiedDisplayLoop(): void {
               // 发送最终结果（卡片平台）
               while (display.cardBusy) await new Promise(r => setTimeout(r, 20));
               const nextSeq = display.sequence + 1;
-              const headerTitle = state.status === "stopped" ? "已停止" : "完成";
-              const headerTemplate = state.status === "stopped" ? "red" : undefined;
+              const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(state.status);
               const cardContent = truncateContent(state.accumulatedContent + state.finalReply) || " ";
               const doneCard = buildProgressCard(cardContent, { showStop: false, headerTitle, headerTemplate });
               await p.cardUpdate(display.cardId, doneCard, nextSeq).catch(() => {});
@@ -1156,7 +1314,7 @@ export function startUnifiedDisplayLoop(): void {
                 continue;
               }
 
-              const finalSt = state.status === "stopped" ? "stopped" : "done";
+              const finalSt = turnFinalStatus(state.status);
               finalizeTurnCards(sessionId, state.turnCount, finalSt).catch(() => {});
               displayCards.delete(chatId);
               if (state.finalReply) {
@@ -1343,6 +1501,7 @@ export function stopSession(sessionId: string): boolean {
   const prompt = activePrompts.get(sessionId);
   if (!prompt) return false;
   prompt.stopped = true;
+  clearPromptProcessMonitor(sessionId);
   cancelQueuedMessage(sessionId);
   prompt.controller.abort();
   console.log(`[${ts()}] [STOP] Session ${sessionId} aborted`);
@@ -1408,7 +1567,7 @@ async function resolveModelEffort(
   if (tool === "cursor") {
     let model = UNKNOWN_MODEL_PLACEHOLDER;
     try {
-      const adapter = getAdapterForTool(tool);
+      const adapter = getAdapterForTool(tool, sessionId);
       const info = await adapter.getSessionInfo(sessionId);
       if (info?.model) model = info.model;
     } catch {
@@ -1425,7 +1584,7 @@ async function resolveModelEffort(
     };
   }
   return {
-    model: anthropicConfigDisplay(CLAUDE_MODEL),
+    model: anthropicConfigDisplay(getModelForSession(sessionId)),
     effort: anthropicConfigDisplay(CLAUDE_EFFORT),
   };
 }
@@ -1434,7 +1593,8 @@ export async function getSessionStatus(chatId: string): Promise<SessionStatus |
   const info = sessionInfoMap.get(chatId);
   if (!info) return null;
 
-  const isActive = activePrompts.has(info.sessionId) && !(activePrompts.get(info.sessionId)?.stopped);
+  const activePrompt = activePrompts.get(info.sessionId);
+  const isActive = !!activePrompt && !activePrompt.stopped && !activePrompt.abnormalExit;
   const { model, effort } = await resolveModelEffort(info.tool, info.sessionId);
 
   const registry = await loadSessionRegistry();
@@ -1509,7 +1669,9 @@ export async function getAllSessionsStatus(): Promise<SessionsListEntry[]> {
         chatId: info.chatId,
         sessionId: info.sessionId,
         chatName: info.chatName || "",
-        active: activePrompts.has(info.sessionId) && !(activePrompts.get(info.sessionId)?.stopped),
+        active: !!activePrompts.get(info.sessionId) &&
+          !activePrompts.get(info.sessionId)?.stopped &&
+          !activePrompts.get(info.sessionId)?.abnormalExit,
         turnCount: info.turnCount,
         startTime: info.startTime,
         model,

package/src/stream-state.ts

@@ -9,17 +9,17 @@ import { USER_DATA_DIR, ts } from "./config.ts";
 
 export const STREAMS_DIR = join(USER_DATA_DIR, "state", "streams");
 
-export interface StreamState {
-  sessionId: string;
-  status: "running" | "done" | "stopped" | "error";
-  accumulatedContent: string;
-  finalReply: string;
-  /** The turn whose terminal text reply has already been delivered to IM. */
-  finalReplySentTurn?: number;
-  finalReplySentAt?: number;
-  chunkCount: number;
-  turnCount: number;
-  contextTokens: number;
+export interface StreamState {
+  sessionId: string;
+  status: "running" | "done" | "stopped" | "error";
+  accumulatedContent: string;
+  finalReply: string;
+  /** The turn whose terminal text reply has already been delivered to IM. */
+  finalReplySentTurn?: number;
+  finalReplySentAt?: number;
+  chunkCount: number;
+  turnCount: number;
+  contextTokens: number;
   updatedAt: number;
   cwd: string;
   tool: string;
@@ -74,7 +74,7 @@ export function _resetRenameForTest(): void {
  * 真文件,这一帧可能被 reader 读到半截,但 readStreamState 的 try/catch 兜底
  * 会让 loop 跳过这一帧,2 秒后下次 write 大概率成功——比写盘失败丢数据好。
  */
-export async function writeStreamState(state: StreamState): Promise<void> {
+export async function writeStreamState(state: StreamState): Promise<void> {
   const filePath = getStreamStatePath(state.sessionId);
   const payload = JSON.stringify(state, null, 2);
   try {
@@ -98,26 +98,26 @@ export async function writeStreamState(state: StreamState): Promise<void> {
   } catch (err) {
     console.error(`[${ts()}] Failed to write stream-state for ${state.sessionId}: ${(err as Error).message}`);
   }
-}
-
-export function isFinalReplySentForTurn(state: Pick<StreamState, "turnCount" | "finalReplySentTurn">): boolean {
-  return state.finalReplySentTurn === state.turnCount;
-}
-
-export async function markFinalReplySent(sessionId: string, turnCount: number, sentAt = Date.now()): Promise<void> {
-  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: string, cwd: string, tool: string, turnCount: number): StreamState {
-  return {
+}
+
+export function isFinalReplySentForTurn(state: Pick<StreamState, "turnCount" | "finalReplySentTurn">): boolean {
+  return state.finalReplySentTurn === state.turnCount;
+}
+
+export async function markFinalReplySent(sessionId: string, turnCount: number, sentAt = Date.now()): Promise<void> {
+  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: string, cwd: string, tool: string, turnCount: number): StreamState {
+  return {
     sessionId,
     status: "running",
     accumulatedContent: "",
@@ -157,4 +157,4 @@ export async function fixStaleStreamStates(): Promise<void> {
   } catch (err) {
     console.error(`[${ts()}] [STREAM-STATE] fixStaleStreamStates failed: ${(err as Error).message}`);
   }
-}
+}