@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/agents/projector/secrets/secret-tools.js

@@ -0,0 +1,124 @@
+import { z } from "zod";
+import { destinationOf, gitIgnores, resolveEnvTarget, resolveIntegrationTarget, resolveProviderTarget, storeSecret, } from "./secret-destination.js";
+import { defineSpec } from "../tool-spec.js";
+/** One tool for every kind of secret: the model names the destination, the user types the value. */
+export function createSecretToolSpecs(context) {
+    /** Checks the destination, asks for the value, stores it. Nothing is asked if the check fails. */
+    async function resolve(input) {
+        const str = (value) => (typeof value === "string" ? value : undefined);
+        switch (input.kind) {
+            case "env": {
+                if (!str(input.key))
+                    throw new Error("Для kind env укажите key — имя переменной");
+                return resolveEnvTarget(context.cwd, str(input.file) || ".env", str(input.key));
+            }
+            case "ai_provider":
+                return resolveProviderTarget({
+                    providerId: str(input.providerId),
+                    name: str(input.name),
+                    url: str(input.url),
+                    model: str(input.model),
+                });
+            case "integration":
+                if (input.integration !== "github" &&
+                    input.integration !== "gitlab" &&
+                    input.integration !== "web_search")
+                    throw new Error("Для kind integration укажите github, gitlab или web_search");
+                return resolveIntegrationTarget(input.integration);
+            default:
+                throw new Error("kind: env, ai_provider или integration");
+        }
+    }
+    return [
+        defineSpec({
+            name: "request_secret",
+            description: "Запросить у пользователя секрет и записать его напрямую в место назначения. Пользователь вводит значение в закрытом поле; тебе возвращается только факт записи, сам секрет нет. kind=env — переменная .env проекта (key, file). kind=ai_provider — ключ провайдера: providerId существующего или name, url, model нового; адрес не должен быть придуман. kind=integration — токен github или gitlab, либо ключ веб-поиска web_search. Места и провайдеры узнай через list_secret_destinations. Значение не угадывай и не придумывай.",
+            shape: {
+                kind: z.enum(["env", "ai_provider", "integration"]).describe("Куда записать"),
+                label: z.string().max(200).optional().describe("Что за секрет, в словах пользователя"),
+                reason: z.string().max(500).optional().describe("Зачем он нужен"),
+                key: z.string().optional().describe("env: имя переменной, например DATABASE_PASSWORD"),
+                file: z.string().optional().describe("env: файл относительно проекта, по умолчанию .env"),
+                providerId: z.string().optional().describe("ai_provider: id существующего провайдера"),
+                name: z.string().max(80).optional().describe("ai_provider: название нового провайдера"),
+                url: z
+                    .string()
+                    .max(500)
+                    .optional()
+                    .describe("ai_provider: адрес API нового провайдера, http или https"),
+                model: z.string().max(200).optional().describe("ai_provider: модель по умолчанию"),
+                integration: z
+                    .enum(["github", "gitlab", "web_search"])
+                    .optional()
+                    .describe("integration: какой токен; web_search — ключ Brave Search для web_search"),
+            },
+            run: async (input) => {
+                const target = await resolve(input);
+                const value = await context.secret({
+                    label: input.label || defaultLabel(target),
+                    reason: input.reason,
+                    destination: destinationOf(target),
+                });
+                if (value === null)
+                    return { stored: false, declined: true };
+                await storeSecret(target, value);
+                if (target.kind === "env_file")
+                    return {
+                        stored: true,
+                        kind: "env",
+                        file: target.file,
+                        key: target.key,
+                        replaced: target.replaces,
+                        gitIgnored: context.cwd ? await gitIgnores(context.cwd, target.path) : undefined,
+                    };
+                if (target.kind === "ai_provider")
+                    return {
+                        stored: true,
+                        kind: "ai_provider",
+                        providerId: target.id,
+                        name: target.name,
+                        replaced: target.replaces,
+                    };
+                return {
+                    stored: true,
+                    kind: "integration",
+                    integration: target.integration,
+                    replaced: target.replaces,
+                };
+            },
+        }),
+    ];
+}
+/**
+ * Shows an existing secret to the person at the screen. The script's stdout goes to the browser
+ * panel, while the tool result says only that it was delivered; the model never receives the value.
+ */
+export function createSecretShowToolSpec(context) {
+    return [
+        defineSpec({
+            name: "show_secret",
+            description: "Показать пользователю секрет, который вернёт скрипт, не получая значение в ответ. Запускает shell-команду на машине пользователя, берёт её stdout и открывает панель только в окне Projector; тебе возвращается лишь факт показа. Используй, когда просят показать ключ, токен или пароль, а не записать его. script — команда, чей stdout и есть секрет (например, cat ~/.ssh/id_ed25519); comment — короткое пояснение пользователю. Значение не печатай в ответе и не угадывай.",
+            shape: {
+                script: z
+                    .string()
+                    .min(1)
+                    .max(8_000)
+                    .describe("Shell-команда, чей stdout — секрет; выполняется на машине пользователя"),
+                label: z.string().max(200).optional().describe("Название секрета в панели"),
+                comment: z.string().max(1_000).optional().describe("Пояснение агента пользователю"),
+            },
+            run: async (input) => context.showSecret({
+                script: input.script,
+                ...(input.label?.trim() ? { label: input.label.trim() } : {}),
+                ...(input.comment?.trim() ? { comment: input.comment.trim() } : {}),
+            }),
+        }),
+    ];
+}
+function defaultLabel(target) {
+    if (target.kind === "env_file")
+        return `Переменная ${target.key}`;
+    if (target.kind === "ai_provider")
+        return `Ключ провайдера «${target.name}»`;
+    return `Токен ${target.label}`;
+}

