@ai-projector/ide 0.0.0-stage → 0.11.1

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

@@ -0,0 +1,320 @@
+import { acpProgram, registerAcpProgram } from "./acp-programs.js";
+import { attachedImages, promptWithHistory } from "../../agent/index.js";
+import { featureEnabled, featurePrompt } from "../../agent-features/index.js";
+import { acpIdeMcpServer } from "../ide-mcp/index.js";
+import { acpWidgetsMcpServer } from "../widgets-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 { configuredMcpServers, sessionMcpServers, userMcpServers, } from "./mcp-config.js";
+export { sessionMcpServers } from "./mcp-config.js";
+import { elicitForm } from "./acp-elicitation.js";
+import { NO_TIMEOUT } from "./acp-client.js";
+import { applySelection, controlsFromSession, shownModel } from "./acp-controls.js";
+import { isCompactCommand } from "./acp-dialect.js";
+import { contentText, createAcpEventMapper, stopReasonError } from "./acp-events.js";
+import { acpAdvertisedDelete, initializeAcp, startAcp } from "./acp-process.js";
+import { acpCommands, acpControls, acpDeleteSession, acpLoadSession, acpSessions, } from "./acp-tools.js";
+import { basename, resolve } from "node:path";
+import { os } from "../../../../core/modules/os/index.js";
+import { pathToFileURL } from "node:url";
+/**
+ * The prompt as ACP blocks: the text, which already names every file as `@path`, plus a link to
+ * each file or folder so an agent can open it without guessing what the name refers to.
+ */
+function promptBlocks(text, parts, cwd, images) {
+    const links = (parts ?? []).flatMap((part) => {
+        if (part.type !== "file")
+            return [];
+        const name = basename(part.path.replace(/\\/g, "/"));
+        return [
+            {
+                type: "resource_link",
+                name: part.range ? `${name}:${part.range.from}-${part.range.to}` : name,
+                uri: pathToFileURL(resolve(cwd ?? "/", part.path)).href,
+            },
+        ];
+    });
+    return [
+        { type: "text", text },
+        ...links,
+        ...images.map((image) => ({ type: "image", mimeType: image.mime, data: image.data })),
+    ];
+}
+/** An external agent driven through its ACP server over stdio. */
+export function createAcpBackend(program) {
+    registerAcpProgram(program);
+    const id = program.id;
+    const terminal = {
+        program: id,
+        executable: id,
+        title: program.label,
+        ...program.terminal,
+    };
+    return {
+        id,
+        label: program.label,
+        program: terminal.program,
+        terminal,
+        capabilities: {
+            hosted: true,
+            get deleteSessions() {
+                return acpAdvertisedDelete(id);
+            },
+        },
+        run: (options) => run(options, id),
+        available: () => !!(program.binary && os.tools.commandExists(program.binary)) ||
+            os.tools.commandExists(program.command),
+        controls: (cwd) => acpControls(id, cwd),
+        commands: (cwd) => acpCommands(id, cwd),
+        sessions: (cwd) => acpSessions(id, cwd),
+        loadSession: (cwd, sessionId) => acpLoadSession(id, cwd, sessionId),
+        deleteSession: (cwd, sessionId) => acpDeleteSession(id, cwd, sessionId),
+        mcpServers: configuredMcpServers,
+    };
+}
+async function run(options, id) {
+    const program = acpProgram(id);
+    const compactCommand = isCompactCommand(options.message, options.parts);
+    const mapper = createAcpEventMapper(options.emit, program.label, program.dialect?.(), {
+        compactCommand,
+    });
+    let sessionId = "";
+    // `session/load` replays the whole conversation; those updates are history, not this answer.
+    let replaying = false;
+    let connection;
+    const abort = () => {
+        if (connection && sessionId)
+            connection.notify("session/cancel", { sessionId });
+        void connection?.close();
+    };
+    connection = await startAcp(id, options.cwd, {
+        onNotification(method, params) {
+            if (replaying)
+                return;
+            if (method === "session/update") {
+                mapper.handleUpdate(String(params.sessionId ?? ""), (params.update ?? {}));
+                return;
+            }
+            acpProgram(id).notifications?.[method]?.(options, params);
+        },
+        onRequest(method, params) {
+            const extension = acpProgram(id).extensions?.[method];
+            if (extension)
+                return extension(options, params);
+            if (method === "elicitation/create")
+                return elicitForm(options, params, acpProgram(id).forms);
+            if (method !== "session/request_permission")
+                throw new Error(`Клиент не поддерживает ${method}`);
+            return decidePermission(options, params);
+        },
+    }, options.run);
+    options.abort?.addEventListener("abort", abort, { once: true });
+    if (options.abort?.aborted)
+        abort();
+    options.emit("status", { phase: "thinking", provider: program.label, model: "" });
+    try {
+        const init = await initializeAcp(connection, id);
+        const [ideEnabled, widgetsEnabled, roleText] = await Promise.all([
+            featureEnabled(id, "ide", options.features),
+            featureEnabled(id, "widgets", options.features),
+            roleContext(options.role, options.cwd),
+        ]);
+        const projectWidgets = widgetsEnabled ? await trustedProjectWidgets(options.projectId) : [];
+        const extraPrompt = [roleText, projectWidgets.length ? renderWidgetGuide(projectWidgets) : ""]
+            .filter(Boolean)
+            .join("\n\n");
+        const extraMcp = [
+            ...(options.projectId && ideEnabled ? [acpIdeMcpServer(options.projectId)] : []),
+            ...(widgetsEnabled ? [acpWidgetsMcpServer(options.projectId)] : []),
+            ...(options.role?.mcp
+                ? await userMcpServers(options.cwd, options.role.mcp, init.agentCapabilities?.mcpCapabilities)
+                : []),
+        ];
+        const session = await openSession(connection, options, init.authMethods ?? [], (active) => {
+            replaying = active;
+        }, init.agentCapabilities?.loadSession === true, init.agentCapabilities?.mcpCapabilities, extraMcp, options.role?.mcp);
+        sessionId = session.sessionId;
+        options.emit("session", { id: sessionId, backend: id });
+        // What the agent offers for this session, with the user's choices applied before the prompt.
+        const offered = controlsFromSession(session.result);
+        if (offered.length) {
+            const chosen = program.normalizeSelection?.(options.selection ?? {}, offered) ?? options.selection ?? {};
+            const applied = await applySelection(connection, sessionId, offered, chosen);
+            mapper.setModel(shownModel(applied));
+            options.emit("controls", { controls: applied });
+            options.emit("status", {
+                phase: "thinking",
+                provider: program.label,
+                model: shownModel(applied),
+            });
+        }
+        // A resumed session already holds the history; a fresh one starts from the replayed chat.
+        // Abilities the user switched on for this agent go before the new message, once per session.
+        const prompt = session.resumed
+            ? options.message
+            : promptWithHistory(options.message, options.history ?? [], await featurePrompt(id, options.features, extraPrompt));
+        const result = (await connection.request("session/prompt", {
+            sessionId,
+            prompt: promptBlocks(prompt, options.parts, options.cwd, init.agentCapabilities?.promptCapabilities?.image === true
+                ? await attachedImages(options.parts)
+                : []),
+        }, NO_TIMEOUT));
+        if (options.abort?.aborted)
+            return;
+        const stopReason = result?.stopReason;
+        if (stopReason === "end_turn" || stopReason === "cancelled") {
+            mapper.finish();
+            options.emit("done", { text: mapper.text.trim(), added: [] });
+        }
+        else
+            options.emit("error", { error: stopReasonError(stopReason) });
+    }
+    catch (error) {
+        if (!options.abort?.aborted)
+            options.emit("error", {
+                error: error instanceof Error ? error.message : "Агент недоступен",
+            });
+    }
+    finally {
+        options.abort?.removeEventListener("abort", abort);
+        await connection.close();
+    }
+}
+/**
+ * Resume the native session when the agent supports it, otherwise start a fresh one. The ACP
+ * `session/load` response has no `sessionId`, so the requested one is kept; an agent without
+ * `loadSession`, or a load that finds no such session, falls back to `session/new` with the
+ * replayed history. Any other load error is reported as is. If the agent refuses until
+ * authenticated, the first advertised method is used once.
+ */
+export async function openSession(connection, options, authMethods, replay, canLoad = true, mcp = {}, extraMcp = [], roleMcp) {
+    const servers = () => sessionMcpServers(options.cwd, mcp, extraMcp, roleMcp);
+    const start = async () => {
+        if (options.sessionId && canLoad) {
+            replay(true);
+            try {
+                const loaded = await connection.request("session/load", {
+                    sessionId: options.sessionId,
+                    cwd: options.cwd,
+                    mcpServers: await servers(),
+                });
+                return { sessionId: options.sessionId, resumed: true, result: loaded };
+            }
+            catch (error) {
+                // A dead connection or a missing login must surface as is; only a session that is gone
+                // (moved project, pruned transcript) falls back to a fresh one.
+                if (error.fatal || isAuthError(error) || !isMissingSession(error))
+                    throw error;
+            }
+            finally {
+                replay(false);
+            }
+        }
+        const created = (await connection.request("session/new", {
+            cwd: options.cwd,
+            mcpServers: await servers(),
+        }));
+        return { sessionId: created.sessionId, resumed: false, result: created };
+    };
+    try {
+        return await start();
+    }
+    catch (error) {
+        const methodId = authMethods.find((method) => method.id)?.id;
+        if (!methodId || !isAuthError(error))
+            throw error;
+        await connection.request("authenticate", { methodId });
+        return await start();
+    }
+}
+/** The requested native session is gone; a fresh one is the only way to continue. */
+function isMissingSession(error) {
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    return /no such session|unknown session|session .*not found|failed to load session/i.test(message);
+}
+/** The agent refuses a session until the CLI is authenticated. */
+function isAuthError(error) {
+    const code = error?.code;
+    if (code === 401)
+        return true;
+    const message = error instanceof Error ? error.message : "";
+    return /authenticat|auth required|not logged|login|log in|авториз/i.test(message);
+}
+/** Longest readable preview sent with a permission request. */
+const DETAIL_LIMIT = 8000;
+/**
+ * A readable preview of what the tool will change. ACP carries edits and MCP arguments in
+ * `toolCall.content` (`diff`/`content` blocks), which the raw input does not show.
+ */
+export function toolCallDetail(toolCall) {
+    const content = Array.isArray(toolCall.content) ? toolCall.content : [];
+    const parts = content
+        .map((item) => {
+        const block = item;
+        if (block.type === "diff")
+            return diffText(block);
+        if (block.type === "content")
+            return contentText(block.content);
+        return "";
+    })
+        .filter(Boolean);
+    if (!parts.length)
+        return undefined;
+    return parts.join("\n\n").slice(0, DETAIL_LIMIT);
+}
+function diffText(block) {
+    const path = block.path ?? "файл";
+    const removed = String(block.oldText ?? "")
+        .split("\n")
+        .map((line) => `-${line}`);
+    const added = String(block.newText ?? "")
+        .split("\n")
+        .map((line) => `+${line}`);
+    return [`--- ${path}`, `+++ ${path}`, ...removed, ...added].join("\n");
+}
+/**
+ * Maps the ACP permission options onto the chat's prompt. A one-time allow/reject is always
+ * preferred: `allow_always` is used only when the user chose "always" (or no one-time option
+ * exists), so a plain "Разрешить" never silently widens the agent's rights.
+ */
+export async function decidePermission(options, params) {
+    const toolCall = (params.toolCall ?? {});
+    const list = Array.isArray(params.options) ? params.options : [];
+    const allowOnce = list.find((item) => item.kind === "allow_once");
+    const allowAlways = list.find((item) => item.kind === "allow_always");
+    const allow = allowOnce ?? allowAlways;
+    if (!options.approve || !allow)
+        return { outcome: { outcome: "cancelled" } };
+    const kind = String(toolCall.kind ?? "").toLowerCase();
+    // The ACP title of a shell call is the command itself. Using it as the tool name repeats the
+    // same line three times in the card (title, tool label and preview), so keep the kind instead.
+    const tool = kind === "execute" ? "bash" : kind === "edit" ? "edit" : kind || "tool";
+    const input = (toolCall.rawInput ?? {});
+    const command = typeof input.command === "string" ? input.command : "";
+    const title = kind === "execute"
+        ? "Выполнить команду в оболочке"
+        : typeof toolCall.title === "string"
+            ? toolCall.title
+            : undefined;
+    const answer = await options
+        .approve({
+        tool,
+        input,
+        ...(title ? { title } : {}),
+        detail: toolCallDetail(toolCall) ?? (command ? `$ ${command}` : undefined),
+        persistent: !!allowAlways,
+    })
+        .catch(() => false);
+    if (answer === false) {
+        const reject = list.find((item) => item.kind === "reject_once") ??
+            list.find((item) => item.kind === "reject_always");
+        if (!reject?.optionId)
+            return { outcome: { outcome: "cancelled" } };
+        return { outcome: { outcome: "selected", optionId: reject.optionId } };
+    }
+    const chosen = answer === "always" ? (allowAlways ?? allowOnce) : (allowOnce ?? allowAlways);
+    if (!chosen?.optionId)
+        return { outcome: { outcome: "cancelled" } };
+    return { outcome: { outcome: "selected", optionId: chosen.optionId } };
+}

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

