@ai-projector/ide 0.0.0-stage → 0.11.1

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

@@ -0,0 +1,180 @@
+import { readFile, stat } from "node:fs/promises";
+import { dirname, extname, join, posix, resolve, sep } from "node:path";
+const ICON_FILES = [
+    "public/favicon.svg",
+    "public/favicon.ico",
+    "public/favicon.png",
+    "public/favicon-32x32.png",
+    "public/apple-touch-icon.png",
+    "public/icon.svg",
+    "public/icon.png",
+    "public/logo.svg",
+    "public/logo.png",
+    "public/icons/icon.svg",
+    "public/icons/icon-512.png",
+    "favicon.svg",
+    "favicon.ico",
+    "src/favicon.svg",
+    "src/assets/favicon.svg",
+    "src/assets/favicon.ico",
+    "src/assets/icon.svg",
+    "src/assets/logo.svg",
+    "src/assets/images/favicon.svg",
+    "src/assets/images/logo.svg",
+    "static/favicon.svg",
+    "static/favicon.ico",
+    "client/public/favicon.svg",
+    "client/public/favicon.ico",
+    "app/public/favicon.svg",
+];
+export const HTML_FILES = [
+    "index.html",
+    "public/index.html",
+    "src/index.html",
+    "client/index.html",
+];
+export const ICON_TYPES = {
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+};
+export function isInside(root, file) {
+    const a = resolve(root);
+    const b = resolve(file);
+    return b === a || b.startsWith(`${a}${sep}`);
+}
+async function existsFile(file) {
+    const info = await stat(file).catch(() => null);
+    return Boolean(info?.isFile());
+}
+function resolveHref(projectDir, htmlFile, href) {
+    const trimmed = href.trim();
+    if (!trimmed || trimmed.startsWith("data:") || /^https?:/i.test(trimmed))
+        return [];
+    const clean = trimmed.split("?")[0]?.split("#")[0] ?? trimmed;
+    if (clean.startsWith("/")) {
+        const rel = clean.slice(1);
+        return [
+            join(projectDir, "public", rel),
+            join(projectDir, "static", rel),
+            join(projectDir, rel),
+            join(dirname(htmlFile), rel),
+        ];
+    }
+    return [resolve(dirname(htmlFile), clean), join(projectDir, "public", clean)];
+}
+/** Icon hrefs in document order; the same scan feeds local folders and remote repositories. */
+function iconHrefs(raw) {
+    const links = raw.slice(0, 48_000).match(/<link\b[^>]*>/gi) ?? [];
+    const hrefs = [];
+    for (const tag of links) {
+        const relAttr = /rel=["']([^"']+)["']/i.exec(tag)?.[1]?.toLowerCase() ?? "";
+        if (!relAttr.includes("icon"))
+            continue;
+        const href = /href=["']([^"']+)["']/i.exec(tag)?.[1];
+        if (href)
+            hrefs.push(href);
+    }
+    return hrefs;
+}
+/** Repository-relative targets of an icon link; empty for remote, data and escaping paths. */
+function remoteIconHrefs(htmlPath, href) {
+    const trimmed = href.trim();
+    if (!trimmed ||
+        trimmed.startsWith("data:") ||
+        trimmed.startsWith("//") ||
+        /^https?:/i.test(trimmed))
+        return [];
+    const clean = trimmed.split("?")[0]?.split("#")[0] ?? "";
+    if (!clean || clean.includes("\\") || clean.includes("\0"))
+        return [];
+    const dir = posix.dirname(htmlPath);
+    const paths = clean.startsWith("/")
+        ? [
+            posix.join("public", clean.slice(1)),
+            posix.join("static", clean.slice(1)),
+            clean.slice(1),
+            posix.join(dir, clean.slice(1)),
+        ]
+        : [posix.join(dir, clean), posix.join("public", clean)];
+    return paths.flatMap((path) => {
+        const normalized = posix.normalize(path);
+        return !normalized ||
+            normalized === "." ||
+            normalized === ".." ||
+            normalized.startsWith("../") ||
+            normalized.startsWith("/")
+            ? []
+            : [normalized];
+    });
+}
+/**
+ * Remote twin of `findFavicon`: links from the repository's HTML pages first, then the known
+ * file names. `paths` is the flat list of blobs in the repository at the selected revision.
+ */
+export function remoteIconCandidates(pages, paths) {
+    const candidates = [];
+    const seen = new Set();
+    const push = (path) => {
+        if (!path || seen.has(path) || !paths.has(path))
+            return;
+        seen.add(path);
+        candidates.push(path);
+    };
+    for (const page of pages) {
+        for (const href of iconHrefs(page.content))
+            for (const path of remoteIconHrefs(page.path, href))
+                push(path);
+    }
+    for (const rel of ICON_FILES)
+        push(rel);
+    return candidates;
+}
+async function iconFromHtml(projectDir) {
+    for (const rel of HTML_FILES) {
+        const htmlFile = join(projectDir, rel);
+        const raw = await readFile(htmlFile, "utf8").catch(() => null);
+        if (!raw)
+            continue;
+        for (const href of iconHrefs(raw)) {
+            for (const candidate of resolveHref(projectDir, htmlFile, href)) {
+                if (isInside(projectDir, candidate) && (await existsFile(candidate))) {
+                    return candidate;
+                }
+            }
+        }
+    }
+    return null;
+}
+export async function findFavicon(projectDir) {
+    const dir = resolve(projectDir);
+    const fromHtml = await iconFromHtml(dir);
+    if (fromHtml)
+        return fromHtml;
+    for (const rel of ICON_FILES) {
+        const file = join(dir, rel);
+        if (await existsFile(file))
+            return file;
+    }
+    return null;
+}
+export async function resolveProjectIcon(projectDir, stored) {
+    if (stored) {
+        const file = stored.startsWith("/") ? stored : join(projectDir, stored);
+        if (isInside(projectDir, file) && (await existsFile(file)))
+            return file;
+    }
+    return findFavicon(projectDir);
+}
+export function letterIconSvg(name) {
+    const letter = (name.trim()[0] || "P").toUpperCase();
+    const safe = letter.replace(/[^\p{L}\p{N}]/gu, "P").slice(0, 1) || "P";
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect width="64" height="64" rx="14" fill="#2c2c28"/><text x="32" y="42" text-anchor="middle" font-size="30" fill="#ecece6" font-family="sans-serif">${safe}</text></svg>`;
+}
+export function iconContentType(file) {
+    return ICON_TYPES[extname(file).toLowerCase()] ?? "application/octet-stream";
+}

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

@@ -0,0 +1,11 @@
+export { inspectProject, inspectProjectCommands } from "./inspect.js";
+export { expandPath, sameLocalPath } from "./inspect.js";
+export { findProjects, listDirectory } from "./discovery.js";
+export { loadProjects, findProject } from "./store.js";
+export { updateProjects } from "./store.js";
+export { iconContentType } from "./favicon.js";
+export { letterIconSvg } from "./favicon.js";
+export { resolveProjectIcon } from "./favicon.js";
+export { findFavicon } from "./favicon.js";
+export { HTML_FILES, remoteIconCandidates } from "./favicon.js";
+export { fetchRemoteIcon } from "./remote-icon.js";

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

@@ -0,0 +1,148 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { os } from "../../../core/modules/os/index.js";
+import { basename, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { findFavicon } from "./favicon.js";
+const PREFERRED = ["dev", "start", "preview", "serve"];
+const SKIP = new Set([
+    ...PREFERRED,
+    "build",
+    "lint",
+    "test",
+    "format",
+    "fmt",
+    "check",
+    "typecheck",
+    "prepare",
+    "preinstall",
+    "postinstall",
+]);
+function commandPrefix(pm) {
+    if (pm === "pnpm")
+        return "pnpm";
+    if (pm === "yarn")
+        return "yarn";
+    if (pm === "bun")
+        return "bun run";
+    return "npm run";
+}
+async function detectPm(dir) {
+    const files = await readdir(dir);
+    if (files.includes("pnpm-lock.yaml") || files.includes("pnpm-workspace.yaml")) {
+        return "pnpm";
+    }
+    if (files.includes("bun.lock") || files.includes("bun.lockb"))
+        return "bun";
+    if (files.includes("yarn.lock"))
+        return "yarn";
+    if (files.includes("package-lock.json"))
+        return "npm";
+    return "pnpm";
+}
+function guessUrl(scripts) {
+    const blob = Object.values(scripts).join(" ");
+    if (/\bnext\b/.test(blob))
+        return "http://localhost:3000";
+    if (/\bnuxt\b/.test(blob))
+        return "http://localhost:3000";
+    if (/\bastro\b/.test(blob))
+        return "http://localhost:4321";
+    return "http://localhost:5173";
+}
+function toCommand(name, prefix) {
+    return { id: randomUUID(), name, cmd: `${prefix} ${name}` };
+}
+/** Drive letter case follows `process.cwd()` on Windows; keep it upper so the same folder is one path. */
+function stabilize(path) {
+    return process.platform === "win32" && /^[a-z]:/i.test(path)
+        ? path[0].toUpperCase() + path.slice(1)
+        : path;
+}
+export function expandPath(input) {
+    const trimmed = input.trim();
+    if (trimmed === "~")
+        return stabilize(os.homeDirectory());
+    if (trimmed.startsWith("~/") || trimmed.startsWith("~\\"))
+        return stabilize(resolve(join(os.homeDirectory(), trimmed.slice(2))));
+    return stabilize(resolve(trimmed));
+}
+/**
+ * Whether two local paths name the same folder. On Windows the filesystem is case-insensitive, so
+ * `C:\Work` and `c:\work` must match; a strict `===` after `expandPath` creates a second project
+ * id and the Projector agent looks like it lost its chat history.
+ */
+export function sameLocalPath(left, right) {
+    const a = expandPath(left);
+    const b = expandPath(right);
+    return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+/** Read script definitions without executing them or replacing project settings. */
+export async function inspectProjectCommands(dir) {
+    const path = expandPath(dir);
+    const info = await stat(path).catch(() => null);
+    if (!info?.isDirectory())
+        throw new Error("Папка не найдена");
+    const raw = await readFile(resolve(path, "package.json"), "utf8").catch(() => null);
+    if (!raw)
+        return [];
+    const pkg = JSON.parse(raw);
+    const scripts = pkg.scripts ?? {};
+    const prefix = commandPrefix(await detectPm(path));
+    const names = [
+        ...PREFERRED.filter((name) => name in scripts),
+        ...Object.keys(scripts).filter((name) => !PREFERRED.includes(name)),
+    ];
+    return names
+        .filter((name) => typeof scripts[name] === "string" && scripts[name].trim())
+        .map((name) => toCommand(name, prefix));
+}
+export async function inspectProject(dir, allowDirectory = false) {
+    const path = expandPath(dir);
+    const info = await stat(path).catch(() => null);
+    if (!info?.isDirectory()) {
+        throw new Error("Папка не найдена");
+    }
+    const raw = await readFile(resolve(path, "package.json"), "utf8").catch(() => null);
+    if (!raw) {
+        if (allowDirectory) {
+            const command = { id: randomUUID(), name: "shell", cmd: "bash" };
+            return {
+                name: basename(path) || path,
+                path,
+                url: "",
+                icon: "",
+                mode: "server",
+                defaultCommandId: command.id,
+                commands: [command],
+            };
+        }
+        throw new Error("В папке нет package.json");
+    }
+    const pkg = JSON.parse(raw);
+    const scripts = pkg.scripts ?? {};
+    const pm = await detectPm(path);
+    const prefix = commandPrefix(pm);
+    const commands = [];
+    for (const key of PREFERRED) {
+        if (scripts[key])
+            commands.push(toCommand(key, prefix));
+    }
+    for (const key of Object.keys(scripts)) {
+        if (SKIP.has(key) || key.startsWith("pre") || key.startsWith("post"))
+            continue;
+        commands.push(toCommand(key, prefix));
+    }
+    if (commands.length === 0) {
+        commands.push(toCommand("dev", prefix));
+    }
+    const icon = (await findFavicon(path)) ?? "";
+    return {
+        name: pkg.name || basename(path),
+        path,
+        url: guessUrl(scripts),
+        icon,
+        mode: "server",
+        defaultCommandId: commands[0].id,
+        commands,
+    };
+}

package/packages/server/modules/projects/remote-icon.js

@@ -0,0 +1,39 @@
+const ICON_LIMIT = 2 * 1024 * 1024;
+/**
+ * Bytes of a project avatar/logo hosted by GitHub or GitLab. The URL comes from the host API, but
+ * redirects and non-image responses are rejected so it cannot become a generic proxy.
+ */
+export async function fetchRemoteIcon(url) {
+    if (!url)
+        return null;
+    let target;
+    try {
+        target = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    if (target.protocol !== "https:" && target.protocol !== "http:")
+        return null;
+    let response;
+    try {
+        response = await fetch(target, {
+            redirect: "error",
+            signal: AbortSignal.timeout(15_000),
+            headers: { "User-Agent": "Projector" },
+        });
+    }
+    catch {
+        return null;
+    }
+    if (!response.ok)
+        return null;
+    const declared = Number(response.headers.get("content-length") || 0);
+    if (declared > ICON_LIMIT)
+        return null;
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (!bytes.length || bytes.length > ICON_LIMIT)
+        return null;
+    const mime = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() || "";
+    return mime.startsWith("image/") ? { mime, bytes } : null;
+}

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

@@ -0,0 +1,41 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { dirname, join } from "node:path";
+function storePath() {
+    return join(dataDir(), "projects.json");
+}
+export async function loadProjects(strict = false) {
+    try {
+        const raw = await readFile(storePath(), "utf8");
+        const parsed = JSON.parse(raw);
+        return (parsed.projects ?? []).map((item) => ({
+            ...item,
+            icon: item.icon ?? "",
+        }));
+    }
+    catch (error) {
+        if (strict && error.code !== "ENOENT")
+            throw error;
+        return [];
+    }
+}
+export async function saveProjects(projects) {
+    const file = storePath();
+    await mkdir(dirname(file), { recursive: true });
+    const tmp = `${file}.tmp`;
+    await writeFile(tmp, `${JSON.stringify({ projects }, null, 2)}\n`, "utf8");
+    await rename(tmp, file);
+}
+let projectWrites = Promise.resolve();
+export async function updateProjects(update) {
+    const operation = projectWrites.then(async () => {
+        const projects = await loadProjects();
+        update(projects);
+        await saveProjects(projects);
+    });
+    projectWrites = operation.catch(() => { });
+    await operation;
+}
+export async function findProject(id) {
+    return (await loadProjects()).find((item) => item.id === id);
+}

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

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

package/packages/server/modules/providers/atomic-file.js

@@ -0,0 +1,29 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, open, rename, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+/** Written in full and flushed to disk before the rename replaces the previous file. */
+export async function writeFileAtomic(file, text) {
+    await mkdir(dirname(file), { recursive: true });
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        const handle = await open(temporary, "w", 0o600);
+        try {
+            await handle.writeFile(text, "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temporary, file);
+    }
+    catch (error) {
+        await rm(temporary, { force: true });
+        throw error;
+    }
+}
+/** Moves a damaged file out of the way so that defaults written next never overwrite it. */
+export async function setAsideBroken(file) {
+    const backup = `${file}.broken-${Date.now()}`;
+    await rename(file, backup).catch(() => { });
+    return backup;
+}

package/packages/server/modules/providers/balance.js

@@ -0,0 +1,125 @@
+import { createHash } from "node:crypto";
+import { HttpError } from "../http/index.js";
+import { normalizeOpenAiBaseUrl } from "./openai-client.js";
+import { resolveOpenAIProvider } from "./provider-store.js";
+const READY_TTL_MS = 60000;
+const FAILED_TTL_MS = 15000;
+const globalState = globalThis;
+const cache = (globalState.projectorProviderBalance ??= new Map());
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
+const amount = (value) => typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value))
+    ? value.trim()
+    : null;
+/** DeepSeek `GET /user/balance`: amounts are decimal strings, one entry per currency. */
+export function deepseekEntries(payload) {
+    const infos = record(payload)?.balance_infos;
+    if (!Array.isArray(infos))
+        return null;
+    const entries = [];
+    for (const item of infos) {
+        const info = record(item);
+        const total = amount(info?.total_balance);
+        const granted = amount(info?.granted_balance);
+        const toppedUp = amount(info?.topped_up_balance);
+        if (typeof info?.currency !== "string" || !info.currency || !total || !granted || !toppedUp)
+            return null;
+        entries.push({ currency: info.currency, total, granted, toppedUp });
+    }
+    return entries;
+}
+function unavailable(message) {
+    return { status: "unavailable", entries: [], available: null, checkedAt: Date.now(), message };
+}
+async function readDeepseek(provider) {
+    if (!provider.apiKey)
+        return unavailable("Нет ключа API");
+    // The balance lives next to the chat API, so the key only goes where it already goes.
+    const endpoint = `${new URL(normalizeOpenAiBaseUrl(provider.url)).origin}/user/balance`;
+    let response;
+    try {
+        response = await fetch(endpoint, {
+            headers: { Authorization: `Bearer ${provider.apiKey}`, Accept: "application/json" },
+            signal: AbortSignal.timeout(10000),
+            redirect: "error",
+        });
+    }
+    catch {
+        return unavailable("Не удалось получить баланс DeepSeek");
+    }
+    if (!response.ok) {
+        await response.body?.cancel();
+        if (response.status === 401)
+            return unavailable("DeepSeek отклонил ключ API");
+        return unavailable(`DeepSeek: ошибка HTTP ${response.status}`);
+    }
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch {
+        return unavailable("Некорректный ответ DeepSeek");
+    }
+    const entries = deepseekEntries(payload);
+    if (!entries)
+        return unavailable("Некорректный ответ DeepSeek");
+    const flag = record(payload)?.is_available;
+    return {
+        status: "ready",
+        entries,
+        available: typeof flag === "boolean" ? flag : null,
+        checkedAt: Date.now(),
+        message: null,
+    };
+}
+function load(provider) {
+    if (provider.kind === "deepseek")
+        return readDeepseek(provider);
+    const message = provider.kind === "qwencloud"
+        ? "Qwen Cloud не отдаёт баланс по ключу API"
+        : provider.kind === "local"
+            ? "Локальному провайдеру баланс не нужен"
+            : "Для этого провайдера баланс недоступен";
+    return Promise.resolve({
+        status: "unsupported",
+        entries: [],
+        available: null,
+        checkedAt: Date.now(),
+        message,
+    });
+}
+/** Balance of the given (default: active) provider; one upstream call per minute and key. */
+export async function providerBalance(providerId) {
+    const provider = await resolveOpenAIProvider({ providerId }).catch((error) => {
+        if (error instanceof HttpError)
+            return null;
+        throw error;
+    });
+    if (!provider)
+        return unavailable("Провайдер не настроен");
+    /** The route and the analytics store need to know whose money this is. */
+    const decorate = (value) => ({
+        ...value,
+        providerId: provider.id,
+        providerName: provider.name,
+    });
+    const key = createHash("sha256")
+        .update(`${provider.id}\n${provider.kind}\n${provider.url}\n${provider.apiKey}`)
+        .digest("hex");
+    const entry = cache.get(key) ?? {};
+    if (!cache.has(key) && cache.size >= 32)
+        cache.delete(cache.keys().next().value);
+    cache.set(key, entry);
+    if (entry.pending)
+        return entry.pending;
+    const ttl = entry.value?.status === "ready" ? READY_TTL_MS : FAILED_TTL_MS;
+    if (entry.value && Date.now() < entry.value.checkedAt + ttl)
+        return entry.value;
+    entry.pending = load(provider)
+        .then((value) => (entry.value = decorate(value)))
+        .finally(() => {
+        entry.pending = undefined;
+    });
+    return entry.pending;
+}

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

@@ -0,0 +1,15 @@
+export { envFallbackFromProcess } from "./provider-store.js";
+export { loadPublicProviders } from "./provider-store.js";
+export { saveProviders } from "./provider-store.js";
+export { setActiveProvider } from "./provider-store.js";
+export { resolveOpenAIProvider } from "./provider-store.js";
+export { loadStoredProviders } from "./provider-store.js";
+export { assertKeyStore, useProviderVault } from "./provider-store.js";
+export { listProviderModels } from "./model-list.js";
+export { pickModel } from "./models.js";
+export { providerBalance } from "./balance.js";
+export { inferProviderKind } from "./kinds.js";
+export { defaultThinkingStyle, isThinkingStyle, quietThinkingBody, THINKING_STYLES, thinkingBody, thinkingLevel, thinkingOptions, } from "./thinking.js";
+export { createQwenOpenAI, normalizeOpenAiBaseUrl } from "./openai-client.js";
+export { quietChatModel } from "./quiet-model.js";
+export { writeFileAtomic } from "./atomic-file.js";

package/packages/server/modules/providers/kinds.js

@@ -0,0 +1,24 @@
+const KINDS = ["custom", "local", "deepseek", "qwencloud"];
+export function isProviderKind(value) {
+    return typeof value === "string" && KINDS.includes(value);
+}
+const LOCAL_HOST = /^(localhost|127\.\d+\.\d+\.\d+|\[::1\]|10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+|172\.(1[6-9]|2\d|3[01])\.\d+\.\d+|[^.]+\.local)$/i;
+/** Kind of a provider saved before kinds existed, guessed from its URL. */
+export function inferProviderKind(url) {
+    const value = url.trim().toLowerCase();
+    if (!value)
+        return "custom";
+    if (value.includes("deepseek.com"))
+        return "deepseek";
+    if (value.includes("dashscope") || value.includes("aliyuncs.com") || value.includes("qwencloud"))
+        return "qwencloud";
+    try {
+        const host = new URL(/^https?:\/\//.test(value) ? value : `http://${value}`).hostname;
+        if (LOCAL_HOST.test(host))
+            return "local";
+    }
+    catch {
+        // An unparsable URL is just a custom provider.
+    }
+    return "custom";
+}

package/packages/server/modules/providers/model-list.js

@@ -0,0 +1,16 @@
+import { loadStoredProviders, resolveOpenAIProvider, envFallbackFromProcess, } from "./provider-store.js";
+import { fetchRemoteModels } from "./models.js";
+/**
+ * Models a provider offers upstream. A draft may bring its own address and key; the stored key is
+ * used only for a provider that is already saved, never for an unknown id.
+ */
+export async function listProviderModels(input) {
+    const fallback = envFallbackFromProcess();
+    const stored = await loadStoredProviders(fallback);
+    const known = stored.providers.find((item) => item.id === input.id);
+    const url = input.url?.trim() || known?.url || "";
+    const typed = input.apiKey?.trim() ?? "";
+    const apiKey = typed ||
+        (known ? (await resolveOpenAIProvider({ providerId: known.id, fallback })).apiKey : "");
+    return fetchRemoteModels(url, apiKey);
+}