@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/providers/thinking.js

@@ -0,0 +1,105 @@
+export const THINKING_STYLES = [
+    "none",
+    "qwen",
+    "vllm",
+    "deepseek",
+    "ollama",
+    "openai",
+    "openrouter",
+];
+export function isThinkingStyle(value) {
+    return typeof value === "string" && THINKING_STYLES.includes(value);
+}
+/** The level that switches thinking off. */
+export const THINKING_OFF = "off";
+const toggle = (field) => ({
+    levels: ["on"],
+    initial: "on",
+    canOff: true,
+    body: (level) => field(level !== THINKING_OFF),
+});
+const PROFILES = {
+    qwen: toggle((on) => ({ enable_thinking: on })),
+    vllm: toggle((on) => ({ chat_template_kwargs: { enable_thinking: on } })),
+    deepseek: {
+        levels: ["low", "high", "max"],
+        initial: "high",
+        canOff: true,
+        body: (level) => {
+            if (level === THINKING_OFF)
+                return { thinking: { type: "disabled" } };
+            return { thinking: { type: "enabled" }, reasoning_effort: level };
+        },
+    },
+    ollama: {
+        levels: ["low", "medium", "high"],
+        initial: "medium",
+        canOff: true,
+        body: (level) => ({ reasoning_effort: level === THINKING_OFF ? "none" : level }),
+    },
+    openai: {
+        levels: ["minimal", "low", "medium", "high"],
+        initial: "medium",
+        canOff: false,
+        body: (level) => ({ reasoning_effort: level }),
+    },
+    openrouter: {
+        levels: ["low", "medium", "high"],
+        initial: "medium",
+        canOff: true,
+        body: (level) => {
+            if (level === THINKING_OFF)
+                return { reasoning: { enabled: false } };
+            return { reasoning: { effort: level } };
+        },
+    },
+};
+const NAMES = {
+    off: "Выключено",
+    on: "Включено",
+    minimal: "Минимальное",
+    low: "Низкое",
+    medium: "Среднее",
+    high: "Высокое",
+    max: "Максимальное",
+};
+/** The dialect a provider of this kind speaks until the user picks another one. */
+export function defaultThinkingStyle(kind) {
+    if (kind === "qwencloud")
+        return "qwen";
+    if (kind === "deepseek")
+        return "deepseek";
+    if (kind === "local")
+        return "ollama";
+    return "none";
+}
+/** Levels to choose from, as options of a chat control; empty when the provider has no knob. */
+export function thinkingOptions(style) {
+    if (style === "none")
+        return [];
+    const profile = PROFILES[style];
+    const levels = profile.canOff ? [THINKING_OFF, ...profile.levels] : profile.levels;
+    return levels.map((value) => ({ value, name: NAMES[value] ?? value }));
+}
+/** The level a request uses: the chosen one when this dialect has it, else the initial one. */
+export function thinkingLevel(style, chosen) {
+    if (style === "none")
+        return THINKING_OFF;
+    const profile = PROFILES[style];
+    if (chosen === THINKING_OFF && profile.canOff)
+        return THINKING_OFF;
+    return profile.levels.includes(chosen ?? "") ? chosen : profile.initial;
+}
+/** Request fields that ask for `chosen` thinking; `undefined` when the provider has no such knob. */
+export function thinkingBody(style, chosen) {
+    if (style === "none")
+        return undefined;
+    return PROFILES[style].body(thinkingLevel(style, chosen));
+}
+/** Request fields for the cheapest answer: thinking off, or the lowest level where it cannot be off. */
+export function quietThinkingBody(style) {
+    if (style === "none")
+        return undefined;
+    const profile = PROFILES[style];
+    return profile.body(profile.canOff ? THINKING_OFF : profile.levels[0]);
+}

package/packages/server/modules/providers/types.js

@@ -0,0 +1 @@
+export {};

package/packages/server/modules/restart/index.js