@@ -0,0 +1,153 @@
+/** Handshake requests (`initialize`, `session/new`, `authenticate`) get a short idle timeout. */
+export const HANDSHAKE_TIMEOUT_MS = 120_000;
+/** A turn waits for the agent and for user approvals, so it is bounded by abort, not by a timer. */
+export const NO_TIMEOUT = 0;
+/** How much of the child's stderr to keep for the failure message. */
+const STDERR_LIMIT = 4000;
+/**
+ * The client half of the Agent Client Protocol: JSON-RPC 2.0 over newline-delimited JSON on a
+ * child process's stdio. One connection lives for a single chat turn and is then closed.
+ * The request timeout (per request, `NO_TIMEOUT` to disable) is idle-based: every incoming message postpones it, so a streaming turn or
+ * a pending permission prompt is not cut off while the agent is still working.
+ */
+export function createAcpConnection(child, handlers) {
+    const label = handlers.label ?? "Агент";
+    let buffer = "";
+    let stderr = "";
+    let nextId = 1;
+    let closed = false;
+    const pending = new Map();
+    const fail = (error) => {
+        if (closed)
+            return;
+        closed = true;
+        error.fatal = true;
+        for (const waiter of pending.values())
+            waiter.reject(error);
+        pending.clear();
+    };
+    const write = (message) => {
+        if (!closed)
+            child.stdin.write(JSON.stringify(message) + "\n");
+    };
+    const respond = (id, result) => write({ jsonrpc: "2.0", id, result });
+    const respondError = (id, code, message) => write({ jsonrpc: "2.0", id, error: { code, message } });
+    /** Any traffic means the agent is alive: postpone every pending request's idle timeout. */
+    const touch = () => {
+        for (const waiter of pending.values())
+            waiter.arm();
+    };
+    async function dispatch(message) {
+        touch();
+        if (message.method && message.id !== undefined) {
+            try {
+                const result = await handlers.onRequest(message.method, (message.params ?? {}));
+                respond(message.id, result ?? {});
+            }
+            catch (error) {
+                respondError(message.id, -32000, error instanceof Error ? error.message : "Ошибка клиента");
+            }
+            return;
+        }
+        if (message.method) {
+            handlers.onNotification(message.method, (message.params ?? {}));
+            return;
+        }
+        if (message.id === undefined)
+            return;
+        const waiter = pending.get(Number(message.id));
+        if (!waiter)
+            return;
+        pending.delete(Number(message.id));
+        if (message.error) {
+            const summary = message.error.message || "Ошибка агента";
+            const details = message.error.data?.details;
+            const error = new Error(typeof details === "string" && details.trim() ? `${summary}: ${details}` : summary);
+            error.code = message.error.code;
+            waiter.reject(error);
+        }
+        else
+            waiter.resolve(message.result);
+    }
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        buffer += chunk;
+        let end;
+        while ((end = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, end).trim();
+            buffer = buffer.slice(end + 1);
+            if (!line)
+                continue;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            void dispatch(message);
+        }
+    });
+    // Drain stderr so a chatty agent cannot block on a full pipe, and keep the tail for errors.
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+        stderr = (stderr + chunk).slice(-STDERR_LIMIT);
+    });
+    child.on("error", (error) => {
+        if (error.code === "ENOENT")
+            fail(new Error(`${label} не найден в PATH`));
+        else
+            fail(new Error(`${label} недоступен: ${error.message}`));
+    });
+    child.on("close", () => {
+        const tail = stderr.trim();
+        fail(new Error(tail ? `${label} завершился до ответа: ${tail}` : `${label} завершился до ответа`));
+    });
+    child.stdin.on("error", () => fail(new Error(`Соединение с ${label} закрыто`)));
+    function request(method, params, timeoutMs = HANDSHAKE_TIMEOUT_MS) {
+        if (closed)
+            return Promise.reject(new Error(`${label} уже завершился`));
+        const id = nextId++;
+        return new Promise((resolve, reject) => {
+            let timer;
+            const arm = () => {
+                clearTimeout(timer);
+                if (timeoutMs > 0)
+                    timer = setTimeout(() => {
+                        pending.delete(id);
+                        const error = new Error(`${label} не ответил вовремя`);
+                        error.fatal = true;
+                        reject(error);
+                    }, timeoutMs);
+            };
+            pending.set(id, {
+                resolve: (value) => {
+                    clearTimeout(timer);
+                    resolve(value);
+                },
+                reject: (error) => {
+                    clearTimeout(timer);
+                    reject(error);
+                },
+                arm,
+            });
+            arm();
+            write({ jsonrpc: "2.0", id, method, params });
+        });
+    }
+    return {
+        request,
+        notify: (method, params) => write({ jsonrpc: "2.0", method, params }),
+        respond,
+        respondError,
+        /** Stops the whole agent tree (when the OS adapter provides it) and waits for exit. */
+        async close() {
+            fail(new Error("Соединение закрыто"));
+            child.stdin.end();
+            if (child.terminate)
+                await child.terminate();
+            else
+                child.kill();
+        },
+    };
+}

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

