@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/launcher/launcher.js

@@ -0,0 +1,352 @@
+import { execFile } from "node:child_process";
+import { basename, dirname, isAbsolute, join } from "node:path";
+import { promisify } from "node:util";
+import { os } from "../../../core/modules/os/index.js";
+import { expandPath, loadProjects, sameLocalPath } from "../projects/index.js";
+import { getSnapshot, startProject, stopProject } from "../processes/index.js";
+import { openBrowser, openWindow, openRoute as openAppRoute } from "../window/index.js";
+import { desktopArgs } from "../window/index.js";
+import { parseLaunchQuery } from "../../../core/modules/launcher/index.js";
+import { browse } from "./browse.js";
+import { projectItem, workspaceRoute } from "./project-entries.js";
+import { searchGithub, searchGitlab } from "./hosted-search.js";
+import { createProjectIn, creationItems, favoriteFolderPath, isDirectory, openProjectAt, parseNewId, inFavoriteFolder, setFavoriteDirectory, } from "./folders.js";
+import { parsePotentialId, potentialItems } from "./potential.js";
+import { appUrl, projectAppUrl } from "../../../core/modules/app-paths/index.js";
+import { importGitlabProject, gitlabCloneTarget } from "../gitlab/index.js";
+import { githubProjectRoute } from "../../../core/modules/github/index.js";
+import { gitlabProjectRoute } from "../../../core/modules/gitlab/index.js";
+export { shortcuts, } from "../../../core/modules/launcher/index.js";
+const execute = promisify(execFile);
+/** Desktop queries are background work; their Node console must never appear over the UI. */
+function runDesktop(args, options = {}) {
+    return execute(process.execPath, [...desktopArgs(), ...args], {
+        ...options,
+        windowsHide: true,
+    });
+}
+import { preferences, toggleFavorite, updatePreferences } from "../preferences/index.js";
+export { preferences, interfaceMode, saveInterface } from "../preferences/index.js";
+export async function shortcutStatus() {
+    try {
+        const { stdout } = await runDesktop(["shortcut-status"], {
+            timeout: 8000,
+        });
+        return JSON.parse(stdout);
+    }
+    catch {
+        return { supported: false, active: false, shortcut: "" };
+    }
+}
+export async function checkShortcut(shortcut) {
+    if (!shortcut)
+        return;
+    try {
+        const { stdout } = await runDesktop(["shortcut-check", shortcut], { timeout: 8000 });
+        const result = JSON.parse(stdout);
+        if (result.supported && !result.available)
+            throw new Error(`Сочетание ${shortcut} уже занято другим приложением`);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes("уже занято"))
+            throw error;
+    }
+}
+let catalog;
+let catalogLoading;
+async function applications() {
+    if (catalog && Date.now() - catalog.at < 15000)
+        return catalog.items;
+    if (catalogLoading)
+        return catalogLoading;
+    catalogLoading = runDesktop(["list"], {
+        timeout: 10000,
+        maxBuffer: 4 * 1024 * 1024,
+    })
+        .then(({ stdout }) => {
+        const items = JSON.parse(stdout);
+        catalog = { at: Date.now(), items };
+        return items;
+    })
+        .finally(() => {
+        catalogLoading = undefined;
+    });
+    return catalogLoading;
+}
+const normalize = (value) => value.toLocaleLowerCase().normalize("NFKD").replace(/\p{M}/gu, "");
+export function matchScore(item, query) {
+    const name = normalize(item.name);
+    const terms = normalize(query).trim().split(/\s+/).filter(Boolean);
+    if (!terms.length)
+        return 0;
+    const haystack = normalize(item.kind === "directory" ? item.name : `${item.name} ${item.keywords} ${item.description}`);
+    let score = 0;
+    for (const term of terms) {
+        if (name === term)
+            score += 120;
+        else if (name.startsWith(term))
+            score += 90;
+        else if (name.includes(term))
+            score += 70;
+        else if (haystack.includes(term))
+            score += 40;
+        else {
+            if (item.kind === "directory")
+                return -1;
+            let cursor = 0;
+            let start = -1;
+            let end = 0;
+            for (let i = 0; i < name.length && cursor < term.length; i++) {
+                if (name[i] === term[cursor]) {
+                    if (start < 0)
+                        start = i;
+                    end = i;
+                    cursor++;
+                }
+            }
+            if (cursor !== term.length)
+                return -1;
+            score += Math.max(1, 25 - (end - start - term.length + 1));
+        }
+    }
+    return score;
+}
+export async function searchLauncher(query, options = {}) {
+    const parsed = parseLaunchQuery(query);
+    if (parsed.scope === "new")
+        return creationItems(parsed.text, (await preferences()).directories);
+    if (parsed.scope === "github")
+        return searchGithub(parsed.text);
+    if (parsed.scope === "gitlab")
+        return searchGitlab(parsed.text);
+    let warning;
+    const [apps, projects, prefs] = await Promise.all([
+        applications().catch(() => {
+            warning = os.capabilities.giLoader
+                ? "Системные приложения недоступны. Проверьте node-gtk и системные библиотеки GIO."
+                : "Системные приложения недоступны.";
+            return [];
+        }),
+        loadProjects(),
+        preferences(),
+    ]);
+    const input = query.trim();
+    const directPath = expandPath(input);
+    if (input && input !== "/" && isAbsolute(directPath) && (await isDirectory(directPath))) {
+        const project = projects.find((item) => sameLocalPath(item.path, directPath));
+        const item = project
+            ? {
+                ...projectItem(project),
+                folder: inFavoriteFolder(project, prefs.directories) || undefined,
+            }
+            : {
+                id: `path:${directPath}`,
+                name: basename(directPath),
+                kind: "directory",
+                description: "открыть папку как проект",
+                route: workspaceRoute(directPath),
+                keywords: directPath,
+                actions: [{ id: "open", title: "Открыть" }],
+            };
+        return {
+            items: [prefs.favorites.includes(item.id) ? { ...item, favorite: true } : item],
+        };
+    }
+    const { scope, text } = parseLaunchQuery(query);
+    // Discovering unregistered folders means reading every favorite folder, which can be huge.
+    // The empty overview must stay cheap: scan only for a text query or the explicit `/` scope.
+    // Surfaces that never need on-disk candidates (the project switcher) opt out explicitly.
+    const disk = options.disk !== false && (scope === "projects" || text !== "");
+    const items = [
+        ...(scope === "all"
+            ? apps.map((app) => ({ ...app, actions: [{ id: "launch", title: "Запустить" }] }))
+            : []),
+        ...projects.map((project) => ({
+            ...projectItem(project),
+            folder: inFavoriteFolder(project, prefs.directories) || undefined,
+        })),
+        ...(disk ? await potentialItems(prefs.directories, projects) : []),
+    ].map((item) => (prefs.favorites.includes(item.id) ? { ...item, favorite: true } : item));
+    if (!text)
+        return { items: browse(items, prefs.usage), warning };
+    const ranked = items.map((item) => ({
+        item,
+        score: matchScore(item, text),
+        usage: prefs.usage[item.id],
+    }));
+    ranked.sort((a, b) => Number(!!b.item.favorite) - Number(!!a.item.favorite) ||
+        b.score - a.score ||
+        Number(!!b.item.folder) - Number(!!a.item.folder) ||
+        (b.usage?.count ?? 0) - (a.usage?.count ?? 0) ||
+        (b.usage?.last ?? 0) - (a.usage?.last ?? 0) ||
+        a.item.name.localeCompare(b.item.name));
+    return {
+        items: ranked
+            .filter((row) => row.score >= 0)
+            .slice(0, 10)
+            .map((row) => row.item),
+        warning,
+    };
+}
+/** Shows a Projector route in the window or browser, per the user's interface mode. */
+async function openRoute(route) {
+    await openAppRoute(appUrl(), route);
+}
+async function rememberOpen(result, opened, inline) {
+    result.route = opened.route;
+    if (!inline)
+        await openRoute(result.route);
+    const id = `project:${opened.project.id}`;
+    await updatePreferences((value) => {
+        const usage = value.usage[id];
+        value.usage[id] = { count: (usage?.count ?? 0) + 1, last: Date.now() };
+    });
+    return result;
+}
+/** All actions of one result and, for a failed project, the tail of its terminal. */
+/** Without an explicit action the item's primary action runs. */
+export async function launchItem(id, action, inline = false, arg) {
+    const result = { ok: true };
+    if (id.startsWith("path:")) {
+        if (action && action !== "open")
+            throw new Error("Для папки доступно только открытие");
+        return rememberOpen(result, await openProjectAt(id.slice(5)), inline);
+    }
+    if (id.startsWith("potential:")) {
+        if (action && action !== "open")
+            throw new Error("Для папки на диске доступно только открытие");
+        const path = parsePotentialId(id);
+        const folders = (await preferences()).directories;
+        if (!folders.some((folder) => sameLocalPath(folder, dirname(expandPath(path)))))
+            throw new Error("Открывать так можно только папку в избранной");
+        return rememberOpen(result, await openProjectAt(path), inline);
+    }
+    if (id.startsWith("new:")) {
+        if (action && action !== "create" && action !== "open")
+            throw new Error("Создать проект можно в избранной папке: new/имя");
+        const target = parseNewId(id);
+        const path = join(target.folder, ...target.segments);
+        const exists = await isDirectory(path);
+        if (action === "create" || (!action && !exists)) {
+            const created = await createProjectIn(target.folder, target.segments);
+            result.route = created.route;
+            if (!inline)
+                await openRoute(result.route);
+            return result;
+        }
+        if (!exists)
+            throw new Error("Папка не найдена");
+        return rememberOpen(result, await openProjectAt(path), inline);
+    }
+    if (action === "folder") {
+        const project = (await loadProjects()).find((p) => `project:${p.id}` === id);
+        if (!project)
+            throw new Error("Избранной папкой можно сделать папку проекта");
+        result.favorite = await setFavoriteDirectory(await favoriteFolderPath(dirname(project.path)));
+        return result;
+    }
+    if (action === "favorite") {
+        const known = id.startsWith("app:")
+            ? (await applications()).some((item) => item.id === id)
+            : id.startsWith("project:") && (await loadProjects()).some((p) => `project:${p.id}` === id);
+        if (!known)
+            throw new Error("В избранное можно добавить приложение или проект");
+        result.favorite = await toggleFavorite(id);
+        return result;
+    }
+    if (id.startsWith("gl:")) {
+        const repository = id.slice(3);
+        if (action === "import") {
+            const { project } = await importGitlabProject({ repository });
+            result.route = workspaceRoute(project.path);
+        }
+        else if (!action || action === "open") {
+            const target = await gitlabCloneTarget(repository);
+            result.route = gitlabProjectRoute(target.instance, target.path);
+        }
+        else
+            throw new Error("Для проекта GitLab доступны открытие и клонирование");
+        if (!inline)
+            await openRoute(result.route);
+    }
+    else if (id.startsWith("gh:")) {
+        if (action && action !== "open")
+            throw new Error("Для репозитория доступно только открытие");
+        result.route = githubProjectRoute(id.slice(3));
+        if (!inline)
+            await openRoute(result.route);
+    }
+    else if (id.startsWith("app:")) {
+        if (action && action !== "launch")
+            throw new Error("Для приложения доступен только запуск");
+        const app = (await applications()).find((item) => item.id === id);
+        if (!app)
+            throw new Error("Приложение больше не доступно");
+        await runDesktop(["launch", id.slice(4)], { timeout: 10000 });
+    }
+    else if (id.startsWith("project:")) {
+        const project = (await loadProjects()).find((p) => `project:${p.id}` === id);
+        if (!project)
+            throw new Error("Проект не найден");
+        if (action === "launch")
+            throw new Error("Для проекта доступны открытие, запуск и остановка");
+        if (action === "stop") {
+            stopProject(project.id);
+            return result;
+        }
+        const current = getSnapshot(project.id);
+        const alive = current.status === "running" || current.status === "starting";
+        if (action === "browser" || action === "window") {
+            if (alive) {
+                const url = current.url || project.url;
+                if (!url)
+                    throw new Error("Проект запускается; адрес пока недоступен");
+                if (action === "window")
+                    openWindow(projectAppUrl(project.id));
+                else
+                    openBrowser(url);
+            }
+            else if (action === "window")
+                startProject(project, arg || undefined, "window");
+            else
+                throw new Error("Проект не запущен");
+            await updatePreferences((value) => {
+                const usage = value.usage[id];
+                value.usage[id] = { count: (usage?.count ?? 0) + 1, last: Date.now() };
+            });
+            return result;
+        }
+        if (action !== "run") {
+            result.route = workspaceRoute(project.path);
+            if (!inline)
+                await openRoute(result.route);
+        }
+        else {
+            const runtime = getSnapshot(project.id);
+            if (runtime.status === "running" || runtime.status === "starting") {
+                const url = runtime.url || project.url;
+                if (!url)
+                    throw new Error("Проект запускается; адрес пока недоступен");
+                if (project.mode === "window")
+                    openWindow(url);
+                else
+                    openBrowser(url);
+            }
+            else
+                startProject(project, arg || undefined);
+        }
+    }
+    else
+        throw new Error("Неизвестный результат поиска");
+    await updatePreferences((value) => {
+        const usage = value.usage[id];
+        value.usage[id] = { count: (usage?.count ?? 0) + 1, last: Date.now() };
+    });
+    return result;
+}
+export async function applicationIcon(id) {
+    const { stdout } = await runDesktop(["icon", id], {
+        timeout: 5000,
+    });
+    return stdout.trim() || null;
+}