@@ -0,0 +1 @@
+export { restartProjector } from "./restart.js";

package/packages/server/modules/restart/restart.js

@@ -0,0 +1,56 @@
+import { spawn } from "node:child_process";
+import { closeSync, mkdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { os } from "../../../core/modules/os/index.js";
+import { dataDir, openLog, serverLogPath } from "../../../core/modules/app-paths/index.js";
+import { quitDesktop } from "../window/index.js";
+const host = globalThis;
+async function prepareRestart(url) {
+    const nativePid = await os.desktopPid("dev.projector.Launcher");
+    mkdirSync(dataDir(), { recursive: true });
+    const log = openLog(serverLogPath(), { rotate: false });
+    const child = (() => {
+        try {
+            return spawn(process.execPath, [
+                fileURLToPath(new URL("../../../cli/app/restart.js", import.meta.url)),
+                String(process.pid),
+                String(nativePid ?? ""),
+            ], { detached: true, stdio: ["ignore", log, log, "ipc"] });
+        }
+        finally {
+            closeSync(log);
+        }
+    })();
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error("Не удалось подготовить перезапуск Projector"));
+        }, 5000);
+        child.once("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.once("exit", (code) => {
+            clearTimeout(timer);
+            reject(new Error(`Перезапуск не подготовлен (${code})`));
+        });
+        child.once("message", (message) => {
+            clearTimeout(timer);
+            if (message !== "READY") {
+                child.kill();
+                reject(new Error("Некорректный ответ процесса перезапуска"));
+                return;
+            }
+            child.unref();
+            resolve();
+        });
+    });
+    await quitDesktop(url);
+}
+/** Survives config reloads and coalesces concurrent clicks into one successor. */
+export function restartProjector(url) {
+    return (host.projectorRestart ??= prepareRestart(url).catch((error) => {
+        host.projectorRestart = undefined;
+        throw error;
+    }));
+}

package/packages/server/modules/secrets/index.js

@@ -0,0 +1 @@
+export { vault, createVault } from "./vault.js";

package/packages/server/modules/secrets/vault.js

@@ -0,0 +1,51 @@
+import { os } from "../../../core/modules/os/index.js";
+const SERVICE = "projector";
+const READ_TTL = 60_000;
+const RETRY_AFTER = 30_000;
+/**
+ * Secrets live in the OS keyring when one is reachable; callers keep a plain-file
+ * fallback and must never treat an unreadable keyring entry as an empty one.
+ */
+export function createVault(backend = os.secrets, mode = () => process.env.PROJECTOR_SECRET_STORE) {
+    let probe;
+    const cache = new Map();
+    const key = (name) => ({ service: SERVICE, account: name });
+    // Temporary XDG directories do not isolate Secret Service: its keys are global.
+    // Tests must inject a backend instead of accessing production credentials.
+    const isolatedTest = () => backend === os.secrets && !!process.env.VITEST;
+    function allowAccess() {
+        if (isolatedTest())
+            throw new Error("Tests cannot access the Projector system keyring");
+    }
+    async function storage() {
+        if (isolatedTest() || mode() === "file")
+            return { backend: "file", reason: "disabled" };
+        const now = Date.now();
+        if (!probe || (!probe.ok && now - probe.at > RETRY_AFTER))
+            probe = { at: now, ok: await backend.available() };
+        return probe.ok ? { backend: "keyring" } : { backend: "file", reason: "unavailable" };
+    }
+    return {
+        storage,
+        async get(name) {
+            allowAccess();
+            const hit = cache.get(name);
+            if (hit && Date.now() - hit.at < READ_TTL)
+                return hit.value;
+            const value = await backend.get(key(name));
+            cache.set(name, { at: Date.now(), value });
+            return value;
+        },
+        async set(name, label, value) {
+            allowAccess();
+            await backend.set(key(name), label, value);
+            cache.set(name, { at: Date.now(), value });
+        },
+        async delete(name) {
+            allowAccess();
+            await backend.delete(key(name));
+            cache.delete(name);
+        },
+    };
+}
+export const vault = createVault();