@@ -0,0 +1,179 @@
+const CATEGORIES = {
+    model: "model",
+    thought_level: "effort",
+    mode: "mode",
+    model_config: "flag",
+};
+const asText = (value) => (typeof value === "string" ? value : "");
+function currentOf(row) {
+    const value = row.currentValue;
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number")
+        return String(value);
+    return asText(value);
+}
+/** ACP select options are flat or grouped (`{ group, name, options }`). */
+function flattenOptions(options, group) {
+    if (!Array.isArray(options))
+        return [];
+    return options.flatMap((item) => {
+        const row = (item ?? {});
+        if (Array.isArray(row.options)) {
+            const name = asText(row.group) || asText(row.name) || group;
+            return flattenOptions(row.options, name || undefined);
+        }
+        const value = asText(row.value);
+        if (!value)
+            return [];
+        return [
+            {
+                value,
+                name: asText(row.name) || value,
+                ...(asText(row.description) ? { description: asText(row.description) } : {}),
+                ...(group ? { group } : {}),
+            },
+        ];
+    });
+}
+function booleanOptions(row) {
+    const on = asText(row.name) || "Да";
+    return [
+        { value: "true", name: on },
+        { value: "false", name: "Выкл" },
+    ];
+}
+function fromConfigOptions(list) {
+    if (!Array.isArray(list))
+        return [];
+    return list.flatMap((item) => {
+        const row = (item ?? {});
+        const id = asText(row.id);
+        if (!id)
+            return [];
+        const type = asText(row.type);
+        const boolean = type === "boolean";
+        const options = boolean
+            ? booleanOptions(row)
+            : type === "select"
+                ? flattenOptions(row.options)
+                : [];
+        if (!options.length)
+            return [];
+        return [
+            {
+                id,
+                category: CATEGORIES[asText(row.category)] ?? (boolean ? "flag" : "other"),
+                name: asText(row.name) || id,
+                ...(asText(row.description) ? { description: asText(row.description) } : {}),
+                current: currentOf(row),
+                options,
+                via: "config",
+                ...(boolean ? { boolean: true } : {}),
+            },
+        ];
+    });
+}
+/** Older agents report `models`/`modes` instead of (or next to) `configOptions`. */
+function legacyControls(result, known) {
+    const controls = [];
+    const models = result.models;
+    if (models && Array.isArray(models.availableModels) && !known.some((c) => c.category === "model"))
+        controls.push({
+            id: "model",
+            category: "model",
+            name: "Модель",
+            current: asText(models.currentModelId),
+            options: models.availableModels.flatMap((model) => asText(model.modelId)
+                ? [
+                    {
+                        value: asText(model.modelId),
+                        name: asText(model.name) || asText(model.modelId),
+                        ...(asText(model.description) ? { description: asText(model.description) } : {}),
+                    },
+                ]
+                : []),
+            via: "model",
+        });
+    const modes = result.modes;
+    if (modes && Array.isArray(modes.availableModes) && !known.some((c) => c.category === "mode"))
+        controls.push({
+            id: "mode",
+            category: "mode",
+            name: "Режим",
+            current: asText(modes.currentModeId),
+            options: modes.availableModes.flatMap((mode) => asText(mode.id)
+                ? [
+                    {
+                        value: asText(mode.id),
+                        name: asText(mode.name) || asText(mode.id),
+                        ...(asText(mode.description) ? { description: asText(mode.description) } : {}),
+                    },
+                ]
+                : []),
+            via: "mode",
+        });
+    return controls.filter((control) => control.options.length);
+}
+const ORDER = ["model", "effort", "flag", "mode", "other"];
+/** The controls of a `session/new` or `session/load` response, model first, then effort. */
+export function controlsFromSession(result) {
+    const row = (result ?? {});
+    const config = fromConfigOptions(row.configOptions);
+    return sorted([...config, ...legacyControls(row, config)]);
+}
+function sorted(controls) {
+    return ORDER.flatMap((category) => controls.filter((control) => control.category === category));
+}
+export function shownModel(controls) {
+    const model = controls.find((control) => control.category === "model");
+    if (!model)
+        return "";
+    return model.options.find((option) => option.value === model.current)?.name ?? model.current;
+}
+/**
+ * Applies the user's choices to a fresh session. Changing the model can change the options of
+ * the others (effort levels may depend on the model), so the controls are re-read from every
+ * `set_config_option` answer. A refused value is skipped: the turn still runs with the agent's own.
+ */
+export async function applySelection(connection, sessionId, controls, selection) {
+    let current = controls;
+    for (const category of ORDER) {
+        for (const control of controls.filter((item) => item.category === category)) {
+            const wanted = selection[control.id];
+            const live = current.find((item) => item.id === control.id);
+            if (!wanted || !live || wanted === live.current)
+                continue;
+            if (!live.options.some((option) => option.value === wanted))
+                continue;
+            try {
+                if (live.via === "config") {
+                    const answer = (await connection.request("session/set_config_option", {
+                        sessionId,
+                        configId: live.id,
+                        value: live.boolean ? wanted === "true" : wanted,
+                    }));
+                    const updated = fromConfigOptions(answer?.configOptions);
+                    if (updated.length)
+                        current = sorted([...updated, ...current.filter((item) => item.via !== "config")]);
+                    else
+                        current = withCurrent(current, live.id, wanted);
+                }
+                else {
+                    await connection.request(live.via === "model" ? "session/set_model" : "session/set_mode", {
+                        sessionId,
+                        ...(live.via === "model" ? { modelId: wanted } : { modeId: wanted }),
+                    });
+                    current = withCurrent(current, live.id, wanted);
+                }
+            }
+            catch {
+                /* The agent refused this value; keep its own. */
+            }
+        }
+    }
+    return current;
+}
+function withCurrent(controls, id, value) {
+    return controls.map((control) => (control.id === id ? { ...control, current: value } : control));
+}