@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/agents/acp/acp-tools.js

@@ -0,0 +1,208 @@
+import { SESSION_LIST_LIMIT, } from "../../agent/index.js";
+import { controlsFromSession } from "./acp-controls.js";
+import { availableCommands, createAcpReplayCollector } from "./acp-events.js";
+import { initializeAcp, startAcp } from "./acp-process.js";
+import { acpProgram } from "./acp-programs.js";
+/** How long an agent's controls are reused: spawning an agent just to list models is not free. */
+const CONTROLS_TTL_MS = 5 * 60_000;
+const controlsCache = new Map();
+/**
+ * Runs `work` against a short-lived agent process that is not tied to a chat turn. Permission
+ * requests are refused: nothing here may run tools.
+ */
+async function withAgent(id, cwd, work, onUpdate) {
+    const connection = await startAcp(id, cwd, {
+        onNotification(method, params) {
+            if (method === "session/update")
+                onUpdate?.((params.update ?? {}));
+        },
+        onRequest() {
+            return { outcome: { outcome: "cancelled" } };
+        },
+    });
+    try {
+        return await work(connection, await initializeAcp(connection, id));
+    }
+    finally {
+        await connection.close();
+    }
+}
+/** Drops the throwaway session so probing does not fill the agent's own history. */
+async function discard(connection, sessionId) {
+    for (const method of ["session/delete", "session/close"]) {
+        try {
+            await connection.request(method, { sessionId }, 10_000);
+            return;
+        }
+        catch {
+            /* The agent may not implement this method; try the next one. */
+        }
+    }
+}
+/** Models, effort levels and modes the agent offers in `cwd`, cached for a few minutes. */
+export function acpControls(id, cwd) {
+    const key = `${id}\n${cwd}`;
+    const cached = controlsCache.get(key);
+    if (cached && Date.now() - cached.at < CONTROLS_TTL_MS)
+        return cached.controls;
+    const controls = withAgent(id, cwd, async (connection) => {
+        const created = (await connection.request("session/new", { cwd, mcpServers: [] }));
+        await discard(connection, created.sessionId);
+        return controlsFromSession(created);
+    });
+    controlsCache.set(key, { at: Date.now(), controls });
+    // A failure must not stick for the whole TTL.
+    controls.catch(() => controlsCache.delete(key));
+    return controls;
+}
+/** How long the slash commands are reused: they follow the project's files, not every call. */
+const COMMANDS_TTL_MS = 60_000;
+/** How long to wait for `available_commands_update` after `session/new`. */
+const COMMANDS_WAIT_MS = 5_000;
+const commandsCache = new Map();
+/** Resolves with an empty list after `ms`: a chat must not wait for commands forever. */
+function waitForCommands(commands, ms) {
+    return Promise.race([
+        commands,
+        new Promise((resolve) => {
+            const timer = setTimeout(() => resolve([]), ms);
+            timer.unref?.();
+        }),
+    ]);
+}
+/**
+ * The slash commands the agent offers in `cwd`. ACP has no request for them: the agent sends
+ * `available_commands_update` after `session/new`. A throwaway session is created for that list
+ * and closed again — no prompt, no model call. The notification may arrive before the response
+ * (the protocol allows it), so it is collected from the first message.
+ */
+export function acpCommands(id, cwd, waitMs = COMMANDS_WAIT_MS) {
+    const key = `${id}\n${cwd}`;
+    const cached = commandsCache.get(key);
+    if (cached && Date.now() - cached.at < COMMANDS_TTL_MS)
+        return cached.commands;
+    let resolveAnnounced;
+    const announced = new Promise((resolve) => (resolveAnnounced = resolve));
+    let collected;
+    let decided = false;
+    const take = (list) => {
+        collected = availableCommands(list);
+        // An empty first snapshot is not final: some agents load commands from project files.
+        if (collected.length) {
+            decided = true;
+            resolveAnnounced?.(collected);
+        }
+    };
+    const commands = withAgent(id, cwd, async (connection) => {
+        const created = (await connection.request("session/new", { cwd, mcpServers: [] }));
+        // The response is authoritative for v2 agents, even when the list is empty.
+        if (created.availableCommands !== undefined) {
+            take(created.availableCommands);
+            decided = true;
+        }
+        if (!decided)
+            await waitForCommands(announced, waitMs);
+        await discard(connection, created.sessionId);
+        return collected ?? [];
+    }, (update) => {
+        if (update.sessionUpdate === "available_commands_update")
+            take(update.availableCommands);
+    });
+    commandsCache.set(key, { at: Date.now(), commands });
+    // A failure must not stick for the whole TTL.
+    commands.catch(() => commandsCache.delete(key));
+    return commands;
+}
+const EMPTY_TITLE = /^(New session - \d{4}-\d\d-\d\dT|untitled|new session)$/i;
+/** The session a raw one was started from, as far as the agent tells it. */
+function parentOf(session) {
+    const meta = session._meta ?? {};
+    for (const value of [
+        session.parentId,
+        session.parentSessionId,
+        meta.parentId,
+        meta.parentSessionId,
+        meta["opencode/parent-session"],
+    ])
+        if (typeof value === "string" && value.trim())
+            return value;
+    return undefined;
+}
+/** The agent a branch runs as, when the listing names it. */
+function agentOf(session) {
+    const meta = session._meta ?? {};
+    for (const value of [session.agent, meta.agent, meta["opencode/agent"]])
+        if (typeof value === "string" && value.trim())
+            return value;
+    return undefined;
+}
+const newestFirst = (a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "");
+/**
+ * Branches of subagents are not chats of their own: they must not push real chats out of the
+ * limited list. Their parents are kept in full, and branches follow those that remain.
+ */
+function capSessions(list) {
+    const mains = list.filter((session) => !session.parent);
+    if (!mains.length)
+        return list.sort(newestFirst).slice(0, SESSION_LIST_LIMIT);
+    const children = new Map();
+    for (const session of list)
+        if (session.parent)
+            children.set(session.parent, [...(children.get(session.parent) ?? []), session]);
+    const kept = new Set(mains.slice(0, SESSION_LIST_LIMIT).map((session) => session.id));
+    const include = (id) => {
+        for (const child of children.get(id) ?? [])
+            if (!kept.has(child.id)) {
+                kept.add(child.id);
+                include(child.id);
+            }
+    };
+    for (const id of [...kept])
+        include(id);
+    return list.filter((session) => kept.has(session.id)).sort(newestFirst);
+}
+/** The agent's own past sessions in `cwd`, newest first; empty when it cannot list them. */
+export function acpSessions(id, cwd, decorate) {
+    return withAgent(id, cwd, async (connection, init) => {
+        if (!init.agentCapabilities?.sessionCapabilities?.list)
+            return [];
+        const answer = (await connection.request("session/list", { cwd }));
+        const list = (answer.sessions ?? []).flatMap((session) => {
+            const title = session.title?.trim();
+            // A session that never received a prompt has no title (or a placeholder like OpenCode's).
+            if (!session.sessionId || !title || EMPTY_TITLE.test(title))
+                return [];
+            const parent = parentOf(session);
+            // Only a branch is named by its agent: the same field on a chat is the mode it runs in.
+            const agent = parent ? agentOf(session) : undefined;
+            return [
+                {
+                    id: session.sessionId,
+                    title,
+                    ...(session.updatedAt ? { updatedAt: session.updatedAt } : {}),
+                    ...(parent ? { parent } : {}),
+                    ...(agent ? { agent } : {}),
+                },
+            ];
+        });
+        return capSessions(decorate ? await decorate(list) : list);
+    });
+}
+/** Removes a past session through `session/delete`, for agents that offer it. */
+export function acpDeleteSession(id, cwd, sessionId) {
+    return withAgent(id, cwd, async (connection, init) => {
+        if (!init.agentCapabilities?.sessionCapabilities?.delete)
+            throw new Error("Агент не умеет удалять сессии");
+        await connection.request("session/delete", { sessionId });
+    });
+}
+/** The messages of a past session, replayed by the agent through `session/load`. */
+export function acpLoadSession(id, cwd, sessionId) {
+    const collector = createAcpReplayCollector(id, sessionId, acpProgram(id).dialect?.());
+    return withAgent(id, cwd, async (connection, init) => {
+        if (!init.agentCapabilities?.loadSession)
+            throw new Error("Агент не умеет восстанавливать прошлые сессии");
+        await connection.request("session/load", { sessionId, cwd, mcpServers: [] });
+        return collector.turns;
+    }, (update) => collector.handleUpdate(update));
+}