package/packages/server/modules/agents/projector/tool-spec.js

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export function defineSpec(spec) {
+    return { ...spec, run: (input) => spec.run(input) };
+}

package/packages/server/modules/agents/projector/tool-specs.js

@@ -0,0 +1,167 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { createSecretShowToolSpec, createSecretToolSpecs } from "./secrets/secret-tools.js";
+import { listSecretDestinations } from "./secrets/secret-destination.js";
+import { findProjects, inspectProject, loadProjects, updateProjects, } from "../../projects/index.js";
+import { defineSpec } from "./tool-spec.js";
+async function addFromPath(path, overrides = {}) {
+    const inspected = await inspectProject(path);
+    const project = {
+        id: randomUUID(),
+        name: overrides.name?.trim() || inspected.name,
+        path: inspected.path,
+        url: overrides.url?.trim() || inspected.url,
+        icon: inspected.icon,
+        mode: overrides.mode ?? inspected.mode,
+        defaultCommandId: inspected.defaultCommandId,
+        commands: inspected.commands,
+        createdAt: new Date().toISOString(),
+    };
+    let result = { project, created: true };
+    await updateProjects((projects) => {
+        const existing = projects.find((item) => item.path === inspected.path);
+        if (existing)
+            result = { project: existing, created: false };
+        else
+            projects.push(project);
+    });
+    return result;
+}
+/** Projector IDE command access and the project catalog: shared by every agent backend. */
+export function createToolSpecs(context) {
+    const described = new Set();
+    const commands = (request) => {
+        if (!context.commands)
+            throw new Error("Откройте чат агента в проекте для доступа к командам");
+        return context.commands(request);
+    };
+    return [
+        defineSpec({
+            name: "list_commands",
+            description: "Найти существующие команды Projector и их области (scope). Пустой query возвращает весь каталог текущего проекта.",
+            shape: { query: z.string().optional() },
+            run: ({ query }) => commands({ operation: "list", query }),
+        }),
+        defineSpec({
+            name: "describe_command",
+            description: "Получить описание, аргументы и контекст команды перед вызовом.",
+            shape: { command: z.string(), scope: z.string() },
+            run: async ({ command, scope }) => {
+                const result = await commands({ operation: "describe", command, scope });
+                described.add(`${scope}\n${command}`);
+                return result;
+            },
+        }),
+        defineSpec({
+            name: "execute_command",
+            description: "Вызвать команду Projector в явной области scope. Только после describe_command для этой же пары command и scope: без него вызов отклоняется. Порядок всегда такой: list_commands, describe_command, execute_command.",
+            shape: {
+                command: z.string(),
+                scope: z.string(),
+                args: z.record(z.string(), z.unknown()).optional(),
+            },
+            run: ({ command, scope, args }) => {
+                if (!described.has(`${scope}\n${command}`))
+                    throw new Error("Сначала вызови describe_command");
+                return commands({ operation: "execute", command, scope, args });
+            },
+        }),
+        ...(context.secret ? createSecretToolSpecs({ cwd: context.cwd, secret: context.secret }) : []),
+        ...(context.showSecret ? createSecretShowToolSpec({ showSecret: context.showSecret }) : []),
+        defineSpec({
+            name: "list_secret_destinations",
+            description: "Куда можно записать секрет через request_secret: провайдеры ИИ (id, название, адрес, модель, есть ли ключ) и интеграции github/gitlab (включены, подключены). Значения секретов не возвращаются.",
+            shape: {},
+            run: async () => listSecretDestinations(),
+        }),
+        defineSpec({
+            name: "list_projects",
+            description: "Список уже добавленных в projector проектов.",
+            shape: {},
+            run: async () => {
+                const projects = await loadProjects();
+                return projects.map((item) => ({
+                    id: item.id,
+                    name: item.name,
+                    path: item.path,
+                    url: item.url,
+                    icon: item.icon || null,
+                    commands: item.commands.map((command) => command.name),
+                }));
+            },
+        }),
+        defineSpec({
+            name: "find_projects",
+            description: "Найти запускаемые приложения (vite/nuxt/next/astro) под корнем. Отсекает packages/, docs/, demo/, speech/ и вложенный мусор. Возвращает уже отсортированный короткий список.",
+            shape: {
+                path: z.string().describe("Корневая папка поиска"),
+                depth: z.number().min(1).max(5).optional().describe("Глубина, по умолчанию 4"),
+            },
+            run: ({ path, depth }) => findProjects(path, depth ?? 4),
+        }),
+        defineSpec({
+            name: "add_project",
+            description: "Добавить один проект. Для нескольких путей используй add_projects.",
+            shape: {
+                path: z.string().describe("Путь к проекту"),
+                name: z.string().optional().describe("Имя, если нужно переименовать"),
+                url: z.string().optional().describe("URL dev-сервера, если известен"),
+                mode: z.enum(["server", "window"]).optional(),
+            },
+            run: async ({ path, name, url, mode }) => {
+                const { project, created } = await addFromPath(path, { name, url, mode });
+                if (created)
+                    context.onProject(project);
+                return {
+                    added: created,
+                    existed: !created,
+                    id: project.id,
+                    name: project.name,
+                    path: project.path,
+                    url: project.url,
+                    icon: project.icon || null,
+                    mode: project.mode,
+                    commands: project.commands.map((item) => ({ name: item.name, cmd: item.cmd })),
+                };
+            },
+        }),
+        defineSpec({
+            name: "add_projects",
+            description: "Добавить несколько приложений сразу. Сам читает package.json и ищет favicon. Пропускает уже добавленные пути.",
+            shape: {
+                paths: z.array(z.string()).min(1).max(16).describe("Пути к приложениям из find_projects"),
+                mode: z.enum(["server", "window"]).optional(),
+            },
+            run: async ({ paths, mode }) => {
+                const added = [];
+                const existed = [];
+                const errors = [];
+                for (const path of paths) {
+                    try {
+                        const { project, created } = await addFromPath(path, { mode });
+                        const row = {
+                            id: project.id,
+                            name: project.name,
+                            path: project.path,
+                            url: project.url,
+                        };
+                        if (created) {
+                            context.onProject(project);
+                            added.push(row);
+                        }
+                        else {
+                            existed.push(row);
+                        }
+                    }
+                    catch (error) {
+                        errors.push({
+                            path,
+                            error: error instanceof Error ? error.message : "не удалось добавить",
+                        });
+                    }
+                }
+                return { added, existed, errors };
+            },
+        }),
+    ];
+}

