@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/agents-integration/opencode/client.js

@@ -0,0 +1,30 @@
+import { readOpenCodeGoKey } from "./credentials.js";
+/** Fixed official destination, bounded request, no upstream body in errors. */
+export async function readGoUsage(timeoutMs = 10000) {
+    const key = await readOpenCodeGoKey();
+    let response;
+    try {
+        response = await fetch("https://opencode.ai/zen/go/v1/usage", {
+            headers: { Authorization: `Bearer ${key}`, Accept: "application/json" },
+            signal: AbortSignal.timeout(timeoutMs),
+            redirect: "error",
+        });
+    }
+    catch {
+        throw new Error("Не удалось получить лимиты OpenCode Go");
+    }
+    if (!response.ok) {
+        await response.body?.cancel();
+        if (response.status === 401)
+            throw new Error("Авторизация OpenCode Go истекла; выполните opencode auth login");
+        if (response.status === 403)
+            throw new Error("Подписка OpenCode Go недоступна");
+        throw new Error(`OpenCode Go: ошибка HTTP ${response.status}`);
+    }
+    try {
+        return await response.json();
+    }
+    catch {
+        throw new Error("Некорректный ответ OpenCode Go");
+    }
+}

package/packages/server/modules/agents-integration/opencode/credentials.js

@@ -0,0 +1,36 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { os } from "../../../../core/modules/os/index.js";
+const UNAVAILABLE = "Авторизация OpenCode недоступна; выполните opencode auth login";
+const NOT_CONNECTED = "OpenCode Go не подключён; выполните opencode auth login";
+const candidates = () => [
+    join(os.dataHome(), "opencode", "auth.json"),
+    join(os.homeDirectory(), ".local", "share", "opencode", "auth.json"),
+];
+/** The data directory and the legacy home path are both checked; the first readable one wins. */
+async function readFirstReadable() {
+    for (const path of candidates()) {
+        try {
+            return await readFile(path, "utf8");
+        }
+        catch {
+            /* Try the next location. */
+        }
+    }
+    throw new Error(UNAVAILABLE);
+}
+/** Use OpenCode's existing Go credentials; never write or publish the auth file. */
+export async function readOpenCodeGoKey() {
+    let auth;
+    try {
+        auth = JSON.parse(process.env.OPENCODE_AUTH_CONTENT ?? (await readFirstReadable()));
+    }
+    catch {
+        throw new Error(UNAVAILABLE);
+    }
+    const entry = auth && typeof auth === "object" ? auth["opencode-go"] : null;
+    const key = entry && typeof entry === "object" ? entry.key : null;
+    if (typeof key !== "string" || !key.trim())
+        throw new Error(NOT_CONNECTED);
+    return key;
+}

package/packages/server/modules/agents-integration/opencode/index.js

@@ -0,0 +1 @@
+export { openCodeUsage } from "./usage.js";

package/packages/server/modules/agents-integration/opencode/usage.js

@@ -0,0 +1,47 @@
+import { createUsageCache } from "../_/usage-cache.js";
+import { readGoUsage } from "./client.js";
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
+export function goWindows(payload) {
+    const usage = record(record(payload)?.usage);
+    function window(name) {
+        const value = record(usage?.[name]);
+        const percent = value?.percent;
+        if (typeof percent !== "number" || !Number.isFinite(percent) || percent < 0 || percent > 100)
+            return null;
+        if (value?.status !== "ok" && value?.status !== "rate-limited")
+            return null;
+        const reset = typeof value.resetsAt === "string" ? Date.parse(value.resetsAt) : NaN;
+        const limited = value.status === "rate-limited";
+        return {
+            usedPercent: limited ? 100 : percent,
+            resetsAt: Number.isFinite(reset) && reset > 0 ? Math.floor(reset / 1000) : null,
+            limited,
+        };
+    }
+    const rolling = window("rolling"), weekly = window("weekly"), monthly = window("monthly");
+    return rolling && weekly && monthly ? { rolling, weekly, monthly } : null;
+}
+const globalState = globalThis;
+const state = (globalState.projectorOpenCodeUsage ??= {});
+/** One poll for all windows, including during HMR; credentials stay on the server. */
+export const openCodeUsage = createUsageCache(state, async () => {
+    try {
+        const windows = goWindows(await readGoUsage());
+        return {
+            status: windows ? "ready" : "unavailable",
+            windows,
+            checkedAt: Date.now(),
+            message: windows ? null : "Лимиты OpenCode Go недоступны",
+        };
+    }
+    catch (error) {
+        return {
+            status: "unavailable",
+            windows: null,
+            checkedAt: Date.now(),
+            message: error instanceof Error ? error.message : "OpenCode Go недоступен",
+        };
+    }
+});

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

