@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/agent/side-request.js

@@ -0,0 +1,142 @@
+import { asString } from "../transport/index.js";
+import { selectionFrom } from "./controls.js";
+import { historyTools } from "./request.js";
+const QUESTION_CHARS = 4_000;
+const HISTORY_TURNS = 200;
+const HISTORY_CHARS = 80_000;
+const TURN_CHARS = 20_000;
+const THREAD_EXCHANGES = 20;
+const THREAD_ANSWER_CHARS = 4_000;
+const RUNNING_TOOLS = 20;
+const PLAN_ITEMS = 30;
+function text(value, limit) {
+    return asString(value).trim().slice(0, limit);
+}
+function exchanges(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.slice(-THREAD_EXCHANGES).flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const row = item;
+        const question = text(row.question, QUESTION_CHARS);
+        const answer = text(row.answer, THREAD_ANSWER_CHARS);
+        return question && answer ? [{ question, answer }] : [];
+    });
+}
+/** Running tools a request reports; malformed rows are dropped and sizes bounded. */
+export function runningToolsFrom(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.slice(0, RUNNING_TOOLS).flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const row = item;
+        const name = text(row.name, 100);
+        if (!name)
+            return [];
+        return [
+            {
+                name,
+                ...(row.input ? { input: text(row.input, 500) } : {}),
+                ...(typeof row.startedAt === "number" && Number.isFinite(row.startedAt)
+                    ? { startedAt: row.startedAt }
+                    : {}),
+            },
+        ];
+    });
+}
+/** Plan items a request reports; malformed rows are dropped and sizes bounded. */
+export function planItemsFrom(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.slice(0, PLAN_ITEMS).flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const row = item;
+        const content = text(row.content, 300);
+        if (!content)
+            return [];
+        return [{ content, status: text(row.status, 40) || "pending" }];
+    });
+}
+const weight = (turn) => turn.content.length +
+    (turn.thoughts?.length ?? 0) +
+    (turn.tools ?? []).reduce((sum, tool) => sum + (tool.input?.length ?? 0) + tool.output.length, 0);
+/** Oldest whole exchanges go first: the side question is about now, not the start of the chat. */
+function fitHistory(turns) {
+    let total = turns.reduce((sum, turn) => sum + weight(turn), 0);
+    let start = 0;
+    while (start < turns.length && (total > HISTORY_CHARS || turns[start].role !== "user")) {
+        total -= weight(turns[start]);
+        start++;
+        while (start < turns.length && turns[start].role !== "user") {
+            total -= weight(turns[start]);
+            start++;
+        }
+    }
+    return turns.slice(start);
+}
+/** The visible conversation a request reports, cut to what a read-only answer needs. */
+export function historyFrom(value) {
+    if (!Array.isArray(value))
+        return [];
+    return fitHistory(value.slice(-HISTORY_TURNS).flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const row = item;
+        const role = row.role === "assistant" ? "assistant" : row.role === "user" ? "user" : null;
+        const content = asString(row.content).slice(0, TURN_CHARS);
+        const tools = historyTools(row.tools);
+        const thoughts = role === "assistant" ? asString(row.thoughts).slice(0, TURN_CHARS) : "";
+        if (!role || (!content.trim() && !thoughts && !tools.length))
+            return [];
+        return [
+            {
+                role,
+                content,
+                ...(thoughts ? { thoughts } : {}),
+                ...(tools.length ? { tools } : {}),
+            },
+        ];
+    }));
+}
+/** The question with what the side model should know before it can call the status tool. */
+function sideMessage(question, thread, running, plan) {
+    const blocks = [];
+    if (thread.length)
+        blocks.push([
+            "Ранее в стороне спрашивали (это не часть основного разговора):",
+            ...thread.map((item, index) => `${index + 1}. Вопрос: ${item.question}\n   Ответ: ${item.answer}`),
+        ].join("\n"));
+    if (running.length)
+        blocks.push([
+            "Сейчас выполняется:",
+            ...running.map((item) => `- ${item.name}${item.input ? `: ${item.input}` : ""}`),
+        ].join("\n"));
+    if (plan.length)
+        blocks.push(["Текущий план:", ...plan.map((item) => `- [${item.status}] ${item.content}`)].join("\n"));
+    blocks.push(`Вопрос в сторону:\n${question}`);
+    return blocks.join("\n\n");
+}
+/** A side question from `POST /api/agent/side`; malformed parts are dropped, sizes bounded. */
+export function sideRequestFrom(body) {
+    const question = text(body.question, QUESTION_CHARS);
+    if (!question)
+        throw new Error("Напишите вопрос в сторону");
+    const thread = exchanges(body.thread);
+    const running = runningToolsFrom(body.running);
+    const plan = planItemsFrom(body.plan);
+    return {
+        question,
+        message: sideMessage(question, thread, running, plan),
+        history: historyFrom(body.history),
+        thread,
+        running,
+        plan,
+        chat: text(body.chat, 200),
+        projectId: text(body.projectId, 200),
+        selection: selectionFrom(body.selection),
+        providerId: text(body.providerId, 200) || undefined,
+    };
+}