package/packages/server/modules/agents/projector/widgets.js

@@ -0,0 +1,4 @@
+import { createWidgetCatalog, } from "../../../../core/modules/widget-catalog/index.js";
+/** What the assistant is told about the chat's components; filled by the composition at startup. */
+export const widgetCatalog = createWidgetCatalog();
+export const registerWidgetDefinition = (definition) => widgetCatalog.register(definition);

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

@@ -0,0 +1,34 @@
+import { fileURLToPath } from "node:url";
+/** Name of the built-in server that exposes on-demand descriptions of special widgets. */
+export const WIDGETS_MCP_SERVER = "projector-widgets";
+/** The stdio MCP server every external agent can start to read the widget catalogue. */
+export function widgetsMcpServer(projectId) {
+    return {
+        name: WIDGETS_MCP_SERVER,
+        command: process.execPath,
+        args: [fileURLToPath(new URL("../../../app/widgets-mcp.js", import.meta.url))],
+        env: projectId ? { PROJECTOR_PROJECT_ID: projectId } : {},
+    };
+}
+/** The Claude Agent SDK takes a server object inline with the same fields. */
+export function claudeWidgetsMcpServer(projectId) {
+    const server = widgetsMcpServer(projectId);
+    return {
+        type: "stdio",
+        command: server.command,
+        args: server.args,
+        env: server.env,
+        // The one tool must be visible immediately instead of hiding behind tool search.
+        alwaysLoad: true,
+    };
+}
+/** ACP passes environment variables as a list of names and values. */
+export function acpWidgetsMcpServer(projectId) {
+    const server = widgetsMcpServer(projectId);
+    return {
+        name: server.name,
+        command: server.command,
+        args: server.args,
+        env: Object.entries(server.env).map(([name, value]) => ({ name, value })),
+    };
+}

