@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/access/hub.js

@@ -0,0 +1,19 @@
+// Only the authenticated connector can mark a socket. HTTP headers never establish trust.
+const state = globalThis;
+const sockets = (state.projectorHubSockets ??= new WeakMap());
+export function markHubSocket(socket, origin) {
+    sockets.set(socket, origin);
+}
+export function isHubRequest(req) {
+    return sockets.has(req.socket);
+}
+export function hubAccessAllowed(req, requireOrigin) {
+    const origin = sockets.get(req.socket);
+    if (!origin || req.headers.host !== new URL(origin).host)
+        return false;
+    if (requireOrigin && !req.headers.origin)
+        return false;
+    if (req.headers.origin && req.headers.origin !== origin)
+        return false;
+    return (req.url ?? "").startsWith("/api/");
+}

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

@@ -0,0 +1,6 @@
+export { accessAllowed, isLocalRequest, lanPassword, registerGatewayGuard, registerGatewayOrigins, } from "./access.js";
+export { authorizeHttp } from "./http.js";
+export { protectLanSockets } from "./connections.js";
+export { hasLanPassword, verifyLanPassword, setLanPassword, clearLanPassword } from "./password.js";
+export { lanUrl, lanUrls } from "./lan-url.js";
+export { markHubSocket } from "./hub.js";

package/packages/server/modules/access/lan-url.js

@@ -0,0 +1,21 @@
+import { networkInterfaces } from "node:os";
+import { APP_PORT } from "../../../core/modules/app-paths/index.js";
+function privateAddresses() {
+    const result = [];
+    for (const entries of Object.values(networkInterfaces())) {
+        for (const entry of entries ?? []) {
+            if (entry.family !== "IPv4" || entry.internal)
+                continue;
+            result.push(entry.address);
+        }
+    }
+    return result;
+}
+/** Все адреса Projector в локальной сети для открытия с других устройств. */
+export function lanUrls() {
+    return privateAddresses().map((address) => `http://${address}:${APP_PORT}`);
+}
+/** Первый адрес Projector в локальной сети. */
+export function lanUrl() {
+    return lanUrls()[0] ?? null;
+}

package/packages/server/modules/access/password.js

