@someonegg/agent-hub 0.0.0-stage → 0.7.0

package/dist/server/server/http/session-path.js

@@ -0,0 +1,10 @@
+export const SESSION_ROOT = "/api/v1/sessions";
+export { isOpaqueId, SESSION_ID_PATTERN } from "../security/opaque-id.js";
+export function sessionPath(pathname) {
+    const [id = "", ...segments] = pathname.slice(SESSION_ROOT.length + 1).split("/");
+    return { id, segments };
+}
+export function readPathname(request, url) {
+    return request.url?.startsWith("/") ? request.url.split("?")[0] : url.pathname;
+}
+//# sourceMappingURL=session-path.js.map

package/dist/server/server/http/session-read-routes.js

@@ -0,0 +1,143 @@
+import { CatalogCapacityError, } from "../catalog/session-catalog-service.js";
+import { RepositoryQueryError } from "../repository/session-queries.js";
+import { SessionUpdatesError, } from "../updates/session-updates-service.js";
+import { invalid, only, optional } from "./query-params.js";
+import { sendJson } from "./router.js";
+import { isOpaqueId, readPathname, SESSION_ROOT, sessionPath } from "./session-path.js";
+/** Shape produced by the update-revision HMAC factory (base64url SHA-256). */
+const REVISION_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+export function createSessionReadRoutes(dependencies) {
+    return {
+        matches: () => true,
+        async handle(request, response, url) {
+            const pathname = readPathname(request, url);
+            const headOnly = request.method === "HEAD";
+            const readMethod = request.method === "GET" || headOnly;
+            if (!readMethod)
+                return false;
+            if (pathname === SESSION_ROOT) {
+                const query = parseListQuery(url.searchParams);
+                return sendWaitResponse(request, response, headOnly, (signal) => dependencies.catalog.wait(headOnly ? undefined : query.after, signal));
+            }
+            if (!pathname.startsWith(`${SESSION_ROOT}/`)) {
+                return notFound(response, headOnly);
+            }
+            const { id, segments } = sessionPath(pathname);
+            if (!isOpaqueId(id))
+                return notFound(response, headOnly);
+            if (segments.length === 1 && segments[0] === "messages") {
+                only(url.searchParams, ["limit", "after", "wait", "stateRevision"]);
+                const limit = optional(url.searchParams, "limit");
+                const after = optional(url.searchParams, "after");
+                const wait = optional(url.searchParams, "wait");
+                const stateRevision = optional(url.searchParams, "stateRevision");
+                if (wait !== undefined && wait !== "true" && wait !== "false")
+                    invalid("wait must be true or false");
+                if (stateRevision !== undefined && !REVISION_PATTERN.test(stateRevision))
+                    invalid("stateRevision is malformed");
+                const query = {
+                    ...(limit === undefined ? {} : { limit: integer(limit, "limit") }),
+                    ...(after === undefined ? {} : { after: integer(after, "after") }),
+                    wait: !headOnly && wait === "true",
+                    ...(stateRevision === undefined
+                        ? {}
+                        : { stateRevision: stateRevision }),
+                };
+                if (!query.wait) {
+                    // Plain reads go straight to the reader; waiter capacity bounds only long polls.
+                    const result = await dependencies.sessions.messages(id, query);
+                    if (result === null)
+                        return notFound(response, headOnly, "session_not_found");
+                    response.setHeader("Cache-Control", "no-store");
+                    sendJson(response, 200, result, headOnly);
+                    return true;
+                }
+                return sendWaitResponse(request, response, headOnly, (signal) => dependencies.updates.wait(id, query, signal));
+            }
+            if (segments.length === 0) {
+                if ([...url.searchParams].length > 0) {
+                    invalid("session metadata does not accept query parameters");
+                }
+                const result = await dependencies.sessions.getSession(id);
+                if (result === null) {
+                    return notFound(response, headOnly, "session_not_found");
+                }
+                sendJson(response, 200, result, headOnly);
+                return true;
+            }
+            return notFound(response, headOnly);
+        },
+        mapError(error, request, response) {
+            if (error instanceof SessionUpdatesError) {
+                const status = error.code === "session_not_found" ? 404 : 429;
+                if (status === 429)
+                    response.setHeader("Retry-After", "2");
+                sendJson(response, status, { error: { code: error.code, message: error.message } }, request.method === "HEAD");
+                return true;
+            }
+            if (error instanceof CatalogCapacityError) {
+                response.setHeader("Retry-After", "2");
+                sendJson(response, 429, { error: { code: "catalog_capacity_exceeded", message: error.message } }, request.method === "HEAD");
+                return true;
+            }
+            if (error instanceof DOMException && error.name === "AbortError") {
+                if (!response.destroyed) {
+                    response.statusCode = 204;
+                    response.end();
+                }
+                return true;
+            }
+            if (!(error instanceof RepositoryQueryError))
+                return false;
+            sendJson(response, 400, { error: { code: error.code, message: error.message } }, request.method === "HEAD");
+            return true;
+        },
+    };
+}
+async function sendWaitResponse(request, response, headOnly, read) {
+    const abort = new AbortController();
+    const disconnect = () => {
+        if (!response.writableEnded)
+            abort.abort();
+    };
+    request.once("aborted", disconnect);
+    response.once("close", disconnect);
+    response.setHeader("Cache-Control", "no-store");
+    try {
+        const result = await read(abort.signal);
+        if (abort.signal.aborted || response.destroyed)
+            return true;
+        if (result === null) {
+            response.statusCode = 204;
+            response.end();
+        }
+        else
+            sendJson(response, 200, result, headOnly);
+        return true;
+    }
+    finally {
+        request.removeListener("aborted", disconnect);
+        response.removeListener("close", disconnect);
+    }
+}
+function parseListQuery(params) {
+    only(params, ["after"]);
+    const after = optional(params, "after");
+    if (after !== undefined && !REVISION_PATTERN.test(after))
+        invalid("after is malformed");
+    return after === undefined ? {} : { after };
+}
+function integer(value, name) {
+    if (!/^\d+$/.test(value))
+        invalid(`${name} must be an integer`);
+    const result = Number(value);
+    if (!Number.isSafeInteger(result)) {
+        invalid(`${name} is outside the supported range`);
+    }
+    return result;
+}
+function notFound(response, headOnly, code = "not_found") {
+    sendJson(response, 404, { error: { code, message: "API resource not found" } }, headOnly);
+    return true;
+}
+//# sourceMappingURL=session-read-routes.js.map

