@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/terminal-control/control.js

@@ -0,0 +1,75 @@
+import { findProject } from "../projects/index.js";
+import { HttpError } from "../http/index.js";
+import { getSnapshot, startProject, stopProject } from "../processes/index.js";
+import { createTerminalSession, listTerminalSessions, renameTerminalSession, stopTerminalSession, terminalSessionSnapshot, terminalSessionText, closeTerminalSession, resolveTerminalFile, } from "../terminal/index.js";
+export async function terminalControl(projectId, method, sessionId, body = {}, link) {
+    const project = await findProject(projectId);
+    if (!project)
+        throw new HttpError(404, "Проект не найден");
+    const id = projectId;
+    if (!sessionId && method === "GET") {
+        return { sessions: listTerminalSessions(id) };
+    }
+    if (!sessionId && method === "POST") {
+        return { session: createTerminalSession(project, body) };
+    }
+    if (sessionId && method === "POST") {
+        const previous = listTerminalSessions(id).find((item) => item.id === sessionId);
+        if (!previous)
+            throw new HttpError(404, "Терминал не найден");
+        if (body.action === "read") {
+            const lines = typeof body.lines === "number" ? body.lines : undefined;
+            return { session: previous, ...terminalSessionText(id, sessionId, lines) };
+        }
+        else if (body.action === "rename") {
+            if (typeof body.title !== "string" || !body.title.trim() || body.title.trim().length > 80)
+                throw new HttpError(400, "Название должно содержать от 1 до 80 символов");
+            return { session: renameTerminalSession(id, sessionId, body.title.trim()) };
+        }
+        else if (body.action === "stop") {
+            const running = getSnapshot(id);
+            if (previous.commandId && running.pid === previous.pid && running.status === "running")
+                stopProject(id);
+            else
+                stopTerminalSession(id, sessionId);
+            return { session: listTerminalSessions(id).find((item) => item.id === sessionId) };
+        }
+        else if (body.action === "restart") {
+            if (previous.docker && previous.docker.kind !== "environment")
+                throw new HttpError(409, "Повторите Docker-действие из панели Docker");
+            if (previous.status !== "exited")
+                throw new HttpError(409, "Сначала завершите сессию");
+            let session;
+            if (previous.commandId) {
+                if (!project.commands.some((command) => command.id === previous.commandId))
+                    throw new HttpError(400, "Команда проекта больше не существует");
+                const running = startProject(project, previous.commandId, "server", previous.id);
+                session = listTerminalSessions(id).find((item) => item.pid === running.pid);
+            }
+            else {
+                session = createTerminalSession(project, { program: previous.program }, undefined, previous.id);
+            }
+            return { session };
+        }
+        else
+            throw new HttpError(400, "Неизвестное действие с сессией");
+    }
+    if (sessionId && method === "GET") {
+        if (link !== undefined)
+            return await resolveTerminalFile(project, sessionId, link);
+        const session = terminalSessionSnapshot(id, sessionId);
+        if (!session)
+            throw new HttpError(404, "Терминал не найден");
+        return { session };
+    }
+    if (sessionId && method === "DELETE") {
+        const session = terminalSessionSnapshot(id, sessionId);
+        if (session &&
+            session.activity?.state !== "idle" &&
+            body.confirmation !== session.activity?.confirmation)
+            return { error: "Подтвердите прерывание процессов", session };
+        closeTerminalSession(id, sessionId);
+        return { ok: true };
+    }
+    throw new HttpError(400, "Неизвестное действие с сессией");
+}

package/packages/server/modules/terminal-control/handlers.js

@@ -0,0 +1,10 @@
+import { accessAllowed } from "../access/index.js";
+import { findProject } from "../projects/index.js";
+import { listTerminalSessions } from "../terminal/index.js";
+import { terminalControl } from "./control.js";
+export const defaultTerminalControlHandlers = {
+    control: terminalControl,
+    sessions: listTerminalSessions,
+    allowed: accessAllowed,
+    project: findProject,
+};

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

@@ -0,0 +1,3 @@
+export { terminalControl } from "./control.js";
+export { attachTerminalControlServer } from "./socket.js";
+export { attachSharedTerminalServer } from "./shared-socket.js";

package/packages/server/modules/terminal-control/shared-socket.js