package/packages/server/modules/spend/index.js

@@ -0,0 +1,2 @@
+export { recordTaskSpend, taskSpend } from "./ledger.js";
+export { addTaskSample, closeSpendStore, readTaskSamples, spendDatabase, } from "./store.js";

package/packages/server/modules/spend/ledger.js

@@ -0,0 +1,82 @@
+import { modelCost, modelTokens, } from "../../../core/modules/usage-analytics/index.js";
+import { addTaskSample, readTaskSamples } from "./store.js";
+const emptyTotals = () => ({
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    tokens: 0,
+    answers: 0,
+    cost: 0,
+    pricedAnswers: 0,
+});
+/**
+ * Remembers one of Projector's own short model calls — Lens, Judge, the doctors, a compaction or
+ * a command review. The chat answers already live in the history; this is the money beside them.
+ */
+export function recordTaskSpend(task, usage, price, meta = {}) {
+    try {
+        const tokens = modelTokens(usage);
+        const total = tokens.input + tokens.output + tokens.cacheRead + tokens.cacheWrite;
+        if (!total)
+            return;
+        addTaskSample({
+            minute: Date.now(),
+            task,
+            provider: meta.provider ?? "",
+            model: meta.model ?? "",
+            ...tokens,
+            cost: price ? modelCost(tokens, price) : 0,
+            priced: Boolean(price),
+        });
+    }
+    catch {
+        // A chart is not worth failing the call it was recorded from.
+    }
+}
+/** Adds one minute bucket to totals. */
+function addSample(totals, sample) {
+    totals.input += sample.input;
+    totals.output += sample.output;
+    totals.cacheRead += sample.cacheRead;
+    totals.cacheWrite += sample.cacheWrite;
+    totals.tokens += sample.input + sample.output + sample.cacheRead + sample.cacheWrite;
+    totals.answers += sample.calls;
+    totals.cost += sample.cost;
+    totals.pricedAnswers += sample.pricedCalls;
+}
+/** What the service calls spent in the range, by task; chat answers are added by the caller. */
+export function taskSpend(since) {
+    const samples = readTaskSamples(since);
+    const totals = emptyTotals();
+    const groups = new Map();
+    let calls = 0;
+    for (const sample of samples) {
+        addSample(totals, sample);
+        calls += sample.calls;
+        const group = groups.get(sample.task);
+        if (group)
+            addSample(group, sample);
+        else
+            groups.set(sample.task, bucketOf(sample));
+    }
+    return {
+        totals,
+        byTask: [...groups.values()].sort((a, b) => b.tokens - a.tokens),
+        calls,
+        samples,
+    };
+}
+function bucketOf(sample) {
+    return {
+        key: sample.task,
+        input: sample.input,
+        output: sample.output,
+        cacheRead: sample.cacheRead,
+        cacheWrite: sample.cacheWrite,
+        tokens: sample.input + sample.output + sample.cacheRead + sample.cacheWrite,
+        answers: sample.calls,
+        cost: sample.cost,
+        pricedAnswers: sample.pricedCalls,
+    };
+}

package/packages/server/modules/spend/store.js