@@ -0,0 +1,68 @@
+import { os } from "../../../core/modules/os/index.js";
+import { mkdirSync, readFileSync, writeFileSync, renameSync, rmSync } from "node:fs";
+import { randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
+import { dirname } from "node:path";
+import { lanPasswordPath } from "../../../core/modules/app-paths/index.js";
+const state = globalThis;
+const listeners = (state.projectorLanPasswordListeners ??= new Set());
+export function onLanPasswordChanged(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+function passwordChanged() {
+    for (const listener of listeners)
+        listener();
+}
+function readStored() {
+    try {
+        const raw = readFileSync(lanPasswordPath(), "utf8").trim();
+        if (!/^[a-f0-9]{32}:[a-f0-9]{128}$/.test(raw))
+            throw new Error("Повреждён файл пароля LAN");
+        const [salt, hash] = raw.split(":");
+        return { salt: Buffer.from(salt, "hex"), hash: Buffer.from(hash, "hex") };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+/** Changes on every password replacement, including replacement with the same password. */
+export function lanPasswordVersion() {
+    return readStored()?.hash.toString("hex") ?? null;
+}
+export function hasLanPassword() {
+    return readStored() !== null;
+}
+export function verifyLanPassword(password) {
+    const stored = readStored();
+    if (!stored)
+        return false;
+    const candidate = scryptSync(password, stored.salt, stored.hash.length);
+    return timingSafeEqual(candidate, stored.hash);
+}
+export function setLanPassword(password) {
+    mkdirSync(dirname(lanPasswordPath()), { recursive: true });
+    const salt = randomBytes(16);
+    const hash = scryptSync(password, salt, 64);
+    const file = lanPasswordPath();
+    const temporary = `${file}.${randomBytes(8).toString("hex")}.tmp`;
+    try {
+        writeFileSync(temporary, `${salt.toString("hex")}:${hash.toString("hex")}\n`, {
+            mode: 0o600,
+            flag: "wx",
+        });
+        renameSync(temporary, file);
+        os.tools.restrictToOwnerSync(file);
+        passwordChanged();
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+export function clearLanPassword() {
+    rmSync(lanPasswordPath(), { force: true });
+    passwordChanged();
+}

package/packages/server/modules/access/session.js

@@ -0,0 +1,38 @@
+import { randomBytes } from "node:crypto";
+import { lanPasswordVersion } from "./password.js";
+const COOKIE = "projector_lan";
+const LIFETIME = 8 * 60 * 60 * 1000;
+const host = globalThis;
+const sessions = (host.projectorLanSessions ??= new Map());
+export function validLanSession(req) {
+    const id = req.headers.cookie?.match(/(?:^|;\s*)projector_lan=([a-f0-9]{64})(?:;|$)/)?.[1];
+    const session = id ? sessions.get(id) : undefined;
+    if (!session)
+        return false;
+    if (session.expires <= Date.now() || session.version !== lanPasswordVersion()) {
+        sessions.delete(id);
+        return false;
+    }
+    return true;
+}
+/** Call only after the request's Bearer password has been verified. */
+export function rememberLanSession(req, res) {
+    if (res.hasHeader("Set-Cookie") ||
+        !req.headers.authorization?.startsWith("Bearer ") ||
+        validLanSession(req))
+        return;
+    const version = lanPasswordVersion();
+    if (!version)
+        return;
+    for (const [id, session] of sessions) {
+        if (session.expires <= Date.now() || session.version !== version)
+            sessions.delete(id);
+    }
+    // Bound memory even when a client authenticates without keeping its cookies.
+    if (sessions.size >= 256)
+        sessions.delete(sessions.keys().next().value);
+    const id = randomBytes(32).toString("hex");
+    sessions.set(id, { version, expires: Date.now() + LIFETIME });
+    const secure = "encrypted" in req.socket && req.socket.encrypted ? "; Secure" : "";
+    res.setHeader("Set-Cookie", `${COOKIE}=${id}; HttpOnly; SameSite=Strict; Path=/; Max-Age=${LIFETIME / 1000}${secure}`);
+}

package/packages/server/modules/agent/agent-host.js

@@ -0,0 +1,46 @@
+import { devcontainerForPath } from "../devcontainer/index.js";
+import { environmentForPath } from "../environments/index.js";
+import { readAttachment } from "./attachments.js";
+/** Env names that must not leak from Projector's server into a coding agent's shell. */
+const PRIVATE_ENV = [
+    "PROVIDERS_SECRET",
+    "OPENAI_API_KEY",
+    "DASHSCOPE_API_KEY",
+    "QWENCLOUD_API_KEY",
+];
+/** The host environment for an external coding agent, without Projector's own secrets. */
+export function agentEnv() {
+    const env = { ...process.env };
+    for (const name of PRIVATE_ENV)
+        delete env[name];
+    return env;
+}
+/** Without a native session the earlier chat is replayed as text. */
+/** The bytes and type of an attached image, for the agents that take images in a prompt. */
+export async function attachedImages(parts) {
+    const images = [];
+    for (const part of parts ?? []) {
+        if (part.type !== "image")
+            continue;
+        const stored = await readAttachment(part.id);
+        if (stored)
+            images.push({ name: part.name, mime: stored.mime, data: stored.content.toString("base64") });
+    }
+    return images;
+}
+export function promptWithHistory(message, history, context = "") {
+    const transcript = history
+        .slice(-10)
+        .map((turn) => `${turn.role === "user" ? "Пользователь" : "Ассистент"}: ${turn.content}`)
+        .join("\n\n");
+    return [
+        ...(history.length ? [`Предыдущая переписка в этом чате:\n\n${transcript}`] : []),
+        ...(context.trim() ? [context.trim()] : []),
+        ...(history.length ? [`Новое сообщение пользователя:\n${message}`] : [message]),
+    ].join("\n\n");
+}
+/** An external agent's tools run on the host, so isolating environments are refused. */
+export async function assertHostProject(cwd, label) {
+    if ((await devcontainerForPath(cwd)) || (await environmentForPath(cwd)))
+        throw new Error(`${label} выполняет инструменты на машине пользователя и недоступен в проектах с Docker-окружением или Dev Container. Откройте терминальную сессию.`);
+}

package/packages/server/modules/agent/agent-runs.js

@@ -0,0 +1,162 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { os } from "../../../core/modules/os/index.js";
+/** Runs with a live host, whichever page started them. */
+export async function listLiveRuns() {
+    const ids = await readdir(runsRoot()).catch(() => []);
+    const runs = await Promise.all(ids
+        .filter((id) => RUN_ID.test(id))
+        .map(async (id) => {
+        if ((await liveHost(id)) === undefined)
+            return;
+        const record = await readRun(id);
+        // A background job shows up as a job, not as a second run.
+        if (!record || record.chat?.startsWith(JOB_CHAT))
+            return;
+        // A run started before its record carried the time: the file's own time is close enough.
+        const startedAt = record.startedAt ??
+            (await stat(join(runDirectory(id), "run.json")).catch(() => null))?.mtimeMs;
+        return {
+            id,
+            backend: record.backend,
+            projectId: record.projectId ?? "",
+            chat: record.chat ?? "",
+            topic: record.message.trim().slice(0, 120),
+            ...(record.session ? { session: record.session } : {}),
+            ...(startedAt !== undefined ? { startedAt } : {}),
+        };
+    }));
+    return runs.filter((run) => !!run);
+}
+/** The `chat` of a run that belongs to a background job (`job:<id>`). */
+export const JOB_CHAT = "job:";
+const RUN_ID = /^[0-9a-f]{12}$/;
+/** A host still alive after this long is stopped and its run removed. */
+const RUN_TTL_MS = 24 * 60 * 60 * 1000;
+/** A finished run nobody rejoined is kept this long, then removed. */
+const RETAIN_MS = 60 * 60 * 1000;
+/** The run of a background job waits longer: a restarted server rejoins it to collect the answer. */
+const JOB_RETAIN_MS = 24 * 60 * 60 * 1000;
+const runsRoot = () => join(dataDir(), "agent", "runs");
+/** The directory of a run; the identifier comes from a client, so its shape is checked. */
+export function runDirectory(id) {
+    if (!RUN_ID.test(id))
+        throw new Error("Некорректный идентификатор хода");
+    return join(runsRoot(), id);
+}
+export async function createRun(record) {
+    const id = randomBytes(6).toString("hex");
+    const dir = runDirectory(id);
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(join(dir, "run.json"), JSON.stringify({ ...record, startedAt: Date.now() }), {
+        mode: 0o600,
+    });
+    return id;
+}
+export async function readRun(id) {
+    try {
+        return JSON.parse(await readFile(join(runDirectory(id), "run.json"), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Notes the agent's session in the stored run. */
+export async function rememberSession(id, session) {
+    const record = await readRun(id);
+    if (!record || record.session === session)
+        return;
+    await writeFile(join(runDirectory(id), "run.json"), JSON.stringify({ ...record, session }), {
+        mode: 0o600,
+    });
+}
+/** A disconnected/replaced reader must never erase a run that still has a live owner. */
+export async function removeRun(id) {
+    if ((await liveHost(id)) !== undefined)
+        return false;
+    const dir = runDirectory(id);
+    // A deep data directory puts the socket in /tmp instead (see `agentHostAddress`).
+    await os.tools.removeAgentHostAddress(dir, os.tools.agentHostAddress(dir));
+    // A host that was just signalled may still write; retry instead of failing on ENOTEMPTY.
+    await rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+    return true;
+}
+/** The host's process identity, so a pid reused by another program later is never signalled. */
+export async function rememberHost(id, pid) {
+    const identity = await os.processes.identity(pid);
+    await writeFile(join(runDirectory(id), "process.json"), JSON.stringify({ pid, identity }));
+}
+async function liveHost(id) {
+    try {
+        const { pid, identity } = JSON.parse(await readFile(join(runDirectory(id), "process.json"), "utf8"));
+        return Number.isInteger(pid) && identity && (await os.processes.identity(pid)) === identity
+            ? pid
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Stops a run's agent and everything it started, whichever server started it. */
+export async function stopRun(id) {
+    const pid = await liveHost(id);
+    if (!pid)
+        return;
+    os.tools.killAgentTree(pid);
+    // Signalling is asynchronous: keep the record until the host actually releases the run.
+    const deadline = Date.now() + 5000;
+    while ((await liveHost(id)) !== undefined && Date.now() < deadline)
+        await sleep(25);
+}
+/**
+ * Drops what nobody will come back for. A finished run (its host is gone) is kept for
+ * `RETAIN_MS` so a reopened page can still replay the answer; a host that outlived `RUN_TTL_MS`
+ * is stopped first. Runs are collected at server start, whenever a new run starts, and one
+ * `RETAIN_MS` after a run ended unseen, so a crash or a closed page leaves nothing behind.
+ */
+export async function pruneRuns(now = Date.now()) {
+    const ids = await readdir(runsRoot()).catch(() => []);
+    for (const id of ids) {
+        if (!RUN_ID.test(id))
+            continue;
+        const dir = runDirectory(id);
+        const last = await Promise.all(["trace.log", "run.json"].map((name) => stat(join(dir, name)).catch(() => null))).then((found) => found.find(Boolean)?.mtimeMs ?? 0);
+        const age = now - last;
+        if ((await liveHost(id)) !== undefined) {
+            if (age < RUN_TTL_MS)
+                continue;
+            await stopRun(id);
+        }
+        else {
+            const job = (await readRun(id))?.chat?.startsWith(JOB_CHAT);
+            if (age < (job ? JOB_RETAIN_MS : RETAIN_MS))
+                continue;
+        }
+        await removeRun(id).catch(() => { });
+    }
+}
+/** Collect finished runs once their retention has passed. */
+export function schedulePrune() {
+    setTimeout(() => void pruneRuns().catch(() => { }), RETAIN_MS + 1000).unref();
+}
+const host = globalThis;
+const active = (host.projectorAgentRuns ??= new Map());
+/** Registers how to cancel a run this server is driving; the returned function forgets it. */
+export function trackRun(id, cancel) {
+    active.set(id, cancel);
+    return () => {
+        if (active.get(id) === cancel)
+            active.delete(id);
+    };
+}
+/** The user pressed stop: cancel the run here, or stop the agent a former server started. */
+export async function cancelRun(id) {
+    const cancel = active.get(id);
+    if (cancel)
+        return cancel();
+    await stopRun(id);
+    await removeRun(id);
+}

package/packages/server/modules/agent/attachments.js

@@ -0,0 +1,88 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { HttpError } from "../http/index.js";
+/** Pictures pasted or dropped into the chat, served inline; anything else is just stored. */
+const TYPES = {
+    "image/png": { ext: "png", magic: (head) => head.subarray(1, 4).toString() === "PNG" },
+    "image/jpeg": { ext: "jpg", magic: (head) => head[0] === 0xff && head[1] === 0xd8 },
+    "image/gif": { ext: "gif", magic: (head) => head.subarray(0, 3).toString() === "GIF" },
+    "image/webp": {
+        ext: "webp",
+        magic: (head) => head.subarray(0, 4).toString() === "RIFF" && head.subarray(8, 12).toString() === "WEBP",
+    },
+};
+/** Files of any type may be attached; pictures also have to be what their header says. */
+const MAX_BYTES = 10 * 1024 * 1024;
+const ID = /^[0-9a-f]{16}$/;
+/** Unused attachments of old chats are removed after this long. */
+const KEEP_MS = 30 * 24 * 60 * 60 * 1000;
+const directory = () => join(dataDir(), "agent", "attachments");
+/** A name that stays readable in a chip and is safe on every platform. */
+function safeName(name) {
+    const base = name.split(/[\\/]/).pop() ?? "";
+    const clean = base
+        .replace(/[\p{Cc}<>:"/\\|?*]+/gu, "_")
+        .replace(/^[.\s]+|[.\s]+$/g, "")
+        .slice(0, 100);
+    return clean || "file";
+}
+async function store(path, content) {
+    await writeFile(`${path}.tmp`, content, { mode: 0o600 });
+    await rename(`${path}.tmp`, path);
+}
+export async function saveAttachment(req, mime, name) {
+    const type = TYPES[mime.trim().toLowerCase()];
+    const keptName = safeName(name);
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > MAX_BYTES)
+            throw new HttpError(413, "Файл больше 10 МБ");
+        chunks.push(chunk);
+    }
+    const content = Buffer.concat(chunks);
+    if (!content.length)
+        throw new HttpError(400, "Пустой файл");
+    const id = randomBytes(8).toString("hex");
+    await mkdir(directory(), { recursive: true, mode: 0o700 });
+    if (type) {
+        if (!type.magic(content))
+            throw new HttpError(400, "Это не изображение");
+        const path = join(directory(), `${id}.${type.ext}`);
+        await store(path, content);
+        void pruneAttachments().catch(() => { });
+        return { id, mime: mime.trim().toLowerCase(), name: keptName, path };
+    }
+    // A file of any type is kept in its own folder and opened from disk, so the chat holds a
+    // normal path the agent can read instead of a copy inside the project.
+    const path = join(directory(), id, keptName);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await store(path, content);
+    void pruneAttachments().catch(() => { });
+    return { id, mime: "application/octet-stream", name: keptName, path };
+}
+/** The stored image, or `null` when the id is unknown or was removed. */
+export async function readAttachment(id) {
+    if (!ID.test(id))
+        return null;
+    for (const [mime, { ext }] of Object.entries(TYPES)) {
+        try {
+            return { mime, content: await readFile(join(directory(), `${id}.${ext}`)) };
+        }
+        catch {
+            // Not stored under this type.
+        }
+    }
+    return null;
+}
+async function pruneAttachments() {
+    const now = Date.now();
+    for (const file of await readdir(directory())) {
+        const path = join(directory(), file);
+        if (now - (await stat(path)).mtimeMs > KEEP_MS)
+            await rm(path, { recursive: true, force: true });
+    }
+}

package/packages/server/modules/agent/backend.js

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

package/packages/server/modules/agent/chat-archive.js

@@ -0,0 +1,67 @@
+import { randomUUID } from "node:crypto";
+import { chatMetaOf, chatTitle, deleteHistory, historyDatabase, loadHistory, saveHistory, } from "./history-store.js";
+import { readAgentHistory, writeAgentHistory } from "./history.js";
+/** Most chats kept per scope; the oldest unpinned ones go first. */
+const KEEP = 100;
+const archiveKey = (id) => `archive:${id}`;
+export function listArchivedChats(scope) {
+    const rows = historyDatabase()
+        .prepare("SELECT id, title, updated, pinned FROM archives WHERE scope = ? ORDER BY pinned DESC, updated DESC")
+        .all(scope);
+    return rows.map((row) => ({
+        id: row.id,
+        title: row.title,
+        updatedAt: row.updated,
+        pinned: row.pinned === 1,
+    }));
+}
+/** Puts the live chat of `scope` aside and empties it; nothing happens to an empty chat. */
+export async function archiveLiveChat(scope) {
+    const turns = await readAgentHistory(scope);
+    if (!turns.length)
+        return undefined;
+    const id = randomUUID();
+    const db = historyDatabase();
+    const meta = chatMetaOf(scope);
+    saveHistory(archiveKey(id), turns);
+    db.prepare("INSERT INTO archives (id, scope, title, updated, pinned, project, backend) VALUES (?, ?, ?, ?, 0, ?, ?)").run(id, scope, meta?.title || chatTitle(turns), new Date().toISOString(), meta?.project ?? "", meta?.backend ?? "");
+    const extra = db
+        .prepare("SELECT id FROM archives WHERE scope = ? AND pinned = 0 ORDER BY updated DESC LIMIT -1 OFFSET ?")
+        .all(scope, KEEP);
+    for (const row of extra)
+        removeArchivedChat(row.id);
+    // The live chat is empty now: it should not linger in the project's list of chats, and its
+    // queue belongs to the chat that was put aside.
+    await writeAgentHistory(scope, [], meta, undefined, undefined, undefined, null);
+    return id;
+}
+/** Makes an archived chat the live one (the one that was live is put aside) and returns it. */
+export async function openArchivedChat(scope, id) {
+    const row = historyDatabase()
+        .prepare("SELECT id, title, project, backend FROM archives WHERE id = ? AND scope = ?")
+        .get(id, scope);
+    const turns = row ? loadHistory(archiveKey(id)) : undefined;
+    if (!row || !turns)
+        throw new Error("Чат не найден");
+    await archiveLiveChat(scope);
+    removeArchivedChat(id);
+    const index = row.project && row.backend
+        ? { project: row.project, backend: row.backend, title: row.title }
+        : undefined;
+    return writeAgentHistory(scope, turns, index, undefined, undefined, undefined, null);
+}
+export function renameArchivedChat(id, change) {
+    const db = historyDatabase();
+    if (change.title !== undefined) {
+        const title = change.title.trim().slice(0, 200);
+        if (!title)
+            throw new Error("Название не может быть пустым");
+        db.prepare("UPDATE archives SET title = ? WHERE id = ?").run(title, id);
+    }
+    if (change.pinned !== undefined)
+        db.prepare("UPDATE archives SET pinned = ? WHERE id = ?").run(change.pinned ? 1 : 0, id);
+}
+export function removeArchivedChat(id) {
+    historyDatabase().prepare("DELETE FROM archives WHERE id = ?").run(id);
+    deleteHistory(archiveKey(id));
+}

package/packages/server/modules/agent/command-bridge.js

@@ -0,0 +1,94 @@
+import { randomUUID } from "node:crypto";
+const host = globalThis;
+const pending = (host.projectorCommandPending ??= new Map());
+/** Each request has a single-use capability, delivered only to its originating SSE client. */
+function bridgeRequest(send, payload, signal, timeoutMs, timeoutMessage) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted)
+            return reject(new Error("Запрос остановлен"));
+        const id = randomUUID();
+        const finish = (result) => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", cancel);
+            pending.delete(id);
+            if (result.error)
+                reject(new Error(result.error));
+            else
+                resolve(result.output);
+        };
+        const cancel = () => finish({ error: "Запрос остановлен" });
+        const timer = setTimeout(() => finish({ error: timeoutMessage }), timeoutMs);
+        pending.set(id, finish);
+        signal.addEventListener("abort", cancel, { once: true });
+        send({ id, ...payload });
+    });
+}
+export function createCommandBridge(emit, signal, timeoutMs = 60000) {
+    return (request) => bridgeRequest((data) => emit("command-request", data), request, signal, timeoutMs, "Projector не ответил на вызов команды");
+}
+/** Resolves `true` only when the user explicitly allows; a denial, timeout or abort rejects or yields `false`. */
+export function createApprovalBridge(emit, signal, timeoutMs = 10 * 60_000) {
+    return async (request) => {
+        const output = await bridgeRequest((data) => emit("permission-request", data), request, signal, timeoutMs, "Разрешение не получено вовремя");
+        const answer = output;
+        if (answer?.allow !== true)
+            return false;
+        return answer.always === true ? "always" : true;
+    };
+}
+/** Resolves the user's answers, `null` when they skip; abort and timeout reject. */
+export function createQuestionBridge(emit, signal, timeoutMs = 60 * 60_000) {
+    return async (request) => {
+        const output = await bridgeRequest((data) => emit("question-request", data), request, signal, timeoutMs, "Ответ на вопрос не получен вовремя");
+        const answers = output?.answers;
+        if (!answers || typeof answers !== "object")
+            return null;
+        const result = {};
+        for (const [id, value] of Object.entries(answers)) {
+            if (!Array.isArray(value))
+                continue;
+            result[id] = value.filter((item) => typeof item === "string").slice(0, 50);
+        }
+        return result;
+    };
+}
+/**
+ * Resolves the typed secret, `null` when the user declines. The value reaches only the caller
+ * that stores it; no event, error text or log of the bridge carries it.
+ */
+export function createSecretBridge(emit, signal, timeoutMs = 10 * 60_000) {
+    return async (request) => {
+        const output = await bridgeRequest((data) => emit("secret-request", data), request, signal, timeoutMs, "Секрет не получен вовремя");
+        const value = output?.value;
+        return typeof value === "string" && value ? value : null;
+    };
+}
+/**
+ * Requests asked by a run held outside this server (its own process): the answer goes back to that
+ * process, which keeps the request open. Registered by whichever server is attached to the run.
+ */
+const relayed = (host.projectorCommandRelayed ??= new Map());
+export function relayRequest(id, deliver) {
+    relayed.set(id, deliver);
+}
+export function unrelayRequests(ids) {
+    for (const id of ids)
+        relayed.delete(id);
+}
+/** Whether the request still waits for its user: a page that joins later may show it. */
+export function isBridgeRequestPending(id) {
+    return pending.has(id) || relayed.has(id);
+}
+export function completeCommandRequest(id, result) {
+    const finish = pending.get(id);
+    if (!finish) {
+        const deliver = relayed.get(id);
+        if (!deliver)
+            return false;
+        relayed.delete(id);
+        deliver(result);
+        return true;
+    }
+    finish(result);
+    return true;
+}

package/packages/server/modules/agent/controls.js

@@ -0,0 +1,10 @@
+/** Longest list sent to the client: agents may hold thousands of past sessions. */
+export const SESSION_LIST_LIMIT = 30;
+export function selectionFrom(value) {
+    const selection = {};
+    if (value && typeof value === "object")
+        for (const [id, item] of Object.entries(value))
+            if (typeof item === "string" && id.length <= 100 && item.length <= 300)
+                selection[id] = item;
+    return selection;
+}

package/packages/server/modules/agent/event-streams.js

@@ -0,0 +1,40 @@
+import { onEventClientClose } from "../events/index.js";
+/**
+ * Answers delivered through a page's events stream, by the page's stream ID: how to detach and
+ * whose answer it is. Kept across hot reloads, which leave answers in progress running.
+ */
+const host = globalThis;
+const state = (host.projectorAgentStreams ??= {
+    detach: new Map(),
+    owners: new Map(),
+});
+/** Replace the page-close subscription only when this generation is activated. */
+export function bindAgentEventStreams() {
+    state.off?.();
+    const off = onEventClientClose((client) => {
+        for (const [stream, owner] of [...state.owners])
+            if (owner === client)
+                state.detach.get(stream)?.();
+    });
+    state.off = off;
+    return () => {
+        off();
+        if (state.off === off)
+            state.off = undefined;
+    };
+}
+/** Registers an answer of `client`; the returned function forgets it. */
+export function trackEventStream(stream, client, detach) {
+    if (!state.off)
+        bindAgentEventStreams();
+    state.detach.set(stream, detach);
+    state.owners.set(stream, client);
+    return () => {
+        state.detach.delete(stream);
+        state.owners.delete(stream);
+    };
+}
+/** The page stopped waiting for the answer. */
+export function detachEventStream(stream) {
+    state.detach.get(stream)?.();
+}