package/packages/server/modules/agents/acp/index.js

@@ -0,0 +1,4 @@
+export { createAcpBackend } from "./acp-backend.js";
+export { acpSessions } from "./acp-tools.js";
+export { registerAcpProgram, } from "./acp-programs.js";
+export { createPlainDialect, extendPlainDialect, inputOf, isCompactCommand, isOver, readCompaction, shorten, uuidV7Time, } from "./acp-dialect.js";

package/packages/server/modules/agents/acp/mcp-config.js

@@ -0,0 +1,100 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { mcpServerConfigs } from "../../agent-mcp/index.js";
+/** `${NAME}` and `${NAME:-fallback}` in a config value, as Claude Code's own `.mcp.json` allows. */
+function expand(value) {
+    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g, (_, name, fallback) => process.env[name] ?? fallback ?? "");
+}
+async function readConfig(cwd) {
+    try {
+        const data = JSON.parse(await readFile(join(cwd, ".mcp.json"), "utf8"));
+        return data.mcpServers && typeof data.mcpServers === "object" ? data.mcpServers : {};
+    }
+    catch {
+        return {};
+    }
+}
+const isStdio = (entry) => typeof entry.command === "string" && !!entry.command && (!entry.type || entry.type === "stdio");
+const remoteKind = (entry) => (entry.type === "http" || entry.type === "sse") && typeof entry.url === "string" && entry.url
+    ? entry.type
+    : undefined;
+const pairs = (value) => (value && typeof value === "object" ? Object.entries(value) : []).map(([name, item]) => ({
+    name,
+    value: expand(String(item)),
+}));
+/** The project's `.mcp.json` servers this agent can be given: stdio ones, and remote ones it supports. */
+export async function projectMcpServers(cwd, support = {}) {
+    if (!cwd)
+        return [];
+    return Object.entries(await readConfig(cwd)).flatMap(([name, entry]) => {
+        if (isStdio(entry))
+            return [
+                {
+                    name,
+                    command: expand(String(entry.command)),
+                    args: Array.isArray(entry.args) ? entry.args.map((item) => expand(String(item))) : [],
+                    env: pairs(entry.env),
+                },
+            ];
+        const kind = remoteKind(entry);
+        if (!kind || !support[kind])
+            return [];
+        return [{ type: kind, name, url: expand(String(entry.url)), headers: pairs(entry.headers) }];
+    });
+}
+/** A parsed config in the shape ACP takes; a remote kind the agent lacks is left out. */
+function acpServer(config, support) {
+    if ("command" in config)
+        return [
+            {
+                name: config.name,
+                command: config.command,
+                args: config.args,
+                env: Object.entries(config.env).map(([name, value]) => ({ name, value })),
+            },
+        ];
+    if (config.sse ? !support.sse : !support.http)
+        return [];
+    return [
+        {
+            type: config.sse ? "sse" : "http",
+            name: config.name,
+            url: config.url,
+            headers: Object.entries(config.headers).map(([name, value]) => ({ name, value })),
+        },
+    ];
+}
+/** The user's own servers a role names; the project's are passed separately from `.mcp.json`. */
+export async function userMcpServers(cwd, names, support = {}) {
+    if (!names.length)
+        return [];
+    return (await mcpServerConfigs(cwd))
+        .filter((config) => config.source === "user" && names.includes(config.name))
+        .flatMap((config) => acpServer(config, support));
+}
+/**
+ * The MCP servers of a session: the project's own, plus the built-in IDE and widget servers when
+ * their features are on. Only those additions may hide a same-named project server; with the
+ * feature off the user's `projector-ide` or `projector-widgets` from `.mcp.json` is passed as is.
+ */
+export async function sessionMcpServers(cwd, support, extra, only) {
+    const project = only
+        ? (await projectMcpServers(cwd, support)).filter((server) => only.includes(server.name))
+        : await projectMcpServers(cwd, support);
+    if (!extra.length)
+        return project;
+    const names = new Set(extra.map((server) => server.name));
+    return [...project.filter((server) => !names.has(server.name)), ...extra];
+}
+/** What the chat shows for an ACP agent: which servers of the project it is given. */
+export async function configuredMcpServers(cwd) {
+    return Object.entries(await readConfig(cwd)).map(([name, entry]) => ({
+        name,
+        status: isStdio(entry)
+            ? "передан агенту"
+            : remoteKind(entry)
+                ? "передан, если агент поддерживает " + remoteKind(entry)
+                : "не передан: неизвестный тип сервера",
+        tools: 0,
+    }));
+}

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

