chatccc 0.2.252 → 0.2.253

package/src/adapters/cursor-session-meta-store.ts

@@ -1,154 +0,0 @@
-// =============================================================================
-// cursor-session-meta-store.ts — Cursor 会话 sessionId → meta 持久化映射
-// =============================================================================
-// 背景：Claude Adapter 通过 SDK 的 getSessionInfo 能拿到会话的真实 cwd（SDK
-// 内部已持久化）。Cursor CLI 没有等价机制，因此 ChatCCC 必须自己维护一份
-// sessionId → { cwd, model } 映射，否则：
-//   1. /git、/cd 等需要"会话真实工作目录"的命令将在 Cursor 会话上 100% 失败
-//   2. /state、/sessions 显示的"模型"只能硬塞 ChatCCC 的 ANTHROPIC 环境变量，
-//      与 Cursor 实际跑的 Composer 2 Fast 等真实模型无关
-//
-// 存储：
-//   文件 state/cursor-session-meta.json，结构：
-//     { "<sessionId>": { "cwd": "...", "model": "..." } }
-//
-// API 设计：
-//   set(sid, partial) → 部分合并写入；只更新非空字段，不会清空其他字段
-//   这样 createSession（拿到 cwd+model）与 prompt（resume 时再次学习）都用同一
-//   接口，但若某次 init 事件少了某字段也不会破坏已记录值。
-//
-// 鲁棒性：文件不存在/损坏/IO 失败一律视为空映射，仅打日志，不阻断主流程。
-// =============================================================================
-
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
-import { USER_DATA_DIR } from "../config.ts";
-
-/** 持久化文件默认路径（生产）。测试可通过 createCursorSessionMetaStore(filePath) 注入。 */
-export const CURSOR_SESSION_META_FILE = join(
-  USER_DATA_DIR,
-  "state",
-  "cursor-session-meta.json",
-);
-
-/**
- * 单条会话元数据。cwd 为必填（无 cwd 的记录视为不完整，get 返回 undefined）；
- * model 可选（cursor agent init 事件理论上一定带，留可选是为防御性兜底）。
- */
-export interface CursorSessionMeta {
-  cwd: string;
-  model?: string;
-}
-
-export interface CursorSessionMetaStore {
-  /** 查询某 sessionId 对应的元数据；未记录或 cwd 缺失返回 undefined。 */
-  get(sessionId: string): Promise<CursorSessionMeta | undefined>;
-  /**
-   * 部分合并写入：仅写入非 undefined / 非空字段；其他字段保持原值。
-   * - 第一次写入若不含 cwd，记录视为不完整，get 仍返回 undefined
-   * - 同 sessionId 重复写入完全相同值时跳过 IO（性能优化）
-   */
-  set(sessionId: string, partial: Partial<CursorSessionMeta>): Promise<void>;
-}
-
-interface RawEntry {
-  cwd?: string;
-  model?: string;
-}
-
-function isNonEmptyString(v: unknown): v is string {
-  return typeof v === "string" && v.length > 0;
-}
-
-/**
- * 解析持久化文件中的单条记录，兼容历史 schema：
- *   - 新版：{ cwd: string, model?: string }
- *   - 历史 v1：纯字符串（直接是 cwd 值）—— 升级前旧数据兼容
- * 非法形态返回 null。
- */
-function parseEntry(raw: unknown): RawEntry | null {
-  if (typeof raw === "string" && raw.length > 0) {
-    return { cwd: raw };
-  }
-  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
-    const obj = raw as Record<string, unknown>;
-    const out: RawEntry = {};
-    if (isNonEmptyString(obj.cwd)) out.cwd = obj.cwd;
-    if (isNonEmptyString(obj.model)) out.model = obj.model;
-    return out;
-  }
-  return null;
-}
-
-/**
- * 创建一个基于 JSON 文件的 store 实例。
- *
- * - 首次访问时懒加载文件到内存缓存；后续读全部走缓存
- * - 写时先合并到缓存再落盘（写失败仅 console.error，不抛异常）
- * - 同一 sessionId 重复 set 完全相同值时跳过 IO
- */
-export function createCursorSessionMetaStore(
-  filePath: string = CURSOR_SESSION_META_FILE,
-): CursorSessionMetaStore {
-  let cache: Record<string, RawEntry> | null = null;
-
-  async function load(): Promise<Record<string, RawEntry>> {
-    if (cache) return cache;
-    try {
-      const raw = await readFile(filePath, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        const out: Record<string, RawEntry> = {};
-        for (const [k, v] of Object.entries(parsed as Record<string, unknown>)) {
-          const entry = parseEntry(v);
-          if (entry) out[k] = entry;
-        }
-        cache = out;
-        return out;
-      }
-    } catch {
-      // 文件不存在 / JSON 损坏 / 读权限失败 → 视为空映射，不阻断主流程
-    }
-    cache = {};
-    return cache;
-  }
-
-  return {
-    async get(sessionId: string): Promise<CursorSessionMeta | undefined> {
-      const map = await load();
-      const entry = map[sessionId];
-      if (!entry || !isNonEmptyString(entry.cwd)) return undefined;
-      return entry.model
-        ? { cwd: entry.cwd, model: entry.model }
-        : { cwd: entry.cwd };
-    },
-
-    async set(
-      sessionId: string,
-      partial: Partial<CursorSessionMeta>,
-    ): Promise<void> {
-      const map = await load();
-      const existing = map[sessionId] ?? {};
-      const merged: RawEntry = { ...existing };
-      if (isNonEmptyString(partial.cwd)) merged.cwd = partial.cwd;
-      if (isNonEmptyString(partial.model)) merged.model = partial.model;
-
-      // 与原值完全相同时跳过 IO
-      if (existing.cwd === merged.cwd && existing.model === merged.model) return;
-
-      map[sessionId] = merged;
-      try {
-        await mkdir(dirname(filePath), { recursive: true });
-        await writeFile(filePath, JSON.stringify(map, null, 2), "utf-8");
-      } catch (err) {
-        console.error(
-          `[cursor-session-meta] failed to persist ${filePath}: ${(err as Error).message}`,
-        );
-      }
-    },
-  };
-}
-
-/** 生产环境共享的全局默认实例（指向 state/cursor-session-meta.json）。 */
-export const defaultCursorSessionMetaStore = createCursorSessionMetaStore();