@@ -0,0 +1,319 @@
+import { EventEmitter } from "node:events";
+import { WebSocket, WebSocketServer } from "ws";
+import { protectLanSockets } from "../access/index.js";
+import { onTerminalSessionsChanged, subscribeTerminalPeer, } from "../terminal/index.js";
+import { defaultTerminalControlHandlers } from "./handlers.js";
+/** Each browser consumer has independent ACK accounting, even on a shared physical socket. */
+class Channel extends EventEmitter {
+    readyState = WebSocket.OPEN;
+    bufferedAmount = 0;
+    queue = [];
+    projectId;
+    deliver;
+    ended;
+    constructor(projectId, deliver, ended) {
+        super();
+        this.projectId = projectId;
+        this.deliver = deliver;
+        this.ended = ended;
+    }
+    send(data) {
+        if (this.readyState === WebSocket.OPEN)
+            this.deliver(data);
+    }
+    terminate() {
+        this.close(1013);
+    }
+    close(code = 1000) {
+        if (this.readyState !== WebSocket.OPEN)
+            return;
+        this.readyState = WebSocket.CLOSED;
+        this.queue.length = 0;
+        this.bufferedAmount = 0;
+        this.emit("close");
+        this.ended(code);
+    }
+}
+/** Splits a large output message into small ones without cutting a surrogate pair. */
+function splitOutput(data) {
+    const parsed = JSON.parse(data);
+    if (parsed.type !== "output" || typeof parsed.data !== "string")
+        return [data];
+    const text = parsed.data;
+    const parts = [];
+    for (let start = 0; start < text.length;) {
+        let end = Math.min(start + 8192, text.length);
+        const last = text.charCodeAt(end - 1);
+        if (end < text.length && last >= 0xd800 && last <= 0xdbff)
+            end--;
+        parts.push(JSON.stringify({ type: "output", data: text.slice(start, end) }));
+        start = end;
+    }
+    return parts;
+}
+const host = globalThis;
+const servers = (host.projectorSharedServers ??= new WeakSet());
+export function attachSharedTerminalServer(server, handlers = defaultTerminalControlHandlers) {
+    if (servers.has(server))
+        return;
+    servers.add(server);
+    const wss = new WebSocketServer({
+        noServer: true,
+        maxPayload: 128 * 1024,
+        perMessageDeflate: false,
+    });
+    const unprotect = protectLanSockets(server, wss, handlers.allowed);
+    const alive = new WeakSet();
+    const heartbeat = setInterval(() => {
+        for (const socket of wss.clients) {
+            if (!alive.has(socket))
+                socket.terminate();
+            else {
+                alive.delete(socket);
+                socket.ping();
+            }
+        }
+    }, 30000);
+    heartbeat.unref();
+    let disposed = false;
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        clearInterval(heartbeat);
+        unprotect();
+        servers.delete(server);
+        server.off("close", dispose);
+        server.off("upgrade", upgrade);
+        for (const socket of wss.clients)
+            socket.terminate();
+        wss.close();
+    };
+    const upgrade = (req, socket, head) => {
+        if (socket.destroyed || socket.writableEnded)
+            return;
+        let url;
+        try {
+            url = new URL(req.url ?? "/", "http://localhost");
+        }
+        catch {
+            return;
+        }
+        if (url.pathname !== "/api/terminal/shared")
+            return;
+        const kind = url.searchParams.get("kind");
+        if (!handlers.allowed(req, true, url.searchParams.get("token") ?? undefined)) {
+            socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
+            return;
+        }
+        if (kind !== "control" && kind !== "data") {
+            socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (client) => {
+            wss.emit("connection", client, req);
+            alive.add(client);
+            client.on("pong", () => alive.add(client));
+            client.on("error", () => client.terminate());
+            bind(client, kind, handlers);
+        });
+    };
+    server.on("upgrade", upgrade);
+    server.once("close", dispose);
+    return dispose;
+}
+function bind(socket, kind, handlers) {
+    const channels = new Map();
+    const opening = new Map();
+    let pumping;
+    let cursor = 0;
+    const send = (message) => {
+        if (socket.readyState === WebSocket.OPEN)
+            socket.send(JSON.stringify(message));
+    };
+    // One frame per channel per pass. Never put an unbounded output burst into ws/TCP.
+    const pump = () => {
+        pumping = undefined;
+        if (socket.readyState !== WebSocket.OPEN)
+            return;
+        const peers = [...channels.values()];
+        const start = cursor;
+        for (let step = 0; step < peers.length; step++) {
+            if (socket.bufferedAmount > 256 * 1024)
+                break;
+            const index = (start + step) % peers.length;
+            cursor = (index + 1) % peers.length;
+            const channel = peers[index];
+            const frame = channel.queue.shift();
+            if (frame) {
+                channel.bufferedAmount -= frame.length;
+                socket.send(frame);
+            }
+        }
+        if ([...channels.values()].some((channel) => channel.queue.length))
+            pumping = setTimeout(pump, socket.bufferedAmount > 256 * 1024 ? 10 : 1);
+    };
+    // The runtime throws between generations (a failed reload or a config restart): a socket that is
+    // still open keeps its last snapshot instead of crashing the process with an unhandled throw.
+    const sessions = (projectId) => {
+        try {
+            return handlers.sessions(projectId);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const snapshot = (peer) => {
+        const current = sessions(peer.projectId);
+        if (current)
+            peer.send(JSON.stringify({ type: "sessions", sessions: current }));
+    };
+    const dirty = new Set();
+    const unsubscribe = kind === "control"
+        ? onTerminalSessionsChanged((projectId) => {
+            if (dirty.has(projectId))
+                return;
+            dirty.add(projectId);
+            queueMicrotask(() => {
+                dirty.delete(projectId);
+                // Compute process activity once per project, not once per browser subscriber.
+                const peers = [...channels.values()].filter((peer) => peer.projectId === projectId);
+                if (!peers.length)
+                    return;
+                const current = sessions(projectId);
+                if (!current)
+                    return;
+                const data = JSON.stringify({ type: "sessions", sessions: current });
+                for (const peer of peers)
+                    peer.send(data);
+            });
+        })
+        : () => { };
+    socket.on("close", () => {
+        unsubscribe();
+        clearTimeout(pumping);
+        opening.clear();
+        for (const peer of channels.values())
+            peer.close(1001);
+        channels.clear();
+    });
+    socket.on("message", (raw, binary) => {
+        try {
+            if (binary)
+                throw new Error("Ожидается JSON");
+            const message = JSON.parse(raw.toString());
+            const id = message.channel;
+            if (typeof id !== "string" || !id || id.length > 100)
+                throw new Error("Некорректный канал");
+            if (message.type === "close") {
+                opening.delete(id);
+                channels.get(id)?.close();
+                return;
+            }
+            if (message.type === "open") {
+                if (channels.has(id) || opening.has(id))
+                    return;
+                if (channels.size + opening.size >= 256 ||
+                    typeof message.projectId !== "string" ||
+                    (kind === "data" && typeof message.sessionId !== "string"))
+                    throw new Error("Некорректная подписка");
+                const attempt = {};
+                opening.set(id, attempt);
+                void handlers
+                    .project(message.projectId)
+                    .then((project) => {
+                    if (opening.get(id) !== attempt || socket.readyState !== WebSocket.OPEN)
+                        return;
+                    opening.delete(id);
+                    if (!project) {
+                        // 4404 is not a normal close: owners must not retry or treat it as an ended session.
+                        send({ type: "closed", channel: id, code: 4404 });
+                        return;
+                    }
+                    const peer = new Channel(project.id, (data) => {
+                        // The JSON string is never shorter than its payload: small messages pass through.
+                        const messages = data.length > 8192 ? splitOutput(data) : [data];
+                        for (const item of messages) {
+                            const frame = JSON.stringify({ type: "message", channel: id, data: item });
+                            peer.queue.push(frame);
+                            peer.bufferedAmount += frame.length;
+                        }
+                        if (peer.bufferedAmount > 2 * 1024 * 1024)
+                            peer.terminate();
+                        else if (!pumping)
+                            pumping = setTimeout(pump, 0);
+                    }, (code) => {
+                        channels.delete(id);
+                        send({ type: "closed", channel: id, code });
+                    });
+                    channels.set(id, peer);
+                    try {
+                        if (kind === "data")
+                            subscribeTerminalPeer(project.id, message.sessionId, peer);
+                        send({ type: "opened", channel: id });
+                        if (kind === "control")
+                            snapshot(peer);
+                        let queue = Promise.resolve();
+                        let queued = 0;
+                        peer.on("message", (data) => {
+                            if (kind === "data")
+                                return;
+                            if (++queued > 64) {
+                                peer.terminate();
+                                return;
+                            }
+                            queue = queue.then(async () => {
+                                --queued;
+                                if (peer.readyState !== WebSocket.OPEN)
+                                    return;
+                                let requestId;
+                                try {
+                                    const request = JSON.parse(data);
+                                    requestId = request.id;
+                                    if (!Number.isSafeInteger(requestId) ||
+                                        !["GET", "POST", "DELETE"].includes(request.method) ||
+                                        (request.sessionId !== undefined && typeof request.sessionId !== "string") ||
+                                        (request.link !== undefined && typeof request.link !== "string") ||
+                                        (request.body !== undefined &&
+                                            (!request.body ||
+                                                typeof request.body !== "object" ||
+                                                Array.isArray(request.body))))
+                                        throw new Error("Некорректный запрос терминала");
+                                    const result = await handlers.control(project.id, request.method, request.sessionId, request.body, request.link);
+                                    peer.send(JSON.stringify({ type: "response", id: requestId, data: result }));
+                                }
+                                catch (error) {
+                                    peer.send(JSON.stringify({
+                                        type: "response",
+                                        id: requestId,
+                                        data: {
+                                            error: error instanceof Error ? error.message : "Ошибка терминала",
+                                        },
+                                    }));
+                                }
+                            });
+                        });
+                    }
+                    catch {
+                        peer.close(1000);
+                    }
+                })
+                    .catch(() => {
+                    if (opening.get(id) !== attempt)
+                        return;
+                    opening.delete(id);
+                    send({ type: "closed", channel: id, code: 1011 });
+                });
+                return;
+            }
+            if (message.type !== "send" ||
+                typeof message.data !== "string" ||
+                message.data.length > 96 * 1024)
+                throw new Error("Некорректное сообщение");
+            channels.get(id)?.emit("message", message.data, false);
+        }
+        catch {
+            socket.close(1008, "Invalid channel message");
+        }
+    });
+}

package/packages/server/modules/terminal-control/socket.js

@@ -0,0 +1,153 @@
+import { WebSocket, WebSocketServer } from "ws";
+import { protectLanSockets } from "../access/index.js";
+import { onTerminalSessionsChanged } from "../terminal/index.js";
+import { defaultTerminalControlHandlers } from "./handlers.js";
+const host = globalThis;
+const servers = (host.projectorTerminalControlServers ??= new WeakSet());
+export function attachTerminalControlServer(server, handlers = defaultTerminalControlHandlers) {
+    if (servers.has(server))
+        return;
+    servers.add(server);
+    const sockets = new WebSocketServer({
+        noServer: true,
+        maxPayload: 64 * 1024,
+        perMessageDeflate: false,
+    });
+    const projects = new Map();
+    const unprotect = protectLanSockets(server, sockets, handlers.allowed);
+    const alive = new WeakSet();
+    const send = (client, message) => {
+        if (client.readyState !== WebSocket.OPEN)
+            return;
+        if (client.bufferedAmount > 1024 * 1024) {
+            client.terminate();
+            return;
+        }
+        client.send(JSON.stringify(message));
+    };
+    // The runtime throws between generations (a failed reload or a config restart): an open socket
+    // keeps its last snapshot instead of crashing the process with an unhandled throw.
+    const snapshot = (client, projectId) => {
+        try {
+            send(client, { type: "sessions", sessions: handlers.sessions(projectId) });
+        }
+        catch { }
+    };
+    const dirty = new Set();
+    const unsubscribe = onTerminalSessionsChanged((projectId) => {
+        if (dirty.has(projectId))
+            return;
+        dirty.add(projectId);
+        queueMicrotask(() => {
+            dirty.delete(projectId);
+            for (const [client, id] of projects)
+                if (id === projectId)
+                    snapshot(client, id);
+        });
+    });
+    const heartbeat = setInterval(() => {
+        for (const client of sockets.clients) {
+            if (!alive.has(client)) {
+                client.terminate();
+                continue;
+            }
+            alive.delete(client);
+            client.ping();
+        }
+    }, 30000);
+    heartbeat.unref();
+    let disposed = false;
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        unsubscribe();
+        clearInterval(heartbeat);
+        unprotect();
+        servers.delete(server);
+        server.off("close", dispose);
+        server.off("upgrade", upgrade);
+        for (const client of sockets.clients)
+            client.terminate();
+        sockets.close();
+    };
+    const upgrade = (req, socket, head) => {
+        if (socket.writableEnded || socket.destroyed)
+            return;
+        let url;
+        try {
+            url = new URL(req.url ?? "/", "http://localhost");
+        }
+        catch {
+            socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+            return;
+        }
+        if (url.pathname !== "/api/terminal/control")
+            return;
+        if (!handlers.allowed(req, true, url.searchParams.get("token") ?? undefined)) {
+            socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
+            return;
+        }
+        const projectId = url.searchParams.get("project") ?? "";
+        void handlers
+            .project(projectId)
+            .then((project) => {
+            if (!project) {
+                socket.end("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+                return;
+            }
+            sockets.handleUpgrade(req, socket, head, (client) => {
+                sockets.emit("connection", client, req);
+                projects.set(client, projectId);
+                alive.add(client);
+                client.on("pong", () => alive.add(client));
+                client.on("error", () => client.terminate());
+                client.on("close", () => projects.delete(client));
+                snapshot(client, projectId);
+                // Serialize mutations from this connection without retrying them after disconnect.
+                let queue = Promise.resolve();
+                let queued = 0;
+                client.on("message", (raw, binary) => {
+                    if (++queued > 64) {
+                        client.terminate();
+                        return;
+                    }
+                    queue = queue.then(async () => {
+                        --queued;
+                        if (client.readyState !== WebSocket.OPEN)
+                            return;
+                        let requestId;
+                        try {
+                            if (binary)
+                                throw new Error("Ожидается JSON");
+                            const message = JSON.parse(raw.toString());
+                            requestId = message.id;
+                            if (!Number.isSafeInteger(requestId) ||
+                                !["GET", "POST", "DELETE"].includes(message.method) ||
+                                (message.sessionId !== undefined && typeof message.sessionId !== "string") ||
+                                (message.link !== undefined && typeof message.link !== "string") ||
+                                (message.body !== undefined &&
+                                    (!message.body ||
+                                        typeof message.body !== "object" ||
+                                        Array.isArray(message.body))))
+                                throw new Error("Некорректный запрос терминала");
+                            const data = await handlers.control(projectId, message.method, message.sessionId, message.body, message.link);
+                            send(client, { type: "response", id: requestId, data });
+                        }
+                        catch (error) {
+                            send(client, {
+                                type: "response",
+                                id: requestId,
+                                data: { error: error instanceof Error ? error.message : "Ошибка терминала" },
+                            });
+                        }
+                    });
+                });
+            });
+        })
+            .catch(() => socket.destroy());
+    };
+    server.on("upgrade", upgrade);
+    server.once("close", dispose);
+    return dispose;
+}

package/packages/server/modules/transport/implementation.js

@@ -0,0 +1,24 @@
+export function json(res, status, body) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(body));
+}
+export async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    const raw = Buffer.concat(chunks).toString("utf8").trim();
+    if (!raw)
+        return {};
+    return JSON.parse(raw);
+}
+export function asString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+export function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}

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

