@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/project-presentation/implementation.js

@@ -0,0 +1,130 @@
+import { createReadStream } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { getSnapshot } from "../processes/index.js";
+import { iconContentType, letterIconSvg } from "../projects/index.js";
+import { asString, escapeHtml } from "../transport/index.js";
+/** A folder inside the project, relative and without `..`; absent or "." means the root. */
+export function scenarioFolder(value) {
+    const text = asString(value)
+        .replace(/\\/g, "/")
+        .replace(/^\.(\/|$)/, "")
+        .replace(/\/+$/, "");
+    if (!text)
+        return undefined;
+    if (text.startsWith("/") || /^[a-zA-Z]:/.test(text) || text.split("/").includes(".."))
+        throw new Error("Папка сценария должна лежать внутри проекта");
+    return text;
+}
+function scenarioUrl(value) {
+    const text = asString(value);
+    if (!text)
+        return undefined;
+    try {
+        if (["http:", "https:"].includes(new URL(text).protocol))
+            return text;
+    }
+    catch {
+        // reported below
+    }
+    throw new Error("Адрес сценария должен начинаться с http:// или https://");
+}
+export function parseCommands(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const row = item;
+        const name = asString(row.name);
+        const cmd = asString(row.cmd);
+        if (!name || !cmd)
+            return [];
+        const command = { id: asString(row.id) || randomUUID(), name, cmd };
+        const cwd = scenarioFolder(row.cwd);
+        const url = scenarioUrl(row.url);
+        if (cwd)
+            command.cwd = cwd;
+        if (url)
+            command.url = url;
+        if (row.mode === "server" || row.mode === "window")
+            command.mode = row.mode;
+        return [command];
+    });
+}
+export function parseMode(value) {
+    return value === "window" ? "window" : "server";
+}
+export function sendIconFile(res, file) {
+    res.statusCode = 200;
+    res.setHeader("Content-Type", iconContentType(file));
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
+    createReadStream(file).pipe(res);
+}
+export function sendLetterIcon(res, name) {
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "image/svg+xml");
+    res.setHeader("Cache-Control", "no-cache");
+    res.end(letterIconSvg(name));
+}
+/** Icon bytes from a remote repository; cached briefly so one page load stays one API pass. */
+export function sendIconBytes(res, mime, bytes, cache = "private, max-age=300") {
+    res.statusCode = 200;
+    res.setHeader("Content-Type", mime);
+    res.setHeader("Cache-Control", cache);
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
+    res.end(bytes);
+}
+/** JSON is valid JS but not safe inside HTML: `</script>` would close the element. */
+function scriptString(value) {
+    return JSON.stringify(value)
+        .replaceAll("<", "\\u003c")
+        .replaceAll(">", "\\u003e")
+        .replaceAll("&", "\\u0026")
+        .replaceAll("\u2028", "\\u2028")
+        .replaceAll("\u2029", "\\u2029");
+}
+export function launchHtml(project, target) {
+    const title = escapeHtml(project.name);
+    const href = `/api/projects/${encodeURIComponent(project.id)}/icon`;
+    return `<!doctype html>
+<html lang="ru">
+<head>
+<meta charset="utf-8">
+<title>${title}</title>
+<link rel="icon" href="${href}">
+<link rel="shortcut icon" href="${href}">
+<meta http-equiv="refresh" content="0;url=${escapeHtml(target)}">
+<style>html,body{margin:0;background:#111;color:#aaa;font:14px sans-serif;height:100%}body{display:grid;place-items:center}</style>
+</head>
+<body>
+<p>открываю ${title}…</p>
+<script>location.replace(${scriptString(target)})</script>
+</body>
+</html>`;
+}
+export function normalizeProject(input, current) {
+    const commands = parseCommands(input.commands);
+    if (commands.length === 0)
+        throw new Error("Нужна хотя бы одна команда");
+    const defaultCommandId = asString(input.defaultCommandId) || current?.defaultCommandId || commands[0].id;
+    return {
+        id: current?.id ?? randomUUID(),
+        name: asString(input.name) || "без имени",
+        path: current?.environment ? current.path : asString(input.path),
+        environment: current?.environment,
+        url: asString(input.url),
+        icon: asString(input.icon),
+        mode: parseMode(input.mode),
+        defaultCommandId: commands.some((item) => item.id === defaultCommandId)
+            ? defaultCommandId
+            : commands[0].id,
+        commands,
+        createdAt: current?.createdAt ?? new Date().toISOString(),
+    };
+}
+export function withRuntime(project) {
+    return { ...project, runtime: getSnapshot(project.id) };
+}