package/src/adapters/jsonl-stream.ts

@@ -1,157 +0,0 @@
-import { createInterface } from "node:readline";
-
-interface JsonLineSink {
-  writeLine(line: string): void;
-}
-
-export const DEFAULT_BAD_JSON_IDLE_TIMEOUT_MS = 120_000;
-export const BAD_JSON_IDLE_TIMEOUT_CODE = "BAD_JSON_IDLE_TIMEOUT";
-
-export class BadJsonIdleTimeoutError extends Error {
-  readonly code = BAD_JSON_IDLE_TIMEOUT_CODE;
-  readonly tool: string;
-  readonly tag: string;
-  readonly timeoutMs: number;
-  readonly lineNumber: number;
-  readonly lineExcerpt: string;
-  readonly parseError: string;
-
-  constructor(args: {
-    tool: string;
-    tag: string;
-    timeoutMs: number;
-    lineNumber: number;
-    lineExcerpt: string;
-    parseError: string;
-  }) {
-    super(
-      `${args.tool} stream stopped after invalid JSON for ${args.timeoutMs}ms ` +
-        `(tag=${args.tag}, line=${args.lineNumber}): ${args.lineExcerpt}`,
-    );
-    this.name = "BadJsonIdleTimeoutError";
-    this.tool = args.tool;
-    this.tag = args.tag;
-    this.timeoutMs = args.timeoutMs;
-    this.lineNumber = args.lineNumber;
-    this.lineExcerpt = args.lineExcerpt;
-    this.parseError = args.parseError;
-  }
-}
-
-export interface ReadJsonLinesDoneInfo {
-  lineCount: number;
-  signalAborted: boolean;
-  protocolError: BadJsonIdleTimeoutError | null;
-}
-
-export interface ReadJsonLinesOptions<T> {
-  input: NodeJS.ReadableStream;
-  tool: string;
-  tag?: string;
-  signal?: AbortSignal;
-  rawLog?: JsonLineSink | null;
-  idleTimeoutMs?: number;
-  parse?: (line: string) => T;
-  onRawLine?: (line: string, lineNumber: number) => void;
-  onParsedLine?: (value: T, line: string, lineNumber: number) => void;
-  onDone?: (info: ReadJsonLinesDoneInfo) => void;
-}
-
-function isJsonLike(line: string): boolean {
-  return line.startsWith("{") || line.startsWith("[");
-}
-
-function lineExcerpt(line: string): string {
-  const max = 500;
-  return line.length <= max ? line : `${line.slice(0, max)}...`;
-}
-
-function parseErrorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-export async function* readJsonLinesWithBadJsonIdleWatchdog<T>({
-  input,
-  tool,
-  tag = tool,
-  signal,
-  rawLog,
-  idleTimeoutMs = DEFAULT_BAD_JSON_IDLE_TIMEOUT_MS,
-  parse = (line: string) => JSON.parse(line) as T,
-  onRawLine,
-  onParsedLine,
-  onDone,
-}: ReadJsonLinesOptions<T>): AsyncGenerator<T> {
-  const rl = createInterface({ input, crlfDelay: Infinity });
-  let lineCount = 0;
-  let protocolError: BadJsonIdleTimeoutError | null = null;
-  let badJsonIdleTimer: ReturnType<typeof setTimeout> | null = null;
-
-  const clearBadJsonIdleTimer = () => {
-    if (!badJsonIdleTimer) return;
-    clearTimeout(badJsonIdleTimer);
-    badJsonIdleTimer = null;
-  };
-
-  const armBadJsonIdleTimer = (line: string, lineNumber: number, error: unknown) => {
-    if (idleTimeoutMs <= 0) return;
-    clearBadJsonIdleTimer();
-    badJsonIdleTimer = setTimeout(() => {
-      protocolError = new BadJsonIdleTimeoutError({
-        tool,
-        tag,
-        timeoutMs: idleTimeoutMs,
-        lineNumber,
-        lineExcerpt: lineExcerpt(line),
-        parseError: parseErrorMessage(error),
-      });
-      rl.close();
-    }, idleTimeoutMs);
-    const timerWithUnref = badJsonIdleTimer as ReturnType<typeof setTimeout> & {
-      unref?: () => void;
-    };
-    timerWithUnref.unref?.();
-  };
-
-  const onAbort = () => {
-    clearBadJsonIdleTimer();
-    rl.close();
-  };
-  signal?.addEventListener("abort", onAbort, { once: true });
-
-  try {
-    for await (const line of rl) {
-      if (signal?.aborted) break;
-      lineCount++;
-      onRawLine?.(line, lineCount);
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-
-      clearBadJsonIdleTimer();
-      rawLog?.writeLine(trimmed);
-
-      try {
-        const parsed = parse(trimmed);
-        onParsedLine?.(parsed, trimmed, lineCount);
-        yield parsed;
-      } catch (error) {
-        if (isJsonLike(trimmed)) {
-          armBadJsonIdleTimer(trimmed, lineCount, error);
-        }
-      }
-    }
-
-    if (protocolError && !signal?.aborted) {
-      throw protocolError;
-    }
-  } finally {
-    signal?.removeEventListener("abort", onAbort);
-    clearBadJsonIdleTimer();
-    rl.close();
-    onDone?.({
-      lineCount,
-      signalAborted: signal?.aborted ?? false,
-      protocolError,
-    });
-  }
-}

