@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/docker/settings.js

@@ -0,0 +1,127 @@
+import { realpath, stat } from "node:fs/promises";
+import { resolve, relative, isAbsolute, sep } from "node:path";
+import { os } from "../../../core/modules/os/index.js";
+import { integrationConfig, updateIntegration } from "../integration-store/index.js";
+import { HttpError } from "../http/index.js";
+export async function dockerContexts() {
+    const { stdout } = await os.tools.runDocker(["context", "ls", "--format", "{{json .}}"]);
+    return stdout
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+        const item = JSON.parse(line);
+        return {
+            name: item.Name,
+            endpoint: item.DockerEndpoint,
+            local: /^(?:unix|npipe):\/\//.test(String(item.DockerEndpoint)),
+        };
+    });
+}
+export async function dockerSettings() {
+    const config = await integrationConfig("docker");
+    return { enabled: config.enabled, context: config.settings.context || "default" };
+}
+export async function configureDocker(input) {
+    if (typeof input.enabled !== "boolean" || typeof input.context !== "string")
+        throw new HttpError(400, "Укажите enabled и Docker context");
+    if (input.enabled) {
+        const contexts = await dockerContexts();
+        if (!contexts.some((item) => item.name === input.context && item.local))
+            throw new HttpError(400, "Выберите локальный Docker context (Unix socket или named pipe)");
+    }
+    await updateIntegration("docker", (config) => ({
+        ...config,
+        enabled: input.enabled,
+        settings: { ...config.settings, context: input.context },
+    }));
+    return dockerSettings();
+}
+export async function requireContext(context) {
+    const settings = await dockerSettings();
+    if (!settings.enabled)
+        throw new HttpError(409, "Включите Docker в настройках интеграций");
+    if (!(await dockerContexts()).some((item) => item.name === context && item.local))
+        throw new HttpError(400, "Доступен только локальный Docker context");
+    return ["--context", context];
+}
+export async function readBinding(projectId) {
+    const config = await integrationConfig("docker");
+    const raw = config.settings[`project:${projectId}`];
+    return raw ? JSON.parse(raw) : null;
+}
+export async function detectedComposeFiles(path) {
+    const found = [];
+    for (const name of ["compose.yaml", "compose.yml", "docker-compose.yaml", "docker-compose.yml"])
+        try {
+            if ((await stat(resolve(path, name))).isFile())
+                found.push(name);
+        }
+        catch {
+            /* Absent. */
+        }
+    return found;
+}
+function strings(value, field) {
+    if (!Array.isArray(value) ||
+        value.length > 20 ||
+        value.some((item) => typeof item !== "string" || !item || item.includes("\0") || item.length > 1024))
+        throw new HttpError(400, `${field}: ожидается список непустых строк`);
+    return value;
+}
+export async function projectFile(path, name) {
+    const root = await realpath(path);
+    const file = await realpath(resolve(root, name));
+    const rel = relative(root, file);
+    if (!rel ||
+        rel === ".." ||
+        rel.startsWith(`..${sep}`) ||
+        isAbsolute(rel) ||
+        !(await stat(file)).isFile())
+        throw new HttpError(400, "Compose и env-файлы должны находиться внутри проекта");
+    return file;
+}
+export async function bindDocker(projectId, path, input) {
+    if (input.binding === null) {
+        await updateIntegration("docker", (config) => {
+            const settings = { ...config.settings };
+            delete settings[`project:${projectId}`];
+            return { ...config, settings };
+        });
+        return null;
+    }
+    if (typeof input.context !== "string" ||
+        typeof input.name !== "string" ||
+        !/^[a-z0-9][a-z0-9_-]*$/.test(input.name))
+        throw new HttpError(400, "Имя Compose: строчные буквы, цифры, дефис и подчёркивание");
+    await requireContext(input.context);
+    const binding = {
+        context: input.context,
+        name: input.name,
+        files: strings(input.files, "files"),
+        profiles: strings(input.profiles ?? [], "profiles"),
+        envFiles: strings(input.envFiles ?? [], "envFiles"),
+    };
+    if (!binding.files.length)
+        throw new HttpError(400, "Выберите Compose-файл");
+    if (binding.profiles.some((profile) => !/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(profile)))
+        throw new HttpError(400, "Некорректное имя profile");
+    for (const file of [...binding.files, ...binding.envFiles])
+        await projectFile(path, file);
+    await updateIntegration("docker", (config) => ({
+        ...config,
+        settings: { ...config.settings, [`project:${projectId}`]: JSON.stringify(binding) },
+    }));
+    return binding;
+}
+/** Entry for the settings overview; live daemon health is owned by the snapshot. */
+export async function dockerIntegrationStatus() {
+    const config = await integrationConfig("docker");
+    return {
+        id: "docker",
+        name: "Docker",
+        description: "Локальные контейнеры и Compose-окружения",
+        enabled: config.enabled,
+        settings: { context: config.settings.context || "default" },
+    };
+}

