@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/agents/claude-code/claude-code-checkpoints.js

@@ -0,0 +1,97 @@
+import { forkSession, getSessionMessages, query } from "@anthropic-ai/claude-agent-sdk";
+import { agentEnv } from "../../agent/index.js";
+import { claudeEnv } from "./claude-code-env.js";
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export const isUuid = (value) => typeof value === "string" && UUID.test(value);
+/** The last entry of the conversation a session holds now: where the next message would attach. */
+export async function chainTail(cwd, sessionId) {
+    try {
+        return (await getSessionMessages(sessionId, { dir: cwd })).at(-1)?.uuid;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The session to continue for a chat that stands at `tail`. A session can only grow at its end, so
+ * when it has moved past `tail` (the user went back and wrote something else) the conversation is
+ * branched off at `tail` and the old session stays as it was, ready to be returned to.
+ */
+export async function sessionAt(cwd, sessionId, tail) {
+    if (!tail || !isUuid(tail))
+        return sessionId;
+    try {
+        const chain = await getSessionMessages(sessionId, { dir: cwd });
+        if (chain.at(-1)?.uuid === tail || !chain.some((message) => message.uuid === tail))
+            return sessionId;
+        return (await forkSession(sessionId, { dir: cwd, upToMessageId: tail })).sessionId;
+    }
+    catch {
+        // The transcript is unreadable: the caller's own fallback (a replay from the history) decides.
+        return sessionId;
+    }
+}
+/** A session that stays open without a prompt, to ask it things; `close` ends it. */
+function idleSession(options) {
+    const idle = (async function* () {
+        await new Promise(() => { });
+    })();
+    return query({ prompt: idle, options });
+}
+/** Puts the project's files back to how they were before the message `messageId` was sent. */
+export async function rewindClaudeFiles(cwd, sessionId, messageId, dryRun) {
+    if (!isUuid(messageId) || !isUuid(sessionId))
+        throw new Error("Некорректный шаг для отката");
+    const session = idleSession({
+        cwd,
+        env: agentEnv(),
+        resume: sessionId,
+        enableFileCheckpointing: true,
+        settingSources: [],
+    });
+    try {
+        const result = await session.rewindFiles(messageId, { dryRun });
+        return {
+            ok: result.canRewind,
+            error: result.error,
+            files: result.filesChanged ?? [],
+            insertions: result.insertions,
+            deletions: result.deletions,
+        };
+    }
+    finally {
+        session.close();
+    }
+}
+const MCP_TTL_MS = 30_000;
+const mcpCache = new Map();
+/** MCP servers Claude Code would start in the folder (user, project and local settings). */
+export function claudeMcpServers(cwd) {
+    const cached = mcpCache.get(cwd);
+    if (cached && Date.now() - cached.at < MCP_TTL_MS)
+        return cached.servers;
+    const servers = (async () => {
+        const session = idleSession({
+            cwd,
+            env: claudeEnv(),
+            settingSources: ["user", "project", "local"],
+        });
+        try {
+            // Servers connect in the background: give the slow ones a moment before reporting.
+            await session.initializationResult();
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+            return (await session.mcpServerStatus()).map((server) => ({
+                name: server.name,
+                status: server.status,
+                tools: server.tools?.length ?? 0,
+                error: server.error,
+            }));
+        }
+        finally {
+            session.close();
+        }
+    })();
+    mcpCache.set(cwd, { at: Date.now(), servers });
+    servers.catch(() => mcpCache.delete(cwd));
+    return servers;
+}

package/packages/server/modules/agents/claude-code/claude-code-env.js

@@ -0,0 +1,46 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { agentEnv } from "../../agent/index.js";
+/**
+ * Variables a running Claude Code session exports to everything it starts. A server launched from
+ * such a session (`vp dev` typed by an agent) would hand them to every terminal and agent it
+ * spawns: `claude` there takes itself for a nested child session and stops saving its transcript,
+ * and the messaging socket/token of the parent session leak into unrelated shells.
+ *
+ * Only the session-bound names are listed. User settings such as `CLAUDE_CODE_USE_BEDROCK` or
+ * `CLAUDE_CODE_OAUTH_TOKEN` are configuration, not session state, and stay.
+ */
+export const CLAUDE_SESSION_ENV = [
+    "CLAUDECODE",
+    "CLAUDE_CODE_CHILD_SESSION",
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_CODE_SESSION_ATTENDED",
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_CODE_EXECPATH",
+    "CLAUDE_CODE_MESSAGING_SOCKET",
+    "CLAUDE_CODE_MESSAGING_TOKEN",
+    "CLAUDE_AGENT_SDK_VERSION",
+    "CLAUDE_PID",
+];
+/** The "Enabled by default" switch of Claude in Chrome, kept by the terminal in `~/.claude.json`. */
+function chromeEnabledByDefault() {
+    try {
+        const config = JSON.parse(readFileSync(join(homedir(), ".claude.json"), "utf8"));
+        return config?.claudeInChromeDefaultEnabled === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The environment of a Claude Code session. The terminal connects `claude-in-chrome` on its own when
+ * it is enabled by default; a session started through the SDK does so only when asked, so the same
+ * setting is passed on as `CLAUDE_CODE_ENABLE_CFC`.
+ */
+export function claudeEnv() {
+    const env = agentEnv();
+    if (env.CLAUDE_CODE_ENABLE_CFC === undefined && chromeEnabledByDefault())
+        env.CLAUDE_CODE_ENABLE_CFC = "1";
+    return env;
+}

package/packages/server/modules/agents/claude-code/claude-code-events.js

@@ -0,0 +1,299 @@
+export const CLAUDE_LABEL = "Claude Code";
+/** Token counts of one request or of the whole answer, as the prompt cache sees them. */
+function usageOf(raw) {
+    return {
+        input: raw?.input_tokens ?? 0,
+        output: raw?.output_tokens ?? 0,
+        cacheRead: raw?.cache_read_input_tokens ?? 0,
+        cacheWrite: raw?.cache_creation_input_tokens ?? 0,
+    };
+}
+function flattenContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return content == null ? "" : JSON.stringify(content);
+    return content
+        .map((part) => {
+        if (part && typeof part === "object" && part.type === "text")
+            return String(part.text ?? "");
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function taskStatus(status) {
+    if (status === "completed")
+        return "done";
+    if (status === "failed")
+        return "error";
+    if (status === "killed")
+        return "stopped";
+    return "running";
+}
+/**
+ * Translates Claude Code SDK messages into the chat's SSE events. Sub-agent output
+ * (`parent_tool_use_id`) is shown as tool chips only, never as the answer text.
+ */
+export function createClaudeEventMapper(emit) {
+    const toolNames = new Map();
+    const streamed = new Set();
+    const thoughtStreamed = new Set();
+    let messageId = "";
+    let text = "";
+    let started = false;
+    let failed = false;
+    let sessionId = "";
+    // The first request of the answer shows what the resumed conversation found in the cache.
+    let firstRequest;
+    const write = (chunk) => {
+        text += chunk;
+        emit("text", { text: chunk });
+    };
+    /** Tasks the panel shows as running; whatever is left when the process ends never reports. */
+    const running = new Set();
+    /** Background subagents, commands and monitors that still work: the process must stay up for them to report. */
+    let working = 0;
+    /** The `done` of a result that came while background agents still work: sent when they are over. */
+    let pendingDone;
+    /** Subagents and background commands: each system message patches one row of the task panel. */
+    function handleTask(message) {
+        const task = (patch) => {
+            if (patch.status) {
+                if (patch.status === "running")
+                    running.add(patch.id);
+                else
+                    running.delete(patch.id);
+            }
+            emit("task", patch);
+        };
+        switch (message.subtype) {
+            case "background_tasks_changed":
+                // A level signal: the whole set of live tasks, so a missed start or end cannot leave it stale.
+                // Background commands count too: their completion report wakes the agent, and closing the
+                // input would kill the process before it can report.
+                working = message.tasks.filter((item) => !item.ambient).length;
+                return;
+            case "task_started":
+                if (message.skip_transcript || message.ambient)
+                    return;
+                task({
+                    id: message.task_id,
+                    kind: message.task_type === "local_bash"
+                        ? "shell"
+                        : message.subagent_type || message.task_type === "local_agent"
+                            ? "agent"
+                            : "other",
+                    title: message.description,
+                    status: "running",
+                    background: message.is_backgrounded === true,
+                    ...(message.subagent_type ? { subagent: message.subagent_type } : {}),
+                    ...(message.prompt ? { prompt: message.prompt } : {}),
+                    ...(message.tool_use_id ? { tool: message.tool_use_id } : {}),
+                });
+                return;
+            case "task_progress":
+                task({
+                    id: message.task_id,
+                    title: message.description,
+                    ...(message.summary ? { summary: message.summary } : {}),
+                    ...(message.last_tool_name ? { lastTool: message.last_tool_name } : {}),
+                    tools: message.usage.tool_uses,
+                    tokens: message.usage.total_tokens,
+                    durationMs: message.usage.duration_ms,
+                });
+                return;
+            case "task_updated": {
+                const { status, description, is_backgrounded: background, error } = message.patch;
+                task({
+                    id: message.task_id,
+                    ...(status ? { status: taskStatus(status) } : {}),
+                    ...(description ? { title: description } : {}),
+                    ...(background === undefined ? {} : { background }),
+                    ...(error ? { summary: error } : {}),
+                });
+                return;
+            }
+            case "task_notification":
+                if (message.skip_transcript || message.ambient)
+                    return;
+                task({
+                    id: message.task_id,
+                    status: message.status === "completed"
+                        ? "done"
+                        : message.status === "failed"
+                            ? "error"
+                            : "stopped",
+                    ...(message.summary ? { summary: message.summary } : {}),
+                    ...(message.usage
+                        ? {
+                            tools: message.usage.tool_uses,
+                            tokens: message.usage.total_tokens,
+                            durationMs: message.usage.duration_ms,
+                        }
+                        : {}),
+                });
+                return;
+            default:
+                return;
+        }
+    }
+    function handle(message) {
+        switch (message.type) {
+            case "system": {
+                if (message.subtype !== "init") {
+                    handleTask(message);
+                    return;
+                }
+                sessionId = message.session_id;
+                emit("session", { id: message.session_id, backend: "claude-code" });
+                emit("status", {
+                    phase: "thinking",
+                    provider: CLAUDE_LABEL,
+                    model: message.model,
+                });
+                return;
+            }
+            case "stream_event": {
+                if (message.parent_tool_use_id)
+                    return;
+                const event = message.event;
+                if (event.type === "message_start") {
+                    messageId = event.message.id;
+                    started = true;
+                    if (text && !text.endsWith("\n"))
+                        write("\n\n");
+                }
+                else if (event.type === "content_block_delta" &&
+                    event.delta.type === "thinking_delta" &&
+                    event.delta.thinking) {
+                    thoughtStreamed.add(messageId);
+                    emit("thought", { text: event.delta.thinking });
+                }
+                else if (event.type === "content_block_delta" &&
+                    event.delta.type === "text_delta" &&
+                    event.delta.text) {
+                    streamed.add(messageId);
+                    write(event.delta.text);
+                }
+                return;
+            }
+            case "assistant": {
+                started = true;
+                if (!firstRequest && !message.parent_tool_use_id)
+                    firstRequest = usageOf(message.message.usage);
+                const content = message.message.content;
+                for (const block of Array.isArray(content) ? content : []) {
+                    if (block.type === "tool_use") {
+                        if (toolNames.has(block.id))
+                            continue;
+                        const name = block.name;
+                        toolNames.set(block.id, name);
+                        emit("tool", {
+                            id: block.id,
+                            name,
+                            input: block.input,
+                            ...(message.parent_tool_use_id ? { parent: message.parent_tool_use_id } : {}),
+                        });
+                    }
+                    else if (block.type === "thinking" &&
+                        block.thinking &&
+                        !message.parent_tool_use_id &&
+                        !thoughtStreamed.has(message.message.id)) {
+                        emit("thought", { text: block.thinking });
+                    }
+                    else if (block.type === "text" &&
+                        !message.parent_tool_use_id &&
+                        !streamed.has(message.message.id)) {
+                        if (text && !text.endsWith("\n"))
+                            write("\n\n");
+                        write(block.text);
+                    }
+                }
+                return;
+            }
+            case "user": {
+                const content = message.message.content;
+                for (const block of Array.isArray(content) ? content : []) {
+                    if (block.type !== "tool_result")
+                        continue;
+                    const id = block.tool_use_id;
+                    const name = toolNames.get(id) ?? "tool";
+                    const output = flattenContent(block.content);
+                    if (block.is_error)
+                        emit("tool-result", { id, name, error: output || "Ошибка инструмента" });
+                    else
+                        emit("tool-result", { id, name, output });
+                }
+                return;
+            }
+            case "result": {
+                if (message.usage)
+                    emit("usage", { ...usageOf(message.usage), first: firstRequest });
+                if (message.subtype === "success" && !message.is_error) {
+                    const done = {
+                        text: (message.result || text).trim(),
+                        added: [],
+                        costUsd: message.total_cost_usd,
+                    };
+                    // Background agents report in a following answer of this same run: the chat stays busy.
+                    if (working > 0) {
+                        pendingDone = done;
+                        emit("status", { phase: "background" });
+                    }
+                    else {
+                        pendingDone = undefined;
+                        emit("done", done);
+                    }
+                }
+                else {
+                    pendingDone = undefined;
+                    failed = true;
+                    const errors = "errors" in message && Array.isArray(message.errors) ? message.errors : [];
+                    const reason = message.subtype === "success"
+                        ? message.result
+                        : message.subtype === "error_max_turns"
+                            ? "Достигнут лимит шагов Claude Code"
+                            : errors.join("\n");
+                    emit("error", { error: reason || "Claude Code завершился с ошибкой" });
+                }
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    return {
+        handle,
+        /** Background tasks still working: the agent process has to be kept alive for them. */
+        get working() {
+            return working;
+        },
+        /**
+         * The process is going away: what still ran in the panel will never report, and the answer
+         * held back for background agents is delivered.
+         */
+        finish() {
+            for (const id of running)
+                emit("task", {
+                    id,
+                    status: "stopped",
+                    summary: "Процесс агента завершился до отчёта о задаче",
+                });
+            running.clear();
+            if (pendingDone)
+                emit("done", pendingDone);
+            pendingDone = undefined;
+        },
+        /** No assistant output yet: the request failed before the model answered. */
+        get started() {
+            return started;
+        },
+        get failed() {
+            return failed;
+        },
+        get sessionId() {
+            return sessionId;
+        },
+    };
+}

package/packages/server/modules/agents/claude-code/claude-code-input.js

@@ -0,0 +1,97 @@
+/** After a result, how long the input stays open for the next answer to start before it closes. */
+const SETTLE_MS = 1500;
+/** The longest the input stays open for background agents that have not reported. */
+const HOLD_MAX_MS = 30 * 60_000;
+/**
+ * The input of one answer: the first message, then whatever the user adds while it runs (the SDK
+ * takes those at once, ahead of the queue). The SDK may answer an added message in the same turn
+ * or in the next one, so the input closes when a result is followed by silence.
+ */
+export function createInput(first) {
+    const queue = [first];
+    let wake;
+    let ended = false;
+    let timer;
+    let capTimer;
+    let resulted = false;
+    let holding = false;
+    const finish = () => {
+        clearTimeout(timer);
+        clearTimeout(capTimer);
+        ended = true;
+        wake?.();
+    };
+    /** Closing ends the agent process and with it every subagent still working inside it. */
+    const settle = () => {
+        clearTimeout(timer);
+        if (resulted && !holding && !queue.length)
+            timer = setTimeout(finish, SETTLE_MS);
+    };
+    async function* stream() {
+        while (true) {
+            const next = queue.shift();
+            if (next)
+                yield next;
+            else if (ended)
+                return;
+            else
+                await new Promise((resolve) => (wake = resolve));
+        }
+    }
+    return {
+        stream: stream(),
+        /** Adds a message to the running answer; `false` once the input is closed. */
+        push(text) {
+            if (ended)
+                return false;
+            clearTimeout(timer);
+            queue.push({
+                type: "user",
+                parent_tool_use_id: null,
+                priority: "now",
+                message: { role: "user", content: [{ type: "text", text }] },
+            });
+            wake?.();
+            return true;
+        },
+        /** Something other than a result arrived: another answer has started. */
+        busy() {
+            resulted = false;
+            clearTimeout(timer);
+        },
+        /**
+         * Background agents still work (or no longer do). While they do, the input stays open: their
+         * reports start a following answer in this process, and closing it would kill them.
+         */
+        hold(on) {
+            if (on === holding)
+                return;
+            holding = on;
+            if (on && !capTimer)
+                capTimer = setTimeout(finish, HOLD_MAX_MS);
+            if (!on) {
+                clearTimeout(capTimer);
+                capTimer = undefined;
+            }
+            settle();
+        },
+        /**
+         * Keeps the input open while background agents work (`working` of them), and waits for the
+         * answer their report starts instead of closing in the gap before it.
+         */
+        follow(message, working) {
+            this.hold(working > 0);
+            if (message.type === "system" &&
+                message.subtype === "task_notification" &&
+                !message.skip_transcript &&
+                !message.ambient)
+                this.busy();
+        },
+        /** A result arrived: the input closes unless the agent goes on to answer something more. */
+        settled() {
+            resulted = true;
+            settle();
+        },
+        close: finish,
+    };
+}

package/packages/server/modules/agents/claude-code/claude-code-replay.js

@@ -0,0 +1,71 @@
+/** Records Claude Code writes into the user's side of a transcript that the user never wrote. */
+const SERVICE_BLOCK = /<(command-name|command-message|command-args|local-command-stdout|local-command-stderr|local-command-caveat|system-reminder)>[\s\S]*?<\/\1>/g;
+/** Only the trace of a slash command or a reminder, nothing the user typed. */
+export const isServiceText = (text) => text.includes("<") && !text.replace(SERVICE_BLOCK, "").trim();
+/** The summary Claude Code puts in as the first message after the context was compacted. */
+export const isCompactSummary = (text) => text.trimStart().startsWith("This session is being continued from a previous conversation");
+const tag = (text, name) => new RegExp(`<${name}>([\\s\\S]*?)</${name}>`).exec(text)?.[1]?.trim() || undefined;
+/** A background task's report, which Claude Code delivers as a user message. */
+export function parseTaskReport(text) {
+    if (!text.trimStart().startsWith("<task-notification>"))
+        return undefined;
+    const taskId = tag(text, "task-id");
+    if (!taskId)
+        return undefined;
+    const status = tag(text, "status");
+    return {
+        taskId,
+        toolUseId: tag(text, "tool-use-id"),
+        status: status === "completed" ? "done" : status === "failed" ? "error" : "stopped",
+        summary: tag(text, "summary"),
+    };
+}
+const SUBAGENT_TOOLS = new Set(["Task", "Agent"]);
+/** The task a tool call starts, if it starts one: a subagent or a command left in the background. */
+export function taskOfCall(name, id, input) {
+    const args = (input && typeof input === "object" ? input : {});
+    const text = (key) => (typeof args[key] === "string" ? args[key] : undefined);
+    const background = args.run_in_background === true;
+    if (name && SUBAGENT_TOOLS.has(name))
+        return {
+            id,
+            kind: "agent",
+            title: text("description") ?? text("subagent_type") ?? "Субагент",
+            status: "running",
+            background,
+            tool: id,
+            ...(text("subagent_type") ? { subagent: text("subagent_type") } : {}),
+            ...(text("prompt") ? { prompt: text("prompt") } : {}),
+        };
+    if (name === "Bash" && background)
+        return {
+            id,
+            kind: "shell",
+            title: text("description") ?? text("command") ?? "Команда",
+            status: "running",
+            background,
+            tool: id,
+        };
+    return undefined;
+}
+/** Applies a report to the task it is about; the task is found by the call that started it. */
+export function applyTaskReport(turns, report) {
+    for (const turn of turns)
+        for (const task of turn.tasks ?? [])
+            if (task.id === report.toolUseId || task.id === report.taskId) {
+                task.status = report.status;
+                if (report.summary)
+                    task.summary = report.summary;
+                return;
+            }
+}
+/** The answer is over: what is still running has no report in the transcript. */
+export function settleTasks(turns) {
+    for (const turn of turns)
+        for (const task of turn.tasks ?? [])
+            if (task.status === "running") {
+                task.status = "stopped";
+                if (task.background)
+                    task.summary ??= "Состояние после ответа неизвестно";
+            }
+}