package/packages/server/modules/launcher/potential.js

@@ -0,0 +1,70 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { sameLocalPath } from "../projects/index.js";
+import { isDirectory } from "./folders.js";
+import { tildePath, workspaceRoute } from "./project-entries.js";
+/** Direct children that are never a project the user would open from a favorite folder. */
+const SKIP = new Set([
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    "venv",
+    "target",
+    "__pycache__",
+]);
+export const potentialId = (path) => `potential:${path}`;
+export const parsePotentialId = (id) => id.slice(10);
+/**
+ * Unregistered direct children of favorite folders. Hidden names and well-known junk
+ * directories are skipped; anything else can be opened as a project.
+ */
+export async function potentialItems(folders, projects) {
+    const groups = [];
+    for (const folder of folders) {
+        if (!(await isDirectory(folder)))
+            continue;
+        const group = [];
+        const entries = await readdir(folder, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") || SKIP.has(entry.name))
+                continue;
+            // Regular files are the overwhelming majority; the dirent already says so, and a
+            // stat per entry makes a home-sized favorite folder crawl.
+            if (entry.isFile())
+                continue;
+            const path = join(folder, entry.name);
+            if (!entry.isDirectory() && !(await isDirectory(path)))
+                continue;
+            if (projects.some((project) => sameLocalPath(project.path, path)))
+                continue;
+            group.push({
+                id: potentialId(path),
+                name: entry.name,
+                kind: "directory",
+                description: `на диске · ${tildePath(folder)}`,
+                route: workspaceRoute(path),
+                keywords: path,
+                folder: true,
+                actions: [{ id: "open", title: "Открыть" }],
+            });
+        }
+        group.sort((a, b) => a.name.localeCompare(b.name));
+        if (group.length)
+            groups.push(group);
+    }
+    const items = [];
+    for (let index = 0;; index++) {
+        let added = false;
+        for (const group of groups) {
+            const item = group[index];
+            if (!item)
+                continue;
+            items.push(item);
+            added = true;
+        }
+        if (!added)
+            break;
+    }
+    return items;
+}