package/packages/server/modules/agent/usage-history.js

@@ -0,0 +1,62 @@
+import { historyDatabase } from "./history-store.js";
+const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+/** Chat id → where the chat belongs. Archived chats live under `archive:<id>` in the turns table. */
+function chatPlaces() {
+    const db = historyDatabase();
+    const places = new Map();
+    const indexed = db.prepare("SELECT chat, scope, backend FROM chat_index").all();
+    for (const row of indexed)
+        places.set(row.chat, { backend: row.backend, project: row.scope });
+    const archived = db.prepare("SELECT id, project, backend FROM archives").all();
+    for (const row of archived)
+        places.set(`archive:${row.id}`, { backend: row.backend, project: row.project });
+    return places;
+}
+/**
+ * Answers with usage since `since`. Every saved version is counted: a branch that was abandoned
+ * still cost tokens. Chats that were deleted keep their answers out of reach of this store.
+ */
+export function readAgentUsage(since = 0) {
+    const db = historyDatabase();
+    const places = chatPlaces();
+    const rows = db
+        .prepare("SELECT chat, data FROM turns WHERE data LIKE '%\"usage\"%'")
+        .all();
+    const records = [];
+    for (const row of rows) {
+        let turn;
+        try {
+            turn = JSON.parse(row.data);
+        }
+        catch {
+            continue;
+        }
+        const usage = turn.usage;
+        if (!usage || turn.role !== "assistant")
+            continue;
+        const at = typeof turn.at === "number" && Number.isFinite(turn.at) ? turn.at : 0;
+        if (at < since)
+            continue;
+        const place = places.get(row.chat);
+        const backend = place?.backend ?? (row.chat.includes(":") ? row.chat.split(":")[0] : "");
+        const cost = typeof usage.cost === "number" && Number.isFinite(usage.cost) && usage.cost >= 0
+            ? usage.cost
+            : undefined;
+        const model = typeof turn.context?.model === "string" && turn.context.model
+            ? turn.context.model
+            : undefined;
+        records.push({
+            chat: row.chat,
+            backend,
+            project: place?.project ?? "",
+            at,
+            input: count(usage.input),
+            output: count(usage.output),
+            cacheRead: count(usage.cacheRead),
+            cacheWrite: count(usage.cacheWrite),
+            ...(cost !== undefined ? { cost } : {}),
+            ...(model ? { model } : {}),
+        });
+    }
+    return records;
+}

package/packages/server/modules/agent/worktrees.js

