@kingcrab/pi-imessage 0.0.43 → 1.0.0

package/dist/web/history.js

@@ -0,0 +1,87 @@
+/** Shared conversation ordering uses message activity, not conversation creation order. */
+export function historyActivity(history) {
+    let latest = 0;
+    for (const entry of history.items) {
+        for (const message of entry.model ?? []) {
+            if ("timestamp" in message && Number.isFinite(message.timestamp))
+                latest = Math.max(latest, message.timestamp);
+        }
+        const data = entry.data;
+        if (!data || typeof data !== "object" || Array.isArray(data))
+            continue;
+        const original = data.original;
+        if (!original || typeof original !== "object" || Array.isArray(original))
+            continue;
+        const date = typeof original.date === "string" ? Date.parse(original.date) : 0;
+        if (Number.isFinite(date))
+            latest = Math.max(latest, date);
+    }
+    return latest;
+}
+/** Preserve displayed messages and pagination without shipping model-only payloads. */
+export function displayHistory(history, limit) {
+    const items = history.items.flatMap((entry) => {
+        const model = (entry.model ?? []).flatMap((message) => {
+            if (message.role !== "user" && message.role !== "assistant")
+                return [];
+            if (message.role === "assistant" && message.stopReason === "toolUse")
+                return [];
+            const content = typeof message.content === "string"
+                ? message.content
+                : message.content
+                    .map((block) => block.type === "text"
+                    ? block.text
+                    : block.type === "image"
+                        ? "[Image attachment]"
+                        : block.type === "toolCall"
+                            ? `[Tool: ${block.name}]`
+                            : "")
+                    .filter(Boolean)
+                    .join("\n");
+            return content ? [{ role: message.role, content, timestamp: message.timestamp }] : [];
+        });
+        if (!model.length)
+            return [];
+        const data = entry.data && typeof entry.data === "object" && !Array.isArray(entry.data) ? entry.data : {};
+        const original = data.original && typeof data.original === "object" && !Array.isArray(data.original)
+            ? data.original
+            : {};
+        return [
+            {
+                id: entry.id,
+                model,
+                data: {
+                    legacy: data.legacy,
+                    original: {
+                        date: original.date,
+                        sender: original.sender,
+                        senderName: original.senderName,
+                        groupName: original.groupName,
+                    },
+                },
+            },
+        ];
+    });
+    if (limit === undefined)
+        return { items, next: history.next, groupName: undefined };
+    // Limit messages, not entries; order matches the browser, including imported dates.
+    const rows = items
+        .flatMap((entry) => entry.model
+        .filter((message) => message.content.replace(/^\[(?:Group '[^']*'|DM|SMS) from [^\]]+\] /, ""))
+        .map((message) => ({
+        message,
+        time: Number(message.timestamp) || Date.parse(String(entry.data.original.date ?? "")) || 0,
+        groupName: entry.data.original.groupName || message.content.match(/^\[Group '([^']*)' from [^\]]+\] /)?.[1],
+    })))
+        .sort((left, right) => left.time - right.time);
+    const groupName = rows.findLast((row) => row.groupName)?.groupName;
+    const selected = new Set(rows.slice(-limit).map((row) => row.message));
+    return {
+        items: items.flatMap((entry) => {
+            const model = entry.model.filter((message) => selected.has(message));
+            return model.length ? [{ ...entry, model }] : [];
+        }),
+        next: history.next,
+        groupName,
+    };
+}

package/dist/web/memory.js

@@ -0,0 +1,81 @@
+/** Read-only UI projection; never changes records or implements memory writes. */
+export function parseMemoryFile(contents, namespace) {
+    const records = [];
+    let invalidRecords = 0;
+    for (const line of contents.split("\n").filter((line) => line.trim())) {
+        try {
+            const record = JSON.parse(line);
+            if (!record ||
+                typeof record !== "object" ||
+                Array.isArray(record) ||
+                !("text" in record) ||
+                typeof record.text !== "string") {
+                invalidRecords++;
+                continue;
+            }
+            records.push({
+                ...record,
+                text: record.text,
+                namespace: "namespace" in record && typeof record.namespace === "string" && record.namespace
+                    ? record.namespace
+                    : namespace,
+            });
+        }
+        catch {
+            invalidRecords++;
+        }
+    }
+    return { namespace, records, invalidRecords };
+}
+/** Filter complete records before returning one page, with supersession resolved across namespaces. */
+export function memoryPage(files, parameters) {
+    const requestedPage = parameters.get("page") ?? "1";
+    if (!/^[1-9]\d*$/.test(requestedPage) || !Number.isSafeInteger(Number(requestedPage)))
+        throw new Error("Invalid memory page");
+    const query = {
+        q: parameters.get("q") ?? "",
+        namespace: parameters.get("namespace") ?? "",
+        kind: parameters.get("kind") ?? "",
+        status: parameters.get("status") ?? "active",
+    };
+    const records = files.flatMap((file) => file.records);
+    const superseded = new Set(records.flatMap((record) => typeof record.supersedes === "string"
+        ? [record.supersedes]
+        : Array.isArray(record.supersedes)
+            ? record.supersedes.filter((id) => typeof id === "string")
+            : []));
+    const search = query.q.toLowerCase();
+    const filtered = records
+        .map((record) => ({
+        ...record,
+        effectiveStatus: typeof record.id === "string" && superseded.has(record.id)
+            ? "superseded"
+            : typeof record.status === "string" && record.status
+                ? record.status
+                : "unknown",
+    }))
+        .filter((record) => (!query.namespace || record.namespace === query.namespace) &&
+        (!query.kind || record.kind === query.kind) &&
+        (!query.status || record.effectiveStatus === query.status) &&
+        (!search || JSON.stringify(record).toLowerCase().includes(search)))
+        .sort((left, right) => String(right.created_at || "").localeCompare(String(left.created_at || "")));
+    const pageSize = 20;
+    const pages = Math.max(1, Math.ceil(filtered.length / pageSize));
+    const page = Math.min(Number(requestedPage), pages);
+    return {
+        records: filtered.slice((page - 1) * pageSize, page * pageSize),
+        total: filtered.length,
+        recordCount: records.length,
+        page,
+        pages,
+        pageSize,
+        query,
+        namespaces: [
+            ...new Set(files.map((file) => file.namespace).concat(records.map((record) => record.namespace))),
+        ].sort(),
+        kinds: [
+            ...new Set(records.flatMap((record) => (typeof record.kind === "string" && record.kind ? [record.kind] : []))),
+        ].sort(),
+        invalidRecords: files.reduce((total, file) => total + file.invalidRecords, 0),
+    };
+}

package/dist/web/page.js

@@ -0,0 +1,28 @@
+function escapeHtml(text) {
+    return text.replace(/[&<>"']/g, (value) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[value] ?? value);
+}
+/** The legacy shell, backed by native read-only APIs rather than legacy host state. */
+export function renderPage(page, state) {
+    const active = page === "/" || page === "/chat" ? "/" : page;
+    const navigation = [
+        ["/", "Recent Chats"],
+        ["/tasks", "Tasks"],
+        ["/scheduled", "Scheduled"],
+        ["/logs", "Logs"],
+        ["/memory", "Memory"],
+        ["/settings", "Settings"],
+    ]
+        .map(([href, label]) => `<a href="${href}"${href === active ? ' class="active" aria-current="page"' : ""}>${label}</a>`)
+        .join("");
+    return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>blue — pi-imessage</title><link rel="stylesheet" href="/assets/style.css">
+<script src="/assets/app.js" defer></script></head>
+<body><nav class="app-nav" aria-label="Main navigation">${navigation}</nav>
+<main class="content" id="main"><header class="page-header"><h1 id="title">Recent Chats</h1>
+<div class="connection"><button id="refresh" type="button">Refresh</button></div></header>
+<div id="toolbar"></div><p id="notice" role="status" hidden></p><div id="view" aria-busy="true"></div>
+<details class="native-state"><summary>Native state</summary><pre id="state">${escapeHtml(state)}</pre></details></main>
+<aside class="chat-list" id="chat-list" aria-label="Conversations" hidden></aside>
+</body></html>`;
+}

package/dist/web/schedules.js

@@ -0,0 +1,74 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { DirectSends } from "../agent/direct-send.js";
+import { EXECUTION_KIND, Schedules } from "../agent/scheduling.js";
+/** Native occurrence tasks are the execution history; this view keeps no parallel log. */
+export function readSchedules(harness) {
+    return harness.commit(async (tx) => {
+        const schedules = await tx.doc(Schedules);
+        const sends = await tx.doc(DirectSends);
+        const jobs = [];
+        for (const schedule of schedules.items) {
+            const task = await tx.task(schedule.taskId);
+            const checkpoint = task?.state.checkpoint;
+            const state = checkpoint && typeof checkpoint === "object" && !Array.isArray(checkpoint) ? checkpoint : undefined;
+            const executions = [];
+            let cursor;
+            do {
+                const page = await tx.scanTasks({ conversationId: schedule.conversationId, kind: EXECUTION_KIND }, 100, cursor);
+                executions.push(...page.items);
+                cursor = page.next;
+            } while (cursor);
+            // Native scans merge live/terminal records; their order is not execution chronology.
+            const runs = executions
+                .sort((a, b) => b.id - a.id)
+                .slice(0, 10)
+                .map((run) => {
+                const outcome = run.state.outcome;
+                const result = outcome?.status === "completed" &&
+                    outcome.result &&
+                    typeof outcome.result === "object" &&
+                    !Array.isArray(outcome.result)
+                    ? outcome.result
+                    : undefined;
+                const receipt = typeof result?.requestId === "string"
+                    ? sends.requests.find((item) => item.requestId === result.requestId)
+                    : undefined;
+                return {
+                    id: run.id,
+                    input: run.input,
+                    status: outcome?.status ?? run.state.status,
+                    result,
+                    error: outcome?.status === "failed" || outcome?.status === "faulted"
+                        ? outcome.error.message
+                        : undefined,
+                    delivery: receipt?.textStatus ?? (result?.requestId ? "queued" : undefined),
+                };
+            });
+            jobs.push({
+                id: schedule.id,
+                name: schedule.name,
+                kind: schedule.kind,
+                enabled: schedule.enabled,
+                time: schedule.time,
+                intervalMs: schedule.intervalMs,
+                timezone: schedule.timezone,
+                chatGuid: schedule.chatGuid,
+                extension: schedule.extension,
+                execution: schedule.execution,
+                conversationId: schedule.conversationId,
+                taskId: schedule.taskId,
+                status: task?.state.outcome?.status ?? task?.state.status ?? "missing",
+                phase: state?.phase,
+                nextAt: state?.phase === "sleep" ? state.at : undefined,
+                runs,
+            });
+        }
+        return {
+            jobs,
+            recent: jobs
+                .flatMap((job) => job.runs.map((run) => ({ ...run, jobId: job.id, name: job.name })))
+                .sort((a, b) => b.id - a.id)
+                .slice(0, 10),
+        };
+    }, BACKGROUND_CONTEXT);
+}

package/dist/web/server.js

@@ -0,0 +1,348 @@
+import { randomUUID } from "node:crypto";
+import { open, readdir, readFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { gzip } from "node:zlib";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { LiveDoc, } from "@earendil-works/pi-durable";
+import { Chats } from "../agent/chats.js";
+import { DirectSends } from "../agent/direct-send.js";
+import { Sessions } from "../agent/health.js";
+import { Deliveries } from "../agent/replies.js";
+import { Schedules } from "../agent/scheduling.js";
+import { readSettings } from "../config/settings.js";
+import { displayHistory, historyActivity } from "./history.js";
+import { memoryPage, parseMemoryFile } from "./memory.js";
+import { renderPage } from "./page.js";
+import { readSchedules } from "./schedules.js";
+import { readTaskTree } from "./tasks.js";
+function readCursor(value) {
+    if (!value)
+        return;
+    if (value.length > 2048)
+        throw new Error("Invalid cursor");
+    const parsed = JSON.parse(Buffer.from(value, "base64url").toString());
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("Invalid cursor");
+    return parsed;
+}
+function redact(value, compact = false, truncateStrings = true) {
+    return JSON.stringify(value, (key, item) => /^(authorization|password|api[_-]?key|(?:(?:access|refresh)[_-]?)?token|secret|credentials?)$/i.test(key)
+        ? "[redacted]"
+        : truncateStrings && typeof item === "string" && item.length > 50000
+            ? `${item.slice(0, 50000)}\n[truncated]`
+            : item, compact ? undefined : 2)
+        .replace(/\b(?:sk-[\w-]{8,}|gh[pousr]_[\w]{8,})\b/g, "[redacted]")
+        .replace(/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer [redacted]");
+}
+const compress = promisify(gzip);
+async function send(response, status, contentType, text) {
+    const encodings = new Map((response.req.headers["accept-encoding"] ?? "").split(",").map((item) => {
+        const [name, ...parameters] = item.trim().toLowerCase().split(";");
+        const quality = parameters
+            .map((parameter) => parameter.trim())
+            .find((parameter) => parameter.startsWith("q="));
+        return [name.trim(), quality ? Number(quality.slice(2)) : 1];
+    }));
+    const body = Buffer.from(text);
+    const useGzip = body.length >= 1024 && (encodings.get("gzip") ?? encodings.get("*") ?? 0) > 0;
+    const payload = useGzip ? await compress(body) : body;
+    response.writeHead(status, {
+        "Content-Type": contentType,
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff",
+        Vary: "Accept-Encoding",
+        "Content-Length": payload.length,
+        ...(useGzip ? { "Content-Encoding": "gzip" } : {}),
+    });
+    response.end(payload);
+}
+function json(response, status, value, compact = false, truncateStrings = true) {
+    return send(response, status, "application/json; charset=utf-8", redact(value, compact, truncateStrings));
+}
+/** Read-only pages and an explicit model health check. Viewing pages never starts work. */
+export async function startWeb(options) {
+    const streams = new Map();
+    let revision = 0;
+    const instance = randomUUID();
+    function viewRevision() {
+        return `${instance}:${revision}`;
+    }
+    function settings() {
+        return readSettings(options.workingDir);
+    }
+    async function history(id, cursor) {
+        const conversation = await options.agent.harness.conversation(id, BACKGROUND_CONTEXT);
+        if (!conversation)
+            throw new Error("Conversation not found");
+        return conversation.entries({}, 100, cursor, BACKGROUND_CONTEXT);
+    }
+    function delivery(id) {
+        return options.agent.harness.snapshot(Deliveries, id, BACKGROUND_CONTEXT);
+    }
+    async function overview() {
+        const [chats, configuration] = await Promise.all([
+            options.agent.harness.snapshot(Chats, BACKGROUND_CONTEXT),
+            settings(),
+        ]);
+        const conversations = await Promise.all((chats?.items ?? []).map(async (chat) => {
+            try {
+                const [entries, receipt] = await Promise.all([
+                    history(chat.conversationId),
+                    delivery(chat.conversationId),
+                ]);
+                const { items, groupName } = displayHistory(entries, 15);
+                return {
+                    ...chat,
+                    updatedAt: historyActivity(entries),
+                    history: { items, groupName },
+                    delivery: {
+                        answers: Object.fromEntries(items.map((entry) => [entry.id, receipt?.answers[entry.id]])),
+                        drafts: Object.fromEntries(items.map((entry) => [entry.id, receipt?.drafts?.[entry.id]])),
+                    },
+                };
+            }
+            catch (error) {
+                return { ...chat, error: error instanceof Error ? error.message : String(error) };
+            }
+        }));
+        return {
+            conversations,
+            revision: viewRevision(),
+            settings: { chatAllowlist: configuration.chatAllowlist },
+        };
+    }
+    const server = createServer((request, response) => {
+        void handle(request, response).catch((error) => {
+            if (!response.headersSent)
+                void json(response, 400, {
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error),
+                }).catch(() => response.destroy());
+            else
+                response.end();
+        });
+    });
+    async function handle(request, response) {
+        const url = new URL(request.url ?? "/", "http://localhost");
+        if (request.method === "GET" && url.pathname === "/favicon.ico") {
+            response.writeHead(204);
+            response.end();
+            return;
+        }
+        if (request.headers["sec-fetch-site"] === "cross-site" ||
+            (request.headers.origin && new URL(request.headers.origin).host !== request.headers.host)) {
+            await json(response, 403, { error: "Cross-origin requests are not allowed" });
+            return;
+        }
+        if (request.method === "GET" && url.pathname === "/health/model") {
+            try {
+                await json(response, 200, await options.agent.health());
+            }
+            catch (error) {
+                await json(response, 503, {
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            return;
+        }
+        if (request.method !== "GET") {
+            await json(response, 404, { error: "Not found" });
+            return;
+        }
+        if (url.pathname === "/events") {
+            response.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-store" });
+            response.write(`event: ready\ndata: ${JSON.stringify({ revision: viewRevision() })}\n\n`);
+            const unsubscribe = options.agent.harness.subscribeCommits(() => {
+                if (!response.write('data: {"updated":true}\n\n')) {
+                    unsubscribe();
+                    response.destroy();
+                }
+            });
+            streams.set(response, unsubscribe);
+            response.on("error", () => {
+                unsubscribe();
+                streams.delete(response);
+            });
+            response.on("close", () => {
+                unsubscribe();
+                streams.delete(response);
+            });
+            return;
+        }
+        const asset = url.pathname === "/assets/style.css"
+            ? "style.css"
+            : url.pathname === "/assets/app.js"
+                ? "app.js"
+                : undefined;
+        if (asset) {
+            const path = new URL(asset, import.meta.url);
+            await send(response, 200, asset.endsWith(".css") ? "text/css; charset=utf-8" : "text/javascript; charset=utf-8", await readFile(path, "utf8"));
+            return;
+        }
+        let value;
+        let compact = false;
+        const page = url.pathname.replace(/\/data$/, "");
+        if (page === "/" || page === "/chat") {
+            const id = url.searchParams.get("conversationId");
+            if (id) {
+                if (!/^\d+$/.test(id))
+                    throw new Error("Invalid conversation ID");
+                const conversation = await options.agent.harness.conversation(Number(id), BACKGROUND_CONTEXT);
+                if (!conversation) {
+                    await json(response, 404, { error: "Conversation not found" });
+                    return;
+                }
+                const cursor = readCursor(url.searchParams.get("cursor"));
+                const detail = {
+                    history: await history(conversation.id, cursor),
+                    delivery: await delivery(conversation.id),
+                    live: await options.agent.harness.snapshot(LiveDoc, conversation.id, BACKGROUND_CONTEXT),
+                    revision: viewRevision(),
+                };
+                if (!url.pathname.endsWith("/data") || url.searchParams.get("view") === "display") {
+                    const [chats, configuration] = await Promise.all([
+                        options.agent.harness.snapshot(Chats, BACKGROUND_CONTEXT),
+                        settings(),
+                    ]);
+                    value = {
+                        history: displayHistory(detail.history),
+                        delivery: detail.delivery,
+                        chat: chats?.items.find((chat) => chat.conversationId === conversation.id),
+                        settings: { chatAllowlist: configuration.chatAllowlist },
+                        revision: detail.revision,
+                    };
+                    compact = true;
+                }
+                else
+                    value = {
+                        history: detail.history,
+                        delivery: detail.delivery,
+                        live: detail.live,
+                        agent: await conversation.agent(BACKGROUND_CONTEXT),
+                    };
+            }
+            else if (!url.pathname.endsWith("/data") || url.searchParams.get("view") === "overview") {
+                value = await overview();
+                compact = true;
+            }
+            else
+                value = {
+                    chats: await options.agent.harness.snapshot(Chats, BACKGROUND_CONTEXT),
+                    sessions: await options.agent.harness.snapshot(Sessions, BACKGROUND_CONTEXT),
+                    tasks: await options.agent.harness.commit((tx) => tx.scanTasks({}, 100), BACKGROUND_CONTEXT),
+                    sends: await options.agent.harness.snapshot(DirectSends, BACKGROUND_CONTEXT),
+                    inspection: await options.agent.harness.inspect(BACKGROUND_CONTEXT),
+                };
+        }
+        else if (page === "/scheduled") {
+            value = await readSchedules(options.agent.harness);
+            compact = true;
+        }
+        else if (page === "/tasks") {
+            value = {
+                ...(await readTaskTree(options.agent.harness)),
+                schedules: await options.agent.harness.snapshot(Schedules, BACKGROUND_CONTEXT),
+                chats: await options.agent.harness.snapshot(Chats, BACKGROUND_CONTEXT),
+                sessions: await options.agent.harness.snapshot(Sessions, BACKGROUND_CONTEXT),
+                revision: viewRevision(),
+            };
+            compact = true;
+        }
+        else if (url.pathname === "/tasks/task/data") {
+            const id = url.searchParams.get("taskId");
+            if (!id || !/^\d+$/.test(id) || !Number.isSafeInteger(Number(id)))
+                throw new Error("Invalid task ID");
+            value = await options.agent.harness.getTask(Number(id), BACKGROUND_CONTEXT);
+            if (!value) {
+                await json(response, 404, { error: "Task not found" });
+                return;
+            }
+        }
+        else if (page === "/settings")
+            value = await settings();
+        else if (page === "/logs") {
+            const cursor = readCursor(url.searchParams.get("cursor"));
+            const tasks = await options.agent.harness.commit((tx) => tx.scanTasks({}, 100, cursor), BACKGROUND_CONTEXT);
+            let hostLog = "";
+            try {
+                const file = await open(join(options.workingDir, "service.log"), "r");
+                try {
+                    const size = (await file.stat()).size;
+                    const buffer = Buffer.alloc(Math.min(size, 50000));
+                    const read = await file.read(buffer, 0, buffer.length, Math.max(0, size - buffer.length));
+                    hostLog = buffer.subarray(0, read.bytesRead).toString();
+                }
+                finally {
+                    await file.close();
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            value = { tasks, hostLog };
+        }
+        else if (page === "/memory") {
+            const root = join(options.workingDir, "skills", "file-memory", "namespaces");
+            const files = await readdir(root, { recursive: true }).catch((error) => {
+                if (error.code === "ENOENT")
+                    return [];
+                throw error;
+            });
+            const namespaces = files.filter((file) => file.endsWith(".jsonl")).sort();
+            if (!url.pathname.endsWith("/data") || url.searchParams.get("view") === "records") {
+                const records = await Promise.all(namespaces.map(async (file) => parseMemoryFile(await readFile(join(root, file), "utf8"), file.slice(0, -6))));
+                value = memoryPage(records, url.searchParams);
+                compact = true;
+            }
+            else {
+                // Keep the raw namespace API shape, but never cut a JSONL record in half.
+                value = await Promise.all(namespaces.map(async (file) => ({
+                    namespace: file.slice(0, -6),
+                    records: await readFile(join(root, file), "utf8"),
+                })));
+            }
+        }
+        else {
+            await json(response, 404, { error: "Not found" });
+            return;
+        }
+        if (url.pathname.endsWith("/data")) {
+            await json(response, 200, value, compact, page !== "/memory");
+            return;
+        }
+        await send(response, 200, "text/html; charset=utf-8", renderPage(page, redact(value, compact, page !== "/memory")));
+    }
+    const unsubscribeRevision = options.agent.harness.subscribeCommits((publication) => {
+        if (publication.changes.length)
+            revision++;
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(options.port ?? 7750, options.host ?? "localhost", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    }).catch((error) => {
+        unsubscribeRevision();
+        throw error;
+    });
+    const address = server.address();
+    if (!address || typeof address === "string")
+        throw new Error("Missing web server address");
+    return {
+        address,
+        async close() {
+            unsubscribeRevision();
+            for (const [stream, unsubscribe] of streams) {
+                unsubscribe();
+                stream.end();
+            }
+            server.closeAllConnections();
+            await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+        },
+    };
+}