@@ -0,0 +1,92 @@
+import { mkdirSync } from "node:fs";
+import { chmod } from "node:fs/promises";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+/**
+ * Service calls are tiny and frequent (Lens runs while the agent works). A minute bucket keeps the
+ * chart honest without one row per caption; a year is the hard limit.
+ */
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS task_samples (
+    minute INTEGER NOT NULL,
+    task TEXT NOT NULL,
+    provider TEXT NOT NULL DEFAULT '',
+    model TEXT NOT NULL DEFAULT '',
+    input INTEGER NOT NULL DEFAULT 0,
+    output INTEGER NOT NULL DEFAULT 0,
+    cache_read INTEGER NOT NULL DEFAULT 0,
+    cache_write INTEGER NOT NULL DEFAULT 0,
+    cost REAL NOT NULL DEFAULT 0,
+    calls INTEGER NOT NULL DEFAULT 0,
+    priced_calls INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (minute, task, provider, model)
+  );
+  CREATE INDEX IF NOT EXISTS task_samples_time ON task_samples (minute);
+`;
+const databases = new Map();
+let lastCompact = 0;
+export function spendDatabase() {
+    const directory = join(dataDir(), "agent");
+    const file = join(directory, "spend.sqlite");
+    const open = databases.get(file);
+    if (open)
+        return open;
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const db = new DatabaseSync(file);
+    db.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000; PRAGMA synchronous = NORMAL;");
+    db.exec(SCHEMA);
+    void chmod(file, 0o600).catch(() => { });
+    databases.set(file, db);
+    return db;
+}
+/** Closes the opened database (a test removing its data directory, a restart). */
+export function closeSpendStore() {
+    for (const db of databases.values())
+        db.close();
+    databases.clear();
+    lastCompact = 0;
+}
+function compact(db, now) {
+    if (now - lastCompact < 3600000)
+        return;
+    lastCompact = now;
+    db.prepare("DELETE FROM task_samples WHERE minute < ?").run(now - 365 * 86400000);
+}
+/** Adds one call to its minute, task and model; calls in the same minute are summed. */
+export function addTaskSample(sample) {
+    const db = spendDatabase();
+    const minute = Math.floor(sample.minute / 60000) * 60000;
+    db.prepare(`INSERT INTO task_samples
+       (minute, task, provider, model, input, output, cache_read, cache_write, cost, calls, priced_calls)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)
+     ON CONFLICT (minute, task, provider, model) DO UPDATE SET
+       input = input + excluded.input,
+       output = output + excluded.output,
+       cache_read = cache_read + excluded.cache_read,
+       cache_write = cache_write + excluded.cache_write,
+       cost = cost + excluded.cost,
+       calls = calls + 1,
+       priced_calls = priced_calls + excluded.priced_calls`).run(minute, sample.task, sample.provider, sample.model, sample.input, sample.output, sample.cacheRead, sample.cacheWrite, sample.cost, sample.priced ? 1 : 0);
+    compact(db, Date.now());
+}
+/** Task buckets since `since`, oldest first. */
+export function readTaskSamples(since) {
+    const rows = spendDatabase()
+        .prepare("SELECT * FROM task_samples WHERE minute >= ? ORDER BY minute")
+        .all(since);
+    return rows.map((row) => ({
+        minute: row.minute,
+        task: row.task,
+        provider: row.provider,
+        model: row.model,
+        input: row.input,
+        output: row.output,
+        cacheRead: row.cache_read,
+        cacheWrite: row.cache_write,
+        cost: row.cost,
+        priced: row.priced_calls > 0,
+        calls: row.calls,
+        pricedCalls: row.priced_calls,
+    }));
+}

package/packages/server/modules/terminal/drop-files.js

@@ -0,0 +1,42 @@
+import { mkdtemp, open, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { HttpError } from "../http/index.js";
+const MAX_DROP_BYTES = 50 * 1024 * 1024;
+export async function saveDroppedFile(req, name, available, retain) {
+    if (!name ||
+        name === "." ||
+        name === ".." ||
+        /[/\\\x00-\x1f\x7f]/.test(name) ||
+        name.length > 255)
+        throw new HttpError(400, "Некорректное имя файла");
+    if (Number(req.headers["content-length"]) > MAX_DROP_BYTES)
+        throw new HttpError(413, "Размер файла превышает 50 МБ");
+    const directory = await mkdtemp(join(tmpdir(), "projector-drop-"));
+    const path = join(directory, name);
+    try {
+        const file = await open(path, "wx", 0o600);
+        try {
+            let bytes = 0;
+            for await (const chunk of req) {
+                bytes += chunk.length;
+                if (bytes > MAX_DROP_BYTES)
+                    throw new HttpError(413, "Размер файла превышает 50 МБ");
+                if (!available())
+                    throw new HttpError(409, "Терминал больше не принимает файлы");
+                await file.writeFile(chunk);
+            }
+        }
+        finally {
+            await file.close();
+        }
+        if (!available())
+            throw new HttpError(409, "Терминал больше не принимает файлы");
+        retain(directory);
+        return path;
+    }
+    catch (error) {
+        await rm(directory, { recursive: true, force: true });
+        throw error;
+    }
+}

package/packages/server/modules/terminal/index.js

@@ -0,0 +1,15 @@
+export { closeProjectTerminals } from "./terminal.js";
+export { terminalSessionSnapshot } from "./terminal.js";
+export { terminalSessionText } from "./terminal.js";
+export { stopTerminalSession } from "./terminal.js";
+export { closeTerminalSession } from "./terminal.js";
+export { createTerminalSession } from "./terminal.js";
+export { configureTerminalPrograms } from "./terminal.js";
+export { listTerminalSessions } from "./terminal.js";
+export { attachTerminalServer } from "./socket.js";
+export { trackMouseEncoding } from "./terminal-mouse.js";
+export { renameTerminalSession } from "./terminal.js";
+export { uploadTerminalFile } from "./terminal.js";
+export { resolveTerminalFile } from "./terminal-file.js";
+export { onTerminalSessionsChanged } from "./session-state.js";
+export { subscribeTerminalPeer } from "./socket.js";

package/packages/server/modules/terminal/link-files.js

@@ -0,0 +1,44 @@
+import { realpath, stat } from "node:fs/promises";
+import { os } from "../../../core/modules/os/index.js";
+import { isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
+import { HttpError } from "../http/index.js";
+export async function resolveTerminalPath(path, projectRoot, cwd) {
+    if (!path || path.length > 4096 || /[\x00-\x1f\x7f]/.test(path))
+        throw new HttpError(400, "Некорректный путь к файлу");
+    const expanded = path.startsWith("~/") ? resolve(os.homeDirectory(), path.slice(2)) : path;
+    const candidates = isAbsolute(expanded)
+        ? [expanded]
+        : [
+            ...[cwd].flat().map((directory) => resolve(directory, expanded)),
+            resolve(projectRoot, expanded),
+        ];
+    const root = await realpath(projectRoot);
+    for (const candidate of new Set(candidates)) {
+        try {
+            const full = await realpath(candidate);
+            if (!(await stat(full)).isFile())
+                continue;
+            const local = relative(root, full);
+            const external = local === ".." || local.startsWith(`..${sep}`) || isAbsolute(local);
+            return { path: external ? full : local.split(sep).join("/"), external };
+        }
+        catch (error) {
+            if (!["ENOENT", "ENOTDIR", "EACCES"].includes(error.code ?? ""))
+                throw error;
+        }
+    }
+    throw new HttpError(404, "Файл из терминала не найден");
+}
+/**
+ * Maps a path printed inside a Dev Container to the project on the host.
+ * Anything that does not stay inside the mounted workspace cannot be opened.
+ */
+export function containerToHost(path, workspace, root) {
+    const inside = path === workspace || path.startsWith(`${workspace}/`);
+    if (!inside && (path.startsWith("/") || path.startsWith("~")))
+        throw new HttpError(404, "Путь находится вне проекта внутри контейнера");
+    const local = normalize(inside ? path.slice(workspace.length + 1) || "." : path);
+    if (local === ".." || local.startsWith(`..${sep}`))
+        throw new HttpError(404, "Путь выходит за пределы проекта");
+    return join(root, local);
+}

package/packages/server/modules/terminal/scenario-folder.js

@@ -0,0 +1,20 @@
+import { realpathSync, statSync } from "node:fs";
+import { join, sep } from "node:path";
+import { HttpError } from "../http/index.js";
+/**
+ * The folder a scenario starts in: it must exist and resolve inside the project, so a link
+ * cannot send a command out of the project.
+ */
+export function scenarioDirectory(root, folder) {
+    const target = join(root, folder);
+    try {
+        const real = realpathSync(target);
+        const base = realpathSync(root);
+        if (statSync(real).isDirectory() && (real === base || real.startsWith(base + sep)))
+            return target;
+    }
+    catch {
+        // reported below
+    }
+    throw new HttpError(400, `Папка сценария не найдена внутри проекта: ${folder}`);
+}

package/packages/server/modules/terminal/session-state.js

@@ -0,0 +1,85 @@
+import {} from "node-pty";
+import headless from "@xterm/headless";
+import serialization from "@xterm/addon-serialize";
+import { WebSocket } from "ws";
+import { trackMouseEncoding } from "./terminal-mouse.js";
+const { Terminal } = headless;
+const { SerializeAddon } = serialization;
+export const MAX_SESSIONS = 24;
+export const MAX_BUFFER = 1024 * 1024;
+const host = globalThis;
+export const state = (host.projectorTerminals ??= {
+    sessions: new Map(),
+    servers: new WeakSet(),
+    hooksBound: false,
+    listeners: new Set(),
+});
+state.listeners ??= new Set();
+export function terminalSessionsChanged(projectId) {
+    for (const listener of state.listeners)
+        listener(projectId);
+}
+export function onTerminalSessionsChanged(listener) {
+    state.listeners.add(listener);
+    return () => {
+        state.listeners.delete(listener);
+    };
+}
+for (const session of state.sessions.values()) {
+    session.pending ??= new Map();
+    session.queued ??= 0;
+    session.paused ??= false;
+    session.mouseEncoding ??= trackMouseEncoding(session.screen);
+    // Retained PTYs can still hold a pre-control-channel onExit closure after HMR.
+    session.controlExitSubscription ??= session.pty.onExit(() => {
+        queueMicrotask(() => terminalSessionsChanged(session.info.projectId));
+    });
+}
+export function size(cols, rows) {
+    if (!Number.isInteger(cols) ||
+        !Number.isInteger(rows) ||
+        Number(cols) < 2 ||
+        Number(cols) > 500 ||
+        Number(rows) < 2 ||
+        Number(rows) > 200) {
+        throw new Error("Некорректный размер терминала");
+    }
+    return { cols: Number(cols), rows: Number(rows) };
+}
+export function send(client, message) {
+    if (client.readyState !== WebSocket.OPEN)
+        return;
+    // A slow client reconnects to a fresh screen instead of accumulating output.
+    if (client.bufferedAmount > MAX_BUFFER) {
+        client.terminate();
+        return;
+    }
+    client.send(JSON.stringify(message));
+}
+export function broadcast(session, message) {
+    for (const client of session.clients) {
+        send(client, message);
+        if (message.type === "output" && client.readyState === WebSocket.OPEN) {
+            session.pending.set(client, (session.pending.get(client) ?? 0) + message.data.length);
+        }
+    }
+    flow(session);
+    if (message.type === "status")
+        terminalSessionsChanged(session.info.projectId);
+}
+export function flow(session) {
+    if (session.disposed || session.info.status !== "running")
+        return;
+    const pending = [...session.pending.values()];
+    if (!session.paused &&
+        (session.queued > MAX_BUFFER / 4 || pending.some((length) => length > MAX_BUFFER / 4))) {
+        session.paused = true;
+        session.pty.pause();
+    }
+    else if (session.paused &&
+        session.queued < MAX_BUFFER / 16 &&
+        pending.every((length) => length < MAX_BUFFER / 16)) {
+        session.paused = false;
+        session.pty.resume();
+    }
+}