@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/openai-gateway/config.js

@@ -0,0 +1,125 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import { BlockList, isIP } from "node:net";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+export function gatewayConfigPath() {
+    return join(dataDir(), "openai-gateway.json");
+}
+const MAX_ORIGINS = 50;
+/** Templates stored beside exact origins: any page of this machine / of the local network, any port. */
+export const ORIGIN_TEMPLATES = ["@localhost", "@lan"];
+const loopback = new BlockList();
+loopback.addSubnet("127.0.0.0", 8, "ipv4");
+loopback.addAddress("::1", "ipv6");
+const privateNetworks = new BlockList();
+for (const [net, prefix] of [
+    ["10.0.0.0", 8],
+    ["172.16.0.0", 12],
+    ["192.168.0.0", 16],
+    ["169.254.0.0", 16],
+])
+    privateNetworks.addSubnet(net, prefix, "ipv4");
+privateNetworks.addSubnet("fc00::", 7, "ipv6");
+privateNetworks.addSubnet("fe80::", 10, "ipv6");
+function inList(list, host) {
+    const family = isIP(host);
+    return family !== 0 && list.check(host, family === 6 ? "ipv6" : "ipv4");
+}
+/** Whether the origin's host is this machine (`@localhost`) or a private network address (`@lan`). */
+function matchesTemplate(origin, template) {
+    let host;
+    try {
+        host = new URL(origin).hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    if (template === "@localhost")
+        return host === "localhost" || host.endsWith(".localhost") || inList(loopback, host);
+    if (template === "@lan")
+        return host.endsWith(".local") || inList(privateNetworks, host);
+    return false;
+}
+/** `https://app.example.com/x` → `https://app.example.com`; anything but http(s) is dropped. */
+export function normalizeOrigins(list) {
+    if (!Array.isArray(list))
+        return [];
+    const origins = new Set();
+    for (const item of list) {
+        if (typeof item !== "string")
+            continue;
+        const template = item.trim().toLowerCase();
+        if (ORIGIN_TEMPLATES.includes(template)) {
+            origins.add(template);
+            continue;
+        }
+        try {
+            const url = new URL(item.trim());
+            if (url.protocol === "http:" || url.protocol === "https:")
+                origins.add(url.origin);
+        }
+        catch {
+            // Not a URL: skipped.
+        }
+    }
+    return [...origins].slice(0, MAX_ORIGINS);
+}
+const hash = (key) => createHash("sha256").update(key).digest("hex");
+function readConfig() {
+    try {
+        const parsed = JSON.parse(readFileSync(gatewayConfigPath(), "utf8"));
+        return {
+            enabled: parsed.enabled === true,
+            keyHash: typeof parsed.keyHash === "string" && parsed.keyHash ? parsed.keyHash : null,
+            origins: normalizeOrigins(parsed.origins),
+        };
+    }
+    catch {
+        return { enabled: false, keyHash: null, origins: [] };
+    }
+}
+function writeConfig(config) {
+    const file = gatewayConfigPath();
+    mkdirSync(dataDir(), { recursive: true });
+    const temporary = `${file}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(config)}\n`, { mode: 0o600 });
+    renameSync(temporary, file);
+}
+/** The gateway spends the user's provider quota, so it is off until switched on. */
+export function gatewayEnabled() {
+    return readConfig().enabled;
+}
+export function gatewayHasKey() {
+    return readConfig().keyHash !== null;
+}
+export function setGatewayEnabled(enabled) {
+    writeConfig({ ...readConfig(), enabled });
+}
+export function gatewayOrigins() {
+    return readConfig().origins;
+}
+/** Invalid entries are dropped; returns the list actually stored. */
+export function setGatewayOrigins(origins) {
+    const list = normalizeOrigins(origins);
+    writeConfig({ ...readConfig(), origins: list });
+    return list;
+}
+export function gatewayOriginAllowed(origin) {
+    const { origins } = readConfig();
+    return origins.includes(origin) || origins.some((entry) => matchesTemplate(origin, entry));
+}
+/** An empty key removes the requirement. */
+export function setGatewayKey(key) {
+    writeConfig({ ...readConfig(), keyHash: key ? hash(key) : null });
+}
+/** `null` when no key is configured, otherwise whether the request carries it as a Bearer token. */
+export function checkGatewayKey(authorization) {
+    const { keyHash } = readConfig();
+    if (!keyHash)
+        return null;
+    const token = authorization?.startsWith("Bearer ") ? authorization.slice(7).trim() : "";
+    const candidate = Buffer.from(hash(token), "hex");
+    const expected = Buffer.from(keyHash, "hex");
+    return candidate.length === expected.length && timingSafeEqual(candidate, expected);
+}