package/packages/server/modules/launcher/project-entries.js

@@ -0,0 +1,165 @@
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
+import { stat } from "node:fs/promises";
+import { os } from "../../../core/modules/os/index.js";
+import { loadProjects } from "../projects/index.js";
+import { getSnapshot, processOutput } from "../processes/index.js";
+import { preferences } from "../preferences/index.js";
+import { githubProjectRoute } from "../../../core/modules/github/index.js";
+import { parseProjectRef, pathToUrlSegments } from "../../../core/modules/project/index.js";
+/** Mirrors the client `projectRoute`: the workspace URL of a project path. */
+export function workspaceRoute(path) {
+    const ref = parseProjectRef(path);
+    if (ref.kind === "github")
+        return githubProjectRoute(ref.repository);
+    const segments = pathToUrlSegments(path).map((segment) => encodeURIComponent(segment).replaceAll("%3A", ":"));
+    return `/projects/${segments.length ? segments.join("/") : "%2F"}`;
+}
+export function projectItem(project) {
+    const command = project.commands.find((c) => c.id === project.defaultCommandId);
+    const state = getSnapshot(project.id).status;
+    const running = state === "running" || state === "starting";
+    return {
+        id: `project:${project.id}`,
+        name: project.name,
+        kind: "project",
+        description: `проект · ${running ? "работает" : state === "stopping" ? "останавливается" : state === "error" ? "ошибка запуска" : (command?.name ?? "без команды")}`,
+        route: workspaceRoute(project.path),
+        status: running
+            ? { state, label: state === "starting" ? "запускается" : "работает" }
+            : state === "stopping"
+                ? { state, label: "останавливается" }
+                : state === "error"
+                    ? { state, label: "ошибка запуска" }
+                    : undefined,
+        keywords: project.path,
+        icon: `/api/projects/${encodeURIComponent(project.id)}/icon`,
+        actions: [
+            { id: "open", title: "Открыть" },
+            ...(command || running
+                ? [
+                    {
+                        id: "run",
+                        title: running ? "Открыть запущенный" : `Запустить ${command.name}`,
+                    },
+                ]
+                : []),
+            ...(running ? [{ id: "stop", title: "Остановить" }] : []),
+        ],
+    };
+}
+const STATE_LABELS = {
+    idle: "остановлен",
+    starting: "запускается",
+    running: "работает",
+    stopping: "останавливается",
+    error: "ошибка запуска",
+};
+export const tildePath = (path) => {
+    const home = os.homeDirectory();
+    if (path === home)
+        return "~";
+    const rel = relative(home, path);
+    // Windows paths use backslashes, but the shown form is always `~/…`.
+    return rel && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)
+        ? `~/${rel.split(sep).join("/")}`
+        : path;
+};
+async function favoriteAction(id) {
+    const favorite = (await preferences()).favorites.includes(id);
+    return { id: "favorite", title: favorite ? "Убрать из избранного" : "Добавить в избранное" };
+}
+async function favoriteFolder(path) {
+    return (await preferences()).directories.includes(dirname(path));
+}
+async function pathExists(path) {
+    return stat(path).then((info) => info.isDirectory(), () => false);
+}
+export async function launchDetail(id) {
+    if (id.startsWith("path:")) {
+        const path = id.slice(5);
+        return {
+            actions: [{ id: "open", title: "Открыть" }],
+            info: { path: tildePath(path), state: "idle", stateLabel: "на диске" },
+        };
+    }
+    if (id.startsWith("potential:")) {
+        const path = id.slice(10);
+        return {
+            actions: [{ id: "open", title: "Открыть" }],
+            info: { path: tildePath(path), state: "idle", stateLabel: "на диске" },
+        };
+    }
+    if (id.startsWith("new:")) {
+        const [folder = "", rel = ""] = id.slice(4).split("\n");
+        const path = join(folder, ...rel.split("/").filter(Boolean));
+        if (await pathExists(path))
+            return {
+                actions: [{ id: "open", title: "Открыть" }],
+                info: { path: tildePath(path), state: "idle", stateLabel: "на диске" },
+            };
+        return { actions: [{ id: "create", title: "Создать проект" }] };
+    }
+    if (!id.startsWith("project:")) {
+        if (id.startsWith("gh:"))
+            return { actions: [{ id: "open", title: "Открыть репозиторий" }] };
+        if (id.startsWith("gl:"))
+            return {
+                actions: [
+                    { id: "open", title: "Открыть проект GitLab" },
+                    { id: "import", title: "Клонировать и открыть" },
+                ],
+            };
+        return { actions: [{ id: "launch", title: "Запустить" }, await favoriteAction(id)] };
+    }
+    const project = (await loadProjects()).find((p) => `project:${p.id}` === id);
+    if (!project)
+        throw new Error("Проект не найден");
+    const runtime = getSnapshot(project.id);
+    const running = runtime.status === "running" || runtime.status === "starting";
+    const commands = [
+        ...project.commands.filter((command) => command.id === project.defaultCommandId),
+        ...project.commands.filter((command) => command.id !== project.defaultCommandId),
+    ];
+    const actions = [{ id: "open", title: "Открыть воркспейс" }];
+    if (running)
+        actions.push({ id: "browser", title: "Открыть в браузере" }, { id: "window", title: "Открыть в окне" }, { id: "stop", title: "Остановить" });
+    else if (runtime.status !== "stopping") {
+        actions.push(...commands.map((command) => ({
+            id: "run",
+            title: `Запустить ${command.name}`,
+            arg: command.id,
+        })));
+        if (commands[0])
+            actions.push({
+                id: "window",
+                title: `Запустить ${commands[0].name} в окне`,
+                arg: commands[0].id,
+            });
+    }
+    const parent = dirname(project.path);
+    actions.push({
+        id: "folder",
+        title: `${(await favoriteFolder(project.path)) ? "Убрать из избранных папок" : "Добавить в избранные папки"}: ${tildePath(parent)}`,
+    });
+    actions.push(await favoriteAction(id));
+    const info = {
+        path: tildePath(project.path),
+        state: runtime.status,
+        stateLabel: STATE_LABELS[runtime.status],
+        command: runtime.commandName ?? undefined,
+        url: running || runtime.status === "stopping"
+            ? (runtime.url ?? project.url) || undefined
+            : undefined,
+        docker: project.environment
+            ? `Docker · ${project.environment.image} · сеть: ${project.environment.network}`
+            : undefined,
+    };
+    const detail = { actions, info };
+    if (runtime.status === "error")
+        detail.failure = {
+            command: runtime.commandName ?? "команда",
+            exitCode: runtime.exitCode,
+            output: processOutput(project.id) ?? "",
+        };
+    return detail;
+}

package/packages/server/modules/network/eu-context.js

@@ -0,0 +1,29 @@
+export const NETWORK_CONTEXT_URL = "https://ipwho.is/";
+/** Fixed public probe; usage requests must not run until EU network context is confirmed. */
+export async function assertEuNetworkContext(timeoutMs) {
+    let response;
+    try {
+        response = await fetch(NETWORK_CONTEXT_URL, {
+            headers: { Accept: "application/json" },
+            signal: AbortSignal.timeout(timeoutMs),
+            redirect: "error",
+        });
+    }
+    catch {
+        throw new Error("Не удалось проверить сетевой контекст");
+    }
+    if (!response.ok) {
+        await response.body?.cancel();
+        throw new Error("Не удалось проверить сетевой контекст");
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        throw new Error("Не удалось проверить сетевой контекст");
+    }
+    const probe = body && typeof body === "object" ? body : null;
+    if (probe?.success !== true || probe.is_eu !== true)
+        throw new Error("Не удалось проверить сетевой контекст");
+}

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

@@ -0,0 +1 @@
+export { assertEuNetworkContext, NETWORK_CONTEXT_URL } from "./eu-context.js";