package/dist/server/server/http/terminal-preview-websocket.js

@@ -0,0 +1,179 @@
+import WebSocket, { WebSocketServer } from "ws";
+import { SessionInteractionError, } from "../interaction/interaction-service.js";
+import { InteractionTransportError } from "../interaction/transport.js";
+import { SESSION_ID_PATTERN, SESSION_ROOT } from "./session-path.js";
+const PATH = new RegExp(`^${SESSION_ROOT}/(${SESSION_ID_PATTERN})/terminal-preview$`);
+const MAX_BUFFERED_BYTES = 2 * 1024 * 1024;
+export function createTerminalPreviewWebSocket(interaction) {
+    const server = new WebSocketServer({
+        noServer: true,
+        perMessageDeflate: false,
+        maxPayload: 1024,
+    });
+    const connections = new Map();
+    const counts = new Map();
+    let closing = false;
+    let shutdownTimer;
+    const heartbeat = setInterval(() => {
+        for (const [socket, connection] of connections) {
+            if (!connection.alive)
+                socket.terminate();
+            else if (socket.readyState === WebSocket.OPEN) {
+                connection.alive = false;
+                socket.ping();
+            }
+        }
+    }, 30_000);
+    heartbeat.unref();
+    return {
+        handle(request, socket, head) {
+            socket.on("error", () => socket.destroy());
+            if (closing)
+                return reject(socket, 503, "Service Unavailable");
+            let url;
+            try {
+                url = new URL(request.url ?? "/", "http://localhost");
+            }
+            catch {
+                return reject(socket, 400, "Bad Request");
+            }
+            const match = PATH.exec(url.pathname);
+            if (!match)
+                return reject(socket, 404, "Not Found");
+            if (url.search)
+                return reject(socket, 400, "Bad Request");
+            const secure = "encrypted" in request.socket && request.socket.encrypted;
+            if (request.headers.origin &&
+                request.headers.origin !== `${secure ? "https" : "http"}://${request.headers.host}`)
+                return reject(socket, 403, "Forbidden");
+            server.handleUpgrade(request, socket, head, (ws) => {
+                const sessionId = match[1];
+                const abort = new AbortController();
+                const count = counts.get(sessionId) ?? 0;
+                const capacityExceeded = connections.size >= 100 || count >= 10;
+                let release;
+                const stop = () => {
+                    abort.abort();
+                    release?.();
+                    release = undefined;
+                };
+                const connection = { alive: true, stop };
+                connections.set(ws, connection);
+                counts.set(sessionId, count + 1);
+                const send = (value) => {
+                    if (abort.signal.aborted || ws.readyState !== WebSocket.OPEN)
+                        return;
+                    if (ws.bufferedAmount > MAX_BUFFERED_BYTES) {
+                        stop();
+                        ws.close(1013, "Preview consumer is too slow");
+                        return;
+                    }
+                    ws.send(JSON.stringify(value), (error) => {
+                        if (error) {
+                            stop();
+                            ws.terminate();
+                        }
+                    });
+                };
+                const finish = (message) => {
+                    if (abort.signal.aborted)
+                        return;
+                    send(message);
+                    stop();
+                    ws.close(message.retryable ? 1013 : 1008, message.code);
+                };
+                const fail = (error) => finish(previewError(error));
+                ws.on("error", () => {
+                    stop();
+                    ws.terminate();
+                });
+                ws.on("pong", () => {
+                    connection.alive = true;
+                });
+                ws.on("message", () => {
+                    stop();
+                    ws.close(1008, "Preview accepts no application messages");
+                });
+                ws.once("close", () => {
+                    stop();
+                    connections.delete(ws);
+                    const remaining = (counts.get(sessionId) ?? 1) - 1;
+                    if (remaining)
+                        counts.set(sessionId, remaining);
+                    else
+                        counts.delete(sessionId);
+                    if (closing && !connections.size)
+                        clearTimeout(shutdownTimer);
+                });
+                if (capacityExceeded) {
+                    finish({
+                        type: "error",
+                        code: "preview_capacity_exceeded",
+                        message: "Too many terminal preview connections",
+                        retryable: true,
+                    });
+                }
+                else if (!interaction) {
+                    fail(new SessionInteractionError("interaction_not_supported", "Interaction is not enabled"));
+                }
+                else {
+                    void interaction
+                        .subscribePreview(sessionId, send, fail, abort.signal)
+                        .then((close) => {
+                        if (abort.signal.aborted)
+                            close();
+                        else
+                            release = close;
+                    })
+                        .catch(fail);
+                }
+            });
+        },
+        close() {
+            if (closing)
+                return;
+            closing = true;
+            clearInterval(heartbeat);
+            for (const [socket, connection] of connections) {
+                connection.stop();
+                socket.close(1001, "Server shutting down");
+            }
+            if (connections.size) {
+                shutdownTimer = setTimeout(() => {
+                    for (const socket of connections.keys())
+                        socket.terminate();
+                }, 1000);
+                shutdownTimer.unref();
+            }
+            server.close();
+        },
+    };
+}
+function reject(socket, status, reason) {
+    socket.end(`HTTP/1.1 ${status} ${reason}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`);
+}
+function previewError(error) {
+    if (error instanceof SessionInteractionError) {
+        return {
+            type: "error",
+            code: error.code,
+            message: error.message,
+            retryable: ["interaction_failed", "operation_result_unknown", "session_busy"].includes(error.code),
+        };
+    }
+    if (error instanceof InteractionTransportError) {
+        return {
+            type: "error",
+            code: error.code === "disconnected" ? "interaction_not_connected" : "interaction_failed",
+            message: error.message,
+            retryable: error.code !== "disconnected",
+        };
+    }
+    return {
+        type: "error",
+        code: "interaction_failed",
+        message: "Terminal Preview is temporarily unavailable",
+        retryable: true,
+    };
+}
+//# sourceMappingURL=terminal-preview-websocket.js.map