@@ -0,0 +1,342 @@
+import { agentEnv, assertHostProject, attachedImages, promptWithHistory, registerInjector, runHostedAgent, } from "../../agent/index.js";
+import { fileURLToPath } from "node:url";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { featureEnabled, featurePrompt } from "../../agent-features/index.js";
+import { claudeIdeMcpServer, IDE_MCP_SERVER } from "../ide-mcp/index.js";
+import { claudeWidgetsMcpServer, WIDGETS_MCP_SERVER } from "../widgets-mcp/index.js";
+import { mcpConfigsForNames, mcpServerConfigs, processMcpConfig } from "../../agent-mcp/index.js";
+import { roleContext } from "../../agent-roles/index.js";
+import { trustedProjectWidgets } from "../../project-widgets/index.js";
+import { renderWidgetGuide } from "../../../../core/modules/widget-catalog/index.js";
+import { createInput } from "./claude-code-input.js";
+import { CLAUDE_LABEL, createClaudeEventMapper } from "./claude-code-events.js";
+import { chainTail, claudeMcpServers, isUuid, rewindClaudeFiles, sessionAt, } from "./claude-code-checkpoints.js";
+import { CLAUDE_CONTROLS, claudeLoadSession, claudeSessions, claudeDeleteSession, claudeUpdateSession, } from "./claude-code-sessions.js";
+import { askClaudeQuestions } from "./questions.js";
+import { claudeEnv } from "./claude-code-env.js";
+/** Claude Code takes the choice natively; `default` leaves the model and effort to its settings. */
+function chosen(options) {
+    const pick = (id) => {
+        const value = options.selection?.[id];
+        return value && value !== "default" ? value : undefined;
+    };
+    const number = (id) => {
+        const value = Number(pick(id));
+        return Number.isFinite(value) && value > 0 ? value : undefined;
+    };
+    return {
+        model: pick("model"),
+        effort: pick("effort"),
+        budget: number("budget"),
+        steps: number("steps"),
+    };
+}
+/** The runner process of a hosted answer (see `server/app/claude-runner.ts`). */
+const RUNNER = fileURLToPath(new URL("../../../app/claude-runner.js", import.meta.url));
+/** The answer of a hosted run: followed through its runner (see `server/app/claude-runner.ts`). */
+async function runHosted(options, handle) {
+    if (!options.cwd)
+        throw new Error("Claude Code работает внутри проекта: откройте чат в проекте");
+    await assertHostProject(options.cwd, CLAUDE_LABEL);
+    await runHostedAgent(options, handle, { runner: RUNNER, cwd: options.cwd, env: agentEnv() }, isUuid(options.messageId) ? options.messageId : undefined);
+}
+/** The run: held by its own process when the route gave it one, otherwise in this process. */
+async function run(options) {
+    if (options.run)
+        return runHosted(options, options.run);
+    return runClaudeCode(options);
+}
+/** The prompt of a Claude Code session: its own preset plus the abilities and role switched on for the chat. */
+export async function claudeSystemPrompt(features, role = "", projectWidgets = "") {
+    const text = [role.trim(), await featurePrompt("claude-code", features), projectWidgets.trim()]
+        .filter(Boolean)
+        .join("\n\n");
+    return {
+        type: "preset",
+        preset: "claude_code",
+        ...(text ? { append: text } : {}),
+        // The host changes the append when the user flips a feature: render the prompt fresh on every
+        // request, otherwise a resumed session keeps the prompt recorded at its first request.
+        snapshot: false,
+    };
+}
+/**
+ * Plain Claude Code behind a chat UI instead of the TUI: its own prompt, tools, login, `CLAUDE.md`
+ * and settings. Nothing about Projector is added to the model's context except the abilities the
+ * user switched on. Runs in the runner process (`server/app/claude-runner.ts`) for a hosted answer,
+ * and in the server process otherwise.
+ */
+export async function runClaudeCode(options) {
+    if (!options.cwd)
+        throw new Error("Claude Code работает внутри проекта: откройте чат в проекте");
+    const requestedMode = options.selection?.["permission-mode"] ?? options.permissionMode ?? "default";
+    const mode = PERMISSION_MODES.find((value) => value === requestedMode);
+    if (!mode)
+        throw new Error("Неизвестный режим разрешений агента");
+    const cwd = options.cwd;
+    await assertHostProject(cwd, CLAUDE_LABEL);
+    const abortController = new AbortController();
+    const forwardAbort = () => abortController.abort();
+    if (options.abort?.aborted)
+        abortController.abort();
+    else
+        options.abort?.addEventListener("abort", forwardAbort, { once: true });
+    const selected = chosen(options);
+    const [ideEnabled, widgetsEnabled, roleText] = await Promise.all([
+        featureEnabled("claude-code", "ide", options.features),
+        featureEnabled("claude-code", "widgets", options.features),
+        roleContext(options.role, cwd),
+    ]);
+    const projectWidgets = widgetsEnabled ? await trustedProjectWidgets(options.projectId) : [];
+    const extraMcp = {
+        ...(options.projectId && ideEnabled
+            ? { [IDE_MCP_SERVER]: claudeIdeMcpServer(options.projectId) }
+            : {}),
+        ...(widgetsEnabled ? { [WIDGETS_MCP_SERVER]: claudeWidgetsMcpServer(options.projectId) } : {}),
+    };
+    // A role with its own MCP list gets exactly those servers: Claude Code must not add the rest.
+    const namedMcp = options.role?.mcp
+        ? Object.fromEntries(mcpConfigsForNames(await mcpServerConfigs(cwd), options.role.mcp)
+            .filter((config) => !(config.name in extraMcp))
+            .map((config) => [config.name, processMcpConfig(config)]))
+        : {};
+    const mcpServers = { ...namedMcp, ...extraMcp };
+    const base = {
+        cwd,
+        abortController,
+        env: claudeEnv(),
+        ...(Object.keys(mcpServers).length ? { mcpServers } : {}),
+        ...(options.role?.mcp ? { strictMcpConfig: true } : {}),
+        includePartialMessages: true,
+        // A background subagent streams no calls of its own: its progress arrives as these summaries.
+        agentProgressSummaries: true,
+        settingSources: ["user", "project", "local"],
+        systemPrompt: await claudeSystemPrompt(options.features, roleText, projectWidgets.length ? renderWidgetGuide(projectWidgets) : ""),
+        ...(widgetsEnabled ? { allowedTools: [`mcp__${WIDGETS_MCP_SERVER}__describe_widget`] } : {}),
+        permissionMode: mode,
+        // Files are backed up before the agent changes them, so a step can be taken back later.
+        enableFileCheckpointing: true,
+        ...(selected.model ? { model: selected.model } : {}),
+        ...(selected.effort ? { effort: selected.effort } : {}),
+        ...(selected.budget ? { maxBudgetUsd: selected.budget } : {}),
+        ...(selected.steps ? { maxTurns: selected.steps } : {}),
+        ...(mode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+        canUseTool: async (toolName, input, context) => {
+            if (toolName === "AskUserQuestion")
+                return askClaudeQuestions(options, input);
+            if (!options.approve)
+                return { behavior: "deny", message: "Клиент не может показать запрос разрешения" };
+            const suggestions = context.suggestions ?? [];
+            const answer = await options
+                .approve({
+                tool: toolName,
+                input,
+                title: context.title ?? context.displayName,
+                persistent: suggestions.length > 0,
+            })
+                .catch(() => false);
+            if (!answer)
+                return { behavior: "deny", message: "Пользователь отклонил действие" };
+            // "Always" turns the rule Claude Code itself suggests into a saved permission.
+            return {
+                behavior: "allow",
+                updatedInput: input,
+                ...(answer === "always" && suggestions.length
+                    ? {
+                        // Kept in the user's own settings, so it holds in every project and for the terminal too.
+                        updatedPermissions: suggestions.map((rule) => ({
+                            ...rule,
+                            destination: "userSettings",
+                        })),
+                    }
+                    : {}),
+            };
+        },
+    };
+    const attempt = async (resume) => {
+        // A failed resume is retried silently, so its error is held back until we know it is final.
+        let heldError;
+        const emit = (event, data) => {
+            if (resume && event === "error")
+                heldError = data;
+            else
+                options.emit(event, data);
+        };
+        const mapper = createClaudeEventMapper(emit);
+        const prompt = resume
+            ? options.message
+            : promptWithHistory(options.message, options.history ?? []);
+        const images = await attachedImages(options.parts);
+        const messageId = isUuid(options.messageId) ? options.messageId : undefined;
+        const input = createInput(userMessage(prompt, images, messageId));
+        const unregister = messageId
+            ? registerInjector(messageId, (text, inputId) => {
+                const accepted = input.push(text);
+                if (accepted)
+                    emit("input", { text, ...(inputId ? { inputId } : {}) });
+                return accepted;
+            })
+            : undefined;
+        const conversation = query({
+            prompt: input.stream,
+            options: { ...base, ...(resume ? { resume } : {}) },
+        });
+        // The ring follows the answer: asked again after tool results, but not more often than this.
+        let contextAt = 0;
+        try {
+            for await (const message of conversation) {
+                mapper.handle(message);
+                input.follow(message, mapper.working);
+                if (message.type === "user" && Date.now() - contextAt > CONTEXT_REFRESH_MS) {
+                    contextAt = Date.now();
+                    void emitContext(conversation, emit);
+                }
+                if (message.type === "result") {
+                    await emitContext(conversation, emit);
+                    input.settled();
+                }
+                else if (message.type === "assistant" || message.type === "stream_event")
+                    input.busy();
+            }
+            mapper.finish();
+        }
+        finally {
+            unregister?.();
+            input.close();
+            conversation.close();
+        }
+        // Where this answer ends in the transcript: the next message can branch off here.
+        if (!mapper.failed && mapper.sessionId) {
+            const tail = await chainTail(cwd, mapper.sessionId);
+            if (tail)
+                options.emit("checkpoint", { tail });
+        }
+        // The session may be gone (project moved, transcript pruned): start over from the history.
+        if (resume && mapper.failed && !mapper.started && !abortController.signal.aborted)
+            return attempt(undefined);
+        if (heldError)
+            options.emit("error", heldError);
+    };
+    try {
+        options.emit("controls", { controls: claudeControls(options.selection ?? {}) });
+        options.emit("status", { phase: "thinking", provider: CLAUDE_LABEL, model: "" });
+        const resume = options.sessionId
+            ? await sessionAt(cwd, options.sessionId, options.tail)
+            : undefined;
+        await attempt(resume);
+    }
+    finally {
+        options.abort?.removeEventListener("abort", forwardAbort);
+    }
+}
+/**
+ * The prompt as one streamed user message: text and images as content blocks, and an ID of our own
+ * that the transcript keeps, which is what a later rewind of the files refers to.
+ */
+function userMessage(text, images, uuid) {
+    return {
+        type: "user",
+        ...(uuid ? { uuid: uuid } : {}),
+        parent_tool_use_id: null,
+        message: {
+            role: "user",
+            content: [
+                { type: "text", text },
+                ...images.map((image) => ({
+                    type: "image",
+                    source: {
+                        type: "base64",
+                        media_type: image.mime,
+                        data: image.data,
+                    },
+                })),
+            ],
+        },
+    };
+}
+/** The least time between two readings of how full the context is during one answer. */
+const CONTEXT_REFRESH_MS = 4000;
+const COMMANDS_TTL_MS = 60_000;
+const commandCache = new Map();
+/**
+ * The slash commands (built in, user's, project's, plugins', skills') Claude Code offers in a
+ * folder. They are only known to a running session, so one is started without a prompt, asked and
+ * closed; the answer is kept for a minute.
+ */
+function claudeCommands(cwd) {
+    const cached = commandCache.get(cwd);
+    if (cached && Date.now() - cached.at < COMMANDS_TTL_MS)
+        return cached.commands;
+    const commands = (async () => {
+        const idle = (async function* () {
+            await new Promise(() => { });
+        })();
+        const session = query({
+            prompt: idle,
+            options: { cwd, env: claudeEnv(), settingSources: ["user", "project", "local"] },
+        });
+        try {
+            return (await session.supportedCommands()).map((item) => ({
+                name: item.name,
+                description: item.description || undefined,
+                hint: item.argumentHint || undefined,
+            }));
+        }
+        finally {
+            session.close();
+        }
+    })();
+    commandCache.set(cwd, { at: Date.now(), commands });
+    commands.catch(() => commandCache.delete(cwd));
+    return commands;
+}
+/** How full the context window is after the turn; a failure only means no indicator. */
+async function emitContext(conversation, emit) {
+    try {
+        const usage = await conversation.getContextUsage({ detail: "summary" });
+        emit("context", {
+            used: usage.totalTokens,
+            size: usage.maxTokens,
+            model: usage.model,
+            compactAt: usage.isAutoCompactEnabled ? usage.autoCompactThreshold : undefined,
+            categories: usage.categories
+                .filter((item) => item.kind === "used" && item.tokens > 0)
+                .map((item) => ({ name: item.name, tokens: item.tokens })),
+        });
+    }
+    catch {
+        // The answer is already complete; the indicator just keeps its previous value.
+    }
+}
+/** The static list with the user's current choice marked. */
+function claudeControls(selection) {
+    return CLAUDE_CONTROLS.map((control) => {
+        const value = selection[control.id];
+        return value && control.options.some((option) => option.value === value)
+            ? { ...control, current: value }
+            : control;
+    });
+}
+/** Claude Code's permission policy: `default` asks in the chat before edits and shell commands. */
+const PERMISSION_MODES = ["default", "plan", "acceptEdits", "auto", "bypassPermissions"];
+export const claudeCodeBackend = {
+    id: "claude-code",
+    label: CLAUDE_LABEL,
+    program: "claude",
+    terminal: { program: "claude", executable: "claude", title: CLAUDE_LABEL },
+    capabilities: {
+        hosted: true,
+        inject: true,
+        branchSession: true,
+        compact: { command: "/compact", hintAt: 0.8, autoAt: 0.9 },
+    },
+    run,
+    controls: async () => CLAUDE_CONTROLS,
+    commands: claudeCommands,
+    sessions: claudeSessions,
+    loadSession: claudeLoadSession,
+    updateSession: claudeUpdateSession,
+    deleteSession: claudeDeleteSession,
+    rewindFiles: (cwd, sessionId, messageId, dryRun) => rewindClaudeFiles(cwd, sessionId, messageId, dryRun),
+    mcpServers: claudeMcpServers,
+};