package/src/adapters/raw-stream-log.ts

@@ -1,124 +0,0 @@
-import { createWriteStream, type Dirent } from "node:fs";
-import { mkdir, readdir, rm, stat, unlink } from "node:fs/promises";
-import { once } from "node:events";
-import { join } from "node:path";
-import { createGzip } from "node:zlib";
-
-export interface RawStreamLogOptions {
-  enabled: boolean;
-  rootDir: string;
-  tool: string;
-  sessionId: string;
-  label: string;
-  maxBytesPerTurn: number;
-  retentionDays: number;
-}
-
-export interface RawStreamLogHandle {
-  filePath: string;
-  writeLine(line: string): void;
-  close(options: { keep: boolean }): Promise<void>;
-}
-
-export function sanitizeLogPathSegment(value: string): string {
-  const safe = value.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^[._]+|_+$/g, "");
-  return safe || "unknown";
-}
-
-async function cleanupOldRawStreamLogs(rootDir: string, retentionDays: number): Promise<void> {
-  if (!Number.isFinite(retentionDays) || retentionDays <= 0) return;
-  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
-
-  const visit = async (dir: string): Promise<void> => {
-    let entries: Dirent[];
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-
-    await Promise.all(entries.map(async (entry) => {
-      const path = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await visit(path);
-        try {
-          await rm(path, { recursive: false });
-        } catch {
-          // Directory is not empty or already gone.
-        }
-        return;
-      }
-
-      if (!entry.isFile()) return;
-      try {
-        const info = await stat(path);
-        if (info.mtimeMs < cutoff) await rm(path, { force: true });
-      } catch {
-        // Best-effort cleanup only.
-      }
-    }));
-  };
-
-  await visit(rootDir);
-}
-
-export async function createRawStreamLog(options: RawStreamLogOptions): Promise<RawStreamLogHandle | null> {
-  if (!options.enabled) return null;
-
-  const maxBytes = Math.max(0, Math.floor(options.maxBytesPerTurn));
-  const tool = sanitizeLogPathSegment(options.tool);
-  const session = sanitizeLogPathSegment(options.sessionId);
-  const label = sanitizeLogPathSegment(options.label);
-  const dir = join(options.rootDir, tool, session);
-  await mkdir(dir, { recursive: true });
-  void cleanupOldRawStreamLogs(join(options.rootDir, tool), options.retentionDays);
-
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const filePath = join(dir, `${timestamp}-${label}.jsonl.gz`);
-  const output = createWriteStream(filePath);
-  const gzip = createGzip();
-  gzip.pipe(output);
-
-  let bytes = 0;
-  let truncated = false;
-  let ended = false;
-
-  const writeLine = (line: string): void => {
-    if (ended || truncated) return;
-    const payload = `${line}\n`;
-    const payloadBytes = Buffer.byteLength(payload, "utf-8");
-    if (maxBytes > 0 && bytes + payloadBytes > maxBytes) {
-      const marker = JSON.stringify({
-        type: "chatccc_raw_stream_log_truncated",
-        reason: "max_bytes_per_turn_exceeded",
-        maxBytesPerTurn: maxBytes,
-        writtenBytes: bytes,
-      });
-      gzip.write(`${marker}\n`);
-      truncated = true;
-      return;
-    }
-    bytes += payloadBytes;
-    gzip.write(payload);
-  };
-
-  const close = async ({ keep }: { keep: boolean }): Promise<void> => {
-    if (ended) return;
-    ended = true;
-    gzip.end();
-    try {
-      await once(output, "finish");
-    } catch {
-      // Ignore close errors; caller cannot recover from debug log failures.
-    }
-    if (!keep) {
-      try {
-        await unlink(filePath);
-      } catch {
-        // Best-effort cleanup only.
-      }
-    }
-  };
-
-  return { filePath, writeLine, close };
-}