package/packages/server/modules/agents/widgets-mcp/index.js

@@ -0,0 +1 @@
+export { acpWidgetsMcpServer, claudeWidgetsMcpServer, WIDGETS_MCP_SERVER, widgetsMcpServer, } from "./config.js";

package/packages/server/modules/agents-integration/_/usage-cache.js

@@ -0,0 +1,19 @@
+/** Adapters own HMR-stable state and decide when their cached response expires. */
+export function createUsageCache(state, load, expiresAt = (value) => value.checkedAt + 60000) {
+    return () => {
+        if (state.pending)
+            return state.pending;
+        if (state.value && Date.now() < expiresAt(state.value))
+            return Promise.resolve(state.value);
+        state.pending = Promise.resolve()
+            .then(load)
+            .then((value) => {
+            state.value = value;
+            return value;
+        })
+            .finally(() => {
+            state.pending = undefined;
+        });
+        return state.pending;
+    };
+}

package/packages/server/modules/agents-integration/claude/client.js

@@ -0,0 +1,33 @@
+import { homedir } from "node:os";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+export class ClaudeUsageError extends Error {
+}
+/**
+ * The plan limits Claude Code reports for its own login. The request is made by the `claude` process
+ * through the Agent SDK, so Projector never reads, stores or sends the login's token.
+ * `null` when plan limits do not apply (API key, Bedrock, Vertex, or no subscription).
+ */
+export async function readClaudeUsage(timeoutMs = 30000) {
+    // A query that never gets a prompt: it only answers the question and is closed at once.
+    const idle = (async function* () {
+        await new Promise(() => { });
+    })();
+    const session = query({ prompt: idle, options: { cwd: homedir(), settingSources: [] } });
+    let timer;
+    try {
+        const usage = await Promise.race([
+            session.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET({ skipBehaviors: true }),
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error("timeout")), timeoutMs);
+            }),
+        ]);
+        return usage.rate_limits_available ? usage.rate_limits : null;
+    }
+    catch {
+        throw new ClaudeUsageError("Не удалось получить лимиты Claude Code; проверьте вход: claude auth login");
+    }
+    finally {
+        clearTimeout(timer);
+        session.close();
+    }
+}

package/packages/server/modules/agents-integration/claude/index.js

@@ -0,0 +1 @@
+export { claudeUsage } from "./usage.js";

package/packages/server/modules/agents-integration/claude/usage.js

