@randomdev/pulsedev 0.1.2

package/core/init.js

@@ -0,0 +1,48 @@
+import { styleText } from "node:util";
+import { write } from "../helpers/writter.js";
+import { cpSync, mkdirSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const TEMPLATES_DIR = join(__dirname, "../web/templates");
+
+const templates = {
+    config: readFileSync(join(TEMPLATES_DIR, "pulsedev.json"), "utf-8"),
+    html: readFileSync(join(TEMPLATES_DIR, "index.html"), "utf-8"),
+    css: readFileSync(join(TEMPLATES_DIR, "index.css"), "utf-8"),
+    js: readFileSync(join(TEMPLATES_DIR, "index.js"), "utf-8"),
+    socket: readFileSync(join(TEMPLATES_DIR, "socket-client.js"), "utf-8"),
+    docs: readFileSync(join(TEMPLATES_DIR, "documentation.html"), "utf-8"),
+};
+
+export async function runInit(currentDirectory) {
+    console.log(styleText("bgBlue", " info ") + " ejecutando init...");
+
+    const source = join(__dirname, "../web/assets");
+    const destiny = join(currentDirectory, 'src', 'assets');
+
+    mkdirSync(join(currentDirectory, 'src'), { recursive: true });
+    mkdirSync(join(currentDirectory, 'src', 'js'), { recursive: true });
+    mkdirSync(join(currentDirectory, 'src', 'css'), { recursive: true });
+
+    cpSync(source, destiny, { recursive: true });
+
+    const finalJs = templates.js.replace('__DOCUMENTATION_HTML__', JSON.stringify(templates.docs));
+
+    try {
+        console.log(styleText("bgMagentaBright", " execute ") + " Creando archivo de configuración.");
+        await write(join(currentDirectory, 'pulsedev.json'), templates.config);
+
+        console.log(styleText("bgMagentaBright", " execute ") + " Creando archivos basicos de servidor. ");
+        await write(join(currentDirectory, 'src', 'index.html'), templates.html);
+        await write(join(currentDirectory, 'src', 'js', 'index.js'), finalJs);
+        await write(join(currentDirectory, 'src', 'js', 'socket-client.js'), templates.socket);
+        await write(join(currentDirectory, 'src', 'css', 'index.css'), templates.css);
+        console.log(styleText("bgGreenBright", " execute ") + " Revisar archivo de configuracion y ejecutar servidor con 'pulsedev run'. ");
+    } catch (err) {
+        console.error(styleText("bgRed", " error: ") + "Fallo al inicializar los archivos: " + err.message);
+    }
+}

package/core/run.js

@@ -0,0 +1,341 @@
+/**
+ * core/run.js — Entry point del comando `pulsedev run`
+ *
+ * Responsabilidad: orquestar todo lo concerniente al comando `run`,
+ * separado del state machine HTTP que vive en serverManager.js.
+ *
+ * ============================================================================
+ * SISTEMA DE FLAGS
+ * ============================================================================
+ *
+ * CONVENCIÓN DE FLAGS
+ * --------------------
+ *   - Formato long: --nombre o --nombre=valor
+ *   - Formato con valor: --port 4000 | --port=4000
+ *   - Booleanos: presencia = true
+ *   - Un flag desconocido (que no sea reservado ni clave del JSON) es error fatal
+ *   - El schema de flags válidos = claves de tu pulsedev.json
+ *
+ * FLAGS RESERVADOS (siempre disponibles, no requieren clave en JSON)
+ * -------------------------------------------------------------------
+ *   --list-flags       Muestra los flags disponibles (= claves de tu JSON)
+ *   --persist          Si se usan flags, persiste el override al JSON en vez
+ *                      de solo override en memoria (opt-in, no destructivo
+ *                      por defecto)
+ *
+ * EJEMPLOS DE USO
+ * ---------------
+ *   pulsedev run
+ *   pulsedev run --list-flags
+ *   pulsedev run --port 4000                       # override en memoria
+ *   pulsedev run --port 4000 --persist             # override + escribe JSON
+ *   pulsedev run --debounceDelay 1 --port 4000
+ *   pulsedev run --outputPath=terminal
+ *
+ * COERCIÓN DE TIPOS
+ * -----------------
+ * Los flags llegan como string desde la CLI. Se coercionan al tipo del valor
+ * original en el JSON:
+ *   - JSON boolean → "true"/"1" = true, todo lo demás = false
+ *   - JSON number  → Number(value) (NaN si inválido → error)
+ *   - JSON array   → JSON.parse(value) (si falla, queda como string)
+ *   - JSON string  → string
+ *   - JSON null    → string
+ *
+ * PRECEDENCIA (de mayor a menor)
+ * ------------------------------
+ *   1. Flag CLI (este sistema)
+ *   2. pulsedev.json (base)
+ *   3. Defaults internos de serverManager
+ *
+ * ============================================================================
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { hostname } from "node:os";
+import { styleText } from "node:util";
+
+import { read, writeFile } from "../helpers/writter.js";
+import {
+    startServer as _startServer,
+    reloadServer as _reloadServer
+} from "./serverManager.js";
+
+const RESERVED_FLAGS = new Set(["list-flags", "persist"]);
+
+/**
+ * Parsea argumentos tipo process.argv en un objeto { flag: valor }.
+ * Soporta: --key value, --key=value, --boolean (presencia = true).
+ * Args que no empiezan con -- se ignoran.
+ */
+function parseFlags(args) {
+    const flags = {};
+    const list = Array.isArray(args) ? args : [];
+
+    for (let i = 0; i < list.length; i++) {
+        const arg = list[i];
+        if (typeof arg !== "string" || !arg.startsWith("--")) continue;
+
+        const eqIdx = arg.indexOf("=");
+        if (eqIdx !== -1) {
+            const key = arg.slice(2, eqIdx);
+            const value = arg.slice(eqIdx + 1);
+            if (key) flags[key] = value;
+            continue;
+        }
+
+        const key = arg.slice(2);
+        if (!key) continue;
+
+        const next = list[i + 1];
+        if (typeof next === "string" && !next.startsWith("--")) {
+            flags[key] = next;
+            i++;
+        } else {
+            flags[key] = true;
+        }
+    }
+
+    return flags;
+}
+
+/**
+ * Convierte un valor crudo de la CLI al tipo del valor original del JSON.
+ * Lanza Error descriptivo si la coerción es imposible.
+ */
+function coerceValue(rawValue, original) {
+    const isBoolFlag = rawValue === true;
+
+    if (typeof original === "boolean") {
+        if (isBoolFlag) return true;
+        const v = String(rawValue).toLowerCase();
+        if (v === "true" || v === "1" || v === "yes") return true;
+        if (v === "false" || v === "0" || v === "no") return false;
+        throw new Error(`valor booleano inválido: ${rawValue}`);
+    }
+
+    if (typeof original === "number") {
+        const n = Number(rawValue);
+        if (Number.isNaN(n)) throw new Error(`valor numérico inválido: ${rawValue}`);
+        return n;
+    }
+
+    if (Array.isArray(original)) {
+        if (isBoolFlag) {
+            throw new Error("se esperaba un array (ej: '[\"*\"]'), se recibió flag booleano");
+        }
+        try {
+            return JSON.parse(rawValue);
+        } catch {
+            throw new Error(`valor de array inválido (debe ser JSON válido): ${rawValue}`);
+        }
+    }
+
+    if (original === null) {
+        return String(rawValue);
+    }
+
+    return String(rawValue);
+}
+
+/**
+ * Devuelve la lista de flags (no reservados) que NO existen como clave en config.
+ */
+function findUnknownFlags(flags, config) {
+    const configKeys = new Set(Object.keys(config));
+    return Object.keys(flags).filter(
+        (k) => !RESERVED_FLAGS.has(k) && !configKeys.has(k)
+    );
+}
+
+/**
+ * Construye un config mergeado a partir del config base y los flags parseados.
+ * No muta el config base. No toca el disco.
+ */
+function mergeConfig(baseConfig, flags) {
+    const merged = { ...baseConfig };
+    for (const [key, rawValue] of Object.entries(flags)) {
+        if (RESERVED_FLAGS.has(key)) continue;
+        if (!(key in merged)) continue;
+        merged[key] = coerceValue(rawValue, merged[key]);
+    }
+    return merged;
+}
+
+/**
+ * Lee el pulsedev.json del directorio y muestra las claves con sus valores
+ * actuales. Cada clave listada es un flag válido para `pulsedev run`.
+ */
+async function listFlags(currentDirectory) {
+    const configPath = join(currentDirectory, "pulsedev.json");
+
+    if (!existsSync(configPath)) {
+        console.error(
+            styleText("bgRed", " error ") +
+            " No se encontró pulsedev.json. Ejecutá `pulsedev init` primero."
+        );
+        process.exit(1);
+    }
+
+    const raw = await read(configPath);
+    if (!raw) {
+        console.error(
+            styleText("bgRed", " error ") +
+            " No se pudo leer pulsedev.json (archivo vacío o ilegible)."
+        );
+        process.exit(1);
+    }
+
+    let config;
+    try {
+        config = JSON.parse(raw);
+    } catch (err) {
+        console.error(
+            styleText("bgRed", " error ") +
+            ` pulsedev.json tiene JSON inválido: ${err.message}`
+        );
+        process.exit(1);
+    }
+
+    const keys = Object.keys(config);
+    if (keys.length === 0) {
+        console.log("pulsedev.json no tiene claves configurables.");
+        return;
+    }
+
+    console.log(
+        styleText("bold", "Flags disponibles (= claves de tu pulsedev.json):")
+    );
+    const maxLen = Math.max(...keys.map((k) => k.length));
+    for (const key of keys) {
+        const current = JSON.stringify(config[key]);
+        const label = `--${key}`.padEnd(maxLen + 3);
+        console.log(`  ${label} (actual: ${current})`);
+    }
+    console.log("");
+    console.log(
+        styleText("dim", "  Flags reservados (no requieren clave en JSON):")
+    );
+    console.log("    --list-flags    Muestra esta lista");
+    console.log("    --persist       Persiste el override al JSON (opt-in)");
+}
+
+/**
+ * Carga el pulsedev.json o termina con error descriptivo.
+ */
+async function loadBaseConfig(currentDirectory) {
+    const configPath = join(currentDirectory, "pulsedev.json");
+
+    if (!existsSync(configPath)) {
+        console.error(
+            styleText("bgRed", " error ") +
+            " No se encontró pulsedev.json. Ejecutá `pulsedev init` primero."
+        );
+        process.exit(1);
+    }
+
+    const raw = await read(configPath);
+    if (!raw) {
+        console.error(
+            styleText("bgRed", " error ") +
+            " No se pudo leer pulsedev.json (archivo vacío o ilegible)."
+        );
+        process.exit(1);
+    }
+
+    try {
+        return JSON.parse(raw);
+    } catch (err) {
+        console.error(
+            styleText("bgRed", " error ") +
+            ` pulsedev.json tiene JSON inválido: ${err.message}`
+        );
+        process.exit(1);
+    }
+}
+
+/**
+ * Valida los flags contra el schema del config. Termina con error si hay
+ * flags desconocidos. Lanza Error si algún valor no se puede coercionar.
+ */
+function validateFlagsOrExit(flags, baseConfig) {
+    const unknown = findUnknownFlags(flags, baseConfig);
+    if (unknown.length === 0) return;
+
+    const available = Object.keys(baseConfig)
+        .map((k) => `--${k}`)
+        .join(", ");
+    console.error(
+        styleText("bgRed", " error ") +
+        ` Flag(s) desconocido(s): ${unknown.map((f) => `--${f}`).join(", ")}\n` +
+        ` Flags disponibles (= claves de tu pulsedev.json): ${available}\n` +
+        ` Ejecutá \`pulsedev run --list-flags\` para ver el detalle de los valores actuales.`
+    );
+    process.exit(1);
+}
+
+/**
+ * Entry point del comando `pulsedev run`.
+ *
+ * @param {string} currentDirectory - cwd donde está el proyecto del usuario
+ * @param {object} [options]
+ * @param {string[]} [options.argv] - args a parsear (default: process.argv.slice(3))
+ * @param {boolean} [options.silent] - suprime el banner
+ */
+export const runCommand = async (currentDirectory, options = {}) => {
+    const argv = Array.isArray(options.argv)
+        ? options.argv
+        : process.argv.slice(3);
+    const flags = parseFlags(argv);
+
+    if (flags["list-flags"]) {
+        await listFlags(currentDirectory);
+        return;
+    }
+
+    const baseConfig = await loadBaseConfig(currentDirectory);
+    validateFlagsOrExit(flags, baseConfig);
+
+    let mergedConfig = baseConfig;
+    const hasUserFlags = Object.keys(flags).some((k) => !RESERVED_FLAGS.has(k));
+
+    if (hasUserFlags) {
+        try {
+            mergedConfig = mergeConfig(baseConfig, flags);
+        } catch (err) {
+            console.error(
+                styleText("bgRed", " error ") +
+                ` No se pudo aplicar el flag: ${err.message}`
+            );
+            process.exit(1);
+        }
+    }
+
+    if (hasUserFlags && flags["persist"]) {
+        const configPath = join(currentDirectory, "pulsedev.json");
+        const serialized = JSON.stringify(mergedConfig, null, 2);
+        await writeFile(configPath, serialized);
+        console.log(
+            styleText("bgYellow", " persist ") +
+            " Configuración sobrescrita en pulsedev.json"
+        );
+    } else if (hasUserFlags) {
+        console.log(
+            styleText("dim", " ⓘ Flags aplicados en memoria (no se modificó el JSON). Usá --persist para persistir.")
+        );
+    }
+
+    if (!options.silent) {
+        const ts = new Date().toISOString();
+        console.log(styleText("dim", `▶ PulseDev ${ts} · ${hostname()}`));
+    }
+
+    return _startServer(currentDirectory, mergedConfig);
+};
+
+export { _startServer as startServer, _reloadServer as reloadServer };
+
+// exported for testing
+export { parseFlags, coerceValue, mergeConfig, findUnknownFlags, RESERVED_FLAGS };
+export { listFlags, loadBaseConfig, validateFlagsOrExit };

package/core/serverManager.js

@@ -0,0 +1,299 @@
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import { styleText } from "node:util";
+import { join, resolve } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import { read, write } from "../helpers/writter.js";
+import { hostname } from "node:os";
+import { contentTypes, binaryExtensions, noHashExtensions } from "../helpers/mimeTypes.js";
+import { injectResourceHashes } from "../helpers/resourceHasher.js";
+import { startWatcher, _closeActiveWatchers } from "../helpers/watcher.js";
+import { initWebSocket, closeAllConnections } from "../helpers/websocket.js";
+
+const state = {
+    config: null,
+    server: null,
+    isRestarting: false,
+    currentDirectory: null,
+    watcherAbortController: null
+};
+
+// exported for testing
+let _reloadCount = 0;
+
+async function upServer(config) {
+    try {
+        const server = createServer(async (req, res) => {
+            let cleanURL = req.url.split("?")[0];
+
+            let targetResource = cleanURL === '/' ? (config.runFile || 'index.html') : cleanURL;
+            let filePath = join(state.currentDirectory, 'src', targetResource);
+
+            /**
+             * Guard contra path traversal:
+             * Si la ruta resuelta se escapa del directorio src/ del proyecto,
+             * respondemos 403 sin tocar el disco.
+             */
+            const srcRoot = resolve(join(state.currentDirectory, 'src'));
+            const resolvedFilePath = resolve(filePath);
+            if (!resolvedFilePath.startsWith(srcRoot)) {
+                res.writeHead(403, { 'Content-Type': 'text/html' });
+                res.end(`
+                <!DOCTYPE html>
+                <html lang="es">
+                <head>
+                    <meta charset="UTF-8">
+                    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                    <title>403 - Acceso Denegado</title>
+                    <style>
+                        * { margin: 0; padding: 0; box-sizing: border-box; }
+                        body {
+                            font-family: 'Segoe UI', -apple-system, BlinkMacSystemFont, Roboto, sans-serif;
+                            background: linear-gradient(135deg, #0f172a 0%, #1e293b 100%);
+                            min-height: 100vh;
+                            display: flex;
+                            justify-content: center;
+                            align-items: center;
+                            color: #f8fafc;
+                        }
+                        .error-card {
+                            background: #1e293b;
+                            border: 1px solid #334155;
+                            border-radius: 12px;
+                            padding: 2.5rem;
+                            text-align: center;
+                            box-shadow: 0 10px 25px rgba(0,0,0,0.3);
+                            max-width: 450px;
+                            width: 90%;
+                        }
+                        .error-code {
+                            font-size: 5rem;
+                            font-weight: 800;
+                            background: linear-gradient(135deg, #f87171 0%, #fb923c 100%);
+                            -webkit-background-clip: text;
+                            background-clip: text;
+                            color: transparent;
+                            line-height: 1;
+                            margin-bottom: 0.5rem;
+                        }
+                        h1 { font-size: 1.5rem; font-weight: 600; color: #f1f5f9; margin-bottom: 0.75rem; }
+                        p { color: #94a3b8; font-size: 0.95rem; line-height: 1.5; margin-bottom: 1.5rem; }
+                        .btn-back {
+                            display: inline-block;
+                            background: linear-gradient(135deg, #f87171 0%, #fb923c 100%);
+                            color: #ffffff;
+                            text-decoration: none;
+                            font-weight: 500;
+                            font-size: 0.9rem;
+                            padding: 0.75rem 1.5rem;
+                            border-radius: 6px;
+                            transition: transform 0.2s, opacity 0.2s;
+                        }
+                        .btn-back:hover { transform: translateY(-1px); opacity: 0.95; }
+                    </style>
+                </head>
+                <body>
+                    <div class="error-card">
+                        <div class="error-code">403</div>
+                        <h1>Acceso denegado</h1>
+                        <p>La ruta solicitada está fuera del directorio permitido.</p>
+                        <a href="/" class="btn-back">Volver al inicio</a>
+                    </div>
+                </body>
+                </html>
+                `);
+                return;
+            }
+
+            let requestMessage = `- ${new Date().toLocaleString()} : ${req.method} : ${req.url} - ${req.headers['user-agent'] || 'unknown'}`;
+
+            if (config.outputPath && config.outputPath === "terminal") {
+                console.log(
+                    styleText("dim", `- ${new Date().toLocaleString()} : `) +
+                    styleText("green", req.method) +
+                    styleText("dim", ` : ${req.url} - ${req.headers['user-agent'] || 'unknown'}`)
+                );
+            } else {
+                if (!existsSync(join(state.currentDirectory, 'logs'))) {
+                    mkdirSync(join(state.currentDirectory, 'logs'), { recursive: true });
+                }
+                await write(join(state.currentDirectory, 'logs', 'requests.log'), requestMessage, config.logLimit || 5);
+            }
+
+            const ext = filePath.split('.').pop();
+
+            const isBinary = binaryExtensions.has(ext);
+
+            try {
+                let content = await readFile(filePath, isBinary ? null : 'utf-8');
+
+                if ((ext === "html" || cleanURL === "/") && !noHashExtensions.has(ext)) {
+                    content = await injectResourceHashes(content, state.currentDirectory);
+                }
+
+                const contentType = contentTypes[ext] || 'text/plain';
+                res.writeHead(200, { 'Content-Type': contentType });
+                res.end(content);
+            } catch {
+                res.writeHead(404, { 'Content-Type': 'text/html' });
+                res.end(`
+                <!DOCTYPE html>
+                <html lang="es">
+                <head>
+                    <meta charset="UTF-8">
+                    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                    <title>404 - Archivo No Encontrado</title>
+                    <style>
+                        * { margin: 0; padding: 0; box-sizing: border-box; }
+                        body {
+                            font-family: 'Segoe UI', -apple-system, BlinkMacSystemFont, Roboto, sans-serif;
+                            background: linear-gradient(135deg, #0f172a 0%, #1e293b 100%);
+                            min-height: 100vh;
+                            display: flex;
+                            justify-content: center;
+                            align-items: center;
+                            color: #f8fafc;
+                        }
+                        .error-card {
+                            background: #1e293b;
+                            border: 1px solid #334155;
+                            border-radius: 12px;
+                            padding: 2.5rem;
+                            text-align: center;
+                            box-shadow: 0 10px 25px rgba(0,0,0,0.3);
+                            max-width: 450px;
+                            width: 90%;
+                        }
+                        .error-code {
+                            font-size: 5rem;
+                            font-weight: 800;
+                            background: linear-gradient(135deg, #38bdf8 0%, #818cf8 100%);
+                            -webkit-background-clip: text;
+                            background-clip: text;
+                            color: transparent;
+                            line-height: 1;
+                            margin-bottom: 0.5rem;
+                        }
+                        h1 { font-size: 1.5rem; font-weight: 600; color: #f1f5f9; margin-bottom: 0.75rem; }
+                        p { color: #94a3b8; font-size: 0.95rem; line-height: 1.5; margin-bottom: 1.5rem; }
+                        .btn-back {
+                            display: inline-block;
+                            background: linear-gradient(135deg, #38bdf8 0%, #6366f1 100%);
+                            color: #ffffff;
+                            text-decoration: none;
+                            font-weight: 500;
+                            font-size: 0.9rem;
+                            padding: 0.75rem 1.5rem;
+                            border-radius: 6px;
+                            transition: transform 0.2s, opacity 0.2s;
+                        }
+                        .btn-back:hover { transform: translateY(-1px); opacity: 0.95; }
+                    </style>
+                </head>
+                <body>
+                    <div class="error-card">
+                        <div class="error-code">404</div>
+                        <h1>Archivo no encontrado</h1>
+                        <p>El recurso que estás intentando cargar no existe en el directorio local o la ruta es incorrecta.</p>
+                        <a href="/" class="btn-back">Volver al inicio</a>
+                    </div>
+                </body>
+                </html>
+                `);
+            }
+        });
+
+        initWebSocket(server);
+
+        state.server = server;
+        server.listen(config.port || 3003);
+        console.log(styleText("bgGreen", " servidor ") + ` corriendo en http://localhost:${config.port || 3003}`);
+    } catch (error) {
+        if (config.outputPath === "log") {
+            if (!existsSync(join(state.currentDirectory, 'logs'))) {
+                mkdirSync(join(state.currentDirectory, 'logs'), { recursive: true });
+            }
+            let messageError = `${Date.now()} - ${hostname()}/${state.currentDirectory}: ${error.message}`;
+            await write(join(state.currentDirectory, 'logs', 'errors.log'), messageError);
+        }
+        console.log(styleText("bgRed", " error: ") + error.message);
+        process.exit(1);
+    }
+}
+
+async function reloadServer() {
+    if (state.isRestarting) return;
+    state.isRestarting = true;
+
+    console.log(styleText("bgYellow", " reseteando ") + " Reiniciando PulseDev...");
+
+    _reloadCount++;
+
+    closeAllConnections();
+
+    if (state.server) {
+        await new Promise((resolve) => state.server.close(() => resolve()));
+    }
+
+    try {
+        const rawConfig = await read(join(state.currentDirectory, 'pulsedev.json'));
+        if (!rawConfig) {
+            console.log(styleText("bgRed", " error ") + " No se pudo leer pulsedev.json al reiniciar.");
+            return;
+        }
+        state.config = JSON.parse(rawConfig);
+        await upServer(state.config);
+    } catch (error) {
+        console.error("Error al reiniciar el servidor:", error.message);
+    } finally {
+        state.isRestarting = false;
+    }
+}
+
+export async function startServer(currentDirectory, preloadedConfig = null) {
+    state.currentDirectory = currentDirectory;
+
+    if (preloadedConfig) {
+        state.config = preloadedConfig;
+    } else {
+        if (!existsSync(join(currentDirectory, 'pulsedev.json'))) {
+            console.log(styleText("bgRed", " warning: ") + "El archivo pulsedev.json no existe en el directorio.");
+            process.exit(1);
+        }
+
+        state.config = JSON.parse(await read(join(currentDirectory, 'pulsedev.json')));
+    }
+    await upServer(state.config);
+
+    // Abortar watchers previos antes de crear nuevos (evita fugas de event loop)
+    if (state.watcherAbortController) {
+        state.watcherAbortController.abort();
+        state.watcherAbortController = null;
+    }
+    await _closeActiveWatchers();
+    state.watcherAbortController = new AbortController();
+    startWatcher(state.config, currentDirectory, reloadServer, state.watcherAbortController.signal);
+}
+
+export { reloadServer };
+
+// exported for testing
+export async function closeServer() {
+    closeAllConnections();
+
+    if (state.watcherAbortController) {
+        state.watcherAbortController.abort();
+        state.watcherAbortController = null;
+    }
+    await _closeActiveWatchers();
+    return new Promise((resolve) => {
+        if (state.server) {
+            state.server.closeAllConnections?.();
+            state.server.close(() => resolve());
+        } else {
+            resolve();
+        }
+    });
+}
+export function getReloadCount() { return _reloadCount; }
+export function resetReloadCount() { _reloadCount = 0; }