package/packages/server/modules/project-presentation/index.js

@@ -0,0 +1 @@
+export { parseCommands, parseMode, sendIconFile, sendLetterIcon, sendIconBytes, launchHtml, normalizeProject, withRuntime, } from "./implementation.js";

package/packages/server/modules/project-widgets/index.js

@@ -0,0 +1,210 @@
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, readFile, realpath, rename, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { os } from "../../../core/modules/os/index.js";
+import { normalizeProjectWidget, PROJECT_WIDGET_LIMITS, } from "../../../core/modules/widget-catalog/index.js";
+import { loadProjects } from "../projects/index.js";
+/** Widgets a project keeps in its repository; inert until the user trusts this exact file. */
+export const projectWidgetsRelativeFile = ".projector/widgets.json";
+export const projectWidgetsTrustFile = () => join(dataDir(), "agent", "widget-trust.json");
+/** A data file is read only on behalf of a trusted widget and never from a secret-looking path. */
+const DATA_LIMIT = 1_000_000;
+const SECRET_NAMES = new Set([".ssh", ".aws", ".npmrc", ".netrc", ".git-credentials", ".git"]);
+const SECRET_PATTERNS = [/(^\.|\.)env($|\.)/i, /\.(pem|key)$/i, /^id_(rsa|ed25519)/i, /\.kdbx$/i];
+const hashOf = (text) => createHash("sha256").update(text).digest("hex");
+async function projectRoot(projectId) {
+    const project = (await loadProjects()).find((item) => item.id === projectId);
+    if (!project)
+        throw new Error("Проект не найден");
+    return realpath(project.path);
+}
+function readTrustFile(text) {
+    try {
+        const value = JSON.parse(text);
+        const projects = {};
+        if (value?.projects && typeof value.projects === "object" && !Array.isArray(value.projects))
+            for (const [path, item] of Object.entries(value.projects)) {
+                const row = item;
+                if (typeof row?.hash === "string" && typeof row.at === "string")
+                    projects[path] = { hash: row.hash, at: row.at };
+            }
+        return { version: 1, projects };
+    }
+    catch {
+        return { version: 1, projects: {} };
+    }
+}
+async function readTrust() {
+    try {
+        return readTrustFile(await readFile(projectWidgetsTrustFile(), "utf8"));
+    }
+    catch {
+        return { version: 1, projects: {} };
+    }
+}
+let queue = Promise.resolve();
+async function writeTrust(file) {
+    const path = projectWidgetsTrustFile();
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${randomBytes(4).toString("hex")}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(file, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    await rename(temporary, path);
+    await os.tools.restrictToOwner(path);
+}
+/** Rejects a `.projector` folder or widgets file that escapes the project through a symlink. */
+async function safeProjectFile(root, file) {
+    const real = await realpath(file);
+    const rel = relative(root, real);
+    if (rel.startsWith("..") || isAbsolute(rel))
+        throw new Error("Файл виджетов проекта указывает за его пределы");
+    return real;
+}
+function widgetsOf(text) {
+    const value = JSON.parse(text);
+    if (!Array.isArray(value?.widgets))
+        throw new Error("В файле виджетов проекта нет widgets");
+    const rows = value.widgets
+        .slice(0, PROJECT_WIDGET_LIMITS.widgets)
+        .filter((item) => !!item && typeof item === "object");
+    const names = rows.flatMap((row) => typeof row.name === "string" && row.name.trim() ? [row.name.trim()] : []);
+    const widgets = [];
+    for (const row of rows) {
+        const widget = normalizeProjectWidget(row, names);
+        if (!widget || widgets.some((known) => known.name === widget.name))
+            continue;
+        widgets.push(widget);
+    }
+    return widgets;
+}
+/** The project's widgets file and its trust decision; a broken or unsafe file is reported, not used. */
+export async function projectWidgetState(projectId) {
+    const root = await projectRoot(projectId);
+    const file = join(root, projectWidgetsRelativeFile);
+    const trust = await readTrust();
+    try {
+        const raw = await readFile(file, "utf8");
+        const real = await safeProjectFile(root, file);
+        const hash = hashOf(raw);
+        let widgets;
+        try {
+            widgets = widgetsOf(raw);
+        }
+        catch (error) {
+            return {
+                projectId,
+                path: root,
+                file: real,
+                exists: true,
+                trusted: false,
+                hash,
+                widgets: [],
+                problem: error instanceof Error && error.message.startsWith("В файле")
+                    ? error.message
+                    : "Файл виджетов проекта повреждён",
+            };
+        }
+        return {
+            projectId,
+            path: root,
+            file: real,
+            exists: true,
+            trusted: trust.projects[root]?.hash === hash,
+            hash,
+            widgets,
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {
+                projectId,
+                path: root,
+                file,
+                exists: false,
+                trusted: false,
+                widgets: [],
+            };
+        return {
+            projectId,
+            path: root,
+            file,
+            exists: false,
+            trusted: false,
+            widgets: [],
+            problem: error instanceof Error ? error.message : "Не удалось прочитать виджеты проекта",
+        };
+    }
+}
+/** Trusts (or stops trusting) the current contents of the project's widgets file. */
+export async function setProjectWidgetTrust(projectId, trusted) {
+    const state = await projectWidgetState(projectId);
+    if (trusted && !state.exists)
+        throw new Error("В проекте нет файла виджетов");
+    if (trusted && (!state.hash || state.problem))
+        throw new Error("Файлу виджетов проекта нельзя доверять");
+    const task = queue.then(async () => {
+        const file = await readTrust();
+        if (trusted)
+            file.projects[state.path] = { hash: state.hash, at: new Date().toISOString() };
+        else
+            delete file.projects[state.path];
+        await writeTrust(file);
+        return projectWidgetState(projectId);
+    });
+    queue = task.catch(() => undefined);
+    return task;
+}
+/** Only the trusted definitions of a project reach the prompt, the client and describe_widget. */
+export async function trustedProjectWidgets(projectId) {
+    if (!projectId)
+        return [];
+    try {
+        const state = await projectWidgetState(projectId);
+        return state.trusted ? state.widgets : [];
+    }
+    catch {
+        return [];
+    }
+}
+function forbiddenDataPath(path) {
+    return path
+        .split(/[\\/]/)
+        .some((segment) => SECRET_NAMES.has(segment.toLowerCase()) ||
+        SECRET_PATTERNS.some((pattern) => pattern.test(segment)));
+}
+async function readDataFile(root, path) {
+    if (forbiddenDataPath(path))
+        throw new Error("Файл данных похож на секрет");
+    const real = await safeProjectFile(root, resolve(root, path));
+    if (forbiddenDataPath(relative(root, real)))
+        throw new Error("Файл данных похож на секрет");
+    const info = await stat(real);
+    if (!info.isFile())
+        throw new Error("Это не файл");
+    if (info.size > DATA_LIMIT)
+        throw new Error("Файл данных больше 1 МБ");
+    return JSON.parse(await readFile(real, "utf8"));
+}
+/** Values of the project-relative JSON files a widget declared, read only while its file is trusted. */
+export async function projectWidgetData(projectId, name) {
+    const state = await projectWidgetState(projectId);
+    if (!state.trusted)
+        throw new Error("Файл виджетов проекта не доверен");
+    const widget = state.widgets.find((item) => item.name === name);
+    if (!widget)
+        throw new Error(`Нет виджета ${name}`);
+    const data = {};
+    const errors = {};
+    for (const [key, path] of Object.entries(widget.data ?? {})) {
+        try {
+            data[key] = await readDataFile(state.path, path);
+        }
+        catch (error) {
+            errors[key] = error instanceof Error ? error.message : "Не удалось прочитать данные";
+        }
+    }
+    return { data, errors };
+}

package/packages/server/modules/projects/discovery.js

@@ -0,0 +1,179 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { findFavicon } from "./favicon.js";
+import { expandPath } from "./inspect.js";
+const SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".output",
+    ".next",
+    ".nuxt",
+    ".vite",
+    "coverage",
+    "venv",
+    ".venv",
+    "target",
+    ".turbo",
+    ".cache",
+]);
+const NESTED_SKIP = new Set([
+    ...SKIP_DIRS,
+    "docs",
+    "doc",
+    "demo",
+    "demos",
+    "examples",
+    "example",
+    "speech",
+    "e2e",
+    "cypress",
+    "tests",
+    "test",
+    "__tests__",
+    "fixtures",
+    "templates",
+    "template",
+    "_template",
+    "vendor",
+]);
+const CONFIG_KIND = [
+    ["vite.config.ts", "vite"],
+    ["vite.config.js", "vite"],
+    ["vite.config.mts", "vite"],
+    ["vite.config.mjs", "vite"],
+    ["nuxt.config.ts", "nuxt"],
+    ["nuxt.config.js", "nuxt"],
+    ["next.config.ts", "next"],
+    ["next.config.js", "next"],
+    ["next.config.mjs", "next"],
+    ["astro.config.mjs", "astro"],
+    ["astro.config.ts", "astro"],
+];
+function detectKind(names, scripts) {
+    for (const [file, kind] of CONFIG_KIND) {
+        if (names.includes(file))
+            return kind;
+    }
+    const blob = `${Object.keys(scripts).join(" ")} ${Object.values(scripts).join(" ")}`;
+    if (/\bnuxt\b/.test(blob))
+        return "nuxt";
+    if (/\bnext\b/.test(blob))
+        return "next";
+    if (/\bastro\b/.test(blob))
+        return "astro";
+    if (/\bvite\b/.test(blob))
+        return "vite";
+    if (names.includes("index.html"))
+        return "vite";
+    if (names.includes("pnpm-workspace.yaml") || names.includes("lerna.json"))
+        return "workspace";
+    return "node";
+}
+function scoreHit(dir, kind, names, scripts, hasIcon) {
+    let score = 0;
+    if (kind === "vite" || kind === "nuxt" || kind === "next" || kind === "astro")
+        score += 50;
+    if (names.includes("index.html"))
+        score += 20;
+    if (scripts.dev || scripts.start)
+        score += 15;
+    if (hasIcon)
+        score += 10;
+    if (dir.includes("/pr/my/"))
+        score += 8;
+    if (dir.includes("/pr/clone/") || dir.includes("/pr/learn/"))
+        score -= 8;
+    if (/tutorial|playground|demo|test-|^vitejs-vite-/.test(basename(dir)))
+        score -= 12;
+    if (kind === "workspace")
+        score -= 40;
+    if (kind === "node" && !scripts.dev && !scripts.start)
+        score -= 20;
+    return score;
+}
+async function analyzeDir(dir, names) {
+    const raw = await readFile(join(dir, "package.json"), "utf8").catch(() => "{}");
+    let pkg = {};
+    try {
+        pkg = JSON.parse(raw);
+    }
+    catch {
+        pkg = {};
+    }
+    const scripts = pkg.scripts ?? {};
+    const kind = detectKind(names, scripts);
+    const icon = await findFavicon(dir);
+    const score = scoreHit(dir, kind, names, scripts, Boolean(icon));
+    return {
+        name: pkg.name || basename(dir),
+        path: dir,
+        kind,
+        score,
+        app: score >= 40 && kind !== "workspace",
+        hasIcon: Boolean(icon),
+        scripts: Object.keys(scripts).filter((key) => ["dev", "start", "preview", "serve"].includes(key)),
+    };
+}
+export async function listDirectory(path) {
+    const root = expandPath(path);
+    const entries = await readdir(root, { withFileTypes: true });
+    const items = await Promise.all(entries
+        .filter((entry) => !entry.name.startsWith(".") && !SKIP_DIRS.has(entry.name))
+        .slice(0, 80)
+        .map(async (entry) => {
+        const full = join(root, entry.name);
+        let hasPackage = false;
+        if (entry.isDirectory()) {
+            const kids = await readdir(full).catch(() => []);
+            hasPackage = kids.includes("package.json");
+        }
+        return {
+            name: entry.name,
+            path: full,
+            type: entry.isDirectory() ? "dir" : "file",
+            hasPackageJson: hasPackage,
+        };
+    }));
+    return { path: root, items };
+}
+export async function findProjects(path, depth = 4) {
+    const root = expandPath(path);
+    const found = [];
+    async function walk(dir, level) {
+        if (found.length >= 80)
+            return;
+        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+        const names = entries.map((item) => item.name);
+        if (names.includes("package.json")) {
+            const hit = await analyzeDir(dir, names);
+            if (hit.app || hit.score >= 30)
+                found.push(hit);
+            if (hit.app)
+                return;
+        }
+        if (level >= depth)
+            return;
+        for (const entry of entries) {
+            if (!entry.isDirectory() || NESTED_SKIP.has(entry.name) || entry.name.startsWith(".")) {
+                continue;
+            }
+            await walk(join(dir, entry.name), level + 1);
+        }
+    }
+    const info = await stat(root).catch(() => null);
+    if (!info?.isDirectory())
+        throw new Error("Папка не найдена");
+    await walk(root, 0);
+    found.sort((a, b) => b.score - a.score);
+    const apps = found.filter((item) => item.app);
+    const picked = (apps.length ? apps : found).slice(0, 16);
+    return {
+        root,
+        hint: "Сразу вызови add_projects со списком path у записей app:true. Не вызывай inspect_path.",
+        count: picked.length,
+        skipped: Math.max(0, found.length - picked.length),
+        projects: picked,
+    };
+}