chatccc 0.2.49 → 0.2.51

package/src/shared.ts

@@ -1,17 +1,17 @@
 import { execSync } from "node:child_process";
-import {
-  appendFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { createServer } from "node:http";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { inspect } from "node:util";
-import { WebSocketServer, WebSocket } from "ws";
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { inspect } from "node:util";
+import { WebSocketServer, WebSocket } from "ws";
 
 import { printServiceDidNotStart } from "./exit-banner.ts";
 
@@ -42,8 +42,11 @@ export function appendStartupTrace(message: string, extra?: Record<string, unkno
 // 进程树：当前进程及其所有祖先（用于避免 taskkill /T 误杀启动链）
 // ---------------------------------------------------------------------------
 
-/** 自当前 PID 沿父链上溯直到系统进程，包含自身 */
+let _cachedAncestorSet: Set<number> | undefined;
+
+/** 自当前 PID 沿父链上溯直到系统进程，包含自身。结果会被缓存，同一进程内多次调用复用。 */
 export function getProcessAncestorPidSet(): Set<number> {
+  if (_cachedAncestorSet) return _cachedAncestorSet;
   const ancestors = new Set<number>();
   let cur: number = process.pid;
   const maxHops = 48;
@@ -74,6 +77,7 @@ export function getProcessAncestorPidSet(): Set<number> {
     if (parent === undefined || Number.isNaN(parent) || parent === cur) break;
     cur = parent;
   }
+  _cachedAncestorSet = ancestors;
   return ancestors;
 }
 
@@ -137,8 +141,9 @@ function collectListeningPidsOnPortWindows(port: number, netstatOut: string): nu
   return out;
 }
 
-/** 在 createRelayServer 之前调用：清掉本机该端口上仍在监听的旧进程（不杀当前进程树祖先） */
-export function freeRelayListenPort(port: number): void {
+/** 在 createRelayServer 之前调用：清掉本机该端口上仍在监听的旧进程（不杀当前进程树祖先）。
+ *  返回实际 kill 的进程数。 */
+export function freeRelayListenPort(port: number): number {
   const ancestors = getProcessAncestorPidSet();
   appendStartupTrace("freeRelayListenPort: begin", {
     port,
@@ -147,9 +152,10 @@ export function freeRelayListenPort(port: number): void {
 
   if (process.platform !== "win32") {
     appendStartupTrace("freeRelayListenPort: skip (non-Windows)", { port });
-    return;
+    return 0;
   }
 
+  let killed = 0;
   try {
     const portOut = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf8", windowsHide: true });
     const pids = collectListeningPidsOnPortWindows(port, portOut);
@@ -159,11 +165,32 @@ export function freeRelayListenPort(port: number): void {
       console.log(`[KILL] Free port ${port}: killing LISTENING/UDP holder PID ${pidNum}...`);
       appendStartupTrace("freeRelayListenPort: killByPid", { port, pid: pidNum });
       killByPid(pidNum);
+      killed++;
     }
   } catch {
     appendStartupTrace("freeRelayListenPort: netstat/findstr (no rows or error)", { port });
   }
-  appendStartupTrace("freeRelayListenPort: end", { port });
+  appendStartupTrace("freeRelayListenPort: end", { port, killed });
+  return killed;
+}
+
+/**
+ * 轮询等待端口释放（Windows 下 taskkill 后端口可能不会立即释放）。
+ * 在 freeRelayListenPort kill 了进程后调用，确认端口真正空闲再 listen。
+ */
+export async function waitForPortFree(port: number, timeoutMs = 3000): Promise<void> {
+  if (process.platform !== "win32") return;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const out = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf8", windowsHide: true });
+      const pids = collectListeningPidsOnPortWindows(port, out);
+      if (pids.length === 0) return;
+    } catch {
+      return;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -355,56 +382,56 @@ export function installCrashLogging(opts: CrashHandlersOptions = {}): InstallCra
 // 文件日志：同时输出到控制台和日志文件
 // ---------------------------------------------------------------------------
 
-export function setupFileLogging(logDir: string, prefix: string): { logPath: string; flush: () => void } {
-  mkdirSync(logDir, { recursive: true });
-  const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const logPath = join(logDir, `${prefix}-${ts}.log`);
-  writeFileSync(logPath, "", { flag: "a", encoding: "utf8" });
-  const origConsoleLog = console.log.bind(console);
-  const origConsoleError = console.error.bind(console);
-  const formatArg = (arg: unknown): string => {
-    if (typeof arg === "string") return arg;
-    if (arg instanceof Error) return arg.stack ?? arg.message;
-    return inspect(arg, { depth: 6, breakLength: Infinity, maxArrayLength: 200 });
-  };
-  const writeLine = (level: string, args: unknown[]) => {
-    try {
-      const line = args.map(formatArg).join(" ");
-      appendFileSync(logPath, `[${new Date().toISOString()}] [${level}] ${line}\n`, "utf8");
-    } catch (err) {
-      try {
-        appendStartupTrace("fileLog write failed", { level, error: err instanceof Error ? err.message : String(err) });
-      } catch {
-        // 日志系统自身不能影响主流程
-      }
-    }
-  };
-  console.log = (...args: unknown[]) => {
-    writeLine("LOG", args);
-    try {
-      origConsoleLog(...args);
-    } catch {
-      // 控制台输出失败也不能拖垮服务
-    }
-  };
-  console.error = (...args: unknown[]) => {
-    writeLine("ERR", args);
-    try {
-      origConsoleError(...args);
-    } catch {
-      // 控制台输出失败也不能拖垮服务
-    }
-  };
-  const flush = () => {
-    try {
-      appendFileSync(logPath, "", "utf8");
-    } catch (err) {
-      appendStartupTrace("fileLog flush failed", { error: err instanceof Error ? err.message : String(err) });
-    }
-  };
-  origConsoleLog(`Log file: ${logPath}`);
-  return { logPath, flush };
-}
+export function setupFileLogging(logDir: string, prefix: string): { logPath: string; flush: () => void } {
+  mkdirSync(logDir, { recursive: true });
+  const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const logPath = join(logDir, `${prefix}-${ts}.log`);
+  writeFileSync(logPath, "", { flag: "a", encoding: "utf8" });
+  const origConsoleLog = console.log.bind(console);
+  const origConsoleError = console.error.bind(console);
+  const formatArg = (arg: unknown): string => {
+    if (typeof arg === "string") return arg;
+    if (arg instanceof Error) return arg.stack ?? arg.message;
+    return inspect(arg, { depth: 6, breakLength: Infinity, maxArrayLength: 200 });
+  };
+  const writeLine = (level: string, args: unknown[]) => {
+    try {
+      const line = args.map(formatArg).join(" ");
+      appendFileSync(logPath, `[${new Date().toISOString()}] [${level}] ${line}\n`, "utf8");
+    } catch (err) {
+      try {
+        appendStartupTrace("fileLog write failed", { level, error: err instanceof Error ? err.message : String(err) });
+      } catch {
+        // 日志系统自身不能影响主流程
+      }
+    }
+  };
+  console.log = (...args: unknown[]) => {
+    writeLine("LOG", args);
+    try {
+      origConsoleLog(...args);
+    } catch {
+      // 控制台输出失败也不能拖垮服务
+    }
+  };
+  console.error = (...args: unknown[]) => {
+    writeLine("ERR", args);
+    try {
+      origConsoleError(...args);
+    } catch {
+      // 控制台输出失败也不能拖垮服务
+    }
+  };
+  const flush = () => {
+    try {
+      appendFileSync(logPath, "", "utf8");
+    } catch (err) {
+      appendStartupTrace("fileLog flush failed", { error: err instanceof Error ? err.message : String(err) });
+    }
+  };
+  origConsoleLog(`Log file: ${logPath}`);
+  return { logPath, flush };
+}
 
 // ---------------------------------------------------------------------------
 // 本地 WebSocket 中继服务器（同一端口、多客户端广播）

package/src/stream-state.ts

@@ -1,94 +1,141 @@
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
-import { USER_DATA_DIR, ts } from "./config.ts";
-
-// ---------------------------------------------------------------------------
-// stream-state.json — 每个 session 的流式输出持久化文件
-// ---------------------------------------------------------------------------
-
-export const STREAMS_DIR = join(USER_DATA_DIR, "state", "streams");
-
-export interface StreamState {
-  sessionId: string;
-  status: "running" | "done" | "stopped" | "error";
-  accumulatedContent: string;
-  finalReply: string;
-  chunkCount: number;
-  turnCount: number;
-  contextTokens: number;
-  updatedAt: number;
-  cwd: string;
-  tool: string;
-}
-
-function getStreamStatePath(sessionId: string): string {
-  return join(STREAMS_DIR, `${sessionId}.json`);
-}
-
-export async function readStreamState(sessionId: string): Promise<StreamState | null> {
-  try {
-    const raw = await readFile(getStreamStatePath(sessionId), "utf-8");
-    const parsed = JSON.parse(raw) as StreamState;
-    if (parsed && typeof parsed.sessionId === "string") return parsed;
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-export async function writeStreamState(state: StreamState): Promise<void> {
-  const filePath = getStreamStatePath(state.sessionId);
-  try {
-    await mkdir(dirname(filePath), { recursive: true });
-    // 先写临时文件再 rename，保证原子性
-    const tmpPath = filePath + ".tmp";
-    await writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
-    await writeFile(filePath, JSON.stringify(state, null, 2), "utf-8");
-  } catch (err) {
-    console.error(`[${ts()}] Failed to write stream-state for ${state.sessionId}: ${(err as Error).message}`);
-  }
-}
-
-export function createEmptyStreamState(sessionId: string, cwd: string, tool: string, turnCount: number): StreamState {
-  return {
-    sessionId,
-    status: "running",
-    accumulatedContent: "",
-    finalReply: "",
-    chunkCount: 0,
-    turnCount,
-    contextTokens: 0,
-    updatedAt: Date.now(),
-    cwd,
-    tool,
-  };
-}
-
-/** 进程重启时修正虚假的 "running" 状态 */
-export async function fixStaleStreamStates(): Promise<void> {
-  // 启动时将残留的 running 标记为 error
-  // 实际 agent 进程已不存在，下次 prompt 时会自然覆盖
-  try {
-    const { readdir } = await import("node:fs/promises");
-    let entries: string[];
-    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 as Error).message}`);
-  }
+import { readFile, writeFile, mkdir, rename, unlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+import { USER_DATA_DIR, ts } from "./config.ts";
+
+// ---------------------------------------------------------------------------
+// stream-state.json — 每个 session 的流式输出持久化文件
+// ---------------------------------------------------------------------------
+
+export const STREAMS_DIR = join(USER_DATA_DIR, "state", "streams");
+
+export interface StreamState {
+  sessionId: string;
+  status: "running" | "done" | "stopped" | "error";
+  accumulatedContent: string;
+  finalReply: string;
+  chunkCount: number;
+  turnCount: number;
+  contextTokens: number;
+  updatedAt: number;
+  cwd: string;
+  tool: string;
+}
+
+function getStreamStatePath(sessionId: string): string {
+  return join(STREAMS_DIR, `${sessionId}.json`);
+}
+
+export async function readStreamState(sessionId: string): Promise<StreamState | null> {
+  try {
+    const raw = await readFile(getStreamStatePath(sessionId), "utf-8");
+    const parsed = JSON.parse(raw) as StreamState;
+    if (parsed && typeof parsed.sessionId === "string") return parsed;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// rename 的可注入实现——仅供测试模拟"Windows EPERM 降级"路径。
+// 生产代码使用 node:fs/promises.rename。
+let renameImpl: typeof rename = rename;
+
+/**
+ * 仅供单测：注入自定义 rename 实现以验证降级分支。
+ * 调用方负责测试结束后用 _resetRenameForTest 还原。
+ */
+export function _setRenameForTest(impl: typeof rename): void {
+  renameImpl = impl;
+}
+
+export function _resetRenameForTest(): void {
+  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: StreamState): Promise<void> {
+  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 as Error).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 as Error).message}`);
+  }
+}
+
+export function createEmptyStreamState(sessionId: string, cwd: string, tool: string, turnCount: number): StreamState {
+  return {
+    sessionId,
+    status: "running",
+    accumulatedContent: "",
+    finalReply: "",
+    chunkCount: 0,
+    turnCount,
+    contextTokens: 0,
+    updatedAt: Date.now(),
+    cwd,
+    tool,
+  };
+}
+
+/** 进程重启时修正虚假的 "running" 状态 */
+export async function fixStaleStreamStates(): Promise<void> {
+  // 启动时将残留的 running 标记为 error
+  // 实际 agent 进程已不存在，下次 prompt 时会自然覆盖
+  try {
+    const { readdir } = await import("node:fs/promises");
+    let entries: string[];
+    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 as Error).message}`);
+  }
 }