@deksden-com/dd-console 0.0.0-stage → 0.2.0

package/dist/server.js

@@ -0,0 +1,341 @@
+import { createServer } from "node:http";
+import { readFile, stat, writeFile, rename, rm } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { acquireServerLock, loadSources, consoleHome } from "./sources.js";
+import { ReaderCache } from "./cache.js";
+import { ReaderPool } from "./reader-pool.js";
+import { derivedSource } from "./readers.js";
+import { id, now } from "./util.js";
+import { openWithin } from "./safe-files.js";
+const webRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), "web");
+const loadBuildInfo = async () => {
+    const value = JSON.parse(await readFile(path.join(path.dirname(fileURLToPath(import.meta.url)), "build.json"), "utf8"));
+    if (typeof value.version !== "string" || typeof value.build_revision !== "string")
+        throw new Error("Некорректная информация о сборке dd-console.");
+    return value;
+};
+const readers = new ReaderCache();
+let workerPool;
+const pool = () => workerPool ??= new ReaderPool();
+const snapshots = new Map();
+const json = (response, status, body, headers = {}) => { response.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", "x-content-type-options": "nosniff", ...headers }); response.end(JSON.stringify(body)); };
+const availability = (diagnostics) => diagnostics.some(item => item.code.endsWith("_unsupported")) ? "unsupported" : diagnostics.some(item => item.severity === "error") ? "unavailable" : diagnostics.length ? "partial" : "available";
+const sourceObservation = (source, diagnostics = [], source_updated_at, observedAt) => ({ id: source.id, kind: source.kind, availability: availability(diagnostics), observed_at: observedAt ?? now(), ...(source_updated_at ? { source_updated_at } : {}) });
+const envelope = (data, diagnostics = [], source) => ({ schema_version: "dd-console/api@1", request_id: id("REQ"), served_at: now(), observed_at: source?.observed_at ?? data?.observed_at ?? now(), data, diagnostics, ...(source ? { source } : {}) });
+const notFound = (response, message = "Не найдено.") => json(response, 404, envelope({ code: "not_found", message }));
+const staleCursor = (response) => json(response, 409, envelope({ code: "stale_cursor", message: "Страница устарела; обновите список." }));
+async function readSources(items, read) {
+    const results = [];
+    for (let offset = 0; offset < items.length; offset += 2)
+        results.push(...await Promise.all(items.slice(offset, offset + 2).map(read)));
+    return results;
+}
+async function sources(env = process.env) { return (await loadSources(env)).sources.filter(source => !source.disabled); }
+async function resolveSource(sourceId, env = process.env) {
+    const registered = await sources(env);
+    const direct = registered.find(source => source.id === sourceId);
+    if (direct)
+        return direct;
+    if (!sourceId?.startsWith("drv."))
+        return undefined;
+    try {
+        const [parentId, evalId, executionId] = JSON.parse(Buffer.from(sourceId.slice(4), "base64url").toString("utf8"));
+        const parent = registered.find(source => source.id === parentId && source.kind === "eval");
+        return parent ? await derivedSource(parent, evalId, executionId) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const readSnapshot = async (operation, ...args) => {
+    const value = await pool().run(operation, ...args);
+    return value ? Object.assign(value, { observed_at: now() }) : null;
+};
+const cachedFlowRuns = (source, refresh = false) => readers.get(JSON.stringify(["flow-runs", source.id, source.root]), 2_000, async () => readSnapshot("flowRuns", source), refresh);
+const cachedSourceFlows = (source, refresh = false) => source.kind === "flow" ? cachedFlowRuns(source, refresh) : readers.get(JSON.stringify(["eval-flows", source.id, source.root]), 2_000, () => readSnapshot("evalFlowRuns", source), refresh);
+const cachedEvalRuns = (source, refresh = false) => readers.get(JSON.stringify(["eval-runs", source.id, source.root]), 2_000, () => readSnapshot("evalRuns", source), refresh);
+const cachedFlowDetail = (source, projectId, runId, refresh = false) => readers.get(JSON.stringify(["flow-detail", source.id, source.root, projectId, runId]), 2_000, async () => readSnapshot("flowDetail", source, projectId, runId), refresh);
+const cachedEvalDetail = (source, evalId, refresh = false) => readers.get(JSON.stringify(["eval-detail", source.id, source.root, evalId]), 2_000, () => readSnapshot("evalDetail", source, evalId), refresh);
+const cachedEvalExecutionDetail = (source, evalId, executionId, refresh = false) => readers.get(JSON.stringify(["eval-execution", source.id, source.root, evalId, executionId]), 2_000, () => readSnapshot("evalExecutionDetail", source, evalId, executionId), refresh);
+const mergeUsage = (items) => {
+    const present = items.filter(item => item.status !== "unavailable");
+    if (!present.length)
+        return { status: "unavailable", input_tokens: null, cached_input_tokens: null, output_tokens: null, total_tokens: null, session_count: 0 };
+    const sum = (key) => present.some(item => item[key] === null) ? null : present.reduce((total, item) => total + item[key], 0);
+    const input_tokens = sum("input_tokens"), cached_input_tokens = sum("cached_input_tokens"), output_tokens = sum("output_tokens"), total_tokens = sum("total_tokens");
+    return { status: present.some(item => item.status === "partial") || [input_tokens, cached_input_tokens, output_tokens, total_tokens].some(value => value === null) ? "partial" : "measured", input_tokens, cached_input_tokens, output_tokens, total_tokens, session_count: present.reduce((total, item) => total + item.session_count, 0) };
+};
+async function sourceSummary(source, refresh = false) { try {
+    const result = source.kind === "flow" ? await cachedFlowRuns(source, refresh) : await cachedEvalRuns(source, refresh);
+    const updated = source.kind === "flow" ? result.runs.map(item => item.updated_at) : result.evals.map(item => item.updated_at);
+    const source_updated_at = updated.filter((item) => Boolean(item)).sort().at(-1);
+    return { id: source.id, kind: source.kind, label: source.label, created_at: source.created_at, availability: availability(result.diagnostics), observed_at: result.observed_at ?? now(), ...(source_updated_at ? { source_updated_at } : {}), detail: result.diagnostics[0]?.message };
+}
+catch (error) {
+    return { id: source.id, kind: source.kind, label: source.label, created_at: source.created_at, availability: "unavailable", observed_at: now(), detail: "Не удалось прочитать источник." };
+} }
+function pathParts(url) { return url.pathname.split("/").filter(Boolean).map(decodeURIComponent); }
+const pageLimit = (url) => Math.min(200, Math.max(1, Math.floor(Number(url.searchParams.get("limit") ?? 50) || 50)));
+function page(url, scope, values, observedAt = now()) {
+    const limit = pageLimit(url);
+    const token = url.searchParams.get("cursor");
+    const filters = ["q", "status", "source", "project", "kind", "case", "origin", "sort", "order"];
+    scope += JSON.stringify(filters.map(key => [key, url.searchParams.get(key) ?? ""]));
+    const value = (item, key) => String(item[key] ?? "");
+    values = values.filter(item => {
+        for (const [query, field] of [["origin", "origin"], ["status", "status"], ["source", "source_id"], ["project", "project_id"], ["kind", "flow_kind"], ["case", "case_id"]])
+            if (url.searchParams.get(query) && value(item, field) !== url.searchParams.get(query))
+                return false;
+        const q = (url.searchParams.get("q") ?? "").toLocaleLowerCase();
+        return !q || ["run_id", "eval_id", "short_id", "case_id", "project_id", "flow_kind", "execution_id", "source_label"].some(key => value(item, key).toLocaleLowerCase().includes(q));
+    });
+    const sort = url.searchParams.get("sort") ?? "updated_at", direction = url.searchParams.get("order") === "asc" ? 1 : -1;
+    const identity = (item) => ["source_id", "project_id", "run_id", "eval_id"].map(key => value(item, key)).join("/");
+    values.sort((left, right) => direction * value(left, sort).localeCompare(value(right, sort)) || identity(left).localeCompare(identity(right)));
+    let snapshotId = "", offset = 0, items = values;
+    if (token) {
+        try {
+            [snapshotId, offset] = JSON.parse(Buffer.from(token, "base64url").toString("utf8"));
+        }
+        catch {
+            return null;
+        }
+        const snapshot = snapshots.get(snapshotId);
+        if (!snapshot || snapshot.scope !== scope || snapshot.expiresAt < Date.now() || !Number.isSafeInteger(offset) || offset < 0)
+            return null;
+        items = snapshot.items;
+        observedAt = snapshot.observed_at;
+    }
+    else {
+        snapshotId = id("SNP");
+        const bytes = Buffer.byteLength(JSON.stringify(values));
+        if (bytes > 64 * 1024 * 1024)
+            throw Object.assign(new Error("Слишком большой список; сузьте фильтры."), { code: "reader_queue_busy" });
+        snapshots.set(snapshotId, { scope, items: values, bytes, observed_at: observedAt, expiresAt: Date.now() + 5 * 60_000 });
+    }
+    for (const [key, snapshot] of snapshots)
+        if (snapshot.expiresAt < Date.now())
+            snapshots.delete(key);
+    while (snapshots.size > 256 || [...snapshots.values()].reduce((sum, snapshot) => sum + snapshot.bytes, 0) > 64 * 1024 * 1024)
+        snapshots.delete(snapshots.keys().next().value);
+    const slice = items.slice(offset, offset + limit), next = offset + slice.length < items.length ? Buffer.from(JSON.stringify([snapshotId, offset + slice.length])).toString("base64url") : null;
+    return { items: slice, total: items.length, next_cursor: next, observed_at: observedAt };
+}
+const textArtifact = (name) => /\.(?:json|jsonl|log|txt|md|out|err)$/i.test(name);
+async function artifactResponse(response, source, item, action, url) {
+    const handle = await openWithin(source.boundary_root ?? source.root, item.file);
+    try {
+        const info = handle.stat(), metadata = { id: item.id, part: item.part, name: item.name, bytes: info.size, preview_available: textArtifact(item.name) };
+        if (action === "download") {
+            response.writeHead(200, { "content-type": "application/octet-stream", "content-length": info.size, "content-disposition": `attachment; filename="artifact"; filename*=UTF-8''${encodeURIComponent(item.name).replace(/'/g, "%27")}`, "x-content-type-options": "nosniff", "cache-control": "no-store" });
+            const stream = handle.stream();
+            stream.on("error", () => response.destroy());
+            response.on("close", () => stream.destroy());
+            stream.pipe(response);
+            return;
+        }
+        if (action === "preview") {
+            if (!metadata.preview_available)
+                return json(response, 415, envelope({ code: "preview_unsupported", message: "Для этого типа доступно только скачивание." }));
+            const offset = Number(url.searchParams.get("offset") ?? 0);
+            if (!Number.isSafeInteger(offset) || offset < 0 || offset > info.size)
+                return json(response, 400, envelope({ code: "bad_offset", message: "Некорректное смещение preview." }));
+            const buffer = Buffer.alloc(Math.min(262144, info.size - offset)), result = await handle.read(buffer, offset);
+            let bytesRead = result.bytesRead;
+            if (offset + bytesRead < info.size && bytesRead) {
+                let start = bytesRead - 1;
+                while (start > 0 && (buffer[start] & 0xc0) === 0x80)
+                    start--;
+                const byte = buffer[start], width = byte >= 0xf0 ? 4 : byte >= 0xe0 ? 3 : byte >= 0xc0 ? 2 : 1;
+                if (start + width > bytesRead)
+                    bytesRead = start;
+            }
+            return json(response, 200, envelope({ ...metadata, text: buffer.subarray(0, bytesRead).toString("utf8"), offset, next_offset: offset + bytesRead < info.size ? offset + bytesRead : null, truncated: offset + bytesRead < info.size }));
+        }
+        return json(response, 200, envelope(metadata));
+    }
+    finally {
+        handle.close();
+    }
+}
+async function staticFile(response, name) { const file = path.join(webRoot, name); try {
+    const info = await stat(file);
+    if (!info.isFile())
+        return false;
+    const content = await readFile(file);
+    response.writeHead(200, { "content-type": name.endsWith(".css") ? "text/css; charset=utf-8" : name.endsWith(".js") ? "text/javascript; charset=utf-8" : "text/html; charset=utf-8", "cache-control": "no-store", "x-content-type-options": "nosniff", "content-security-policy": "default-src 'self'; connect-src 'self'; img-src 'self'; style-src 'self'; script-src 'self'" });
+    response.end(content);
+    return true;
+}
+catch {
+    return false;
+} }
+export async function requestHandler(request, response, env = process.env, build) {
+    const host = request.headers.host ?? "";
+    if (!/^127\.0\.0\.1:\d+$/.test(host) && !/^localhost:\d+$/.test(host))
+        return json(response, 400, envelope({ code: "bad_host", message: "Недопустимый Host." }));
+    if (request.socket.localPort && Number(host.split(":").at(-1)) !== request.socket.localPort)
+        return json(response, 400, envelope({ code: "bad_host", message: "Неверный порт Host." }));
+    const origin = request.headers.origin;
+    if (origin && origin !== `http://${host}`)
+        return json(response, 403, envelope({ code: "bad_origin", message: "Недопустимый Origin." }));
+    if (request.method !== "GET" && request.method !== "HEAD")
+        return json(response, 405, envelope({ code: "method_not_allowed", message: "Только чтение." }));
+    const url = new URL(request.url ?? "/", `http://${host}`);
+    let parts;
+    try {
+        parts = pathParts(url);
+    }
+    catch {
+        return json(response, 400, envelope({ code: "bad_path", message: "Некорректное кодирование URL." }));
+    }
+    if (url.searchParams.has("limit") && (!Number.isSafeInteger(Number(url.searchParams.get("limit"))) || Number(url.searchParams.get("limit")) < 1 || Number(url.searchParams.get("limit")) > 200))
+        return json(response, 400, envelope({ code: "bad_limit", message: "limit должен быть целым числом от 1 до 200." }));
+    if (url.searchParams.has("sort") && !["updated_at", "created_at", "status", "run_id", "eval_id"].includes(url.searchParams.get("sort")))
+        return json(response, 400, envelope({ code: "bad_sort", message: "Неизвестное поле сортировки." }));
+    if (url.searchParams.has("order") && !["asc", "desc"].includes(url.searchParams.get("order")))
+        return json(response, 400, envelope({ code: "bad_order", message: "order должен быть asc или desc." }));
+    const refresh = url.searchParams.get("refresh") === "1";
+    if (url.pathname === "/healthz")
+        return json(response, 200, { ok: true, ...(build ?? { version: "0.1.0" }) });
+    if (url.pathname === "/api/v1/sources")
+        return json(response, 200, envelope(await readSources(await sources(env), source => sourceSummary(source, refresh))));
+    if (url.pathname === "/api/v1/overview") {
+        const active = await sources(env);
+        const summaries = await readSources(active, source => sourceSummary(source, refresh));
+        const flow = await readSources(active, item => cachedSourceFlows(item, refresh));
+        const evals = await readSources(active.filter(item => item.kind === "eval"), item => cachedEvalRuns(item, refresh));
+        return json(response, 200, envelope({ sources: summaries, usage: mergeUsage(flow.map(item => item.usage)), flows: flow.flatMap(item => item.runs).sort((a, b) => (b.updated_at ?? "").localeCompare(a.updated_at ?? "")).slice(0, 20), evals: evals.flatMap(item => item.evals).sort((a, b) => (b.updated_at ?? "").localeCompare(a.updated_at ?? "")).slice(0, 20) }, flow.flatMap(item => item.diagnostics)));
+    }
+    if (url.pathname === "/api/v1/flows") {
+        const data = await readSources(await sources(env), item => cachedSourceFlows(item, refresh));
+        const result = page(url, "flows", data.flatMap(item => item.runs), data.map(item => item.observed_at ?? now()).sort()[0]);
+        return result ? json(response, 200, envelope(result, data.flatMap(item => item.diagnostics))) : staleCursor(response);
+    }
+    if (url.pathname === "/api/v1/evals") {
+        const data = await readSources((await sources(env)).filter(item => item.kind === "eval"), item => cachedEvalRuns(item, refresh));
+        const result = page(url, "evals", data.flatMap(item => item.evals), data.map(item => item.observed_at ?? now()).sort()[0]);
+        return result ? json(response, 200, envelope(result, data.flatMap(item => item.diagnostics))) : staleCursor(response);
+    }
+    const current = await resolveSource(parts[3], env);
+    if (parts[0] === "api" && parts[1] === "v1" && parts[2] === "sources" && !current)
+        return notFound(response, "Источник не найден.");
+    if (parts.slice(0, 3).join("/") === "api/v1/sources" && current?.kind === "flow" && parts[4] === "projects" && parts[6] === "runs" && parts[5] && parts[7]) {
+        if (parts.length !== 8 && !((parts[8] === "events" && parts.length === 9) || (["works", "sessions", "checks"].includes(parts[8] ?? "") && parts.length === 10) || (parts[8] === "stages" && parts[10] === "attempts" && parts.length === 12) || (parts[8] === "artifacts" && [10, 11].includes(parts.length))))
+            return notFound(response);
+        const detail = await cachedFlowDetail(current, parts[5], parts[7], refresh);
+        if (!detail)
+            return notFound(response, "Flow не найден.");
+        if (parts[8] === "events") {
+            const result = await pool().run("flowEvents", current, parts[5], parts[7], pageLimit(url), url.searchParams.get("cursor"));
+            return result ? json(response, 200, envelope(result, [...detail.diagnostics, ...result.diagnostics], sourceObservation(current, [...detail.diagnostics, ...result.diagnostics], detail.updated_at, detail.observed_at))) : staleCursor(response);
+        }
+        if (parts[8] === "stages" && parts[9] && parts[10] === "attempts" && parts[11]) {
+            const attempt = detail.stages.find(item => item.stage === parts[9] && item.attempt === parts[11]);
+            if (!attempt)
+                return notFound(response, "Попытка стадии не найдена.");
+            const attempts = detail.stages.filter(item => item.stage === attempt.stage).sort((left, right) => (left.order ?? 0) - (right.order ?? 0)), index = attempts.findIndex(item => item.attempt === attempt.attempt);
+            return json(response, 200, envelope({ ...attempt, previous_attempt: attempts[index - 1]?.attempt ?? null, next_attempt: attempts[index + 1]?.attempt ?? null }, detail.diagnostics, sourceObservation(current, detail.diagnostics, detail.updated_at, detail.observed_at)));
+        }
+        if (parts[8] === "works" && parts[9]) {
+            const item = detail.works.find(work => work.id === parts[9]);
+            return item ? json(response, 200, envelope({ ...item, checks: detail.checks.filter(check => check.work_id === item.id) }, detail.diagnostics, sourceObservation(current, detail.diagnostics, detail.updated_at, detail.observed_at))) : notFound(response, "Работа не найдена.");
+        }
+        if (parts[8] === "sessions" && parts[9]) {
+            const item = detail.sessions.find(session => session.id === parts[9]);
+            return item ? json(response, 200, envelope({ ...item, works: detail.works.filter(work => item.work_ids?.includes(work.id)) }, detail.diagnostics, sourceObservation(current, detail.diagnostics, detail.updated_at, detail.observed_at))) : notFound(response, "Сессия не найдена.");
+        }
+        if (parts[8] === "checks" && parts[9]) {
+            const item = detail.checks.find(check => check.id === parts[9]);
+            return item ? json(response, 200, envelope({ ...item, session_ids: detail.works.find(work => work.id === item.work_id)?.session_ids ?? [], attempts: detail.works.find(work => work.id === item.work_id)?.attempts ?? [] }, detail.diagnostics, sourceObservation(current, detail.diagnostics, detail.updated_at, detail.observed_at))) : notFound(response, "Проверка не найдена.");
+        }
+        if (parts[8] === "artifacts" && parts[9]) {
+            if (parts.length > 11 || parts[10] && !["download", "preview"].includes(parts[10]))
+                return notFound(response);
+            const item = await pool().run("flowArtifact", current, parts[5], parts[7], parts[9], url.searchParams.get("part") ?? "receipt");
+            if (!item)
+                return notFound(response, "Артефакт отсутствует или недоступен.");
+            return artifactResponse(response, current, item, parts[10], url);
+        }
+        if (parts.length !== 8)
+            return notFound(response);
+        return json(response, 200, envelope(detail, detail.diagnostics, sourceObservation(current, detail.diagnostics, detail.updated_at, detail.observed_at)));
+    }
+    if (parts.slice(0, 3).join("/") === "api/v1/sources" && current?.kind === "eval" && parts[4] === "evals" && parts[5]) {
+        if (parts.length !== 6 && !(parts[6] === "events" && parts.length === 7) && !(parts[6] === "executions" && parts.length === 8))
+            return notFound(response);
+        if (parts[6] === "executions" && parts[7]) {
+            const execution = await cachedEvalExecutionDetail(current, parts[5], parts[7], refresh);
+            return execution ? json(response, 200, envelope(execution, execution.diagnostics, sourceObservation(current, execution.diagnostics, undefined, execution.observed_at))) : notFound(response, "Execution не найден.");
+        }
+        const detail = await cachedEvalDetail(current, parts[5], refresh);
+        if (!detail)
+            return notFound(response, "Eval не найден.");
+        if (parts[6] === "events") {
+            const result = await pool().run("evalEvents", current, parts[5], pageLimit(url), url.searchParams.get("cursor"));
+            return result ? json(response, 200, envelope(result, [...detail.diagnostics, ...result.diagnostics], sourceObservation(current, [...detail.diagnostics, ...result.diagnostics], detail.updated_at, detail.observed_at))) : staleCursor(response);
+        }
+        return json(response, 200, envelope(detail, detail.diagnostics, sourceObservation(current, detail.diagnostics, detail.updated_at, detail.observed_at)));
+    }
+    if (url.pathname === "/app.js" && await staticFile(response, "app.js"))
+        return;
+    if (url.pathname === "/style.css" && await staticFile(response, "style.css"))
+        return;
+    if (!url.pathname.startsWith("/api/")) {
+        if (await staticFile(response, "index.html"))
+            return;
+    }
+    return notFound(response);
+}
+export async function serve(port, env = process.env) {
+    const releaseLock = await acquireServerLock(env);
+    let build;
+    try {
+        build = { ...await loadBuildInfo(), pid: process.pid, instance: id("SERVER") };
+    }
+    catch (error) {
+        await releaseLock();
+        throw error;
+    }
+    const server = createServer((request, response) => void requestHandler(request, response, env, build).catch(error => { const code = error.code; const busy = code === "reader_queue_busy" || code === "reader_deadline"; if (code === "stale_cursor")
+        return staleCursor(response); if (response.headersSent) {
+        response.destroy();
+        return;
+    } json(response, busy ? 503 : 500, envelope({ code: busy ? "reader_queue_busy" : "read_failed", message: busy ? "Локальное чтение временно недоступно. Повторите запрос." : "Не удалось прочитать локальные данные." }), busy ? { "retry-after": "1" } : {}); }));
+    try {
+        await new Promise((resolve, reject) => { server.once("error", reject); server.listen(port, "127.0.0.1", () => { server.off("error", reject); resolve(); }); });
+    }
+    catch (error) {
+        await releaseLock();
+        throw error;
+    }
+    const address = server.address();
+    if (!address || typeof address === "string")
+        throw new Error("Сервер не вернул TCP адрес.");
+    const ownedPool = pool();
+    const closed = new Promise((resolve, reject) => server.once("close", () => {
+        if (workerPool === ownedPool)
+            workerPool = undefined;
+        void (async () => { try {
+            await rm(path.join(consoleHome(env), "server.json"), { force: true });
+            await ownedPool.close();
+        }
+        finally {
+            await releaseLock();
+        } })().then(() => resolve(), reject);
+    }));
+    // Callers may await closed to ensure the lock and workers have been released.
+    closed.catch(() => { });
+    const url = `http://127.0.0.1:${address.port}`, stateFile = path.join(consoleHome(env), "server.json");
+    try {
+        await writeFile(`${stateFile}.tmp`, JSON.stringify({ ...build, url }), { mode: 0o600 });
+        await rename(`${stateFile}.tmp`, stateFile);
+    }
+    catch (error) {
+        server.close();
+        await closed;
+        throw error;
+    }
+    return { server, url, env, closed };
+}

package/dist/sources.js

@@ -0,0 +1,137 @@
+import { access, mkdir, readFile, realpath, rename, stat, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import path from "node:path";
+import { acquireFileLock } from "./file-lock.js";
+import { id, now } from "./util.js";
+export const consoleHome = (env = process.env) => path.resolve(env.DD_CONSOLE_HOME ?? path.join(env.HOME ?? ".", ".dd-console"));
+const registryPath = (env = process.env) => path.join(consoleHome(env), "sources.json");
+const serverLockPath = (env = process.env) => path.join(consoleHome(env), "server.lock");
+async function loadLocalSources(env = process.env) {
+    const file = registryPath(env);
+    try {
+        const text = await readFile(file, "utf8");
+        let value;
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            throw new Error("sources registry is invalid; it was left unchanged");
+        }
+        if (!value || value.schema_version !== 1 || !Array.isArray(value.sources))
+            throw new Error("sources registry format is unsupported");
+        if (value.sources.some(source => !source || typeof source.id !== "string" || !/^SRC-[a-zA-Z0-9-]+$/.test(source.id) || !["flow", "eval"].includes(source.kind) || typeof source.root !== "string" || !path.isAbsolute(source.root) || typeof source.label !== "string" || typeof source.created_at !== "string" || source.disabled !== undefined && typeof source.disabled !== "boolean" || ["database_path", "boundary_root", "allowed_run_id"].some(key => key in source)))
+            throw new Error("sources registry entries are invalid; it was left unchanged");
+        if (new Set(value.sources.map(source => source.id)).size !== value.sources.length)
+            throw new Error("duplicate source identity");
+        return value;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { schema_version: 1, sources: [] };
+        throw error;
+    }
+}
+// The producer registry is read on every request, so new homes need no restart.
+export async function loadSources(env = process.env) {
+    const local = await loadLocalSources(env);
+    let registry;
+    try {
+        registry = JSON.parse(await readFile(path.join(env.HOME ?? ".", ".dd-eval", "homes.json"), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return local;
+        throw new Error("Eval homes registry is invalid or unreadable");
+    }
+    if (registry?.schema_version !== 1 || !Array.isArray(registry.homes) || registry.homes.some(h => !h || typeof h.id !== "string" || !/^SRC-[a-zA-Z0-9-]+$/.test(h.id) || typeof h.root !== "string" || !path.isAbsolute(h.root) || typeof h.label !== "string" || typeof h.created_at !== "string" || typeof h.disabled !== "boolean"))
+        throw new Error("Eval homes registry format is invalid");
+    if (new Set(registry.homes.map(h => h.id)).size !== registry.homes.length || new Set(registry.homes.map(h => h.root)).size !== registry.homes.length)
+        throw new Error("Duplicate Eval home identity");
+    for (const home of registry.homes) {
+        const existing = local.sources.find(s => s.kind === "eval" && s.root === home.root);
+        if (existing) {
+            existing.disabled = existing.disabled || home.disabled;
+            continue;
+        }
+        if (local.sources.some(s => s.id === home.id))
+            throw new Error("Conflicting Eval home identity");
+        local.sources.push({ id: home.id, root: home.root, label: home.label, created_at: home.created_at, disabled: home.disabled, kind: "eval" });
+    }
+    return local;
+}
+async function withRegistryLock(env, action) {
+    const file = registryPath(env);
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const release = await acquireFileLock(`${file}.lock`, 50, "sources registry is busy");
+    try {
+        return await action();
+    }
+    finally {
+        await release();
+    }
+}
+export async function acquireServerLock(env = process.env) {
+    const file = serverLockPath(env);
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    return acquireFileLock(file, 1, "dd-console уже запущен для этого DD_CONSOLE_HOME");
+}
+async function saveSources(registry, env = process.env) {
+    const file = registryPath(env);
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temp = `${file}.${process.pid}.tmp`;
+    await writeFile(temp, `${JSON.stringify(registry, null, 2)}\n`, { mode: 0o600 });
+    await rename(temp, file);
+}
+export async function sourceAdd(kind, root, label, env = process.env) {
+    const canonical = await realpath(path.resolve(root));
+    await access(canonical, constants.R_OK);
+    if (!(await stat(canonical)).isDirectory())
+        throw new Error("source root must be a directory");
+    return withRegistryLock(env, async () => {
+        const registry = await loadLocalSources(env);
+        const existing = registry.sources.find(item => item.kind === kind && item.root === canonical);
+        if (existing) {
+            if (existing.disabled) {
+                existing.disabled = false;
+                await saveSources(registry, env);
+            }
+            return existing;
+        }
+        const inherited = (await loadSources(env)).sources.find(item => item.kind === kind && item.root === canonical);
+        const source = { id: inherited?.id ?? id("SRC"), kind, root: canonical, label: label ?? inherited?.label ?? path.basename(canonical), created_at: inherited?.created_at ?? now() };
+        registry.sources.push(source);
+        await saveSources(registry, env);
+        return source;
+    });
+}
+export async function sourceRemove(sourceId, env = process.env) {
+    await withRegistryLock(env, async () => {
+        const registry = await loadLocalSources(env);
+        let source = registry.sources.find(item => item.id === sourceId);
+        if (!source) {
+            const inherited = (await loadSources(env)).sources.find(item => item.id === sourceId);
+            if (inherited) {
+                source = { ...inherited };
+                registry.sources.push(source);
+            }
+        }
+        if (!source)
+            throw new Error(`unknown source ${sourceId}`);
+        source.disabled = true;
+        await saveSources(registry, env);
+    });
+}
+export async function ensureDefaultSources(flowHome, evalHome, env = process.env) {
+    const values = [["flow", flowHome ?? env.DD_FLOW_HOME ?? path.join(env.HOME ?? ".", ".dd-flow")], ["eval", evalHome ?? env.DD_EVAL_HOME ?? path.join(env.HOME ?? ".", ".dd-eval")]];
+    for (const [kind, root] of values) {
+        if (!root)
+            continue;
+        try {
+            await sourceAdd(kind, root, undefined, env);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+}

package/dist/util.js

@@ -0,0 +1,25 @@
+import crypto from "node:crypto";
+import path from "node:path";
+import { realpath } from "node:fs/promises";
+export const now = () => new Date().toISOString();
+export const id = (prefix) => `${prefix}-${crypto.randomUUID()}`;
+export const safeJson = (text, fallback) => { try {
+    return JSON.parse(text);
+}
+catch {
+    return fallback;
+} };
+export const inside = (root, candidate) => {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+};
+export const realpathInside = async (root, candidate) => {
+    try {
+        return inside(await realpath(root), await realpath(candidate));
+    }
+    catch {
+        return false;
+    }
+};
+export const string = (value) => typeof value === "string" ? value : undefined;
+export const asArray = (value) => Array.isArray(value) ? value : [];