chatccc 0.2.252 → 0.2.254

package/dist/src/adapters/cursor-adapter.js

@@ -0,0 +1,491 @@
+// =============================================================================
+// cursor-adapter.ts — Cursor Agent CLI 适配器
+// =============================================================================
+// 通过 agent -p --output-format stream-json 与 Cursor agent 交互。
+// 命令行可通过 config.json cursor.path / cursor.model 自定义。
+// =============================================================================
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseUserCommand } from "./adapter-interface.js";
+import { config, CURSOR_AGENT_COMMAND, CURSOR_AGENT_ARGS, PROJECT_ROOT, RAW_STREAM_LOGS_DIR } from "../config.js";
+import { defaultCursorSessionMetaStore, } from "./cursor-session-meta-store.js";
+import { killProcessTree } from "./proc-tree-kill.js";
+import { createRawStreamLog, } from "./raw-stream-log.js";
+import { readJsonLinesWithBadJsonIdleWatchdog } from "./jsonl-stream.js";
+// ---------------------------------------------------------------------------
+// 特殊注入提示
+// ---------------------------------------------------------------------------
+const CURSOR_SPECIFIC_PROMPT_PATH = join(PROJECT_ROOT, "agent-prompts", "cursor_specific.md");
+function readCursorSpecificInjectionPrompt() {
+    try {
+        if (!existsSync(CURSOR_SPECIFIC_PROMPT_PATH))
+            return null;
+        const prompt = readFileSync(CURSOR_SPECIFIC_PROMPT_PATH, "utf-8").trim();
+        return prompt.length > 0 ? prompt : null;
+    }
+    catch {
+        return null;
+    }
+}
+function buildCursorPromptText(userText) {
+    const prompt = readCursorSpecificInjectionPrompt();
+    if (!prompt)
+        return userText;
+    return [
+        "[ChatCCC Cursor-specific injection prompt]",
+        prompt,
+        "[/ChatCCC Cursor-specific injection prompt]",
+        "",
+        userText,
+    ].join("\n");
+}
+function createCursorStreamStats() {
+    return { stdoutLength: 0, rawLineCount: 0, parsedLineCount: 0 };
+}
+function isCursorAuthRelatedError(stderr) {
+    const text = stderr.toLowerCase();
+    return (text.includes("authentication required") ||
+        text.includes("not logged in") ||
+        text.includes("login") ||
+        text.includes("sign in") ||
+        text.includes("unauthorized") ||
+        text.includes("401") ||
+        text.includes("cursor_api_key") ||
+        text.includes("api key"));
+}
+const CURSOR_VISIBLE_STDERR_MAX_CHARS = 1200;
+function sanitizeCursorStderr(stderr) {
+    return stderr
+        .replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/gi, "Bearer <redacted>")
+        .replace(/\bsk-[A-Za-z0-9_-]{12,}\b/g, "<redacted-api-key>")
+        .replace(/\b(api[_-]?key|token|authorization|password)\s*[:=]\s*["']?[^\s"']+/gi, "$1=<redacted>")
+        .trim();
+}
+function formatCursorVisibleStderr(stderr) {
+    const sanitized = sanitizeCursorStderr(stderr);
+    if (sanitized.length <= CURSOR_VISIBLE_STDERR_MAX_CHARS)
+        return sanitized;
+    return `${sanitized.slice(0, CURSOR_VISIBLE_STDERR_MAX_CHARS)}\n...(stderr truncated)`;
+}
+export function formatCursorAgentEmptyOutputMessage(args) {
+    if (args.exitCode === 0)
+        return null;
+    if (args.stdoutLength !== 0)
+        return null;
+    if (args.stderr.trim().length === 0)
+        return null;
+    const stderrBlock = `[Cursor stderr] exit=${args.exitCode ?? "unknown"}:\n${formatCursorVisibleStderr(args.stderr)}`;
+    if (isCursorAuthRelatedError(args.stderr)) {
+        return `Cursor Agent 没有返回内容。检测到认证相关错误，可能需要重新登录 Cursor Agent，或配置 CURSOR_API_KEY。请在本机运行 agent status 检查状态；如未登录，请运行 agent login 后重试。\n\n${stderrBlock}`;
+    }
+    return `Cursor Agent 没有返回内容。底层命令异常退出，错误信息如下：\n\n${stderrBlock}`;
+}
+function createCursorAgentFailureError(info) {
+    const stderr = info.stderr.trim().slice(0, 500);
+    return new Error(`Cursor Agent exited without stream-json output (exit=${info.code ?? "unknown"}, stderr=${stderr})`);
+}
+// ---------------------------------------------------------------------------
+// normalizeCursorMessage — Cursor 消息 → UnifiedStreamMessage | null
+// ---------------------------------------------------------------------------
+/** Cursor tool_call 内部 key → 统一工具名 */
+function mapToolCallKey(key) {
+    const KEY_MAP = {
+        globToolCall: "Glob",
+        shellToolCall: "Bash",
+        readToolCall: "Read",
+        writeToolCall: "Write",
+        editToolCall: "Edit",
+        grepToolCall: "Grep",
+        webSearchToolCall: "WebSearch",
+        webFetchToolCall: "WebFetch",
+        taskToolCall: "Agent",
+        notebookEditToolCall: "NotebookEdit",
+    };
+    return KEY_MAP[key] ?? key;
+}
+export function normalizeCursorMessage(msg) {
+    if (msg.type === "assistant" && msg.message?.content) {
+        // 按 cursor 官方 stream-json 规范区分三类 assistant 事件，避免 text 重复累加：
+        //   ┌────────────────┬───────────────┬─────────────────┐
+        //   │ 种类            │ timestamp_ms  │ model_call_id   │
+        //   ├────────────────┼───────────────┼─────────────────┤
+        //   │ Streaming delta│ 有             │ 无               │ → 唯一带新文本（text）
+        //   │ Buffered flush │ 有             │ 有               │ → 工具调用前完整快照（text_final）
+        //   │ Final flush    │ 无             │ 无               │ → 回合末完整快照（text_final）
+        //   └────────────────┴───────────────┴─────────────────┘
+        // 文档：cursor.com/docs/cli/reference/output-format
+        const isStreamingDelta = msg.timestamp_ms !== undefined && msg.model_call_id === undefined;
+        const blocks = [];
+        for (const block of msg.message.content) {
+            if (block.type === "thinking" && block.thinking) {
+                blocks.push({ type: "thinking", thinking: block.thinking });
+            }
+            else if (block.type === "tool_use") {
+                blocks.push({
+                    type: "tool_use",
+                    id: block.tool_use_id,
+                    name: block.name ?? "unknown",
+                    input: block.input,
+                });
+            }
+            else if (block.type === "tool_result") {
+                blocks.push({
+                    type: "tool_result",
+                    tool_use_id: block.tool_use_id ?? "",
+                    content: block.content,
+                    is_error: block.is_error,
+                });
+            }
+            else if (block.type === "redacted_thinking") {
+                blocks.push({ type: "redacted_thinking" });
+            }
+            else if (block.type === "search_result") {
+                blocks.push({
+                    type: "search_result",
+                    query: block.query ?? "",
+                });
+            }
+            else if (block.type === "text" && block.text) {
+                blocks.push(isStreamingDelta
+                    ? { type: "text", text: block.text }
+                    : { type: "text_final", text: block.text });
+            }
+        }
+        return { type: "assistant", blocks };
+    }
+    // Cursor agent 发出的独立 thinking delta 消息
+    if (msg.type === "thinking" && msg.subtype === "delta" && msg.text) {
+        return {
+            type: "assistant",
+            blocks: [{ type: "thinking", thinking: msg.text }],
+        };
+    }
+    // Cursor agent 发出的独立 tool_call 消息（tool_call.started / tool_call.completed）
+    if (msg.type === "tool_call" && msg.call_id && msg.tool_call) {
+        const toolKey = Object.keys(msg.tool_call)[0];
+        if (!toolKey)
+            return null;
+        const toolData = msg.tool_call[toolKey];
+        if (!toolData)
+            return null;
+        if (msg.subtype === "started") {
+            return {
+                type: "assistant",
+                blocks: [
+                    {
+                        type: "tool_use",
+                        id: msg.call_id,
+                        name: mapToolCallKey(toolKey),
+                        input: toolData.args ?? {},
+                    },
+                ],
+            };
+        }
+        if (msg.subtype === "completed") {
+            const resultRaw = toolData.result;
+            const hasSuccess = resultRaw && "success" in resultRaw;
+            const hasError = resultRaw && "error" in resultRaw;
+            return {
+                type: "assistant",
+                blocks: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: msg.call_id,
+                        content: hasSuccess
+                            ? resultRaw.success?.stdout ??
+                                resultRaw.success
+                            : hasError
+                                ? resultRaw.error
+                                : resultRaw ?? {},
+                        is_error: hasError || undefined,
+                    },
+                ],
+            };
+        }
+        return null;
+    }
+    if (msg.type === "user" && msg.message?.content) {
+        // Cursor resume 模式会先 echo 一条用户输入消息（text 块就是用户原始输入），
+        // 不应混入 assistant 输出累加。这里只保留 tool_result（工具调用反馈）。
+        const blocks = [];
+        for (const block of msg.message.content) {
+            if (block.type === "tool_result") {
+                blocks.push({
+                    type: "tool_result",
+                    tool_use_id: block.tool_use_id ?? "",
+                    content: block.content,
+                    is_error: block.is_error,
+                });
+            }
+        }
+        return { type: "user", blocks };
+    }
+    // result 消息：cursor 官方推荐的"权威最终文本"来源（流末发出，含完整一段文字）。
+    // 提取为 assistant 的 text_final 块，由 session.ts 累积到 finalCompleteText。
+    if (msg.type === "result" && typeof msg.result === "string" && msg.result.length > 0) {
+        return {
+            type: "assistant",
+            blocks: [{ type: "text_final", text: msg.result }],
+            isFinalResponse: true,
+        };
+    }
+    if (msg.type === "system" && msg.subtype === "compact_boundary") {
+        const meta = msg.compact_metadata;
+        if (!meta)
+            return null;
+        return {
+            type: "system",
+            blocks: [
+                {
+                    type: "compact_boundary",
+                    trigger: meta.trigger ?? "auto",
+                    pre_tokens: meta.pre_tokens ?? 0,
+                    post_tokens: meta.post_tokens,
+                },
+            ],
+        };
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// 子进程辅助函数
+// ---------------------------------------------------------------------------
+function spawnAgent(extraArgs, cwd, stdinText, modelOverride, mode, spawnImpl = spawn) {
+    let allArgs;
+    if (mode) {
+        // plan/ask 模式：移除 --force/--yolo，添加 --mode plan/ask
+        allArgs = CURSOR_AGENT_ARGS.filter(a => a !== "--force" && a !== "--yolo");
+        allArgs.push("--mode", mode);
+        allArgs.push(...extraArgs);
+    }
+    else {
+        allArgs = [...CURSOR_AGENT_ARGS, ...extraArgs];
+    }
+    if (modelOverride) {
+        // 替换全局 --model 为 per-session override
+        const modelIdx = allArgs.findIndex((a, i) => a === "--model" && i + 1 < allArgs.length);
+        if (modelIdx >= 0) {
+            allArgs[modelIdx + 1] = modelOverride;
+        }
+        else {
+            allArgs.push("--model", modelOverride);
+        }
+    }
+    const proc = spawnImpl(CURSOR_AGENT_COMMAND, allArgs, {
+        cwd,
+        stdio: [stdinText !== undefined ? "pipe" : "ignore", "pipe", "pipe"],
+        windowsHide: true,
+        shell: true,
+    });
+    console.log(`[Cursor debug] spawn: cmd=${CURSOR_AGENT_COMMAND}, args=[${allArgs.join(", ")}], cwd=${cwd ?? "(none)"}, stdinLen=${stdinText?.length ?? 0}, pid=${proc.pid}`);
+    // 收集 stderr，子进程异常退出时输出到日志，方便排查静默失败
+    let stderr = "";
+    let closeInfo = null;
+    let resolveClose = () => { };
+    const closePromise = new Promise((resolve) => {
+        resolveClose = resolve;
+    });
+    const settleClose = (code, signal) => {
+        if (closeInfo)
+            return;
+        closeInfo = { code, signal, stderr };
+        if (stderr.trim()) {
+            console.error(`[Cursor stderr] exit=${code}: ${stderr.trim().slice(0, 2000)}`);
+        }
+        resolveClose(closeInfo);
+    };
+    proc.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
+    proc.once("error", (err) => {
+        stderr += `${stderr ? "\n" : ""}${err.message}`;
+        settleClose(null, null);
+    });
+    proc.once("close", (code, signal) => { settleClose(code, signal); });
+    if (stdinText !== undefined) {
+        proc.stdin.write(stdinText);
+        proc.stdin.end();
+    }
+    return {
+        proc,
+        getStderr: () => stderr,
+        waitForClose: async () => {
+            if (closeInfo)
+                return { ...closeInfo, stderr };
+            const info = await closePromise;
+            return { ...info, stderr };
+        },
+    };
+}
+async function* readJsonLines(proc, signal, debugTag, rawLog, stats, idleTimeoutMs) {
+    const tag = debugTag ?? "cursor";
+    yield* readJsonLinesWithBadJsonIdleWatchdog({
+        input: proc.stdout,
+        tool: "cursor",
+        tag,
+        signal,
+        rawLog,
+        idleTimeoutMs,
+        parse: (line) => JSON.parse(line),
+        onRawLine: (line) => {
+            if (stats) {
+                stats.rawLineCount++;
+                stats.stdoutLength += Buffer.byteLength(line, "utf-8") + 1;
+            }
+        },
+        onParsedLine: () => {
+            if (stats)
+                stats.parsedLineCount++;
+        },
+        onDone: (info) => {
+            console.log(`[Cursor debug] ${tag} readJsonLines done: ${info.lineCount} raw lines, signalAborted=${info.signalAborted}`);
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// 适配器实现
+// ---------------------------------------------------------------------------
+class CursorAdapter {
+    displayName = "Cursor";
+    sessionDescPrefix = "Cursor Session:";
+    activeProcs = new Set();
+    metaStore;
+    modelOverride;
+    spawnImpl;
+    badJsonIdleTimeoutMs;
+    constructor(metaStore, modelOverride, spawnImpl = spawn, badJsonIdleTimeoutMs) {
+        this.metaStore = metaStore;
+        this.modelOverride = modelOverride;
+        this.spawnImpl = spawnImpl;
+        this.badJsonIdleTimeoutMs = badJsonIdleTimeoutMs;
+    }
+    async createSession(cwd, signal) {
+        if (signal?.aborted)
+            throw new Error("Cursor session creation aborted");
+        const handle = spawnAgent(["ok"], cwd, undefined, this.modelOverride, undefined, this.spawnImpl);
+        const proc = handle.proc;
+        const stats = createCursorStreamStats();
+        this.activeProcs.add(proc);
+        const onAbort = () => { void killProcessTree(proc.pid); };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        try {
+            for await (const msg of readJsonLines(proc, signal, "createSession", null, stats, this.badJsonIdleTimeoutMs)) {
+                if (msg.type === "system" && msg.subtype === "init" && msg.session_id) {
+                    const sessionId = msg.session_id;
+                    await this.metaStore
+                        .set(sessionId, { cwd: msg.cwd ?? cwd, model: msg.model })
+                        .catch(() => { });
+                    return { sessionId };
+                }
+            }
+            if (signal?.aborted)
+                throw new Error("Cursor session creation aborted");
+            const closeInfo = await handle.waitForClose();
+            const visibleMessage = formatCursorAgentEmptyOutputMessage({
+                exitCode: closeInfo.code,
+                stdoutLength: stats.stdoutLength,
+                stderr: closeInfo.stderr,
+            });
+            if (visibleMessage)
+                throw new Error(visibleMessage);
+            throw new Error("No session ID in Cursor init event");
+        }
+        finally {
+            signal?.removeEventListener("abort", onAbort);
+            await killProcessTree(proc.pid);
+            this.activeProcs.delete(proc);
+        }
+    }
+    async *prompt(sessionId, userText, cwd, signal, options) {
+        console.log(`[Cursor debug] prompt start: sessionId=${sessionId}, cwd=${cwd}, userTextLen=${userText.length}`);
+        const cmd = parseUserCommand(userText);
+        const handle = spawnAgent(["--resume", sessionId], cwd, buildCursorPromptText(userText), this.modelOverride, cmd.mode ?? undefined, this.spawnImpl);
+        const proc = handle.proc;
+        this.activeProcs.add(proc);
+        if (proc.pid !== undefined)
+            options?.onProcessStart?.({ pid: proc.pid });
+        const rawLogConfig = config.rawStreamLogs.cursor;
+        let rawLog = null;
+        try {
+            rawLog = await createRawStreamLog({
+                enabled: rawLogConfig.enabled,
+                rootDir: RAW_STREAM_LOGS_DIR,
+                tool: "cursor",
+                sessionId,
+                label: "prompt",
+                maxBytesPerTurn: rawLogConfig.maxBytesPerTurn,
+                retentionDays: rawLogConfig.retentionDays,
+            });
+        }
+        catch (err) {
+            console.error(`[Cursor raw stream log] create failed: ${err.message}`);
+        }
+        // 见 codex-adapter.ts 同位置注释：spawn 用了 shell:true，必须杀整棵树，
+        // 否则 abort 后真正在跑的孙进程 cursor-agent 还会继续输出 & 占用资源。
+        const onAbort = () => { void killProcessTree(proc.pid); };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        let sawResult = false;
+        const stats = createCursorStreamStats();
+        try {
+            for await (const raw of readJsonLines(proc, signal, sessionId, rawLog, stats, this.badJsonIdleTimeoutMs)) {
+                if (signal?.aborted)
+                    break;
+                if (raw.type === "system" &&
+                    raw.subtype === "init" &&
+                    raw.session_id &&
+                    (raw.cwd || raw.model)) {
+                    this.metaStore
+                        .set(raw.session_id, { cwd: raw.cwd, model: raw.model })
+                        .catch(() => { });
+                }
+                const normalized = normalizeCursorMessage(raw);
+                if (normalized)
+                    yield normalized;
+                // result 是流末事件，收到后立即结束进程，防止 CLI 僵死导致 readline 挂起。
+                if (raw.type === "result") {
+                    sawResult = true;
+                    void killProcessTree(proc.pid);
+                    break;
+                }
+            }
+            if (!signal?.aborted && !sawResult) {
+                const closeInfo = await handle.waitForClose();
+                const visibleMessage = formatCursorAgentEmptyOutputMessage({
+                    exitCode: closeInfo.code,
+                    stdoutLength: stats.stdoutLength,
+                    stderr: closeInfo.stderr,
+                });
+                if (visibleMessage) {
+                    yield {
+                        type: "assistant",
+                        blocks: [{ type: "text_final", text: visibleMessage }],
+                    };
+                    throw createCursorAgentFailureError(closeInfo);
+                }
+            }
+        }
+        finally {
+            signal?.removeEventListener("abort", onAbort);
+            await killProcessTree(proc.pid);
+            await rawLog?.close({ keep: rawLogConfig.keepCompleted || signal?.aborted === true || !sawResult });
+            this.activeProcs.delete(proc);
+            if (proc.pid !== undefined)
+                options?.onProcessExit?.({ pid: proc.pid });
+            console.log(`[Cursor debug] prompt end: sessionId=${sessionId}, signalAborted=${signal?.aborted ?? false}`);
+        }
+    }
+    async getSessionInfo(sessionId) {
+        const meta = await this.metaStore.get(sessionId);
+        if (!meta)
+            return { sessionId };
+        return meta.model
+            ? { sessionId, cwd: meta.cwd, model: meta.model }
+            : { sessionId, cwd: meta.cwd };
+    }
+    async closeSession(_sessionId) {
+        // 子进程由 prompt 的 finally 自动 kill
+    }
+}
+export function createCursorAdapter(options = {}) {
+    return new CursorAdapter(options.metaStore ?? defaultCursorSessionMetaStore, options.model, options.spawn, options.badJsonIdleTimeoutMs);
+}

package/dist/src/adapters/cursor-session-meta-store.js

@@ -0,0 +1,116 @@
+// =============================================================================
+// 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.js";
+/** 持久化文件默认路径（生产）。测试可通过 createCursorSessionMetaStore(filePath) 注入。 */
+export const CURSOR_SESSION_META_FILE = join(USER_DATA_DIR, "state", "cursor-session-meta.json");
+function isNonEmptyString(v) {
+    return typeof v === "string" && v.length > 0;
+}
+/**
+ * 解析持久化文件中的单条记录，兼容历史 schema：
+ *   - 新版：{ cwd: string, model?: string }
+ *   - 历史 v1：纯字符串（直接是 cwd 值）—— 升级前旧数据兼容
+ * 非法形态返回 null。
+ */
+function parseEntry(raw) {
+    if (typeof raw === "string" && raw.length > 0) {
+        return { cwd: raw };
+    }
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        const obj = raw;
+        const out = {};
+        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 = CURSOR_SESSION_META_FILE) {
+    let cache = null;
+    async function load() {
+        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 = {};
+                for (const [k, v] of Object.entries(parsed)) {
+                    const entry = parseEntry(v);
+                    if (entry)
+                        out[k] = entry;
+                }
+                cache = out;
+                return out;
+            }
+        }
+        catch {
+            // 文件不存在 / JSON 损坏 / 读权限失败 → 视为空映射，不阻断主流程
+        }
+        cache = {};
+        return cache;
+    }
+    return {
+        async get(sessionId) {
+            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, partial) {
+            const map = await load();
+            const existing = map[sessionId] ?? {};
+            const merged = { ...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.message}`);
+            }
+        },
+    };
+}
+/** 生产环境共享的全局默认实例（指向 state/cursor-session-meta.json）。 */
+export const defaultCursorSessionMetaStore = createCursorSessionMetaStore();