chatccc 0.2.252 → 0.2.253

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

@@ -0,0 +1,497 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseUserCommand } from "./adapter-interface.js";
+import { CHATCCC_PORT, config, PROJECT_ROOT, RAW_STREAM_LOGS_DIR } from "../config.js";
+import { defaultClaudeSessionMetaStore, } from "./claude-session-meta-store.js";
+import { createRawStreamLog, } from "./raw-stream-log.js";
+import { getClaudeSdkEntryPath } from "../claude-sdk-installer.js";
+const CLAUDE_SPECIFIC_PROMPT_PATH = join(PROJECT_ROOT, "agent-prompts", "claude_specific.md");
+export function buildSdkEnv(subagentModel, apiKey, baseUrl) {
+    const subagentModelTrim = (subagentModel ?? "").trim();
+    const apiKeyTrim = (apiKey ?? "").trim();
+    const baseUrlTrim = (baseUrl ?? "").trim();
+    const env = { ...process.env };
+    let mutated = preferGitBashOnWindows(env);
+    // Claude Code 2.1.136+ 会在每次请求中注入 x-anthropic-billing-header，
+    // 导致 prompt 前缀变化、缓存命中率急剧下降。设为 0 关闭。
+    env.CLAUDE_CODE_ATTRIBUTION_HEADER = "0";
+    mutated = true;
+    if (subagentModelTrim || apiKeyTrim || baseUrlTrim) {
+        delete env.ANTHROPIC_AUTH_TOKEN;
+        delete env.CLAUDE_CODE_OAUTH_TOKEN;
+        delete env.ANTHROPIC_MODEL;
+        delete env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+        delete env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+        delete env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+        delete env.CLAUDE_CODE_EFFORT_LEVEL;
+        delete env.CLAUDE_CODE_SUBAGENT_MODEL;
+        mutated = true;
+    }
+    if (subagentModelTrim)
+        env.CLAUDE_CODE_SUBAGENT_MODEL = subagentModelTrim;
+    if (apiKeyTrim)
+        env.ANTHROPIC_API_KEY = apiKeyTrim;
+    if (baseUrlTrim)
+        env.ANTHROPIC_BASE_URL = baseUrlTrim;
+    return mutated ? env : undefined;
+}
+function preferGitBashOnWindows(env) {
+    if (process.platform !== "win32")
+        return false;
+    const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") ?? "PATH";
+    const rawPath = env[pathKey];
+    if (!rawPath)
+        return false;
+    const parts = rawPath.split(delimiter).filter((part) => part && part !== "%PATH%");
+    const preferred = findPreferredGitBashPath(parts);
+    if (!preferred) {
+        const nextPath = parts.join(delimiter);
+        if (nextPath !== rawPath) {
+            env[pathKey] = nextPath;
+            return true;
+        }
+        return false;
+    }
+    const preferredLower = preferred.toLowerCase();
+    const reordered = [
+        preferred,
+        ...parts.filter((part) => part.toLowerCase() !== preferredLower),
+    ];
+    const nextPath = reordered.join(delimiter);
+    if (nextPath === rawPath)
+        return false;
+    env[pathKey] = nextPath;
+    return true;
+}
+function findPreferredGitBashPath(pathParts) {
+    const programFilesGit = join(process.env.ProgramFiles ?? "C:\\Program Files", "Git", "usr", "bin");
+    if (existsSync(join(programFilesGit, "bash.exe")))
+        return programFilesGit;
+    return pathParts.find((part) => {
+        if (!/(\\|\/)(Git)(\\|\/)usr(\\|\/)bin$/i.test(part) &&
+            !/(\\|\/)Fork(\\|\/)gitInstance(\\|\/)[^\\/]+(\\|\/)bin$/i.test(part)) {
+            return false;
+        }
+        return existsSync(join(part, "bash.exe"));
+    });
+}
+function readMcpServersConfig() {
+    const settingsPath = join(homedir(), ".claude", "settings.json");
+    try {
+        if (!existsSync(settingsPath))
+            return undefined;
+        const raw = readFileSync(settingsPath, "utf-8");
+        const settings = JSON.parse(raw);
+        const mcpServers = settings.mcpServers;
+        if (!mcpServers || Object.keys(mcpServers).length === 0)
+            return undefined;
+        return mcpServers;
+    }
+    catch {
+        return undefined;
+    }
+}
+function logMcpConfig() {
+    const settingsPath = join(homedir(), ".claude", "settings.json");
+    const ts = new Date().toISOString();
+    try {
+        if (!existsSync(settingsPath)) {
+            console.log(`[${ts}] [MCP-DIAG] settings.json not found at ${settingsPath}`);
+            return;
+        }
+        const raw = readFileSync(settingsPath, "utf-8");
+        const settings = JSON.parse(raw);
+        const mcpServers = settings.mcpServers;
+        if (!mcpServers || Object.keys(mcpServers).length === 0) {
+            console.log(`[${ts}] [MCP-DIAG] No mcpServers configured in settings.json`);
+            return;
+        }
+        console.log(`[${ts}] [MCP-DIAG] mcpServers found: ${JSON.stringify(Object.keys(mcpServers))}`);
+        for (const [name, cfg] of Object.entries(mcpServers)) {
+            const item = cfg;
+            console.log(`[${ts}] [MCP-DIAG]   ${name}: type=${item.type}, command=${item.command}, args=${JSON.stringify(item.args)}`);
+        }
+    }
+    catch (err) {
+        console.log(`[${ts}] [MCP-DIAG] Failed to read settings.json: ${err.message}`);
+    }
+}
+export function normalizeSdkMessage(msg) {
+    // SDK result/success 是 Claude 对本轮完整结束的权威确认。文本已经由之前的
+    // assistant 消息累计，因此这里只发送终态信号，避免重复追加 result 文本。
+    if (msg.type === "result" && msg.subtype === "success") {
+        return {
+            type: "assistant",
+            blocks: [],
+            isFinalResponse: true,
+        };
+    }
+    if ((msg.type === "assistant" || msg.type === "user") &&
+        msg.message?.content) {
+        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.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) {
+                if (msg.type === "user")
+                    continue;
+                blocks.push({ type: "text", text: block.text });
+            }
+        }
+        return { type: msg.type, blocks };
+    }
+    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;
+}
+export function readClaudeSpecificInjectionPrompt() {
+    try {
+        if (!existsSync(CLAUDE_SPECIFIC_PROMPT_PATH))
+            return null;
+        const prompt = readFileSync(CLAUDE_SPECIFIC_PROMPT_PATH, "utf-8").trim();
+        return prompt.length > 0 ? prompt : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function buildClaudePromptText(userText, injectionPrompt = readClaudeSpecificInjectionPrompt(), sessionId) {
+    let prompt = injectionPrompt?.trim();
+    if (!prompt)
+        return userText;
+    // 动态替换注入提示词中的占位符（端口、session_id 等）
+    if (sessionId) {
+        prompt = prompt
+            .replace(/\{\{stop_stuck_url\}\}/g, `http://127.0.0.1:${CHATCCC_PORT}/api/agent/stop-stuck-loop`)
+            .replace(/\{\{session_id\}\}/g, sessionId);
+    }
+    return [
+        "[ChatCCC Claude-specific injection prompt]",
+        prompt,
+        "[/ChatCCC Claude-specific injection prompt]",
+        "",
+        userText,
+    ].join("\n");
+}
+let sdkModulePromise = null;
+/**
+ * 按需加载 Claude Code 引擎（Agent SDK）。SDK 不在 chatccc 的 dependencies 中，
+ * 首次使用前需在设置页「Claude Code」卡片点「安装引擎」下载到 ~/.chatccc/claude-sdk/。
+ */
+export function loadClaudeSdkModule() {
+    if (!sdkModulePromise) {
+        sdkModulePromise = import(__rewriteRelativeImportExtension(pathToFileURL(getClaudeSdkEntryPath()).href))
+            .then((m) => m)
+            .catch((err) => {
+            sdkModulePromise = null;
+            const detail = err instanceof Error ? err.message : String(err);
+            throw new Error(`Claude Code 引擎（SDK）未安装或加载失败：${detail}。` +
+                "请在设置页「Claude Code」卡片点击「安装引擎」后重试。");
+        });
+    }
+    return sdkModulePromise;
+}
+/**
+ * 测试钩子：注入假 SDK 模块（vitest 的 vi.mock 无法拦截变量路径的动态 import）。
+ * 传入 null 恢复为真实按需加载。
+ */
+export function __setClaudeSdkModuleForTest(module) {
+    sdkModulePromise = module ? Promise.resolve(module) : null;
+}
+function buildSdkOptions(args) {
+    const { cwd, model, effort, isEmpty, subagentModel, apiKey, baseUrl, maxTurn, abortController, userText, } = args;
+    const cmd = parseUserCommand(userText);
+    const limited = cmd.mode !== null;
+    const options = {
+        cwd,
+        abortController,
+        settingSources: ["user", "project", "local"],
+        permissionMode: limited ? "default" : "bypassPermissions",
+        autoCompactEnabled: true,
+        maxTurns: maxTurn,
+        skills: "all",
+        ...(limited ? {
+            settings: {
+                permissions: {
+                    allow: [
+                        "Read",
+                        `Bash(curl -s -X POST http://127.0.0.1:${CHATCCC_PORT}/api/agent/stop-stuck-loop *)`,
+                    ],
+                },
+            },
+        } : {}),
+        stderr: (data) => {
+            const trimmed = data.trim();
+            if (!trimmed)
+                return;
+            const ts = new Date().toISOString();
+            console.log(`[${ts}] [CLAUDE-STDERR] ${trimmed.slice(0, 2000)}`);
+        },
+    };
+    if (!limited) {
+        options.allowDangerouslySkipPermissions = true;
+    }
+    if (!isEmpty(model)) {
+        options.model = model;
+    }
+    if (!isEmpty(effort)) {
+        options.effort = effort;
+    }
+    const env = buildSdkEnv(subagentModel, apiKey, baseUrl);
+    if (env) {
+        options.env = env;
+    }
+    const mcpServers = readMcpServersConfig();
+    if (mcpServers) {
+        options.mcpServers = mcpServers;
+    }
+    return options;
+}
+function safeRawStreamJson(value) {
+    try {
+        return JSON.stringify(value) ?? "null";
+    }
+    catch (err) {
+        return JSON.stringify({
+            type: "chatccc_raw_stream_log_serialize_error",
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+function bridgeAbortSignal(signal, controller) {
+    if (!signal)
+        return undefined;
+    const onAbort = () => controller.abort();
+    if (signal.aborted) {
+        controller.abort();
+        return undefined;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    return () => signal.removeEventListener("abort", onAbort);
+}
+function closeSdkSession(session) {
+    session.close();
+}
+function toSdkSessionOptions(options) {
+    return options;
+}
+class ClaudeAdapter {
+    displayName = "Claude Code";
+    sessionDescPrefix = "Claude Code Session:";
+    model;
+    effort;
+    subagentModel;
+    apiKey;
+    baseUrl;
+    isEmpty;
+    metaStore;
+    maxTurn;
+    constructor(options) {
+        this.model = options.model;
+        this.effort = options.effort;
+        this.subagentModel = options.subagentModel;
+        this.apiKey = options.apiKey;
+        this.baseUrl = options.baseUrl;
+        this.isEmpty = options.isEmpty;
+        this.metaStore = options.metaStore ?? defaultClaudeSessionMetaStore;
+        this.maxTurn = options.maxTurn ?? 0;
+    }
+    async createSession(cwd, signal) {
+        logMcpConfig();
+        const abortController = new AbortController();
+        const removeAbortListener = bridgeAbortSignal(signal, abortController);
+        if (abortController.signal.aborted) {
+            removeAbortListener?.();
+            throw new Error("Claude session creation aborted");
+        }
+        const sdk = await loadClaudeSdkModule();
+        let sessionId;
+        const session = sdk.unstable_v2_createSession(toSdkSessionOptions(buildSdkOptions({
+            cwd,
+            model: this.model,
+            effort: this.effort,
+            isEmpty: this.isEmpty,
+            subagentModel: this.subagentModel,
+            apiKey: this.apiKey,
+            baseUrl: this.baseUrl,
+            maxTurn: this.maxTurn,
+            abortController,
+            userText: "",
+        })));
+        try {
+            await session.send("ok");
+            for await (const raw of session.stream()) {
+                const msg = raw;
+                if (msg.session_id && !sessionId) {
+                    sessionId = msg.session_id;
+                    await this.metaStore.set(sessionId, {
+                        cwd: msg.cwd ?? cwd,
+                        model: msg.model,
+                    }).catch(() => { });
+                    const ts = new Date().toISOString();
+                    console.log(`[${ts}] [CLAUDE-SDK] createSession: ${sessionId}`);
+                }
+            }
+        }
+        finally {
+            removeAbortListener?.();
+            closeSdkSession(session);
+        }
+        if (sessionId)
+            return { sessionId };
+        throw new Error("No session ID in Claude init event");
+    }
+    async *prompt(sessionId, userText, cwd, signal, options) {
+        const abortController = new AbortController();
+        const removeAbortListener = bridgeAbortSignal(signal, abortController);
+        if (abortController.signal.aborted)
+            return;
+        let aborted = false;
+        let completed = false;
+        const rawLogConfig = config.rawStreamLogs.claude;
+        let rawLog = null;
+        const sdk = await loadClaudeSdkModule();
+        const session = sdk.unstable_v2_resumeSession(sessionId, toSdkSessionOptions(buildSdkOptions({
+            cwd,
+            model: this.model,
+            effort: this.effort,
+            isEmpty: this.isEmpty,
+            subagentModel: this.subagentModel,
+            apiKey: this.apiKey,
+            baseUrl: this.baseUrl,
+            maxTurn: this.maxTurn,
+            abortController,
+            userText,
+        })));
+        options?.onSessionCreated?.(() => session.close());
+        try {
+            try {
+                rawLog = await createRawStreamLog({
+                    enabled: rawLogConfig.enabled,
+                    rootDir: RAW_STREAM_LOGS_DIR,
+                    tool: "claude",
+                    sessionId,
+                    label: "prompt",
+                    maxBytesPerTurn: rawLogConfig.maxBytesPerTurn,
+                    retentionDays: rawLogConfig.retentionDays,
+                });
+            }
+            catch (err) {
+                console.error(`[Claude raw stream log] create failed: ${err.message}`);
+            }
+            await session.send(buildClaudePromptText(userText, undefined, sessionId));
+            for await (const raw of session.stream()) {
+                if (abortController.signal.aborted) {
+                    aborted = true;
+                    break;
+                }
+                const msg = raw;
+                rawLog?.writeLine(safeRawStreamJson(msg));
+                if (msg.type === "system" && msg.subtype === "init" && msg.session_id) {
+                    const meta = {};
+                    if (msg.cwd)
+                        meta.cwd = msg.cwd;
+                    if (msg.model)
+                        meta.model = msg.model;
+                    if (Object.keys(meta).length > 0) {
+                        this.metaStore.set(msg.session_id, meta).catch(() => { });
+                    }
+                }
+                const normalized = normalizeSdkMessage(msg);
+                if (normalized)
+                    yield normalized;
+            }
+            completed = !aborted && !abortController.signal.aborted;
+        }
+        finally {
+            removeAbortListener?.();
+            if (aborted || abortController.signal.aborted) {
+                abortController.abort();
+            }
+            closeSdkSession(session);
+            await rawLog?.close({
+                keep: rawLogConfig.keepCompleted || abortController.signal.aborted || !completed,
+            });
+        }
+    }
+    async getSessionInfo(sessionId) {
+        const meta = await this.metaStore.get(sessionId);
+        try {
+            const sdk = await loadClaudeSdkModule();
+            const sdkInfo = await sdk.getSessionInfo(sessionId, meta?.cwd ? { dir: meta.cwd } : undefined);
+            if (sdkInfo) {
+                return {
+                    sessionId: sdkInfo.sessionId,
+                    cwd: sdkInfo.cwd ?? meta?.cwd,
+                    summary: sdkInfo.summary,
+                    lastModified: sdkInfo.lastModified,
+                    model: meta?.model,
+                };
+            }
+        }
+        catch {
+            // Fall back to the local meta store below.
+        }
+        if (!meta)
+            return { sessionId };
+        return meta.model
+            ? { sessionId, cwd: meta.cwd, model: meta.model }
+            : { sessionId, cwd: meta.cwd };
+    }
+    async closeSession(_sessionId) {
+        // SDK query streams are request scoped and are closed in prompt/createSession.
+    }
+}
+export function createClaudeAdapter(options) {
+    return new ClaudeAdapter(options);
+}

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

@@ -0,0 +1,92 @@
+// =============================================================================
+// claude-session-meta-store.ts — Claude 会话 sessionId → meta 持久化映射
+// =============================================================================
+// 背景：Claude Agent SDK 的 getSessionInfo 可能因 cwd / 本地记录缺失而查不到。
+// ChatCCC 额外维护 sessionId → { cwd, model } 映射作为展示与恢复兜底。
+//
+// 存储：
+//   文件 state/claude-session-meta.json，结构：
+//     { "<sessionId>": { "cwd": "...", "model": "..." } }
+//
+// API 设计：
+//   set(sid, partial) → 部分合并写入；只更新非空字段，不会清空其他字段
+// =============================================================================
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { USER_DATA_DIR } from "../config.js";
+export const CLAUDE_SESSION_META_FILE = join(USER_DATA_DIR, "state", "claude-session-meta.json");
+function isNonEmptyString(v) {
+    return typeof v === "string" && v.length > 0;
+}
+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;
+}
+export function createClaudeSessionMetaStore(filePath = CLAUDE_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;
+            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(`[claude-session-meta] failed to persist ${filePath}: ${err.message}`);
+            }
+        },
+    };
+}
+export const defaultClaudeSessionMetaStore = createClaudeSessionMetaStore();