package/packages/server/modules/docker/snapshot.js

@@ -0,0 +1,105 @@
+import { os } from "../../../core/modules/os/index.js";
+import { daemonState } from "./daemon.js";
+import { dockerSettings, dockerContexts, readBinding, detectedComposeFiles } from "./settings.js";
+export function containerSummary(item) {
+    const labels = item.Config?.Labels ?? {};
+    const ports = [];
+    for (const [key, values] of Object.entries(item.NetworkSettings?.Ports ?? {})) {
+        const [privatePort, protocol] = key.split("/");
+        for (const port of values ?? []) {
+            const address = port.HostIp || "0.0.0.0";
+            const host = address === "0.0.0.0"
+                ? "127.0.0.1"
+                : address === "::"
+                    ? "[::1]"
+                    : address.includes(":")
+                        ? `[${address}]`
+                        : address;
+            ports.push({
+                address,
+                privatePort: Number(privatePort),
+                publicPort: Number(port.HostPort),
+                protocol: protocol,
+                url: protocol === "tcp" ? `http://${host}:${port.HostPort}` : null,
+            });
+        }
+    }
+    return {
+        id: item.Id,
+        name: String(item.Name).replace(/^\//, ""),
+        image: item.Config?.Image ?? "",
+        state: item.State?.Status ?? "unknown",
+        health: item.State?.Health?.Status ?? null,
+        exitCode: item.State?.ExitCode ?? 0,
+        startedAt: item.State?.StartedAt ?? "",
+        project: labels["com.docker.compose.project"] ?? "",
+        service: labels["com.docker.compose.service"] ?? "",
+        workingDirectory: labels["com.docker.compose.project.working_dir"] ?? "",
+        ports,
+        mounts: (item.Mounts ?? []).map((mount) => ({
+            type: mount.Type,
+            source: mount.Source,
+            target: mount.Destination,
+            writable: !!mount.RW,
+        })),
+    };
+}
+export async function dockerSnapshot(project, requestedContext) {
+    const settings = await dockerSettings();
+    const binding = project ? await readBinding(project.id) : null;
+    const result = {
+        ...settings,
+        context: requestedContext || binding?.context || settings.context,
+        contexts: [],
+        connected: false,
+        version: "",
+        composeVersion: "",
+        error: "",
+        containers: [],
+        binding,
+        detectedFiles: project ? await detectedComposeFiles(project.path) : [],
+    };
+    try {
+        result.contexts = await dockerContexts();
+        if (!settings.enabled)
+            return result;
+        if (!result.contexts.some((item) => item.name === result.context && item.local))
+            throw new Error("Выбранный Docker context недоступен или не является локальным");
+        const prefix = ["--context", result.context];
+        const { stdout } = await os.tools.runDocker([
+            ...prefix,
+            "info",
+            "--format",
+            "{{.ServerVersion}}",
+        ]);
+        result.version = stdout.trim();
+        result.connected = true;
+        try {
+            result.composeVersion = (await os.tools.runDocker([...prefix, "compose", "version", "--short"])).stdout.trim();
+        }
+        catch {
+            /* CLI plugin missing; container actions still work. */
+        }
+        const ids = (await os.tools.runDocker([...prefix, "ps", "-aq", "--no-trunc"])).stdout
+            .trim()
+            .split("\n")
+            .filter(Boolean);
+        for (let offset = 0; offset < ids.length; offset += 50) {
+            const inspected = await os.tools.runDocker([
+                ...prefix,
+                "inspect",
+                "--type",
+                "container",
+                ...ids.slice(offset, offset + 50),
+            ]);
+            result.containers.push(...JSON.parse(inspected.stdout).map(containerSummary));
+        }
+    }
+    catch (error) {
+        result.connected = false;
+        result.containers = [];
+        result.error = error instanceof Error ? error.message : "Docker недоступен";
+        result.daemon = daemonState(error);
+    }
+    return result;
+}

package/packages/server/modules/environments/execution.js

@@ -0,0 +1,125 @@
+import { randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { resolve, relative, isAbsolute, sep } from "node:path";
+import { os } from "../../../core/modules/os/index.js";
+import { loadProjects } from "../projects/index.js";
+import { serverId } from "./reconcile.js";
+import { HttpError } from "../http/index.js";
+export function environmentLaunch(project, command, interactive = true, publish = true) {
+    const environment = project.environment;
+    if (!environment)
+        throw new HttpError(409, "Проект не использует Docker");
+    const root = realpathSync(project.path);
+    if (root !== project.path || root.includes(","))
+        throw new HttpError(409, "Путь Docker-проекта изменён или содержит запятую");
+    const { uid, gid } = os.userIdentity();
+    if (uid <= 0)
+        throw new HttpError(409, "Docker-окружение требует непривилегированного пользователя Projector");
+    const name = `projector-env-${randomUUID()}`;
+    const args = [
+        "--context",
+        environment.context,
+        "run",
+        "--rm",
+        "--name",
+        name,
+        "--label",
+        `io.projector.environment=${project.id}`,
+        "--label",
+        `io.projector.server=${serverId}`,
+        "--init",
+        "--read-only",
+        "--cap-drop=ALL",
+        "--security-opt=no-new-privileges:true",
+        "--pids-limit=256",
+        "--memory=2g",
+        "--memory-swap=2g",
+        "--cpus=2",
+        "--user",
+        `${uid}:${gid}`,
+        "--network",
+        environment.network,
+        "--mount",
+        `type=bind,source=${root},target=/workspace`,
+        "--tmpfs",
+        "/tmp:rw,nosuid,nodev,size=256m",
+        "--tmpfs",
+        `/home/node:rw,nosuid,nodev,uid=${uid},gid=${gid},size=256m`,
+        "--workdir",
+        "/workspace",
+        "--env",
+        "HOME=/home/node",
+        "--env",
+        "TERM=xterm-256color",
+        "--env",
+        "GIT_CONFIG_GLOBAL=/dev/null",
+        "--env",
+        "GIT_CONFIG_NOSYSTEM=1",
+        "--entrypoint",
+        "/bin/bash",
+    ];
+    if (interactive)
+        args.push("-it");
+    if (publish && environment.network !== "none")
+        for (const port of environment.ports)
+            args.push("-p", `127.0.0.1::${port}`);
+    args.push(environment.image, "--noprofile", "--norc", "-c", 'mkdir -p /tmp/projector-bin; if command -v corepack >/dev/null; then corepack enable --install-directory /tmp/projector-bin; fi; export PATH="/tmp/projector-bin:/workspace/node_modules/.bin:$PATH"; exec "$@"', "projector-environment", ...command);
+    return {
+        file: "docker",
+        args,
+        title: `Docker · ${project.name}`,
+        docker: { context: environment.context, kind: "environment", containerId: name },
+    };
+}
+export async function stopEnvironmentContainer(context, name, retry = false) {
+    if (!/^projector-env-[a-f0-9-]{36}$/.test(name))
+        throw new Error("Некорректное имя окружения");
+    // Retry if the PTY client was stopped while Docker was still creating the container.
+    for (let attempt = 0; attempt < (retry ? 10 : 1); attempt++) {
+        try {
+            await os.tools.runDocker(["--context", context, "rm", "--force", name]);
+            return;
+        }
+        catch {
+            await new Promise((done) => setTimeout(done, 100));
+        }
+    }
+}
+export async function environmentForPath(path) {
+    const root = resolve(path);
+    return (await loadProjects(true)).find((project) => {
+        const rel = relative(project.path, root);
+        return project.environment && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+    });
+}
+export async function runEnvironmentCommand(project, command, timeout = 30_000, signal, credentialFile, onOutput) {
+    const launch = environmentLaunch(project, command, false, false);
+    if (credentialFile)
+        launch.args.splice(launch.args.indexOf("--entrypoint"), 0, "--env-file", credentialFile);
+    try {
+        return await os.tools.runDocker(launch.args, { timeout, signal, onOutput });
+    }
+    finally {
+        await stopEnvironmentContainer(launch.docker.context, launch.docker.containerId);
+    }
+}
+export async function environmentPorts(context, name) {
+    const result = await os.tools.runDocker(["--context", context, "port", name]);
+    return result.stdout
+        .trim()
+        .split("\n")
+        .flatMap((line) => {
+        const match = /^(\d+)\/tcp -> 127\.0\.0\.1:(\d+)$/.exec(line);
+        return match ? [{ container: Number(match[1]), url: `http://127.0.0.1:${match[2]}` }] : [];
+    });
+}
+export function stopEnvironmentContainerSync(context, name) {
+    if (!/^projector-env-[a-f0-9-]{36}$/.test(name))
+        return;
+    try {
+        os.tools.runDockerSync(["--context", context, "rm", "--force", name]);
+    }
+    catch {
+        /* Already gone. */
+    }
+}

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

@@ -0,0 +1,3 @@
+export { parseDockerEnvironment, prepareDockerEnvironment } from "./settings.js";
+export { environmentPorts, stopEnvironmentContainerSync, environmentLaunch, stopEnvironmentContainer, runEnvironmentCommand, environmentForPath, } from "./execution.js";
+export { reconcileEnvironmentContainers, reconcileOnStartup } from "./reconcile.js";

package/packages/server/modules/environments/reconcile.js

@@ -0,0 +1,62 @@
+import { os } from "../../../core/modules/os/index.js";
+import { loadProjects } from "../projects/index.js";
+const host = globalThis;
+/** Names this server process: pid plus start time, so a reused pid is not mistaken for it. */
+export const serverId = `${process.pid}-${(await os.processes.identity(process.pid)) ?? "0"}`;
+/** True while the process named by an owner label is still running. */
+async function ownerAlive(owner) {
+    const match = /^(\d+)-(\d+)$/.exec(owner);
+    if (!match)
+        return undefined;
+    return (await os.processes.identity(Number(match[1]))) === match[2];
+}
+/**
+ * Removes Projector's isolated-environment containers whose server process is gone
+ * (SIGKILL, crash, power loss). A container is touched only if it carries Projector's
+ * label AND its owner is provably dead or missing; containers of a live Projector
+ * (another instance, a test server) and of unknown label formats are left alone.
+ */
+export async function reconcileEnvironmentContainers(contexts, run = (args) => os.tools.runDocker(args)) {
+    let removed = 0;
+    for (const context of new Set(contexts)) {
+        try {
+            const { stdout } = await run([
+                "--context",
+                context,
+                "ps",
+                "-a",
+                "--filter",
+                "label=io.projector.environment",
+                "--format",
+                '{{.ID}} {{.Label "io.projector.server"}}',
+            ]);
+            const orphans = [];
+            for (const line of stdout.split("\n")) {
+                const [id, owner = ""] = line.trim().split(" ");
+                if (!/^[a-f0-9]{12,64}$/.test(id ?? ""))
+                    continue;
+                if (owner === "")
+                    orphans.push(id); // created before owners were recorded
+                else if ((await ownerAlive(owner)) === false)
+                    orphans.push(id);
+            }
+            if (orphans.length)
+                await run(["--context", context, "rm", "--force", ...orphans]);
+            removed += orphans.length;
+        }
+        catch {
+            /* Docker is not running for this context: nothing to clean. */
+        }
+    }
+    return removed;
+}
+/** Once per server process, not per HMR reload. */
+export async function reconcileOnStartup() {
+    if (host.projectorReconciled)
+        return;
+    host.projectorReconciled = true;
+    const contexts = (await loadProjects()).flatMap((project) => project.environment ? [project.environment.context] : []);
+    const removed = await reconcileEnvironmentContainers(contexts);
+    if (removed)
+        console.log(`Удалено контейнеров от прошлого запуска Projector: ${removed}`);
+}

package/packages/server/modules/environments/settings.js

@@ -0,0 +1,58 @@
+import { os } from "../../../core/modules/os/index.js";
+import { DEFAULT_ENVIRONMENT_IMAGE, } from "../../../core/modules/environment/index.js";
+import { HttpError } from "../http/index.js";
+export function parseDockerEnvironment(value, context = "default") {
+    if (value === undefined || value === "local")
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new HttpError(400, "Некорректное окружение");
+    const input = value;
+    if (input.kind !== "docker" ||
+        Object.keys(input).some((key) => !["kind", "image", "network", "ports"].includes(key)))
+        throw new HttpError(400, "Docker-окружение принимает только image, network и ports");
+    const image = input.image ?? DEFAULT_ENVIRONMENT_IMAGE;
+    const network = input.network ?? "none";
+    const ports = input.ports ?? [];
+    if (typeof image !== "string" ||
+        image.length > 256 ||
+        !/^[a-zA-Z0-9][a-zA-Z0-9._/:@-]*$/.test(image))
+        throw new HttpError(400, "Некорректный Docker image");
+    if (network !== "none" && network !== "bridge")
+        throw new HttpError(400, "network: none или bridge");
+    if (!Array.isArray(ports) ||
+        ports.length > 5 ||
+        ports.some((port) => !Number.isInteger(port) || port < 1 || port > 65535) ||
+        new Set(ports).size !== ports.length)
+        throw new HttpError(400, "Укажите до пяти уникальных TCP-портов");
+    if (network === "none" && ports.length)
+        throw new HttpError(400, "Публикация портов требует сети bridge");
+    return { kind: "docker", context, image, network, ports };
+}
+export async function prepareDockerEnvironment(environment, options = {}) {
+    const result = await os.tools.runDocker(["context", "inspect", environment.context]);
+    const context = JSON.parse(result.stdout)[0];
+    if (!/^(?:unix|npipe):\/\//.test(context?.Endpoints?.docker?.Host ?? ""))
+        throw new HttpError(400, "Docker-окружения поддерживают только локальный Unix socket");
+    await os.tools.runDocker([
+        "--context",
+        environment.context,
+        "info",
+        "--format",
+        "{{.ServerVersion}}",
+    ]);
+    const prefix = ["--context", environment.context];
+    try {
+        await os.tools.runDocker([...prefix, "image", "inspect", environment.image], {
+            signal: options.signal,
+        });
+    }
+    catch (error) {
+        if (options.signal?.aborted)
+            throw error;
+        options.onPull?.();
+        await os.tools.runDocker([...prefix, "pull", environment.image], {
+            timeout: 300_000,
+            signal: options.signal,
+        });
+    }
+}

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

@@ -0,0 +1,85 @@
+import { isLocalRequest } from "../access/index.js";
+import { onProcessEvent } from "../processes/index.js";
+// Vite reloads the API modules without closing open event streams: keep the clients across reloads.
+const host = globalThis;
+const state = (host.projectorEvents ??= {
+    clients: new Set(),
+    closeListeners: new Set(),
+    bound: false,
+});
+const { clients: sseClients, closeListeners } = state;
+export function bindEvents() {
+    if (state.bound)
+        return;
+    state.bound = true;
+    onProcessEvent((event, data) => broadcastEvent(event, data));
+}
+/**
+ * Sends an event to every open stream; with `clientId` only to that page and `localOnly` to
+ * loopback pages. Returns how many streams it wrote to.
+ */
+export function broadcastEvent(event, data, clientId, localOnly = false) {
+    const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    let sent = 0;
+    for (const client of sseClients)
+        if ((!localOnly || client.local) &&
+            (!clientId || client.id === clientId || client.pages?.has(clientId))) {
+            client.res.write(payload);
+            sent++;
+        }
+    return sent;
+}
+/** Called when a page's stream closes: owners of per-page resources release them. */
+export function onEventClientClose(listener) {
+    closeListeners.add(listener);
+    return () => {
+        closeListeners.delete(listener);
+    };
+}
+export function attachSse(req, res) {
+    bindEvents();
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+    });
+    res.write(":\n\n");
+    const client = {
+        res,
+        id: new URL(req.url ?? "/", "http://localhost").searchParams.get("client") ?? "",
+        local: isLocalRequest(req),
+    };
+    sseClients.add(client);
+    req.on("close", () => {
+        sseClients.delete(client);
+        for (const id of [client.id, ...(client.pages ?? [])])
+            if (id)
+                for (const listener of closeListeners)
+                    listener(id);
+    });
+}
+/**
+ * Binds pages to the stream `stream` or releases them: what a page owns (file watchers) lives
+ * as long as the stream, or until the page is removed. False when the stream is gone.
+ */
+export function updateEventPages(stream, add, remove) {
+    const client = [...sseClients].find((item) => item.id === stream);
+    if (!client)
+        return false;
+    const pages = (client.pages ??= new Set());
+    for (const id of add)
+        if (id !== stream)
+            pages.add(id);
+    for (const id of remove)
+        if (pages.delete(id))
+            for (const listener of closeListeners)
+                listener(id);
+    return true;
+}
+export function notifyLauncherShow() {
+    broadcastEvent("launcher-show", {});
+}
+/** Whether a page has an open event stream, directly or bound to a shared one. */
+export function hasEventClient(clientId) {
+    return [...sseClients].some((item) => item.id === clientId || item.pages?.has(clientId));
+}

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

@@ -0,0 +1 @@
+export { bindEvents, attachSse, notifyLauncherShow, broadcastEvent, onEventClientClose, updateEventPages, hasEventClient, } from "./implementation.js";

package/packages/server/modules/folder-picker/index.js

@@ -0,0 +1 @@
+export { pickFolder } from "./pick-folder.js";

package/packages/server/modules/folder-picker/pick-folder.js

@@ -0,0 +1,2 @@
+import { os } from "../../../core/modules/os/index.js";
+export const pickFolder = () => os.pickFolder();

package/packages/server/modules/git-import/clone.js

@@ -0,0 +1,47 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { os } from "../../../core/modules/os/index.js";
+import { HttpError } from "../http/index.js";
+/** Hardened HTTPS clone: no hooks, no redirects, token only through a temporary askpass helper. */
+export async function cloneOverHttps(url, destination, token, credentials, signal) {
+    const helper = await mkdtemp(join(tmpdir(), "projector-git-"));
+    try {
+        const script = os.tools.gitAskpass(credentials);
+        const askpass = join(helper, script.filename);
+        await writeFile(askpass, script.contents, { mode: 0o700 });
+        // Resolved per call, so a `child_process` replacement installed after import still applies.
+        await promisify(execFile)("git", [
+            "-c",
+            "credential.helper=",
+            "-c",
+            "core.hooksPath=/dev/null",
+            "-c",
+            "http.followRedirects=false",
+            "clone",
+            "--",
+            url,
+            destination,
+        ], {
+            env: {
+                ...process.env,
+                GIT_ASKPASS: askpass,
+                GIT_TERMINAL_PROMPT: "0",
+                [credentials.tokenEnv]: token,
+            },
+            timeout: 300_000,
+            maxBuffer: 1024 * 1024,
+            signal,
+        });
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
+        throw new HttpError(400, credentials.failure);
+    }
+    finally {
+        await rm(helper, { recursive: true, force: true });
+    }
+}