@@ -0,0 +1,49 @@
+import { createUsageCache } from "../_/usage-cache.js";
+import { readClaudeUsage } from "./client.js";
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
+export function claudeWindows(payload) {
+    const usage = record(payload);
+    function window(name) {
+        const value = record(usage?.[name]);
+        const percent = value?.utilization;
+        if (typeof percent !== "number" || !Number.isFinite(percent) || percent < 0)
+            return null;
+        const reset = typeof value?.resets_at === "string" ? Date.parse(value.resets_at) : NaN;
+        return {
+            usedPercent: Math.min(100, percent),
+            limited: percent >= 100,
+            resetsAt: Number.isFinite(reset) && reset > 0 ? Math.floor(reset / 1000) : null,
+        };
+    }
+    const rolling = window("five_hour"), weekly = window("seven_day");
+    return rolling || weekly ? { rolling, weekly } : null;
+}
+const globalState = globalThis;
+const state = (globalState.projectorClaudeUsage ??= {});
+const interval = 5 * 60000;
+/** Cache for all tabs and HMR: one Claude Code query per interval, however many tabs ask. */
+export const claudeUsage = createUsageCache(state, async () => {
+    try {
+        const windows = claudeWindows(await readClaudeUsage());
+        const checkedAt = Date.now();
+        return {
+            status: windows ? "ready" : "unavailable",
+            windows,
+            checkedAt,
+            nextCheckAt: checkedAt + interval,
+            message: windows ? null : "Лимиты подписки Claude Code недоступны",
+        };
+    }
+    catch (error) {
+        const checkedAt = Date.now();
+        return {
+            status: "unavailable",
+            windows: null,
+            checkedAt,
+            nextCheckAt: checkedAt + interval,
+            message: error instanceof Error ? error.message : "Claude Code недоступен",
+        };
+    }
+}, (value) => value.nextCheckAt);

package/packages/server/modules/agents-integration/codex/cli.js

@@ -0,0 +1,86 @@
+import { os } from "../../../../core/modules/os/index.js";
+import { assertEuNetworkContext } from "../../network/index.js";
+/** One bounded JSON-RPC request over the authenticated local Codex CLI. */
+export function codexRequest(method, params, timeoutMs = 15000) {
+    return new Promise((resolve, reject) => {
+        const child = os.tools.spawnProcess({
+            command: "codex",
+            args: ["app-server", "--stdio"],
+            env: process.env,
+            stdio: ["pipe", "pipe", "ignore"],
+            shell: os.platform === "win32" && os.tools.commandExists("codex"),
+        });
+        if (!child.stdin || !child.stdout) {
+            child.kill();
+            reject(new Error("Codex CLI недоступен"));
+            return;
+        }
+        const { stdin, stdout } = child;
+        let buffer = "";
+        let settled = false;
+        let requested = false;
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            stdin.end();
+            child.kill();
+            const killTimer = setTimeout(() => child.kill("SIGKILL"), 1000);
+            killTimer.unref();
+            child.once("close", () => clearTimeout(killTimer));
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const timer = setTimeout(() => finish(new Error("Codex CLI не ответил вовремя")), timeoutMs);
+        const send = (message) => stdin.write(JSON.stringify(message) + "\n");
+        child.on("error", () => finish(new Error("Codex CLI недоступен")));
+        stdin.on("error", () => finish(new Error("Соединение с Codex CLI закрыто")));
+        child.once("close", () => finish(new Error("Codex CLI завершился до ответа")));
+        stdout.on("data", (chunk) => {
+            buffer += chunk;
+            if (buffer.length > 1024 * 1024)
+                return finish(new Error("Ответ Codex CLI слишком большой"));
+            let end;
+            while (!settled && (end = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, end);
+                buffer = buffer.slice(end + 1);
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (!message || typeof message !== "object")
+                    continue;
+                if (message.id !== 1 && message.id !== 2)
+                    continue;
+                if (message.error)
+                    return finish(new Error("Запрос Codex недоступен; проверьте вход в Codex CLI"));
+                if (message.id === 1 && !requested) {
+                    requested = true;
+                    send({ method: "initialized" });
+                    send({ id: 2, method, params });
+                }
+                else if (message.id === 2 && requested)
+                    finish(undefined, message.result);
+            }
+        });
+        stdout.setEncoding("utf8");
+        send({
+            id: 1,
+            method: "initialize",
+            params: {
+                clientInfo: { name: "projector", title: "Projector", version: "1.0" },
+                capabilities: null,
+            },
+        });
+    });
+}
+export async function readCodexRateLimits(timeoutMs = 15000) {
+    await assertEuNetworkContext(timeoutMs);
+    return codexRequest("account/rateLimits/read", { excludeResetCreditDetails: true }, timeoutMs);
+}

package/packages/server/modules/agents-integration/codex/index.js

@@ -0,0 +1 @@
+export { codexUsage } from "./usage.js";

package/packages/server/modules/agents-integration/codex/usage.js