@@ -0,0 +1,2 @@
+export { createRouteDispatcher } from "./router.js";
+export { json, readBody, asString, escapeHtml } from "./implementation.js";

package/packages/server/modules/transport/router.js

@@ -0,0 +1,16 @@
+import { addRoute, createRouter, findRoute } from "rou3";
+/** Built per HTTP generation; never owns sockets, subscriptions, or agent processes. */
+export function createRouteDispatcher(definitions) {
+    const router = createRouter();
+    for (const route of definitions) {
+        for (const method of typeof route.method === "string" ? [route.method] : route.method)
+            addRoute(router, method, route.path, route.handler);
+    }
+    return async (context) => {
+        const route = findRoute(router, context.method, context.path);
+        if (!route)
+            return false;
+        await route.data({ ...context, params: route.params ?? {} });
+        return true;
+    };
+}

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

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

package/packages/server/modules/usage-analytics/index.js

@@ -0,0 +1,4 @@
+export { recordAgentLimits, readLimitSeries, usageWindowsOf } from "./limits.js";
+export { recordProviderBalance, readProviderSpend } from "./providers.js";
+export { usageAnalytics, rangeStart } from "./overview.js";
+export { closeAnalyticsStore, readLatestLimitSamples, readLimitSamples, readProviderSamples, } from "./store.js";