package/packages/server/modules/openai-gateway/gateway.js

@@ -0,0 +1,178 @@
+import { Readable } from "node:stream";
+import { HttpError } from "../http/index.js";
+import { envFallbackFromProcess, loadStoredProviders, normalizeOpenAiBaseUrl, resolveOpenAIProvider, } from "../providers/index.js";
+export const GATEWAY_PREFIX = "/api/openai/v1";
+const MAX_BODY = 32 * 1024 * 1024;
+/** Enough for a provider error; a larger body is replaced by a generated error. */
+const MAX_ERROR_BODY = 64 * 1024;
+/** Hop-by-hop and length headers must not be copied from a decoded upstream body. */
+const SKIP_HEADERS = new Set([
+    "content-length",
+    "content-encoding",
+    "transfer-encoding",
+    "connection",
+]);
+export function openAiError(res, status, message, type = "invalid_request_error") {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify({ error: { message, type, param: null, code: null } }));
+}
+async function readJson(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > MAX_BODY)
+            throw new HttpError(413, "Запрос слишком большой");
+        chunks.push(chunk);
+    }
+    try {
+        const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        if (value && typeof value === "object" && !Array.isArray(value))
+            return value;
+    }
+    catch {
+        // Reported below with the other malformed bodies.
+    }
+    throw new HttpError(400, "Тело запроса должно быть JSON-объектом");
+}
+const redact = (text, secret) => secret ? text.split(secret).join("[redacted]") : text;
+/** A bounded read of an upstream error body; a broken or oversized body yields what arrived. */
+async function readErrorBody(body) {
+    if (!body)
+        return "";
+    const reader = body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        while (size < MAX_ERROR_BODY) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value)
+                continue;
+            chunks.push(value);
+            size += value.length;
+        }
+        if (size >= MAX_ERROR_BODY)
+            await reader.cancel().catch(() => { });
+    }
+    catch {
+        // A body that breaks mid-read is still replaced by a generated error.
+    }
+    return Buffer.concat(chunks).subarray(0, MAX_ERROR_BODY).toString("utf8");
+}
+const optionalString = (value) => typeof value === "string" ? value : null;
+/** Only the OpenAI error fields may reach the client; everything else is dropped. */
+function sanitizeErrorBody(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const error = value.error;
+    if (!error || typeof error !== "object" || Array.isArray(error))
+        return null;
+    const fields = error;
+    if (typeof fields.message !== "string")
+        return null;
+    return {
+        message: fields.message,
+        type: optionalString(fields.type) ?? "invalid_request_error",
+        param: optionalString(fields.param),
+        code: optionalString(fields.code),
+    };
+}
+/** Every registered model of every enabled provider, so a client picks a provider by its model. */
+export async function listModels() {
+    const { providers } = await loadStoredProviders(envFallbackFromProcess());
+    const seen = new Set();
+    const data = [];
+    for (const provider of providers) {
+        if (!provider.enabled || !provider.url.trim())
+            continue;
+        for (const { alias } of provider.models) {
+            if (seen.has(alias))
+                continue;
+            seen.add(alias);
+            data.push({ id: alias, object: "model", created: 0, owned_by: provider.id });
+        }
+    }
+    return { object: "list", data };
+}
+async function providerForModel(model) {
+    const fallback = envFallbackFromProcess();
+    if (typeof model === "string" && model.trim()) {
+        const name = model.trim();
+        const { providers } = await loadStoredProviders(fallback);
+        const match = providers.find((item) => item.enabled && item.url.trim() && item.models.some((row) => row.alias === name));
+        if (match)
+            return resolveOpenAIProvider({ providerId: match.id, model: name, fallback });
+    }
+    return resolveOpenAIProvider({ fallback });
+}
+/** Forwards an OpenAI-style request to the provider that serves its model and streams the answer back. */
+export async function forward(req, res, endpoint) {
+    const body = await readJson(req);
+    const provider = await providerForModel(body.model);
+    // The client asks by registered name; upstream knows the model by its own id.
+    body.model = provider.model;
+    const base = normalizeOpenAiBaseUrl(provider.url);
+    const abort = new AbortController();
+    res.on("close", () => {
+        if (!res.writableFinished)
+            abort.abort();
+    });
+    const upstream = await fetch(`${base}${endpoint}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Accept: String(req.headers.accept ?? "application/json"),
+            ...(provider.apiKey ? { Authorization: `Bearer ${provider.apiKey}` } : {}),
+        },
+        body: JSON.stringify(body),
+        signal: abort.signal,
+    });
+    // Upstream failures are internal: the client gets a generic OpenAI error, the details stay in the log.
+    if (upstream.status >= 500) {
+        const detail = await readErrorBody(upstream.body);
+        console.error(`OpenAI-шлюз: провайдер ответил ${upstream.status}: ${redact(detail.slice(0, 2000), provider.apiKey)}`);
+        res.setHeader("Cache-Control", "no-store");
+        openAiError(res, 502, "Провайдер вернул ошибку", "api_error");
+        return;
+    }
+    // A 4xx keeps its status for the client, but only the OpenAI error fields are forwarded.
+    if (upstream.status >= 400) {
+        const sanitized = sanitizeErrorBody(await readErrorBody(upstream.body));
+        res.setHeader("Cache-Control", "no-store");
+        if (sanitized) {
+            res.statusCode = upstream.status;
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+            res.end(JSON.stringify({ error: sanitized }));
+        }
+        else {
+            openAiError(res, upstream.status, "Провайдер отклонил запрос");
+        }
+        return;
+    }
+    res.statusCode = upstream.status;
+    upstream.headers.forEach((value, name) => {
+        if (!SKIP_HEADERS.has(name.toLowerCase()))
+            res.setHeader(name, value);
+    });
+    res.setHeader("Cache-Control", "no-store");
+    if (!upstream.body) {
+        res.end();
+        return;
+    }
+    Readable.fromWeb(upstream.body)
+        .on("error", (error) => {
+        console.error(`OpenAI-шлюз: поток провайдера прерван: ${redact(error?.message ?? String(error), provider.apiKey)}`);
+        res.destroy();
+    })
+        .pipe(res);
+}

package/packages/server/modules/openai-gateway/index.js

@@ -0,0 +1,7 @@
+import { registerGatewayGuard, registerGatewayOrigins } from "../access/index.js";
+import { checkGatewayKey, gatewayOriginAllowed } from "./config.js";
+// With a key the gateway authenticates itself; the LAN password then does not apply to it.
+registerGatewayGuard((req) => checkGatewayKey(req.headers.authorization) ?? undefined);
+registerGatewayOrigins(gatewayOriginAllowed);
+export { checkGatewayKey, gatewayEnabled, gatewayHasKey, gatewayOriginAllowed, gatewayOrigins, setGatewayOrigins, setGatewayEnabled, setGatewayKey, } from "./config.js";
+export { GATEWAY_PREFIX, forward, listModels, openAiError } from "./gateway.js";

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

@@ -0,0 +1,7 @@
+export { preferences } from "./preferences.js";
+export { updatePreferences } from "./preferences.js";
+export { interfaceMode } from "./preferences.js";
+export { saveInterface } from "./preferences.js";
+export { toggleFavorite, setFavoriteDirectory } from "./preferences.js";
+export { setAgentMode, setAgentDefault, configureAgentPreferences } from "./preferences.js";
+export { setAgentEnabled } from "./preferences.js";

package/packages/server/modules/preferences/preferences.js

@@ -0,0 +1,142 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { shortcuts } from "../../../core/modules/launcher/index.js";
+let catalog = { programs: () => [], toggleable: () => [] };
+/** Points the settings at the registry; `server/app/agents.ts` calls it after registering. */
+export function configureAgentPreferences(value) {
+    catalog = value;
+}
+const preferencesPath = () => join(dataDir(), "launcher.json");
+let saving = Promise.resolve();
+export async function preferences() {
+    try {
+        const data = JSON.parse(await readFile(preferencesPath(), "utf8"));
+        return {
+            mode: interfaceMode(data.mode),
+            shortcut: shortcuts.includes(data.shortcut) ? data.shortcut : "Ctrl+Alt+Space",
+            usage: data.usage ?? {},
+            favorites: Array.isArray(data.favorites)
+                ? data.favorites.filter((id) => typeof id === "string")
+                : [],
+            directories: Array.isArray(data.directories)
+                ? data.directories.filter((path) => typeof path === "string")
+                : [],
+            agentModes: agentModes(data.agentModes),
+            agentDefaults: agentDefaults(data.agentDefaults),
+            disabledAgents: disabledAgents(data.disabledAgents),
+        };
+    }
+    catch {
+        return {
+            mode: "native",
+            shortcut: "Ctrl+Alt+Space",
+            usage: {},
+            favorites: [],
+            directories: [],
+            agentModes: {},
+            agentDefaults: {},
+            disabledAgents: [],
+        };
+    }
+}
+function disabledAgents(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((id) => typeof id === "string" && catalog.toggleable().includes(id));
+}
+function agentDefaults(value) {
+    const defaults = {};
+    if (!value || typeof value !== "object")
+        return defaults;
+    for (const [backend, choice] of Object.entries(value)) {
+        if (!choice || typeof choice !== "object")
+            continue;
+        const picked = {};
+        for (const [id, item] of Object.entries(choice))
+            if (typeof item === "string")
+                picked[id] = item;
+        if (Object.keys(picked).length)
+            defaults[backend] = picked;
+    }
+    return defaults;
+}
+function agentModes(value) {
+    const modes = {};
+    if (value && typeof value === "object")
+        for (const program of catalog.programs())
+            if (value[program] === "gui")
+                modes[program] = "gui";
+    return modes;
+}
+export function interfaceMode(value) {
+    return value === "window" || value === "browser" ? value : "native";
+}
+export function updatePreferences(update) {
+    const task = saving.then(async () => {
+        const value = await preferences();
+        update(value);
+        await mkdir(dataDir(), { recursive: true });
+        const file = preferencesPath();
+        await writeFile(`${file}.tmp`, JSON.stringify(value, null, 2) + "\n");
+        await rename(`${file}.tmp`, file);
+    });
+    saving = task.catch(() => undefined);
+    return task;
+}
+export function saveInterface(mode, shortcut) {
+    return updatePreferences((value) => {
+        value.mode = mode;
+        if (shortcut !== undefined)
+            value.shortcut = shortcut;
+    });
+}
+/** Adds or removes a favorite and returns the new state. */
+export async function toggleFavorite(id) {
+    let favorite = false;
+    await updatePreferences((value) => {
+        favorite = !value.favorites.includes(id);
+        value.favorites = favorite
+            ? [...value.favorites, id]
+            : value.favorites.filter((entry) => entry !== id);
+    });
+    return favorite;
+}
+/** Adds or removes a favorite folder; `on` forces the state, otherwise it toggles. Returns the new state. */
+export async function setFavoriteDirectory(path, on) {
+    let favorite = false;
+    await updatePreferences((value) => {
+        favorite = on ?? !value.directories.includes(path);
+        const rest = value.directories.filter((entry) => entry !== path);
+        value.directories = favorite ? [...rest, path] : rest;
+    });
+    return favorite;
+}
+/** Sets how new sessions of `program` open; TUI is the default and is stored as absence. */
+export async function setAgentMode(program, mode) {
+    if (!catalog.programs().includes(program))
+        throw new Error("У этого агента нет графического режима");
+    await updatePreferences((value) => {
+        if (mode === "gui")
+            value.agentModes[program] = "gui";
+        else
+            delete value.agentModes[program];
+    });
+}
+/** Switches an agent backend on or off; the built-in Projector agent cannot be disabled. */
+export async function setAgentEnabled(backend, enabled) {
+    if (!catalog.toggleable().includes(backend))
+        throw new Error("Этого агента нельзя отключить");
+    await updatePreferences((value) => {
+        const rest = value.disabledAgents.filter((id) => id !== backend);
+        value.disabledAgents = enabled ? rest : [...rest, backend];
+    });
+}
+/** Remembers one control choice of an agent backend as the default for new chats. */
+export async function setAgentDefault(backend, id, value) {
+    if (!backend || !id || backend.length > 40 || id.length > 100 || value.length > 300)
+        throw new Error("Некорректный выбор");
+    await updatePreferences((preferences) => {
+        preferences.agentDefaults[backend] = { ...preferences.agentDefaults[backend], [id]: value };
+    });
+}

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

@@ -0,0 +1,6 @@
+export { getSnapshot } from "./processes.js";
+export { listSnapshots } from "./processes.js";
+export { onProcessEvent } from "./processes.js";
+export { startProject } from "./processes.js";
+export { stopProject } from "./processes.js";
+export { processOutput } from "./processes.js";

package/packages/server/modules/processes/processes.js

@@ -0,0 +1,174 @@
+import { environmentPorts } from "../environments/index.js";
+import { createTerminalSession, stopTerminalSession, terminalSessionText, } from "../terminal/index.js";
+import { projectAppUrl } from "../../../core/modules/app-paths/index.js";
+import { openWindow } from "../window/index.js";
+const URL_RE = /https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]):\d+[^\s)]*/i;
+const ANSI_RE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[mK]`, "g");
+// Vite reloads the API modules without stopping their child processes.
+// Keep ownership and snapshots across those reloads to avoid duplicate starts.
+const host = globalThis;
+const state = (host.projectorProcesses ??= {
+    sessions: new Map(),
+    listeners: new Set(),
+});
+const { sessions, listeners } = state;
+export function onProcessEvent(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+function emit(event, data) {
+    for (const listener of listeners)
+        listener(event, data);
+}
+function snapshot(session) {
+    return {
+        projectId: session.project.id,
+        commandId: session.commandId,
+        commandName: session.commandName,
+        status: session.status,
+        pid: session.terminal.pid,
+        url: session.url,
+        startedAt: session.startedAt,
+        exitCode: session.exitCode,
+    };
+}
+function idleSnapshot(projectId) {
+    return {
+        projectId,
+        commandId: null,
+        commandName: null,
+        status: "idle",
+        pid: null,
+        url: null,
+        startedAt: null,
+        exitCode: null,
+    };
+}
+function consumeChunk(session, chunk) {
+    const data = session.leftover + chunk.replace(ANSI_RE, "");
+    const lines = data.split(/\r?\n/);
+    session.leftover = (lines.pop() ?? "").slice(-4096);
+    for (const line of lines) {
+        const match = line.match(URL_RE);
+        if (!match)
+            continue;
+        if (session.project.environment) {
+            const docker = session.terminal.docker;
+            const port = Number(new URL(match[0]).port);
+            if (docker)
+                void environmentPorts(docker.context, docker.containerId)
+                    .then((ports) => {
+                    const address = ports.find((item) => item.container === port);
+                    if (!address || session.status !== "running")
+                        return;
+                    session.url = address.url;
+                    emit("status", snapshot(session));
+                    maybeOpenWindow(session);
+                })
+                    .catch(() => { });
+            continue;
+        }
+        const url = match[0]
+            .replace("0.0.0.0", "localhost")
+            .replace("127.0.0.1", "localhost")
+            .replace("[::1]", "localhost");
+        if (session.url === url)
+            continue;
+        session.url = url;
+        emit("status", snapshot(session));
+        maybeOpenWindow(session);
+    }
+}
+function maybeOpenWindow(session) {
+    if (!session.pendingWindow)
+        return;
+    const url = session.url || session.project.url;
+    if (!url)
+        return;
+    session.pendingWindow = false;
+    openWindow(projectAppUrl(session.project.id));
+}
+export function listSnapshots() {
+    return [...sessions.values()].map(snapshot);
+}
+/** Tail of the last run's terminal output, or null when the project has no session. */
+export function processOutput(projectId, lines = 40) {
+    const session = sessions.get(projectId);
+    if (!session)
+        return null;
+    try {
+        return terminalSessionText(projectId, session.terminal.id, lines).text;
+    }
+    catch {
+        return null;
+    }
+}
+export function getSnapshot(projectId) {
+    const session = sessions.get(projectId);
+    return session ? snapshot(session) : idleSnapshot(projectId);
+}
+export function startProject(project, commandId, mode, replacingId) {
+    const current = sessions.get(project.id);
+    if (current &&
+        (current.status === "running" || current.status === "starting" || current.status === "stopping")) {
+        throw new Error("Проект уже запущен");
+    }
+    const command = project.commands.find((item) => item.id === (commandId ?? project.defaultCommandId)) ??
+        project.commands[0];
+    if (!command)
+        throw new Error("Нет команды для запуска");
+    let session;
+    const terminal = createTerminalSession(project, { program: "shell", commandId: command.id }, {
+        output: (data) => consumeChunk(session, data),
+        exit: (code) => {
+            session.exitCode = code;
+            session.status = session.status !== "stopping" && code !== 0 ? "error" : "idle";
+            emit("status", snapshot(session));
+        },
+    }, replacingId);
+    // A scenario's own address and mode win over the project's; the project supplies the rest.
+    const url = command.url || project.url || "";
+    session = {
+        project,
+        commandId: command.id,
+        commandName: command.name,
+        terminal,
+        status: "running",
+        url: project.environment ? null : url || null,
+        startedAt: terminal.startedAt,
+        exitCode: null,
+        pendingWindow: (mode ?? command.mode ?? project.mode) === "window",
+        leftover: "",
+    };
+    sessions.set(project.id, session);
+    emit("status", snapshot(session));
+    emit("terminal-started", { projectId: project.id, sessionId: terminal.id });
+    if (session.pendingWindow && url && !project.environment) {
+        setTimeout(() => {
+            if (sessions.get(project.id) !== session || session.status !== "running")
+                return;
+            if (!session.url)
+                session.url = url;
+            maybeOpenWindow(session);
+        }, 1600);
+    }
+    return snapshot(session);
+}
+export function stopProject(projectId) {
+    const session = sessions.get(projectId);
+    if (!session || session.status === "idle")
+        return idleSnapshot(projectId);
+    // A run whose terminal is already gone (for example, it exited) has nothing left to stop.
+    try {
+        session.status = "stopping";
+        emit("status", snapshot(session));
+        stopTerminalSession(projectId, session.terminal.id);
+    }
+    catch {
+        session.status = "idle";
+        emit("status", snapshot(session));
+    }
+    return snapshot(session);
+}