@@ -0,0 +1,45 @@
+import { createUsageCache } from "../_/usage-cache.js";
+import { readCodexRateLimits } from "./cli.js";
+const record = (value) => value !== null && typeof value === "object" ? value : null;
+export function weeklyWindow(payload) {
+    const data = record(payload);
+    const buckets = record(data?.rateLimitsByLimitId);
+    const limits = record(buckets?.codex) ?? record(data?.rateLimits);
+    for (const name of ["primary", "secondary"]) {
+        const window = record(limits?.[name]);
+        if (window?.windowDurationMins !== 7 * 24 * 60)
+            continue;
+        const used = window.usedPercent;
+        if (typeof used !== "number" || !Number.isFinite(used) || used < 0 || used > 100)
+            continue;
+        const reset = window.resetsAt;
+        return {
+            usedPercent: used,
+            windowDurationMins: window.windowDurationMins,
+            resetsAt: typeof reset === "number" && Number.isFinite(reset) && reset > 0 ? reset : null,
+        };
+    }
+    return null;
+}
+const globalState = globalThis;
+const state = (globalState.projectorCodexUsage ??= {});
+/** Share polls across workspaces and HMR; expose only normalized usage, never account data. */
+export const codexUsage = createUsageCache(state, async () => {
+    try {
+        const weekly = weeklyWindow(await readCodexRateLimits());
+        return {
+            status: weekly ? "ready" : "unavailable",
+            weekly,
+            checkedAt: Date.now(),
+            message: weekly ? null : "Недельный лимит Codex недоступен",
+        };
+    }
+    catch (error) {
+        return {
+            status: "unavailable",
+            weekly: null,
+            checkedAt: Date.now(),
+            message: error instanceof Error ? error.message : "Codex CLI недоступен",
+        };
+    }
+});

package/packages/server/modules/agents-integration/cursor/client.js

@@ -0,0 +1,40 @@
+import { assertEuNetworkContext } from "../../network/index.js";
+import { readCursorAccessToken } from "./credentials.js";
+const USAGE_URL = "https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage";
+/** Fixed official destination, bounded request, no upstream body in errors. */
+export async function readCursorUsage(timeoutMs = 10000) {
+    const token = await readCursorAccessToken();
+    await assertEuNetworkContext(timeoutMs);
+    let response;
+    try {
+        response = await fetch(USAGE_URL, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                "Connect-Protocol-Version": "1",
+            },
+            body: "{}",
+            signal: AbortSignal.timeout(timeoutMs),
+            redirect: "error",
+        });
+    }
+    catch {
+        throw new Error("Не удалось получить лимиты Cursor");
+    }
+    if (!response.ok) {
+        await response.body?.cancel();
+        if (response.status === 401)
+            throw new Error("Авторизация Cursor истекла; выполните agent login");
+        if (response.status === 403)
+            throw new Error("Подписка Cursor недоступна");
+        throw new Error(`Cursor: ошибка HTTP ${response.status}`);
+    }
+    try {
+        return await response.json();
+    }
+    catch {
+        throw new Error("Некорректный ответ Cursor");
+    }
+}

package/packages/server/modules/agents-integration/cursor/credentials.js

@@ -0,0 +1,34 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { os } from "../../../../core/modules/os/index.js";
+const UNAVAILABLE = "Авторизация Cursor недоступна; выполните agent login";
+const candidates = () => [
+    join(os.configHome(), "cursor", "auth.json"),
+    join(os.configHome(), "Cursor", "auth.json"),
+];
+/** The auth file lives under either spelling of the directory; the first readable one wins. */
+async function readFirstReadable() {
+    for (const path of candidates()) {
+        try {
+            return await readFile(path, "utf8");
+        }
+        catch {
+            /* Try the next location. */
+        }
+    }
+    throw new Error(UNAVAILABLE);
+}
+/** Use Cursor Agent CLI credentials; never write or publish the auth file. */
+export async function readCursorAccessToken() {
+    let auth;
+    try {
+        auth = JSON.parse(process.env.CURSOR_AUTH_CONTENT ?? (await readFirstReadable()));
+    }
+    catch {
+        throw new Error(UNAVAILABLE);
+    }
+    const token = auth && typeof auth === "object" ? auth.accessToken : null;
+    if (typeof token !== "string" || !token.trim())
+        throw new Error(UNAVAILABLE);
+    return token;
+}

package/packages/server/modules/agents-integration/cursor/index.js

@@ -0,0 +1 @@
+export { cursorUsage } from "./usage.js";