package/src/adapters/resource-monitor.ts

@@ -1,141 +0,0 @@
-// =============================================================================
-// resource-monitor.ts — CLI 进程资源监控（CPU + 内存）
-// =============================================================================
-// 对所有 chatccc 启动的 CLI 进程持续监控 CPU 和内存占用。
-// 若连续 3 分钟两项指标均无变化，判定为僵死，发出 "stuck" 事件。
-// =============================================================================
-
-import { exec } from "node:child_process";
-import { EventEmitter } from "node:events";
-
-const CHECK_INTERVAL_MS = 30_000; // 30 秒检查一次
-const STUCK_THRESHOLD = 6; // 连续 6 次无变化 = 3 分钟
-
-interface ProcessSnapshot {
-  cpu: number;
-  memory: number;
-  unchangedCount: number;
-}
-
-interface TrackedProcess {
-  pid: number;
-  sessionId: string;
-  snapshot: ProcessSnapshot;
-}
-
-export const resourceMonitor = new EventEmitter();
-
-const tracked = new Map<number, TrackedProcess>();
-
-let timer: ReturnType<typeof setInterval> | null = null;
-
-function startIfNeeded(): void {
-  if (timer) return;
-  timer = setInterval(checkAll, CHECK_INTERVAL_MS);
-  timer.unref?.();
-}
-
-function stopIfIdle(): void {
-  if (tracked.size > 0) return;
-  if (timer) { clearInterval(timer); timer = null; }
-}
-
-export function registerProcess(pid: number, sessionId: string): void {
-  tracked.set(pid, { pid, sessionId, snapshot: { cpu: -1, memory: -1, unchangedCount: 0 } });
-  startIfNeeded();
-}
-
-export function unregisterProcess(pid: number): void {
-  tracked.delete(pid);
-  stopIfIdle();
-}
-
-// ---------------------------------------------------------------------------
-// 批量查询进程指标（Windows PowerShell）
-// ---------------------------------------------------------------------------
-
-function execPowerShell(script: string, timeoutMs: number): Promise<string> {
-  return new Promise((resolve, reject) => {
-    exec(
-      `powershell -NoProfile -Command "${script}"`,
-      { timeout: timeoutMs, windowsHide: true },
-      (err, stdout) => {
-        if (err) reject(err);
-        else resolve(stdout);
-      },
-    );
-  });
-}
-
-async function getProcessMetrics(pids: number[]): Promise<Map<number, { cpu: number; memory: number }>> {
-  const result = new Map<number, { cpu: number; memory: number }>();
-  if (pids.length === 0) return result;
-
-  const psScript = `Get-Process -Id ${pids.join(",")} -ErrorAction SilentlyContinue | ForEach-Object { "$($_.Id)|$($_.CPU)|$($_.WorkingSet64)" }`;
-
-  try {
-    const stdout = await execPowerShell(psScript, 10_000);
-    for (const line of stdout.trim().split(/\r?\n/)) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      const [idStr, cpuStr, memStr] = trimmed.split("|");
-      const id = parseInt(idStr, 10);
-      const cpu = parseFloat(cpuStr);
-      const memory = parseInt(memStr, 10);
-      if (!isNaN(id) && !isNaN(cpu) && !isNaN(memory)) {
-        result.set(id, { cpu, memory });
-      }
-    }
-  } catch {
-    // PowerShell 查询失败时跳过本轮，下次重试
-  }
-
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// 定时检查
-// ---------------------------------------------------------------------------
-
-async function checkAll(): Promise<void> {
-  if (tracked.size === 0) return;
-
-  const pids = [...tracked.keys()];
-  const metrics = await getProcessMetrics(pids);
-
-  for (const [pid, tp] of tracked) {
-    const m = metrics.get(pid);
-    if (!m) {
-      // 进程已不存在，停止追踪
-      tracked.delete(pid);
-      continue;
-    }
-
-    const prev = tp.snapshot;
-    const cpuChanged = m.cpu !== prev.cpu;
-    // 内存允许 ±1% 波动，避免正常抖动触发误判
-    const memTolerance = prev.memory > 0 ? Math.max(prev.memory * 0.01, 1024 * 1024) : 1024 * 1024;
-    const memChanged = Math.abs(m.memory - prev.memory) > memTolerance;
-
-    if (!cpuChanged && !memChanged) {
-      tp.snapshot.unchangedCount++;
-      if (tp.snapshot.unchangedCount >= STUCK_THRESHOLD) {
-        const idleMinutes = Math.round(
-          (tp.snapshot.unchangedCount * CHECK_INTERVAL_MS) / 60_000,
-        );
-        resourceMonitor.emit("stuck", {
-          pid: tp.pid,
-          sessionId: tp.sessionId,
-          idleMinutes,
-        });
-        tracked.delete(pid);
-      }
-    } else {
-      tp.snapshot.unchangedCount = 0;
-    }
-    tp.snapshot.cpu = m.cpu;
-    tp.snapshot.memory = m.memory;
-  }
-
-  stopIfIdle();
-}