@@ -0,0 +1,38 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { appearanceFile, defaultAppearance, isAppearanceChoice, } from "../../../core/modules/appearance/index.js";
+const appearancePath = () => join(dataDir(), appearanceFile);
+let pending = Promise.resolve();
+export async function readAppearanceChoice() {
+    try {
+        const data = JSON.parse(await readFile(appearancePath(), "utf8"));
+        return isAppearanceChoice(data?.choice) ? data.choice : defaultAppearance;
+    }
+    catch {
+        // Appearance is cosmetic: a missing, damaged or unreadable file must not block the app.
+        return defaultAppearance;
+    }
+}
+export async function writeAppearanceChoice(value) {
+    if (!isAppearanceChoice(value))
+        throw new Error("Неизвестная цветовая схема");
+    const task = pending.then(async () => {
+        await mkdir(dataDir(), { recursive: true });
+        const file = appearancePath();
+        const temporary = `${file}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(temporary, JSON.stringify({ choice: value }, null, 2) + "\n", {
+                mode: 0o600,
+            });
+            await rename(temporary, file);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+        return { choice: value };
+    });
+    pending = task.catch(() => undefined);
+    return task;
+}

package/packages/server/modules/browser/cookies.js

@@ -0,0 +1,112 @@
+import { getDomain } from "tldts";
+const MAX_COOKIES = 3000;
+const MAX_SIZE = 4096;
+const store = globalThis;
+const jar = (store.projectorBrowserJar ??= []);
+const domainMatches = (host, domain) => host === domain || host.endsWith(`.${domain}`);
+const defaultPath = (path) => {
+    const end = path.lastIndexOf("/");
+    return end > 0 ? path.slice(0, end) : "/";
+};
+const pathMatches = (path, cookie) => path === cookie ||
+    (path.startsWith(cookie) && (cookie.endsWith("/") || path[cookie.length] === "/"));
+/** Принимает заголовок Set-Cookie ответа на запрос `url`. */
+export function storeCookie(header, url, now = Date.now()) {
+    if (header.length > MAX_SIZE)
+        return;
+    const [pair, ...attributes] = header.split(";");
+    const separator = pair.indexOf("=");
+    if (separator < 1)
+        return;
+    const cookie = {
+        name: pair.slice(0, separator).trim(),
+        value: pair.slice(separator + 1).trim(),
+        domain: url.hostname,
+        hostOnly: true,
+        path: defaultPath(url.pathname),
+        secure: false,
+        sameSite: "lax",
+    };
+    let maxAge;
+    for (const attribute of attributes) {
+        const [rawName = "", ...rest] = attribute.split("=");
+        const name = rawName.trim().toLowerCase();
+        const value = rest.join("=").trim();
+        if (name === "domain" && value) {
+            const domain = value.replace(/^\./, "").toLowerCase();
+            if (!domainMatches(url.hostname, domain))
+                return;
+            if (!getDomain(domain, { allowPrivateDomains: true })) {
+                // Публичный суффикс или IP: Domain допустим только как сам хост и остаётся host-only.
+                if (url.hostname !== domain || !domain.includes("."))
+                    return;
+            }
+            else {
+                cookie.domain = domain;
+                cookie.hostOnly = false;
+            }
+        }
+        else if (name === "path" && value.startsWith("/"))
+            cookie.path = value;
+        else if (name === "secure")
+            cookie.secure = true;
+        else if (name === "samesite") {
+            const mode = value.toLowerCase();
+            if (mode === "none" || mode === "strict" || mode === "lax")
+                cookie.sameSite = mode;
+        }
+        else if (name === "max-age" && /^-?\d+$/.test(value))
+            maxAge = Number(value);
+        else if (name === "expires") {
+            const time = Date.parse(value);
+            if (Number.isFinite(time))
+                cookie.expires = time;
+        }
+    }
+    if (maxAge !== undefined)
+        cookie.expires = now + maxAge * 1000;
+    if (cookie.secure && url.protocol !== "https:")
+        return;
+    const index = jar.findIndex((item) => item.name === cookie.name && item.domain === cookie.domain && item.path === cookie.path);
+    if (index !== -1)
+        jar.splice(index, 1);
+    if (cookie.expires !== undefined && cookie.expires <= now)
+        return;
+    jar.push(cookie);
+    if (jar.length > MAX_COOKIES)
+        jar.shift();
+}
+/** Заголовок Cookie для запроса `url`; просроченные cookies удаляются. */
+export function cookieHeader(url, request, now = Date.now()) {
+    for (let index = jar.length - 1; index >= 0; index--) {
+        const expires = jar[index].expires;
+        if (expires !== undefined && expires <= now)
+            jar.splice(index, 1);
+    }
+    return jar
+        .filter((cookie) => {
+        if (cookie.secure && url.protocol !== "https:")
+            return false;
+        if (cookie.hostOnly
+            ? url.hostname !== cookie.domain
+            : !domainMatches(url.hostname, cookie.domain))
+            return false;
+        if (!pathMatches(url.pathname, cookie.path))
+            return false;
+        if (cookie.sameSite === "none" || request.sameSite)
+            return true;
+        return cookie.sameSite === "lax" && request.navigation;
+    })
+        .sort((a, b) => b.path.length - a.path.length)
+        .map((cookie) => `${cookie.name}=${cookie.value}`)
+        .join("; ");
+}
+/** Грубая граница «сайта»: последние две метки имени (три для `co.uk`-подобных). */
+export function siteOf(hostname) {
+    const labels = hostname.toLowerCase().split(".");
+    const wide = labels.length > 2 && labels.at(-1).length === 2 && labels.at(-2).length <= 3;
+    return labels.slice(wide ? -3 : -2).join(".");
+}
+export function clearCookies() {
+    jar.length = 0;
+}

package/packages/server/modules/browser/guard.js

@@ -0,0 +1,55 @@
+import { lookup } from "node:dns";
+import { BlockList, isIP } from "node:net";
+/** Адреса машины и локальной сети: прокси их не открывает, чтобы страница из интернета не ходила во внутренние сервисы. */
+const internal = new BlockList();
+for (const [net, prefix] of [
+    ["0.0.0.0", 8],
+    ["10.0.0.0", 8],
+    ["100.64.0.0", 10],
+    ["127.0.0.0", 8],
+    ["169.254.0.0", 16],
+    ["172.16.0.0", 12],
+    ["192.0.0.0", 24],
+    ["192.168.0.0", 16],
+    ["198.18.0.0", 15],
+    ["224.0.0.0", 3],
+])
+    internal.addSubnet(net, prefix, "ipv4");
+for (const [net, prefix] of [
+    ["::", 128],
+    ["::1", 128],
+    ["fc00::", 7],
+    ["fe80::", 10],
+    ["ff00::", 8],
+])
+    internal.addSubnet(net, prefix, "ipv6");
+export function isInternalAddress(address) {
+    const mapped = address.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
+    const value = mapped?.[1] ?? address;
+    const family = isIP(value);
+    return !family || internal.check(value, family === 6 ? "ipv6" : "ipv4");
+}
+/** Для адреса-литерала Node не вызывает `lookup`, поэтому он проверяется отдельно. */
+export function isInternalLiteral(hostname) {
+    const literal = hostname.replace(/^\[|\]$/g, "");
+    return !!isIP(literal) && isInternalAddress(literal);
+}
+export const INTERNAL_MESSAGE = "Прокси не открывает адреса локальной сети";
+/**
+ * DNS-разрешение с проверкой: сокет подключается к тому же адресу, который проверен,
+ * поэтому DNS rebinding не обходит запрет.
+ */
+export const guardedLookup = ((hostname, options, callback) => {
+    const done = (typeof options === "function" ? options : callback);
+    const all = typeof options === "object" && !!options && options.all;
+    lookup(hostname, { all: true }, (error, addresses) => {
+        if (error)
+            return done(error);
+        const allowed = addresses.filter((item) => !isInternalAddress(item.address));
+        if (!allowed.length)
+            return done(new Error(INTERNAL_MESSAGE));
+        if (all)
+            return done(null, allowed);
+        done(null, allowed[0].address, allowed[0].family);
+    });
+});

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

@@ -0,0 +1,2 @@
+export { handleProxyHost, isProxyHost } from "./proxy.js";
+export { proxyKey } from "./key.js";

package/packages/server/modules/browser/key.js

@@ -0,0 +1,34 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+const store = globalThis;
+/**
+ * Секрет в имени хоста прокси. Его знает только интерфейс Projector (он получает ключ через
+ * проверенный API), поэтому чужая страница не может обратиться к `*.proxy.localhost` и
+ * воспользоваться cookies прокси. Хранится на диске, чтобы localStorage сайтов переживал restart.
+ */
+export function proxyKey() {
+    if (store.projectorBrowserKey)
+        return store.projectorBrowserKey;
+    const path = join(dataDir(), "browser-proxy-key");
+    let key = "";
+    try {
+        key = readFileSync(path, "utf8").trim();
+    }
+    catch {
+        // The key is created below on first use.
+    }
+    if (!/^[0-9a-f]{16}$/.test(key)) {
+        key = randomBytes(8).toString("hex");
+        mkdirSync(dataDir(), { recursive: true });
+        writeFileSync(path, key, { mode: 0o600 });
+        try {
+            chmodSync(path, 0o600);
+        }
+        catch {
+            // Best effort on platforms without POSIX modes.
+        }
+    }
+    return (store.projectorBrowserKey = key);
+}

package/packages/server/modules/browser/proxy.js

@@ -0,0 +1,255 @@
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { fromProxyUrl, parseProxyHost, proxyUrl, } from "../../../core/modules/browser/index.js";
+import { isLocalRequest } from "../access/index.js";
+import { INTERNAL_MESSAGE, guardedLookup, isInternalLiteral } from "./guard.js";
+import { cookieHeader, siteOf, storeCookie } from "./cookies.js";
+import { proxyKey } from "./key.js";
+import { rewriteCss, rewriteHtml } from "./rewrite.js";
+const MAX_REWRITE = 20 * 1024 * 1024;
+const REQUEST_TIMEOUT = 30_000;
+const METHODS = new Set(["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]);
+/** Заголовки запроса, которые переходят к сайту как есть. Cookie, Origin и Referer собираются отдельно. */
+const FORWARDED = [
+    "accept",
+    "accept-language",
+    "user-agent",
+    "range",
+    "if-range",
+    "if-none-match",
+    "if-modified-since",
+    "content-type",
+    "content-length",
+    "authorization",
+    "cache-control",
+    "pragma",
+    "x-requested-with",
+    "access-control-request-method",
+    "access-control-request-headers",
+];
+/** Заголовки ответа, которые запрещали бы встраивание, привязывали к настоящему origin или ломают переписанное тело. */
+const DROPPED = new Set([
+    "x-frame-options",
+    "content-security-policy",
+    "content-security-policy-report-only",
+    "cross-origin-opener-policy",
+    "cross-origin-embedder-policy",
+    "cross-origin-resource-policy",
+    "set-cookie",
+    "set-cookie2",
+    "strict-transport-security",
+    "content-encoding",
+    "transfer-encoding",
+    "connection",
+    "keep-alive",
+    "location",
+    "content-location",
+    "link",
+    "report-to",
+    "nel",
+    "alt-svc",
+    "public-key-pins",
+    "clear-site-data",
+    "origin-agent-cluster",
+    "permissions-policy",
+]);
+class ProxyError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+function fail(res, status, message) {
+    if (res.headersSent)
+        return res.destroy();
+    res.writeHead(status, {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": "no-store",
+    });
+    res.end(message);
+}
+/** Настоящий origin, который сайт должен увидеть вместо origin прокси; `undefined`, если это не страница прокси. */
+function realOrigin(value) {
+    if (!value)
+        return;
+    try {
+        const host = parseProxyHost(new URL(value).host);
+        return host?.origin;
+    }
+    catch {
+        return;
+    }
+}
+function charsetOf(type, head) {
+    const label = type.match(/charset\s*=\s*["']?([\w:.-]+)/i)?.[1] ??
+        (type.startsWith("text/html")
+            ? head
+                .subarray(0, 2048)
+                .toString("latin1")
+                .match(/<meta[^>]+charset\s*=\s*["']?([\w:.-]+)/i)?.[1]
+            : undefined);
+    try {
+        return new TextDecoder(label ?? "utf-8").encoding;
+    }
+    catch {
+        return "utf-8";
+    }
+}
+function readLimited(response) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        response.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > MAX_REWRITE) {
+                response.destroy();
+                reject(new ProxyError(413, "Страница слишком большая для просмотра"));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        response.on("end", () => resolve(Buffer.concat(chunks)));
+        response.on("error", reject);
+    });
+}
+/** Заголовки запроса к сайту: Origin и Referer возвращаются к настоящим адресам, cookies берутся из jar. */
+function upstreamHeaders(req, target) {
+    const headers = { "accept-encoding": "identity" };
+    for (const name of FORWARDED) {
+        const value = req.headers[name];
+        if (typeof value === "string")
+            headers[name] = value;
+    }
+    const origin = realOrigin(req.headers.origin);
+    if (origin)
+        headers.origin = origin;
+    const referer = typeof req.headers.referer === "string" ? fromProxyUrl(req.headers.referer) : undefined;
+    if (referer)
+        headers.referer = referer;
+    const initiator = origin ?? (referer ? new URL(referer).origin : undefined);
+    const sameSite = !initiator || siteOf(new URL(initiator).hostname) === siteOf(target.hostname);
+    const navigation = req.headers["sec-fetch-mode"] === "navigate" && req.method === "GET";
+    const cookie = cookieHeader(target, { navigation, sameSite });
+    if (cookie)
+        headers.cookie = cookie;
+    return headers;
+}
+function responseHeaders(upstream, target, host) {
+    const out = {};
+    for (const [name, value] of Object.entries(upstream.headers)) {
+        if (DROPPED.has(name) || value === undefined)
+            continue;
+        if (name === "access-control-allow-origin") {
+            let mapped = value;
+            if (mapped !== "*" && mapped !== "null")
+                mapped = (proxyUrl(mapped, host.suffix) ?? mapped).replace(/\/$/, "");
+            out[name] = mapped;
+            continue;
+        }
+        out[name] = Array.isArray(value) ? value.join(", ") : value;
+    }
+    const location = upstream.headers.location;
+    if (location) {
+        try {
+            const next = new URL(location, target);
+            out.location = proxyUrl(next, host.suffix) ?? location;
+        }
+        catch {
+            out.location = location;
+        }
+    }
+    for (const header of upstream.headers["set-cookie"] ?? [])
+        storeCookie(header, target);
+    return out;
+}
+async function serve(req, res, host) {
+    if (!isLocalRequest(req))
+        throw new ProxyError(403, "Прокси доступен только на этом компьютере");
+    if (host.nonce !== proxyKey())
+        throw new ProxyError(404, "Не найдено");
+    const method = req.method ?? "GET";
+    if (!METHODS.has(method))
+        throw new ProxyError(405, "Метод не поддерживается");
+    if (!req.url?.startsWith("/") || req.url.startsWith("//"))
+        throw new ProxyError(400, "Некорректный адрес");
+    const target = new URL(req.url, host.origin);
+    if (target.origin !== host.origin)
+        throw new ProxyError(400, "Некорректный адрес");
+    if (isInternalLiteral(target.hostname))
+        throw new ProxyError(403, INTERNAL_MESSAGE);
+    const context = { page: target, suffix: host.suffix };
+    const send = target.protocol === "https:" ? httpsRequest : httpRequest;
+    const upstream = await new Promise((resolve, reject) => {
+        const outgoing = send(target, {
+            method,
+            headers: upstreamHeaders(req, target),
+            lookup: guardedLookup,
+            timeout: REQUEST_TIMEOUT,
+        }, resolve);
+        outgoing.on("timeout", () => outgoing.destroy(new ProxyError(504, "Сайт не отвечает")));
+        outgoing.on("error", (error) => reject(error instanceof ProxyError
+            ? error
+            : new ProxyError(error.message === INTERNAL_MESSAGE ? 403 : 502, error.message === INTERNAL_MESSAGE
+                ? INTERNAL_MESSAGE
+                : `Не удалось открыть сайт: ${error.message}`)));
+        res.on("close", () => outgoing.destroy());
+        if (method === "GET" || method === "HEAD")
+            outgoing.end();
+        else
+            req.pipe(outgoing);
+    });
+    const status = upstream.statusCode ?? 502;
+    const headers = responseHeaders(upstream, target, host);
+    const type = (upstream.headers["content-type"] ?? "").toLowerCase();
+    const rewrite = method !== "HEAD" &&
+        status !== 204 &&
+        status !== 304 &&
+        (type.startsWith("text/html") || type.startsWith("text/css"));
+    if (!rewrite) {
+        if (upstream.headers["content-length"])
+            headers["content-length"] = upstream.headers["content-length"];
+        res.writeHead(status, headers);
+        if (method === "HEAD") {
+            upstream.resume();
+            res.end();
+            return;
+        }
+        upstream.pipe(res);
+        upstream.on("error", () => res.destroy());
+        return;
+    }
+    const raw = await readLimited(upstream);
+    const text = new TextDecoder(charsetOf(type, raw)).decode(raw);
+    const html = type.startsWith("text/html");
+    const body = Buffer.from(html ? rewriteHtml(text, context) : rewriteCss(text, context), "utf8");
+    delete headers.etag;
+    delete headers["last-modified"];
+    headers["content-type"] = `${type.split(";")[0]}; charset=utf-8`;
+    headers["content-length"] = String(body.length);
+    headers["cache-control"] = "no-store";
+    res.writeHead(status, headers);
+    res.end(body);
+}
+/**
+ * Запрос к origin прокси (`<хост>.<тег>.<nonce>.proxy.localhost`). Выполняется до общей проверки
+ * доступа: Host такого запроса не доверенный, поэтому обработчик сам требует loopback-клиента и nonce.
+ * Возвращает `false`, если запрос не к прокси.
+ */
+export async function handleProxyHost(req, res) {
+    const host = parseProxyHost(req.headers.host ?? "");
+    if (!host)
+        return false;
+    try {
+        await serve(req, res, host);
+    }
+    catch (error) {
+        if (error instanceof ProxyError)
+            fail(res, error.status, error.message);
+        else
+            fail(res, 500, "Ошибка прокси");
+    }
+    return true;
+}
+/** Запрос адресован origin прокси (по заголовку Host). */
+export const isProxyHost = (req) => !!parseProxyHost(req.headers.host ?? "");