agent-lyceum 0.28.0 → 0.29.0

package/web/dist/public/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="zh-Hant">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>agent-lyceum</title>
+    <script type="module" crossorigin src="/assets/index-D2JeeQpl.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B1Ld6Pl5.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/web/dist/server/http.js

@@ -0,0 +1,94 @@
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".json": "application/json; charset=utf-8",
+    ".woff2": "font/woff2",
+};
+function inside(root, file) {
+    const rel = path.relative(root, file);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+function sendFile(res, file) {
+    const ext = path.extname(file);
+    res.writeHead(200, {
+        "Content-Type": MIME[ext] ?? "application/octet-stream",
+        "Cache-Control": ext === ".html" ? "no-cache" : "public, max-age=3600",
+    });
+    fs.createReadStream(file).pipe(res);
+}
+export function serveStatic(staticDir, req, res) {
+    const root = path.resolve(staticDir);
+    let pathname = "/";
+    try {
+        pathname = decodeURIComponent(new URL(req.url ?? "/", "http://127.0.0.1").pathname);
+    }
+    catch {
+        res.writeHead(400);
+        res.end();
+        return;
+    }
+    const requested = path.resolve(root, `.${pathname}`);
+    if (!inside(root, requested)) {
+        res.writeHead(403);
+        res.end();
+        return;
+    }
+    if (fs.existsSync(requested) && fs.statSync(requested).isFile()) {
+        sendFile(res, requested);
+        return;
+    }
+    const ext = path.extname(pathname);
+    const index = path.join(root, "index.html");
+    if ((ext && ext !== ".html") || !fs.existsSync(index)) {
+        res.writeHead(404);
+        res.end();
+        return;
+    }
+    sendFile(res, index);
+}
+export function writeEvent(res, event) {
+    res.write(`data: ${JSON.stringify(event)}\n\n`);
+}
+export function attachEvents(hub, req, res) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+    });
+    const unsubscribe = hub.subscribe((event) => writeEvent(res, event));
+    const ping = setInterval(() => {
+        res.write(": ping\n\n");
+    }, 15_000);
+    const done = () => {
+        clearInterval(ping);
+        unsubscribe();
+    };
+    req.on("close", done);
+    res.on("error", done);
+}
+export function listen(port, host, onRequest) {
+    const server = http.createServer(onRequest);
+    const sockets = new Set();
+    server.on("connection", (socket) => {
+        sockets.add(socket);
+        socket.on("close", () => sockets.delete(socket));
+    });
+    return new Promise((resolve, reject) => {
+        const fail = (err) => {
+            if (err.code === "EADDRINUSE")
+                reject(new Error(`Port ${port} is already in use.`));
+            else
+                reject(err);
+        };
+        server.once("error", fail);
+        server.listen(port, host, () => {
+            server.off("error", fail);
+            resolve({ server, sockets });
+        });
+    });
+}

package/web/dist/server/hub.js

@@ -0,0 +1,97 @@
+export function createWebHub(factory) {
+    const watchers = new Map();
+    const latest = new Map();
+    const listeners = new Set();
+    let quota;
+    let quotaToken = 0;
+    const emit = (event) => {
+        for (const listener of listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                /* one subscriber cannot stop the others */
+            }
+        }
+    };
+    const sync = () => {
+        let names;
+        try {
+            names = factory.list();
+        }
+        catch {
+            return;
+        }
+        const want = new Set(names);
+        for (const [name, watch] of watchers) {
+            if (want.has(name))
+                continue;
+            watch.close();
+            watchers.delete(name);
+            latest.delete(name);
+            emit({ type: "removed", name });
+        }
+        for (const name of names) {
+            if (watchers.has(name))
+                continue;
+            try {
+                const watch = factory.watch(name, (frame) => {
+                    latest.set(name, frame);
+                    emit({ type: "frame", name, frame });
+                });
+                watchers.set(name, watch);
+            }
+            catch (e) {
+                const frame = { schema_version: 1, error: e.message };
+                latest.set(name, frame);
+                emit({ type: "frame", name, frame });
+            }
+        }
+        for (const watch of watchers.values()) {
+            try {
+                watch.beat();
+            }
+            catch {
+                /* one project's sweep cannot stop the others */
+            }
+        }
+    };
+    const refreshQuota = () => {
+        if (!factory.quota)
+            return Promise.resolve(quota);
+        const token = ++quotaToken;
+        return factory
+            .quota()
+            .then((reports) => {
+            if (token !== quotaToken)
+                return quota;
+            quota = reports;
+            emit({ type: "quota", reports });
+            return reports;
+        })
+            .catch(() => quota);
+    };
+    return {
+        start: sync,
+        beat: sync,
+        refreshQuota,
+        close() {
+            quotaToken += 1;
+            for (const watch of watchers.values())
+                watch.close();
+            watchers.clear();
+            listeners.clear();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            const projects = [...latest].map(([name, frame]) => ({ name, frame })).sort((a, b) => a.name.localeCompare(b.name));
+            try {
+                listener({ type: "snapshot", projects, ...(quota ? { quota } : {}) });
+            }
+            catch {
+                listeners.delete(listener);
+            }
+            return () => listeners.delete(listener);
+        },
+    };
+}

package/web/dist/server/open.js

@@ -0,0 +1,9 @@
+import { spawn } from "node:child_process";
+export function openBrowser(url) {
+    if (process.platform === "darwin")
+        spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+    else if (process.platform === "win32")
+        spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
+    else
+        spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+}

package/web/dist/start.js

@@ -0,0 +1,58 @@
+import { createWebHub } from "./server/hub.js";
+import { attachEvents, listen, serveStatic } from "./server/http.js";
+import { openBrowser } from "./server/open.js";
+export async function startWebServer(opts) {
+    const hub = createWebHub(opts.factory);
+    hub.start();
+    hub.refreshQuota();
+    const heartbeat = setInterval(() => hub.beat(), opts.heartbeatMs ?? 5_000);
+    const quotaBeat = setInterval(() => hub.refreshQuota(), 60_000);
+    const { server, sockets } = await listen(opts.port, opts.host, (req, res) => {
+        const pathname = (req.url ?? "/").split("?")[0] ?? "/";
+        if (pathname === "/events") {
+            attachEvents(hub, req, res);
+            return;
+        }
+        if (pathname === "/quota" && req.method === "POST") {
+            void hub.refreshQuota().then((reports) => {
+                res.writeHead(200, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" });
+                res.end(JSON.stringify(reports ?? []));
+            }, () => {
+                if (res.headersSent)
+                    return;
+                res.writeHead(500);
+                res.end();
+            });
+            return;
+        }
+        if (req.method !== "GET" && req.method !== "HEAD") {
+            res.writeHead(405);
+            res.end();
+            return;
+        }
+        serveStatic(opts.staticDir, req, res);
+    });
+    const address = server.address();
+    const port = typeof address === "object" && address ? address.port : opts.port;
+    const host = opts.host === "0.0.0.0" || opts.host === "::" ? "127.0.0.1" : opts.host;
+    const shown = host.includes(":") ? `[${host}]` : host;
+    const url = `http://${shown}:${port}/`;
+    if (opts.open)
+        openBrowser(url);
+    return {
+        url,
+        close: () => new Promise((resolve, reject) => {
+            clearInterval(heartbeat);
+            clearInterval(quotaBeat);
+            hub.close();
+            for (const socket of sockets)
+                socket.destroy();
+            server.close((err) => {
+                if (err && err.code !== "ERR_SERVER_NOT_RUNNING")
+                    reject(err);
+                else
+                    resolve();
+            });
+        }),
+    };
+}

package/web/dist/types.js

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