@@ -0,0 +1,136 @@
+import { execFile } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdir, stat } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { promisify } from "node:util";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+const run = promisify(execFile);
+const WORKTREE_ID = /^[0-9a-f]{8}$/;
+const IDENTITY = {
+    GIT_AUTHOR_NAME: "Projector",
+    GIT_AUTHOR_EMAIL: "projector@localhost",
+    GIT_COMMITTER_NAME: "Projector",
+    GIT_COMMITTER_EMAIL: "projector@localhost",
+};
+const git = async (cwd, args, env = {}) => (await run("git", args, { cwd, env: { ...process.env, ...env }, maxBuffer: 16 * 1024 * 1024 })).stdout.trim();
+const gitFailure = (error) => {
+    const { stderr, message } = error;
+    return (stderr || message || "git завершился с ошибкой").trim();
+};
+const branchOf = (id) => `projector/${id}`;
+const folderOf = (projectId, id) => join(dataDir(), "worktrees", `${projectId}-${id}`);
+/** Where a project folder lies inside its repository, so the copy can be entered at the same place. */
+async function layout(projectPath) {
+    let root;
+    try {
+        root = await git(projectPath, ["rev-parse", "--show-toplevel"]);
+    }
+    catch {
+        throw new Error("Изолированная копия работает только в git-проекте");
+    }
+    return { root, inside: relative(root, projectPath) };
+}
+/** A separate copy of the project (a git worktree on its own branch) for one agent chat to work in. */
+export async function createWorktree(projectId, projectPath) {
+    const { root, inside } = await layout(projectPath);
+    try {
+        await git(root, ["rev-parse", "--verify", "-q", "HEAD"]);
+    }
+    catch {
+        throw new Error("В git-репозитории нет ни одного коммита: сначала сделайте коммит, потом копия");
+    }
+    const id = randomBytes(4).toString("hex");
+    const folder = folderOf(projectId, id);
+    await mkdir(join(dataDir(), "worktrees"), { recursive: true, mode: 0o700 });
+    try {
+        await git(root, ["worktree", "add", "-b", branchOf(id), folder, "HEAD"]);
+    }
+    catch (error) {
+        throw new Error(`Не удалось создать копию проекта: ${gitFailure(error)}`);
+    }
+    return { id, branch: branchOf(id), cwd: join(folder, inside) };
+}
+/** The folder an agent works in for this copy; the identifier comes from a client, so it is checked. */
+export async function worktreeCwd(projectId, id, projectPath) {
+    if (!WORKTREE_ID.test(id))
+        throw new Error("Некорректная изолированная копия");
+    const { inside } = await layout(projectPath);
+    const folder = folderOf(projectId, id);
+    try {
+        await stat(folder);
+    }
+    catch {
+        throw new Error("Изолированная копия уже удалена");
+    }
+    return join(folder, inside);
+}
+export async function worktreeStatus(projectId, id, projectPath) {
+    const cwd = await worktreeCwd(projectId, id, projectPath);
+    const { root } = await layout(cwd);
+    const lines = (await git(root, ["status", "--porcelain"])).split("\n").filter(Boolean);
+    const committed = (await git(root, ["diff", "--name-only", "HEAD", branchOf(id)])).split("\n");
+    return {
+        id,
+        branch: branchOf(id),
+        changed: new Set([...lines, ...committed.filter(Boolean)]).size,
+    };
+}
+/**
+ * Brings the copy's changes into the project: they are committed on the copy's branch and merged
+ * into the branch the project is on. A merge that cannot go through is undone and reported.
+ */
+export async function mergeWorktree(projectId, id, projectPath) {
+    const cwd = await worktreeCwd(projectId, id, projectPath);
+    const copy = (await layout(cwd)).root;
+    const main = (await layout(projectPath)).root;
+    await git(copy, ["add", "-A"]);
+    const dirty = (await git(copy, ["status", "--porcelain"])) !== "";
+    if (dirty)
+        await git(copy, ["commit", "-m", "Изменения агента из изолированной копии"], IDENTITY);
+    const ahead = Number(await git(main, ["rev-list", "--count", `HEAD..${branchOf(id)}`]));
+    if (!ahead) {
+        await removeWorktree(projectId, id, projectPath);
+        return { merged: false, message: "В копии нет изменений: она удалена" };
+    }
+    try {
+        await git(main, ["merge", "--no-edit", branchOf(id)], IDENTITY);
+    }
+    catch (error) {
+        await git(main, ["merge", "--abort"]).catch(() => undefined);
+        throw new Error(`Слить не удалось, проект не изменён: ${gitFailure(error)}`);
+    }
+    await removeWorktree(projectId, id, projectPath);
+    return { merged: true, message: "Изменения влиты в проект, копия удалена" };
+}
+/**
+ * A second copy that starts from what a running job's copy has right now: its dirty work is
+ * committed on the copy's own branch and the fork branches off it. The source copy stays as is.
+ */
+export async function forkWorktree(projectId, projectPath, sourceCwd) {
+    const source = (await layout(sourceCwd)).root;
+    const { root: main, inside } = await layout(projectPath);
+    const branch = (await git(source, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+    if (!branch.startsWith("projector/"))
+        throw new Error("Форк доступен только изолированной копии Projector");
+    await git(source, ["add", "-A"]);
+    if ((await git(source, ["status", "--porcelain"])) !== "")
+        await git(source, ["commit", "-m", "Состояние перед форком"], IDENTITY);
+    const id = randomBytes(4).toString("hex");
+    const folder = folderOf(projectId, id);
+    await mkdir(join(dataDir(), "worktrees"), { recursive: true, mode: 0o700 });
+    try {
+        await git(main, ["worktree", "add", "-b", branchOf(id), folder, branch]);
+    }
+    catch (error) {
+        throw new Error(`Не удалось создать форк копии: ${gitFailure(error)}`);
+    }
+    return { id, branch: branchOf(id), cwd: join(folder, inside) };
+}
+/** Deletes the copy and its branch together with everything the agent did in it. */
+export async function removeWorktree(projectId, id, projectPath) {
+    if (!WORKTREE_ID.test(id))
+        throw new Error("Некорректная изолированная копия");
+    const { root } = await layout(projectPath);
+    await git(root, ["worktree", "remove", "--force", folderOf(projectId, id)]).catch(() => undefined);
+    await git(root, ["branch", "-D", branchOf(id)]).catch(() => undefined);
+}

package/packages/server/modules/agent-features/catalog.js

@@ -0,0 +1,18 @@
+import { createAgentFeatureCatalog, } from "../../../core/modules/agent-features/index.js";
+/**
+ * The features this server offers and the agents it can give them to. Both are filled by the
+ * composition (`server/app/features.ts`), so this module never names a concrete ability or agent.
+ */
+export const agentFeatureCatalog = createAgentFeatureCatalog();
+const agents = new Map();
+export const registerAgentFeature = (feature) => agentFeatureCatalog.register(feature);
+export function registerFeatureAgent(agent) {
+    agents.set(agent.id, agent);
+}
+export function featureAgents() {
+    return [...agents.values()];
+}
+export function hasFeatureAgent(id) {
+    return agents.has(id);
+}
+export {};

package/packages/server/modules/agent-features/index.js

@@ -0,0 +1,2 @@
+export { agentFeatureCatalog, featureAgents, registerAgentFeature, registerFeatureAgent, } from "./catalog.js";
+export { enabledFeatureText, enabledFeatures, FEATURE_PROMPT_END, featureEnabled, featurePrompt, featureSettings, featuresFile, sessionTitleWithoutInjected, setFeatureAgent, splitFeaturePrompt, } from "./store.js";

package/packages/server/modules/agent-features/store.js

@@ -0,0 +1,172 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { agentFeatureCatalog, featureAgents, hasFeatureAgent, } from "./catalog.js";
+/** Where the user's choices live: `$XDG_DATA_HOME/projector/agent/features.json`. */
+export const featuresFile = () => join(dataDir(), "agent", "features.json");
+function stateOf(text) {
+    try {
+        const data = JSON.parse(text);
+        const features = {};
+        if (data?.features && typeof data.features === "object")
+            for (const [id, value] of Object.entries(data.features))
+                if (Array.isArray(value))
+                    features[id] = value.filter((agent) => typeof agent === "string");
+        return { features };
+    }
+    catch {
+        return { features: {} };
+    }
+}
+async function readState() {
+    try {
+        return stateOf(await readFile(featuresFile(), "utf8"));
+    }
+    catch {
+        return { features: {} };
+    }
+}
+/** Writes through a temporary file, so a failed save never leaves half a settings file. */
+async function writeState(state) {
+    const path = featuresFile();
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+    await rename(temporary, path);
+}
+/** The agents a feature is on for: the saved choice, or the feature's defaults before the first change. */
+function enabledAgents(feature, state) {
+    const saved = state.features[feature.id];
+    const agents = saved ?? feature.defaults ?? [];
+    return agents.filter((id) => hasFeatureAgent(id));
+}
+/** What the island shows: every feature with every agent it can be given to. */
+export async function featureSettings() {
+    const state = await readState();
+    return {
+        features: agentFeatureCatalog.list().map((feature) => ({
+            id: feature.id,
+            title: feature.title,
+            summary: feature.summary,
+            agents: featureAgents().map((agent) => ({
+                id: agent.id,
+                label: agent.label,
+                enabled: enabledAgents(feature, state).includes(agent.id),
+            })),
+        })),
+        file: featuresFile(),
+    };
+}
+/** One write at a time: two toggles read the same file and must not lose each other's change. */
+let queue = Promise.resolve();
+/** Turns one feature on or off for one agent; returns the state the island should show. */
+export async function setFeatureAgent(featureId, agentId, enabled) {
+    const feature = agentFeatureCatalog.get(featureId);
+    if (!feature)
+        throw new Error(`Неизвестная возможность: ${featureId}`);
+    if (!hasFeatureAgent(agentId))
+        throw new Error(`Неизвестный агент: ${agentId}`);
+    const task = queue.then(async () => {
+        const state = await readState();
+        const current = enabledAgents(feature, state);
+        state.features[feature.id] = enabled
+            ? [...new Set([...current, agentId])]
+            : current.filter((id) => id !== agentId);
+        await writeState(state);
+        return featureSettings();
+    });
+    queue = task.catch(() => undefined);
+    return task;
+}
+/** The ids of the features the agent has on: the chat's choice, or the user's defaults. */
+export async function enabledFeatures(agentId, features) {
+    if (features)
+        return agentFeatureCatalog
+            .list()
+            .filter((feature) => features.includes(feature.id))
+            .map((feature) => feature.id);
+    const state = await readState();
+    return agentFeatureCatalog
+        .list()
+        .filter((feature) => enabledAgents(feature, state).includes(agentId))
+        .map((feature) => feature.id);
+}
+export async function featureEnabled(agentId, featureId, features) {
+    return (await enabledFeatures(agentId, features)).includes(featureId);
+}
+/**
+ * The instructions of every feature the agent has on, or an empty string. `features` is the chat's
+ * own choice (an empty list means none); without it the user's defaults for the agent apply.
+ * Backends combine this text with their own prompt: Projector reads it into the system prompt,
+ * others into the first message of a session.
+ */
+export async function enabledFeatureText(agentId, features) {
+    const ids = new Set(await enabledFeatures(agentId, features));
+    return agentFeatureCatalog
+        .list()
+        .filter((feature) => ids.has(feature.id))
+        .map((feature) => feature.instruction().trim())
+        .filter(Boolean)
+        .join("\n\n");
+}
+/** Marks where the injected abilities end and the user's own message begins. */
+export const FEATURE_PROMPT_END = "<!-- projector:features:end -->";
+/** The feature text framed for an agent that has no Projector prompt of its own. */
+export async function featurePrompt(agentId, features, extra = "") {
+    const text = [extra.trim(), await enabledFeatureText(agentId, features)]
+        .filter(Boolean)
+        .join("\n\n");
+    if (!text)
+        return "";
+    return `[Projector] В этом чате включены дополнительные возможности Projector. Пользуйся ими, когда это уместно; обычные вопросы не загромождай.\n\n${text}\n\n${FEATURE_PROMPT_END}`;
+}
+/**
+ * Splits a native session's first message into the instructions Projector injected and what the
+ * user actually wrote. Sessions from before the marker are matched against the same prefix when
+ * the agent still has the same abilities.
+ */
+export function splitFeaturePrompt(text, legacy) {
+    const marker = FEATURE_PROMPT_END;
+    const index = text.indexOf(marker);
+    let rest;
+    let injected;
+    if (index >= 0) {
+        injected = text.slice(0, index).trim() || undefined;
+        rest = text.slice(index + marker.length).trim();
+    }
+    else {
+        const prefix = legacy?.trim();
+        if (prefix && text.startsWith(prefix)) {
+            injected = prefix;
+            rest = text.slice(prefix.length).trim();
+        }
+        else {
+            rest = text;
+        }
+    }
+    // A resumed session also carries the replayed chat before the new message: the actual words
+    // are after this heading, the transcript itself is already shown as the session's own turns.
+    const heading = "Новое сообщение пользователя:\n";
+    const message = rest.lastIndexOf(heading);
+    if (message >= 0)
+        rest = rest.slice(message + heading.length).trim();
+    return { text: rest, ...(injected ? { injected } : {}) };
+}
+/**
+ * The title of a session an agent named after its first prompt: Projector's injected abilities
+ * are not the conversation, so the user's own words become the title. An old title whose prompt
+ * no longer matches the current abilities still ends with the message: its last paragraph is the
+ * best name available.
+ */
+export function sessionTitleWithoutInjected(title, legacy) {
+    const split = splitFeaturePrompt(title, legacy);
+    if (split.text !== title)
+        return split.text || title;
+    if (!title.startsWith("[Projector]"))
+        return title;
+    const at = title.lastIndexOf("\n\n");
+    if (at < 0)
+        return title;
+    const tail = title.slice(at + 2).trim();
+    return tail && tail !== title ? tail : title;
+}

package/packages/server/modules/agent-mcp/index.js

@@ -0,0 +1,106 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/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 ?? "");
+}
+export const userMcpFile = () => join(dataDir(), "agent", "mcp.json");
+async function readEntries(path) {
+    try {
+        const data = JSON.parse(await readFile(path, "utf8"));
+        return data.mcpServers && typeof data.mcpServers === "object" ? data.mcpServers : {};
+    }
+    catch {
+        return {};
+    }
+}
+const pairs = (value) => Object.fromEntries((value && typeof value === "object" ? Object.entries(value) : []).map(([name, item]) => [
+    name,
+    expand(String(item)),
+]));
+function toConfig(name, source, entry) {
+    if (entry.disabled === true)
+        return undefined;
+    if (typeof entry.command === "string" && entry.command && (!entry.type || entry.type === "stdio"))
+        return {
+            name,
+            source,
+            command: expand(entry.command),
+            args: Array.isArray(entry.args) ? entry.args.map((item) => expand(String(item))) : [],
+            env: pairs(entry.env),
+        };
+    if ((entry.type === "http" || entry.type === "sse") && typeof entry.url === "string" && entry.url)
+        return {
+            name,
+            source,
+            url: expand(entry.url),
+            sse: entry.type === "sse",
+            headers: pairs(entry.headers),
+        };
+    return undefined;
+}
+/** The user's servers and the project's `.mcp.json`; a project server of the same name wins nothing over the user's. */
+export async function mcpServerConfigs(cwd) {
+    const user = await readEntries(userMcpFile());
+    const project = cwd ? await readEntries(join(cwd, ".mcp.json")) : {};
+    return [
+        ...Object.entries(user).map(([name, entry]) => toConfig(name, "user", entry)),
+        ...Object.entries(project)
+            .filter(([name]) => !(name in user))
+            .map(([name, entry]) => toConfig(name, "project", entry)),
+    ].filter((item) => !!item);
+}
+/** Keeps only the servers a role names; an omitted list keeps every configured server. */
+export function mcpConfigsForNames(configs, names) {
+    if (names === undefined)
+        return [...configs];
+    const wanted = new Set(names);
+    return configs.filter((config) => wanted.has(config.name));
+}
+/** The shape Claude Code's SDK takes in `mcpServers` for an explicit server. */
+export function processMcpConfig(config) {
+    if ("command" in config)
+        return {
+            type: "stdio",
+            command: config.command,
+            args: config.args,
+            env: config.env,
+        };
+    return {
+        type: config.sse ? "sse" : "http",
+        url: config.url,
+        headers: config.headers,
+    };
+}
+/** The user's server list as written, for the settings page; empty when there is none yet. */
+export async function readUserMcp() {
+    try {
+        return await readFile(userMcpFile(), "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+/** Saves the user's server list after checking it is `{ "mcpServers": { ... } }`; empty text removes it. */
+export async function writeUserMcp(text) {
+    const path = userMcpFile();
+    if (!text.trim()) {
+        await rm(path, { force: true });
+        return;
+    }
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`Не JSON: ${error.message}`);
+    }
+    const servers = data?.mcpServers;
+    if (!servers || typeof servers !== "object" || Array.isArray(servers))
+        throw new Error('Нужен объект вида { "mcpServers": { "имя": { … } } }');
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, text.trim() + "\n", { mode: 0o600 });
+    await rename(temporary, path);
+}

package/packages/server/modules/agent-roles/index.js

@@ -0,0 +1,3 @@
+export { createChatRole, deleteChatRole, readAgentRole, rolesFile, roleSettings, saveChatRole, saveServiceRole, resetServiceRole, serviceRoleSelection, } from "./store.js";
+export { createProjectRole, deleteProjectRole, projectRoleState, projectRolesRelativeFile, projectRolesTrustFile, readProjectAgentRole, saveProjectRole, setProjectRoleTrust, } from "./project.js";
+export { roleContext, rolePromptText, selectedNames } from "./runtime.js";