loop-task 2.1.4 → 2.1.7

package/dist/daemon/http-server.js

@@ -1,599 +0,0 @@
-import http from "node:http";
-import fs from "node:fs";
-import { HTTP_API_PORT, HTTP_API_HOST, LOG_TAIL_DEFAULT } from "../config/constants.js";
-import { daemonLog } from "./daemon-log.js";
-import { tail } from "../shared/tail.js";
-import { buildLoopOptions } from "../loop-config.js";
-function sendJson(res, status, data) {
-    const body = JSON.stringify(data);
-    res.writeHead(status, {
-        "Content-Type": "application/json",
-        "Content-Length": Buffer.byteLength(body),
-    });
-    res.end(body);
-}
-function sendOk(res, data, status = 200) {
-    sendJson(res, status, { ok: true, data: data ?? null });
-}
-function sendError(res, status, message) {
-    sendJson(res, status, { ok: false, error: { message } });
-}
-function sendNotFound(res, id) {
-    sendError(res, 404, `Not found: ${id}`);
-}
-function matchRoute(routes, method, pathSegments) {
-    for (const route of routes) {
-        if (route.method !== method)
-            continue;
-        if (route.segments.length !== pathSegments.length)
-            continue;
-        const params = {};
-        let matched = true;
-        for (let i = 0; i < route.segments.length; i++) {
-            const routeSeg = route.segments[i];
-            const pathSeg = pathSegments[i];
-            if (routeSeg.startsWith(":")) {
-                params[routeSeg.slice(1)] = decodeURIComponent(pathSeg);
-            }
-            else if (routeSeg !== pathSeg) {
-                matched = false;
-                break;
-            }
-        }
-        if (matched) {
-            return { params, handler: route.handler };
-        }
-    }
-    return null;
-}
-function parsePath(url) {
-    if (!url)
-        return [];
-    const pathname = url.split("?")[0] ?? "";
-    return pathname.split("/").filter((s) => s.length > 0);
-}
-function parseQuery(url) {
-    if (!url)
-        return new URLSearchParams();
-    const qs = url.split("?")[1] ?? "";
-    return new URLSearchParams(qs);
-}
-async function readBody(req) {
-    return new Promise((resolve, reject) => {
-        let body = "";
-        req.on("data", (chunk) => {
-            body += chunk.toString();
-            if (body.length > 1024 * 1024) {
-                reject(new Error("Body too large"));
-                req.destroy();
-            }
-        });
-        req.on("end", () => {
-            if (!body.trim()) {
-                resolve({});
-                return;
-            }
-            try {
-                resolve(JSON.parse(body));
-            }
-            catch {
-                reject(new Error("Invalid JSON body"));
-            }
-        });
-        req.on("error", reject);
-    });
-}
-export class HttpApiServer {
-    server;
-    manager;
-    taskManager;
-    projectManager;
-    routes = [];
-    sseClients = new Set();
-    constructor(manager, taskManager, projectManager) {
-        this.manager = manager;
-        this.taskManager = taskManager;
-        this.projectManager = projectManager;
-        this.server = http.createServer((req, res) => this.handleRequest(req, res));
-        this.registerRoutes();
-    }
-    async listen(port = HTTP_API_PORT, host = HTTP_API_HOST) {
-        return new Promise((resolve, reject) => {
-            this.server.on("error", (err) => {
-                if (err.code === "EADDRINUSE") {
-                    daemonLog(`HTTP API server: port ${port} already in use, skipping HTTP transport`);
-                    resolve();
-                }
-                else {
-                    reject(err);
-                }
-            });
-            this.server.listen(port, host, () => {
-                daemonLog(`HTTP API server listening on ${host}:${port}`);
-                resolve();
-            });
-        });
-    }
-    async close() {
-        for (const client of this.sseClients) {
-            client.destroy();
-        }
-        this.sseClients.clear();
-        return new Promise((resolve) => {
-            this.server.close(() => resolve());
-        });
-    }
-    broadcastEvent(event, data) {
-        const payload = `event: ${event}\ndata: ${JSON.stringify(data ?? {})}\n\n`;
-        for (const client of this.sseClients) {
-            try {
-                client.write(payload);
-            }
-            catch {
-                this.sseClients.delete(client);
-            }
-        }
-    }
-    registerRoutes() {
-        const r = (method, path, handler) => {
-            const segments = path.split("/").filter((s) => s.length > 0);
-            this.routes.push({ method, segments, handler });
-        };
-        r("GET", "/api/loops", (_req, res) => {
-            sendOk(res, this.manager.list());
-        });
-        r("GET", "/api/loops/:id", (_req, res, params) => {
-            const meta = this.manager.status(params.id);
-            if (!meta) {
-                sendNotFound(res, params.id);
-                return;
-            }
-            sendOk(res, meta);
-        });
-        r("POST", "/api/loops", async (req, res) => {
-            try {
-                const body = await readBody(req);
-                const intervalHuman = body.intervalHuman ?? "5m";
-                const { options } = buildLoopOptions(intervalHuman, {
-                    command: body.command,
-                    commandArgs: body.commandArgs,
-                    taskId: body.taskId,
-                    cwd: body.cwd,
-                    now: body.now,
-                    maxRuns: body.maxRuns,
-                    verbose: body.verbose,
-                    description: body.description,
-                    projectId: body.projectId,
-                    offset: body.offset,
-                });
-                const id = this.manager.start(options, intervalHuman);
-                sendOk(res, { id }, 201);
-            }
-            catch (err) {
-                sendError(res, 400, err instanceof Error ? err.message : String(err));
-            }
-        });
-        r("PATCH", "/api/loops/:id", async (req, res, params) => {
-            try {
-                const body = await readBody(req);
-                const intervalHuman = body.intervalHuman ?? "5m";
-                const { options } = buildLoopOptions(intervalHuman, {
-                    command: body.command,
-                    commandArgs: body.commandArgs,
-                    taskId: body.taskId,
-                    cwd: body.cwd,
-                    now: body.now,
-                    maxRuns: body.maxRuns,
-                    verbose: body.verbose,
-                    description: body.description,
-                    projectId: body.projectId,
-                    offset: body.offset,
-                });
-                const ok = await this.manager.update(params.id, options, intervalHuman);
-                if (!ok) {
-                    sendNotFound(res, params.id);
-                    return;
-                }
-                sendOk(res, { id: params.id });
-            }
-            catch (err) {
-                sendError(res, 400, err instanceof Error ? err.message : String(err));
-            }
-        });
-        r("DELETE", "/api/loops/:id", async (_req, res, params) => {
-            const ok = await this.manager.delete(params.id);
-            if (!ok) {
-                sendNotFound(res, params.id);
-                return;
-            }
-            sendOk(res);
-        });
-        r("POST", "/api/loops/:id/pause", (_req, res, params) => {
-            if (!this.manager.pause(params.id)) {
-                sendNotFound(res, params.id);
-                return;
-            }
-            sendOk(res);
-        });
-        r("POST", "/api/loops/:id/resume", (_req, res, params) => {
-            if (!this.manager.resume(params.id)) {
-                sendNotFound(res, params.id);
-                return;
-            }
-            sendOk(res);
-        });
-        r("POST", "/api/loops/:id/trigger", (_req, res, params) => {
-            if (this.manager.isMaxRunsBlocked(params.id)) {
-                sendError(res, 400, "Max runs reached");
-                return;
-            }
-            if (this.manager.isRunning(params.id)) {
-                sendError(res, 409, "Loop is already running");
-                return;
-            }
-            if (!this.manager.trigger(params.id)) {
-                sendNotFound(res, params.id);
-                return;
-            }
-            sendOk(res);
-        });
-        r("POST", "/api/loops/:id/stop", (_req, res, params) => {
-            if (!this.manager.stopLoop(params.id)) {
-                sendNotFound(res, params.id);
-                return;
-            }
-            sendOk(res);
-        });
-        r("POST", "/api/loops/stop-all", (_req, res) => {
-            const count = this.manager.stopAllLoops();
-            sendOk(res, { count });
-        });
-        r("GET", "/api/loops/:id/logs", (_req, res, params) => {
-            const logPath = this.manager.getLogPath(params.id);
-            if (!logPath) {
-                sendNotFound(res, params.id);
-                return;
-            }
-            const query = parseQuery(_req.url);
-            const tailCount = parseInt(query.get("tail") ?? String(LOG_TAIL_DEFAULT), 10);
-            if (!fs.existsSync(logPath)) {
-                sendOk(res, "");
-                return;
-            }
-            const content = fs.readFileSync(logPath, "utf-8");
-            sendOk(res, tail(content, tailCount).join("\n"));
-        });
-        r("GET", "/api/loops/:id/logs/stream", (_req, res, params) => {
-            const logPath = this.manager.getLogPath(params.id);
-            if (!logPath) {
-                sendNotFound(res, params.id);
-                return;
-            }
-            res.writeHead(200, {
-                "Content-Type": "text/event-stream",
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-            });
-            const query = parseQuery(_req.url);
-            const tailCount = parseInt(query.get("tail") ?? "0", 10);
-            if (fs.existsSync(logPath)) {
-                const content = fs.readFileSync(logPath, "utf-8");
-                for (const line of tail(content, tailCount)) {
-                    if (line) {
-                        res.write(`data: ${line}\n\n`);
-                    }
-                }
-            }
-            let fileSize = fs.existsSync(logPath) ? fs.statSync(logPath).size : 0;
-            const watcher = fs.watch(logPath, (eventType) => {
-                if (eventType === "rename" && !fs.existsSync(logPath)) {
-                    watcher.close();
-                    res.write("event: end\ndata: {}\n\n");
-                    res.end();
-                    return;
-                }
-                if (eventType === "change") {
-                    try {
-                        const stat = fs.statSync(logPath);
-                        if (stat.size > fileSize) {
-                            const fd = fs.openSync(logPath, "r");
-                            const buf = Buffer.alloc(stat.size - fileSize);
-                            fs.readSync(fd, buf, 0, buf.length, fileSize);
-                            fs.closeSync(fd);
-                            fileSize = stat.size;
-                            for (const line of buf.toString().split("\n")) {
-                                if (line) {
-                                    res.write(`data: ${line}\n\n`);
-                                }
-                            }
-                        }
-                    }
-                    catch {
-                        watcher.close();
-                        res.end();
-                    }
-                }
-            });
-            _req.on("close", () => {
-                watcher.close();
-                res.end();
-            });
-        });
-        r("GET", "/api/loops/:id/runs/:num", (_req, res, params) => {
-            const { id, num } = params;
-            const logPath = this.manager.getLogPath(id);
-            if (!logPath || !fs.existsSync(logPath)) {
-                sendOk(res, "");
-                return;
-            }
-            const meta = this.manager.status(id);
-            if (!meta) {
-                sendNotFound(res, id);
-                return;
-            }
-            const runNumber = parseInt(num, 10);
-            const records = meta.runHistory
-                .filter((r) => r.runNumber === runNumber)
-                .sort((a, b) => a.logOffset - b.logOffset);
-            if (records.length === 0) {
-                sendOk(res, "");
-                return;
-            }
-            const buffer = fs.readFileSync(logPath);
-            const allSorted = meta.runHistory.slice().sort((a, b) => a.logOffset - b.logOffset);
-            const parts = records.map((record) => {
-                const start = record.logOffset;
-                const idx = allSorted.indexOf(record);
-                const end = idx < allSorted.length - 1 ? allSorted[idx + 1].logOffset : buffer.length;
-                return buffer.toString("utf-8", start, end);
-            });
-            sendOk(res, parts.join(""));
-        });
-        r("GET", "/api/tasks", (_req, res) => {
-            sendOk(res, this.taskManager.list());
-        });
-        r("GET", "/api/tasks/:id", (_req, res, params) => {
-            const task = this.taskManager.get(params.id);
-            if (!task) {
-                sendNotFound(res, params.id);
-                return;
-            }
-            sendOk(res, task);
-        });
-        r("POST", "/api/tasks", async (req, res) => {
-            try {
-                const body = await readBody(req);
-                if (!body.name?.trim()) {
-                    sendError(res, 400, "Task name is required");
-                    return;
-                }
-                if (!body.command?.trim()) {
-                    sendError(res, 400, "Task command is required");
-                    return;
-                }
-                const task = this.taskManager.create(body);
-                sendOk(res, task, 201);
-            }
-            catch (err) {
-                sendError(res, 400, err instanceof Error ? err.message : String(err));
-            }
-        });
-        r("PATCH", "/api/tasks/:id", async (req, res, params) => {
-            try {
-                const body = await readBody(req);
-                const updated = this.taskManager.update(params.id, body);
-                if (!updated) {
-                    sendNotFound(res, params.id);
-                    return;
-                }
-                sendOk(res, updated);
-            }
-            catch (err) {
-                sendError(res, 400, err instanceof Error ? err.message : String(err));
-            }
-        });
-        r("DELETE", "/api/tasks/:id", (_req, res, params) => {
-            if (!this.taskManager.delete(params.id)) {
-                sendNotFound(res, params.id);
-                return;
-            }
-            sendOk(res);
-        });
-        r("GET", "/api/projects", (_req, res) => {
-            sendOk(res, this.projectManager.getAll());
-        });
-        r("POST", "/api/projects", async (req, res) => {
-            try {
-                const body = await readBody(req);
-                if (!body.name?.trim()) {
-                    sendError(res, 400, "Project name is required");
-                    return;
-                }
-                const project = this.projectManager.create(body.name.trim(), body.color ?? "#ffffff");
-                sendOk(res, project, 201);
-            }
-            catch (err) {
-                sendError(res, 400, err instanceof Error ? err.message : String(err));
-            }
-        });
-        r("PATCH", "/api/projects/:id", async (req, res, params) => {
-            try {
-                const body = await readBody(req);
-                if (!body.name?.trim()) {
-                    sendError(res, 400, "Project name is required");
-                    return;
-                }
-                this.projectManager.update(params.id, body.name.trim(), body.color);
-                sendOk(res);
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                if (msg.includes("not found")) {
-                    sendNotFound(res, params.id);
-                }
-                else {
-                    sendError(res, 400, msg);
-                }
-            }
-        });
-        r("DELETE", "/api/projects/:id", (_req, res, params) => {
-            try {
-                this.projectManager.delete(params.id);
-                sendOk(res);
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                if (msg.includes("not found") || msg.includes("system")) {
-                    sendError(res, 400, msg);
-                }
-                else {
-                    sendError(res, 500, msg);
-                }
-            }
-        });
-        r("GET", "/api/openapi.json", (_req, res) => {
-            const spec = this.buildOpenApiSpec();
-            const body = JSON.stringify(spec, null, 2);
-            res.writeHead(200, {
-                "Content-Type": "application/json",
-                "Content-Length": Buffer.byteLength(body),
-            });
-            res.end(body);
-        });
-        r("GET", "/api/docs", (_req, res) => {
-            const html = this.buildSwaggerHtml();
-            res.writeHead(200, {
-                "Content-Type": "text/html",
-                "Content-Length": Buffer.byteLength(html),
-            });
-            res.end(html);
-        });
-        r("GET", "/", (_req, res) => {
-            const html = this.buildSwaggerHtml();
-            res.writeHead(200, {
-                "Content-Type": "text/html",
-                "Content-Length": Buffer.byteLength(html),
-            });
-            res.end(html);
-        });
-        r("GET", "/api/events", (_req, res) => {
-            res.writeHead(200, {
-                "Content-Type": "text/event-stream",
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-            });
-            res.write(": connected\n\n");
-            this.sseClients.add(res);
-            _req.on("close", () => {
-                this.sseClients.delete(res);
-            });
-        });
-    }
-    buildOpenApiSpec() {
-        return {
-            openapi: "3.0.3",
-            info: {
-                title: "loop-task HTTP API",
-                version: "1.0.0",
-                description: "REST + SSE API for managing loops, tasks, projects, and logs. All endpoints are localhost-only (127.0.0.1).",
-            },
-            servers: [
-                { url: `http://${HTTP_API_HOST}:${HTTP_API_PORT}`, description: "Local daemon" },
-            ],
-            paths: {
-                "/api/loops": {
-                    get: { summary: "List all loops", tags: ["Loops"], responses: { "200": { description: "Array of loops", content: { "application/json": { schema: { type: "array" } } } } } },
-                    post: { summary: "Create a new loop", tags: ["Loops"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { command: { type: "string" }, commandArgs: { type: "array", items: { type: "string" } }, intervalHuman: { type: "string", example: "5m" }, cwd: { type: "string" }, description: { type: "string" }, taskId: { type: "string" }, now: { type: "boolean" }, maxRuns: { type: "integer" }, verbose: { type: "boolean" }, projectId: { type: "string" }, offset: { type: "integer" } } } } } }, responses: { "201": { description: "Loop created", content: { "application/json": { schema: { type: "object", properties: { id: { type: "string" } } } } } }, "400": { description: "Validation error" } } },
-                },
-                "/api/loops/{id}": {
-                    get: { summary: "Get loop status", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Loop details" }, "404": { description: "Not found" } } },
-                    patch: { summary: "Update a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], requestBody: { content: { "application/json": { schema: { type: "object" } } } }, responses: { "200": { description: "Updated" }, "400": { description: "Validation error" }, "404": { description: "Not found" } } },
-                    delete: { summary: "Delete a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Deleted" }, "404": { description: "Not found" } } },
-                },
-                "/api/loops/{id}/pause": { post: { summary: "Pause a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Paused" }, "404": { description: "Not found" } } } },
-                "/api/loops/{id}/resume": { post: { summary: "Resume a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Resumed" }, "404": { description: "Not found" } } } },
-                "/api/loops/{id}/trigger": { post: { summary: "Trigger a loop now", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Triggered" }, "404": { description: "Not found" }, "400": { description: "Max runs reached" }, "409": { description: "Already running" } } } },
-                "/api/loops/{id}/stop": { post: { summary: "Stop a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Stopped" }, "404": { description: "Not found" } } } },
-                "/api/loops/stop-all": { post: { summary: "Stop all loops", tags: ["Loops"], responses: { "200": { description: "All stopped", content: { "application/json": { schema: { type: "object", properties: { count: { type: "integer" } } } } } } } } },
-                "/api/loops/{id}/logs": { get: { summary: "Fetch loop logs", tags: ["Logs"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }, { name: "tail", in: "query", schema: { type: "integer", default: 50 } }], responses: { "200": { description: "Log content" }, "404": { description: "Not found" } } } },
-                "/api/loops/{id}/logs/stream": { get: { summary: "Stream logs via SSE", tags: ["Logs"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }, { name: "tail", in: "query", schema: { type: "integer" } }], responses: { "200": { description: "SSE stream" }, "404": { description: "Not found" } } } },
-                "/api/loops/{id}/runs/{num}": { get: { summary: "Get run-specific log", tags: ["Logs"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }, { name: "num", in: "path", required: true, schema: { type: "integer" } }], responses: { "200": { description: "Run log content" } } } },
-                "/api/tasks": {
-                    get: { summary: "List all tasks", tags: ["Tasks"], responses: { "200": { description: "Array of tasks" } } },
-                    post: { summary: "Create a task", tags: ["Tasks"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { id: { type: "string" }, name: { type: "string" }, command: { type: "string" }, commandArgs: { type: "array", items: { type: "string" } }, onSuccessTaskId: { type: "string" }, onFailureTaskId: { type: "string" } } } } } }, responses: { "201": { description: "Task created" }, "400": { description: "Validation error" } } },
-                },
-                "/api/tasks/{id}": {
-                    get: { summary: "Get a task", tags: ["Tasks"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Task details" }, "404": { description: "Not found" } } },
-                    patch: { summary: "Update a task", tags: ["Tasks"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], requestBody: { content: { "application/json": { schema: { type: "object" } } } }, responses: { "200": { description: "Updated" }, "404": { description: "Not found" } } },
-                    delete: { summary: "Delete a task", tags: ["Tasks"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Deleted" }, "404": { description: "Not found" } } },
-                },
-                "/api/projects": {
-                    get: { summary: "List all projects", tags: ["Projects"], responses: { "200": { description: "Array of projects" } } },
-                    post: { summary: "Create a project", tags: ["Projects"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { name: { type: "string" }, color: { type: "string" } } } } } }, responses: { "201": { description: "Project created" }, "400": { description: "Validation error" } } },
-                },
-                "/api/projects/{id}": {
-                    patch: { summary: "Update a project", tags: ["Projects"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], requestBody: { content: { "application/json": { schema: { type: "object", properties: { name: { type: "string" }, color: { type: "string" } } } } } }, responses: { "200": { description: "Updated" }, "404": { description: "Not found" }, "400": { description: "Validation error" } } },
-                    delete: { summary: "Delete a project", tags: ["Projects"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Deleted" }, "400": { description: "Cannot delete system project" } } },
-                },
-                "/api/events": { get: { summary: "Subscribe to daemon events via SSE", tags: ["Events"], responses: { "200": { description: "SSE event stream" } } } },
-                "/api/openapi.json": { get: { summary: "OpenAPI 3.0 spec", tags: ["Docs"], responses: { "200": { description: "OpenAPI JSON spec" } } } },
-                "/api/docs": { get: { summary: "Swagger UI", tags: ["Docs"], responses: { "200": { description: "HTML page" } } } },
-            },
-        };
-    }
-    buildSwaggerHtml() {
-        const specUrl = "/api/openapi.json";
-        return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>loop-task API</title>
-  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css">
-  <style>
-    body { margin: 0; }
-    .swagger-ui { max-width: 1200px; margin: 0 auto; }
-    .header { background: #0d1117; color: #58a6ff; padding: 12px 24px; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; font-size: 14px; }
-    .header a { color: #58a6ff; text-decoration: none; }
-    .header a:hover { text-decoration: underline; }
-  </style>
-</head>
-<body>
-  <div class="header">
-    <strong>loop-task HTTP API</strong> &mdash;
-    <a href="/api/openapi.json">OpenAPI JSON</a> &mdash;
-    <a href="/api/docs">Swagger UI</a>
-  </div>
-  <div id="swagger-ui"></div>
-  <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
-  <script>
-    window.onload = function() {
-      window.ui = SwaggerUIBundle({
-        url: "${specUrl}",
-        dom_id: "#swagger-ui",
-        deepLinking: true,
-        presets: [SwaggerUIBundle.presets.apis],
-        layout: "BaseLayout",
-      });
-    };
-  </script>
-</body>
-</html>`;
-    }
-    async handleRequest(req, res) {
-        try {
-            const pathSegments = parsePath(req.url);
-            const match = matchRoute(this.routes, req.method ?? "GET", pathSegments);
-            if (!match) {
-                sendError(res, 404, `Not found: ${req.method} ${req.url}`);
-                return;
-            }
-            await match.handler(req, res, match.params);
-        }
-        catch (err) {
-            if (!res.headersSent) {
-                sendError(res, 500, err instanceof Error ? err.message : String(err));
-            }
-        }
-    }
-}