package/dist/server/server/http/upload-routes.js

@@ -0,0 +1,124 @@
+import { mkdir, readFile, realpath } from "node:fs/promises";
+import { join } from "node:path";
+import { isPreviewableUploadType, MAX_UPLOAD_BYTES } from "../../shared/uploads.js";
+import { resolveHomeDirectory } from "../config.js";
+import { validAttachmentId } from "../uploads/store.js";
+import { RequestBodyError } from "./request-body.js";
+import { sendJson } from "./router.js";
+import { isOpaqueId } from "./session-path.js";
+const SESSION_UPLOAD_PATH = /^\/api\/v1\/sessions\/([^/]+)\/uploads(?:\/([^/]+)(\/(?:content|thumbnail))?)?$/;
+async function* uploadChunks(request) {
+    let size = 0;
+    for await (const chunk of request.iterator({ destroyOnReturn: false })) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.byteLength;
+        if (size > MAX_UPLOAD_BYTES) {
+            request.resume();
+            throw new RequestBodyError(413, "body_too_large", "Files must be at most 20 MiB");
+        }
+        yield buffer;
+    }
+    if (!request.complete || request.aborted)
+        throw new Error("Upload interrupted");
+}
+export async function uploadDirectory(configured = join(resolveHomeDirectory(), "uploads")) {
+    await mkdir(configured, { recursive: true });
+    return realpath(configured);
+}
+export function createUploadRoutes(store, sessions) {
+    return {
+        matches: (url) => url.pathname === "/api/v1/uploads" || SESSION_UPLOAD_PATH.test(url.pathname),
+        async handle(request, response, url) {
+            const match = SESSION_UPLOAD_PATH.exec(url.pathname);
+            const [, encodedSessionId, attachmentId, contentPath] = match ?? [];
+            let id;
+            try {
+                id = match ? decodeURIComponent(encodedSessionId) : url.searchParams.get("sessionId");
+            }
+            catch {
+                throw new RequestBodyError(400, "invalid_session", "Invalid sessionId");
+            }
+            if (!id)
+                throw new RequestBodyError(400, "invalid_session", "sessionId is required");
+            if (!isOpaqueId(id))
+                throw new RequestBodyError(400, "invalid_session", "Invalid sessionId");
+            if (attachmentId && !validAttachmentId(attachmentId))
+                throw new RequestBodyError(400, "invalid_session", "Invalid attachment ID");
+            const method = request.method;
+            if (method === "POST" || method === "DELETE") {
+                const protocol = "encrypted" in request.socket && request.socket.encrypted ? "https" : "http";
+                if (request.headers.origin &&
+                    request.headers.origin !== `${protocol}://${request.headers.host}`)
+                    throw new RequestBodyError(403, "forbidden", "Cross-origin uploads are not allowed");
+            }
+            let allowedMethod = "GET";
+            if (!match)
+                allowedMethod = "POST";
+            else if (attachmentId && !contentPath)
+                allowedMethod = "DELETE";
+            if (method !== allowedMethod) {
+                response.setHeader("Allow", allowedMethod);
+                sendJson(response, 405, {
+                    error: { code: "method_not_allowed", message: "Method not allowed" },
+                });
+                return true;
+            }
+            if (!match) {
+                if (Number(request.headers["content-length"]) > MAX_UPLOAD_BYTES) {
+                    request.resume();
+                    throw new RequestBodyError(413, "body_too_large", "Files must be at most 20 MiB");
+                }
+                if (!(await sessions.getSession(id)))
+                    throw new RequestBodyError(404, "not_found", "Session not found");
+                const attachment = await store.upload(id, url.searchParams.get("filename") ?? "file", request.headers["content-type"] ?? "application/octet-stream", uploadChunks(request));
+                sendJson(response, 201, attachment);
+            }
+            else if (!attachmentId) {
+                if (!(await sessions.getSession(id)))
+                    throw new RequestBodyError(404, "not_found", "Session not found");
+                sendJson(response, 200, { items: await store.list(id) });
+            }
+            else if (!contentPath) {
+                await store.delete(id, attachmentId);
+                sendJson(response, 200, { deleted: true });
+            }
+            else if (contentPath === "/thumbnail") {
+                const data = await store.thumbnail(id, attachmentId);
+                if (!data)
+                    throw new RequestBodyError(404, "not_found", "Thumbnail unavailable");
+                response.setHeader("Content-Type", "image/webp");
+                response.setHeader("X-Content-Type-Options", "nosniff");
+                response.setHeader("Cache-Control", "private, max-age=86400");
+                response.end(data);
+            }
+            else {
+                const content = await (async () => {
+                    const attachment = await store.get(id, attachmentId);
+                    if (!attachment)
+                        return null;
+                    try {
+                        return { attachment, data: await readFile(attachment.path) };
+                    }
+                    catch (error) {
+                        if (error.code === "ENOENT")
+                            return null;
+                        throw error;
+                    }
+                })();
+                if (!content)
+                    throw new RequestBodyError(404, "not_found", "Attachment not found");
+                const { attachment, data } = content;
+                const preview = isPreviewableUploadType(attachment.type) && !url.searchParams.has("download");
+                response.setHeader("Content-Type", preview ? attachment.type : "application/octet-stream");
+                response.setHeader("X-Content-Type-Options", "nosniff");
+                response.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
+                response.setHeader("Cache-Control", "no-store");
+                response.setHeader("Content-Disposition", `${preview ? "inline" : "attachment"}; filename*=UTF-8''${encodeURIComponent(attachment.filename).replace(/['()*]/g, (c) => `%${c.charCodeAt(0).toString(16)}`)}`);
+                response.end(data);
+            }
+            return true;
+        },
+        mapError: () => false,
+    };
+}
+//# sourceMappingURL=upload-routes.js.map