twd-relay 0.3.0 → 1.1.0

package/dist/cli.js

@@ -1,259 +1,311 @@
 #!/usr/bin/env node
 import { createServer } from "http";
-import WebSocket$1, { WebSocketServer, WebSocket } from "ws";
-const DEFAULT_PATH = "/__twd/ws";
+import WebSocket, { WebSocket as WebSocket$1, WebSocketServer } from "ws";
+//#region src/relay/createTwdRelay.ts
+var DEFAULT_PATH = "/__twd/ws";
 function createTwdRelay(server, options) {
-  const path = options?.path ?? DEFAULT_PATH;
-  const onError = options?.onError;
-  const wss = new WebSocketServer({ noServer: true });
-  let browser = null;
-  const clients = /* @__PURE__ */ new Set();
-  let runInProgress = false;
-  function sendError(ws, code, message) {
-    const msg = { type: "error", code, message };
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify(msg));
-    }
-  }
-  function broadcastToClients(data) {
-    for (const client of clients) {
-      if (client.readyState === WebSocket.OPEN) {
-        client.send(data);
-      }
-    }
-  }
-  function sendConnectedStatus(ws) {
-    const msg = { type: "connected", browser: browser !== null && browser.readyState === WebSocket.OPEN };
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify(msg));
-    }
-  }
-  function notifyBrowserDisconnected() {
-    broadcastToClients(JSON.stringify({ type: "connected", browser: false }));
-  }
-  function handleBrowserMessage(data) {
-    let parsed;
-    try {
-      parsed = JSON.parse(data);
-    } catch {
-      return;
-    }
-    if (parsed.type === "run:complete") {
-      runInProgress = false;
-    }
-    broadcastToClients(data);
-  }
-  function handleClientMessage(ws, data) {
-    let parsed;
-    try {
-      parsed = JSON.parse(data);
-    } catch {
-      sendError(ws, "INVALID_MESSAGE", "Invalid JSON");
-      return;
-    }
-    if (!parsed.type) {
-      sendError(ws, "INVALID_MESSAGE", 'Missing "type" field');
-      return;
-    }
-    if (parsed.type === "run") {
-      if (!browser || browser.readyState !== WebSocket.OPEN) {
-        sendError(ws, "NO_BROWSER", "No browser connected");
-        return;
-      }
-      if (runInProgress) {
-        sendError(ws, "RUN_IN_PROGRESS", "A test run is already in progress");
-        return;
-      }
-      runInProgress = true;
-      browser.send(data);
-      return;
-    }
-    if (parsed.type === "status") {
-      if (!browser || browser.readyState !== WebSocket.OPEN) {
-        sendError(ws, "NO_BROWSER", "No browser connected");
-        return;
-      }
-      browser.send(data);
-      return;
-    }
-    sendError(ws, "UNKNOWN_COMMAND", `Unknown command: ${parsed.type}`);
-  }
-  function handleConnection(ws) {
-    let identified = false;
-    const identifyHandler = (raw) => {
-      const data = typeof raw === "string" ? raw : raw.toString();
-      if (!identified) {
-        let parsed;
-        try {
-          parsed = JSON.parse(data);
-        } catch {
-          sendError(ws, "INVALID_MESSAGE", "Invalid JSON");
-          return;
-        }
-        if (parsed.type !== "hello" || parsed.role !== "browser" && parsed.role !== "client") {
-          sendError(ws, "INVALID_MESSAGE", 'First message must be a hello with role "browser" or "client"');
-          return;
-        }
-        identified = true;
-        if (parsed.role === "browser") {
-          if (browser && browser.readyState === WebSocket.OPEN) {
-            browser.close(1e3, "Replaced by new browser");
-          }
-          browser = ws;
-          runInProgress = false;
-          ws.on("close", () => {
-            if (browser === ws) {
-              browser = null;
-              runInProgress = false;
-              notifyBrowserDisconnected();
-            }
-          });
-          broadcastToClients(JSON.stringify({ type: "connected", browser: true }));
-          ws.on("message", (raw2) => {
-            const msg = typeof raw2 === "string" ? raw2 : raw2.toString();
-            handleBrowserMessage(msg);
-          });
-        } else {
-          clients.add(ws);
-          ws.on("close", () => {
-            clients.delete(ws);
-          });
-          sendConnectedStatus(ws);
-          ws.on("message", (raw2) => {
-            const msg = typeof raw2 === "string" ? raw2 : raw2.toString();
-            handleClientMessage(ws, msg);
-          });
-        }
-        ws.removeListener("message", identifyHandler);
-      }
-    };
-    ws.on("message", identifyHandler);
-    ws.on("error", (err) => {
-      if (onError) onError(err);
-    });
-  }
-  const upgradeHandler = (request, socket, head) => {
-    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
-    if (url.pathname === path) {
-      wss.handleUpgrade(request, socket, head, (ws) => {
-        handleConnection(ws);
-      });
-    }
-  };
-  server.on("upgrade", upgradeHandler);
-  wss.on("error", (err) => {
-    if (onError) onError(err);
-  });
-  return {
-    close() {
-      server.removeListener("upgrade", upgradeHandler);
-      for (const client of clients) {
-        client.close(1e3, "Relay shutting down");
-      }
-      clients.clear();
-      if (browser && browser.readyState === WebSocket.OPEN) {
-        browser.close(1e3, "Relay shutting down");
-      }
-      browser = null;
-      runInProgress = false;
-      wss.close();
-    },
-    get browserConnected() {
-      return browser !== null && browser.readyState === WebSocket.OPEN;
-    },
-    get clientCount() {
-      return clients.size;
-    }
-  };
+	const path = options?.path ?? DEFAULT_PATH;
+	const onError = options?.onError;
+	const wss = new WebSocketServer({ noServer: true });
+	let browser = null;
+	const clients = /* @__PURE__ */ new Set();
+	let runInProgress = false;
+	let lastHeartbeat = null;
+	let heartbeatCheckTimer = null;
+	const HEARTBEAT_TIMEOUT_MS = 12e4;
+	const HEARTBEAT_CHECK_INTERVAL_MS = 1e4;
+	function sendError(ws, code, message) {
+		const msg = {
+			type: "error",
+			code,
+			message
+		};
+		if (ws.readyState === WebSocket$1.OPEN) ws.send(JSON.stringify(msg));
+	}
+	function broadcastToClients(data) {
+		for (const client of clients) if (client.readyState === WebSocket$1.OPEN) client.send(data);
+	}
+	function sendConnectedStatus(ws) {
+		const msg = {
+			type: "connected",
+			browser: browser !== null && browser.readyState === WebSocket$1.OPEN
+		};
+		if (ws.readyState === WebSocket$1.OPEN) ws.send(JSON.stringify(msg));
+	}
+	function notifyBrowserDisconnected() {
+		broadcastToClients(JSON.stringify({
+			type: "connected",
+			browser: false
+		}));
+	}
+	function startHeartbeatTracking() {
+		lastHeartbeat = Date.now();
+		heartbeatCheckTimer = setInterval(() => {
+			if (runInProgress && lastHeartbeat !== null) {
+				if (Date.now() - lastHeartbeat > HEARTBEAT_TIMEOUT_MS) {
+					runInProgress = false;
+					stopHeartbeatTracking();
+					broadcastToClients(JSON.stringify({
+						type: "run:abandoned",
+						reason: "heartbeat_timeout"
+					}));
+				}
+			}
+		}, HEARTBEAT_CHECK_INTERVAL_MS);
+	}
+	function stopHeartbeatTracking() {
+		lastHeartbeat = null;
+		if (heartbeatCheckTimer !== null) {
+			clearInterval(heartbeatCheckTimer);
+			heartbeatCheckTimer = null;
+		}
+	}
+	function handleBrowserMessage(data) {
+		let parsed;
+		try {
+			parsed = JSON.parse(data);
+		} catch {
+			return;
+		}
+		if (parsed.type === "heartbeat") {
+			lastHeartbeat = Date.now();
+			return;
+		}
+		if (parsed.type === "run:complete") {
+			runInProgress = false;
+			stopHeartbeatTracking();
+		}
+		broadcastToClients(data);
+	}
+	function handleClientMessage(ws, data) {
+		let parsed;
+		try {
+			parsed = JSON.parse(data);
+		} catch {
+			sendError(ws, "INVALID_MESSAGE", "Invalid JSON");
+			return;
+		}
+		if (!parsed.type) {
+			sendError(ws, "INVALID_MESSAGE", "Missing \"type\" field");
+			return;
+		}
+		if (parsed.type === "run") {
+			if (!browser || browser.readyState !== WebSocket$1.OPEN) {
+				sendError(ws, "NO_BROWSER", "No browser connected");
+				return;
+			}
+			if (runInProgress) {
+				sendError(ws, "RUN_IN_PROGRESS", "A test run is already in progress. If the previous run appears stuck, the browser tab may be backgrounded and throttled — foreground the TWD tab (identified by the \"[TWD …]\" title prefix) or reload it. The relay also auto-clears the lock after 120s of heartbeat silence.");
+				return;
+			}
+			runInProgress = true;
+			startHeartbeatTracking();
+			browser.send(data);
+			return;
+		}
+		if (parsed.type === "status") {
+			if (!browser || browser.readyState !== WebSocket$1.OPEN) {
+				sendError(ws, "NO_BROWSER", "No browser connected");
+				return;
+			}
+			browser.send(data);
+			return;
+		}
+		sendError(ws, "UNKNOWN_COMMAND", `Unknown command: ${parsed.type}`);
+	}
+	function handleConnection(ws) {
+		let identified = false;
+		const identifyHandler = (raw) => {
+			const data = typeof raw === "string" ? raw : raw.toString();
+			if (!identified) {
+				let parsed;
+				try {
+					parsed = JSON.parse(data);
+				} catch {
+					sendError(ws, "INVALID_MESSAGE", "Invalid JSON");
+					return;
+				}
+				if (parsed.type !== "hello" || parsed.role !== "browser" && parsed.role !== "client") {
+					sendError(ws, "INVALID_MESSAGE", "First message must be a hello with role \"browser\" or \"client\"");
+					return;
+				}
+				identified = true;
+				if (parsed.role === "browser") {
+					if (browser && browser.readyState === WebSocket$1.OPEN) browser.close(1e3, "Replaced by new browser");
+					browser = ws;
+					runInProgress = false;
+					stopHeartbeatTracking();
+					ws.on("close", () => {
+						if (browser === ws) {
+							browser = null;
+							runInProgress = false;
+							stopHeartbeatTracking();
+							notifyBrowserDisconnected();
+						}
+					});
+					broadcastToClients(JSON.stringify({
+						type: "connected",
+						browser: true
+					}));
+					ws.on("message", (raw) => {
+						handleBrowserMessage(typeof raw === "string" ? raw : raw.toString());
+					});
+				} else {
+					clients.add(ws);
+					ws.on("close", () => {
+						clients.delete(ws);
+					});
+					sendConnectedStatus(ws);
+					ws.on("message", (raw) => {
+						handleClientMessage(ws, typeof raw === "string" ? raw : raw.toString());
+					});
+				}
+				ws.removeListener("message", identifyHandler);
+			}
+		};
+		ws.on("message", identifyHandler);
+		ws.on("error", (err) => {
+			if (onError) onError(err);
+		});
+	}
+	const upgradeHandler = (request, socket, head) => {
+		if (new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`).pathname === path) wss.handleUpgrade(request, socket, head, (ws) => {
+			handleConnection(ws);
+		});
+	};
+	server.on("upgrade", upgradeHandler);
+	wss.on("error", (err) => {
+		if (onError) onError(err);
+	});
+	return {
+		close() {
+			server.removeListener("upgrade", upgradeHandler);
+			stopHeartbeatTracking();
+			for (const client of clients) client.close(1e3, "Relay shutting down");
+			clients.clear();
+			if (browser && browser.readyState === WebSocket$1.OPEN) browser.close(1e3, "Relay shutting down");
+			browser = null;
+			runInProgress = false;
+			wss.close();
+		},
+		get browserConnected() {
+			return browser !== null && browser.readyState === WebSocket$1.OPEN;
+		},
+		get clientCount() {
+			return clients.size;
+		}
+	};
 }
+//#endregion
+//#region src/cli/run.ts
 function run(options) {
-  const { port, timeout, path, host } = options;
-  const url = `ws://${host}:${port}${path}`;
-  console.log(`Connecting to ${url}...`);
-  const ws = new WebSocket$1(url);
-  let runSent = false;
-  let runComplete = false;
-  let failed = false;
-  const timer = setTimeout(() => {
-    console.error(`
-Timeout: no run:complete received within ${timeout / 1e3}s`);
-    ws.close();
-    process.exit(1);
-  }, timeout);
-  ws.on("open", () => {
-    ws.send(JSON.stringify({ type: "hello", role: "client" }));
-  });
-  ws.on("message", (data) => {
-    const msg = JSON.parse(data.toString());
-    switch (msg.type) {
-      case "connected":
-        if (msg.browser && !runSent) {
-          runSent = true;
-          console.log("Browser connected, triggering test run...\n");
-          ws.send(JSON.stringify({ type: "run", scope: "all" }));
-        } else if (!msg.browser) {
-          console.log("Waiting for browser to connect...");
-        }
-        break;
-      case "run:start":
-        console.log(`Running ${msg.testCount} test(s)...
-`);
-        break;
-      case "test:start":
-        console.log(`  RUN:  ${msg.suite} > ${msg.name}`);
-        break;
-      case "test:pass":
-        console.log(`  PASS: ${msg.suite} > ${msg.name} (${msg.duration}ms)`);
-        break;
-      case "test:fail":
-        failed = true;
-        console.log(`  FAIL: ${msg.suite} > ${msg.name} (${msg.duration}ms)`);
-        if (msg.error) {
-          console.log(`    Error: ${msg.error}`);
-        }
-        break;
-      case "test:skip":
-        console.log(`  SKIP: ${msg.suite} > ${msg.name}`);
-        break;
-      case "run:complete": {
-        const duration = (msg.duration / 1e3).toFixed(1);
-        console.log(`
---- Run complete ---`);
-        console.log(`Passed: ${msg.passed} | Failed: ${msg.failed} | Skipped: ${msg.skipped}`);
-        console.log(`Duration: ${duration}s`);
-        runComplete = true;
-        clearTimeout(timer);
-        ws.close();
-        process.exit(failed || msg.failed > 0 ? 1 : 0);
-        break;
-      }
-      case "error":
-        console.error(`Error [${msg.code}]: ${msg.message}`);
-        break;
-    }
-  });
-  ws.on("close", () => {
-    clearTimeout(timer);
-    if (!runComplete) {
-      console.error("Connection closed before run completed");
-      process.exit(1);
-    }
-  });
-  ws.on("error", (err) => {
-    clearTimeout(timer);
-    console.error(`Connection error: ${err.message}`);
-    process.exit(1);
-  });
+	const { port, timeout, path, host, testNames, maxTestDurationMs } = options;
+	const url = `ws://${host}:${port}${path}`;
+	console.log(`Connecting to ${url}...`);
+	const ws = new WebSocket(url);
+	let runSent = false;
+	let runComplete = false;
+	let failed = false;
+	const timer = setTimeout(() => {
+		console.error(`\nTimeout: no run:complete received within ${timeout / 1e3}s`);
+		ws.close();
+		process.exit(1);
+	}, timeout);
+	ws.on("open", () => {
+		ws.send(JSON.stringify({
+			type: "hello",
+			role: "client"
+		}));
+	});
+	ws.on("message", (data) => {
+		const msg = JSON.parse(data.toString());
+		switch (msg.type) {
+			case "connected":
+				if (msg.browser && !runSent) {
+					runSent = true;
+					console.log("Browser connected, triggering test run...\n");
+					const runMsg = {
+						type: "run",
+						scope: "all"
+					};
+					if (testNames?.length) runMsg.testNames = testNames;
+					if (maxTestDurationMs !== void 0) runMsg.maxTestDurationMs = maxTestDurationMs;
+					ws.send(JSON.stringify(runMsg));
+				} else if (!msg.browser) console.log("Waiting for browser to connect...");
+				break;
+			case "run:start":
+				console.log(`Running ${msg.testCount} test(s)...\n`);
+				break;
+			case "test:start":
+				console.log(`  RUN:  ${msg.suite} > ${msg.name}`);
+				break;
+			case "test:pass":
+				console.log(`  PASS: ${msg.suite} > ${msg.name} (${msg.duration}ms)`);
+				break;
+			case "test:fail":
+				failed = true;
+				console.log(`  FAIL: ${msg.suite} > ${msg.name} (${msg.duration}ms)`);
+				if (msg.error) console.log(`    Error: ${msg.error}`);
+				break;
+			case "test:skip":
+				console.log(`  SKIP: ${msg.suite} > ${msg.name}`);
+				break;
+			case "run:complete": {
+				const duration = (msg.duration / 1e3).toFixed(1);
+				console.log(`\n--- Run complete ---`);
+				console.log(`Passed: ${msg.passed} | Failed: ${msg.failed} | Skipped: ${msg.skipped}`);
+				console.log(`Duration: ${duration}s`);
+				runComplete = true;
+				clearTimeout(timer);
+				ws.close();
+				process.exit(failed || msg.failed > 0 ? 1 : 0);
+				break;
+			}
+			case "run:aborted": {
+				failed = true;
+				const seconds = typeof msg.durationMs === "number" ? (msg.durationMs / 1e3).toFixed(1) : "?";
+				console.error(`\nRun aborted: test "${msg.testName ?? "?"}" ran for ${seconds}s — threshold exceeded.\nThe TWD browser tab is likely backgrounded and throttled by the browser.\nForeground the TWD tab (identified by the "[TWD …]" title prefix) and keep it active, then retry.\nFor unattended runs, prefer \`twd-cli\` which drives a headless browser with no tab throttling.`);
+				break;
+			}
+			case "run:abandoned":
+				console.error("\nRun abandoned — browser tab appears frozen. Refresh the browser tab and retry.");
+				clearTimeout(timer);
+				ws.close();
+				process.exit(1);
+				break;
+			case "error":
+				console.error(`Error [${msg.code}]: ${msg.message}`);
+				break;
+		}
+	});
+	ws.on("close", () => {
+		clearTimeout(timer);
+		if (!runComplete) {
+			console.error("Connection closed before run completed");
+			process.exit(1);
+		}
+	});
+	ws.on("error", (err) => {
+		clearTimeout(timer);
+		console.error(`Connection error: ${err.message}`);
+		process.exit(1);
+	});
 }
-const args = process.argv.slice(2);
-const subcommand = args.find((a) => !a.startsWith("--"));
+//#endregion
+//#region src/cli/standalone.ts
+var args = process.argv.slice(2);
+var subcommand = args.find((a) => !a.startsWith("--"));
 function parseFlag(name) {
-  const idx = args.indexOf(name);
-  if (idx !== -1 && args[idx + 1]) return args[idx + 1];
-  return void 0;
+	const idx = args.indexOf(name);
+	if (idx !== -1 && args[idx + 1]) return args[idx + 1];
+}
+function parseFlagAll(name) {
+	const values = [];
+	for (let i = 0; i < args.length; i++) if (args[i] === name && args[i + 1] && !args[i + 1].startsWith("--")) values.push(args[i + 1]);
+	return values;
 }
 function printHelp() {
-  console.log(`Usage: twd-relay [command] [options]
+	console.log(`Usage: twd-relay [command] [options]
 
 Commands:
   (none), serve   Start the standalone relay server (default)
@@ -264,10 +316,14 @@ Options for serve:
   --path <path>   WebSocket path (default: /__twd/ws)
 
 Options for run:
-  --port <port>      Relay port to connect to (default: 5173)
-  --host <host>      Relay host to connect to (default: localhost)
-  --path <path>      WebSocket path (default: /__twd/ws)
-  --timeout <ms>     Timeout in ms (default: 180000)
+  --port <port>                   Relay port to connect to (default: 5173)
+  --host <host>                   Relay host to connect to (default: localhost)
+  --path <path>                   WebSocket path (default: /__twd/ws)
+  --timeout <ms>                  Timeout in ms (default: 180000)
+  --test <name>                   Filter tests by name substring (repeatable)
+  --max-test-duration <ms>        Abort if any single test exceeds this many
+                                  ms (default from browser client, typically
+                                  5000; 0 disables)
 
 Examples:
   twd-relay                     # start relay on port 9876
@@ -275,61 +331,83 @@ Examples:
   twd-relay run                 # trigger run via Vite dev server on 5173
   twd-relay run --port 9876     # trigger run on custom port
   twd-relay run --host 192.168.1.10 --path /app/__twd/ws
-  twd-relay run --timeout 30000 # custom timeout`);
+  twd-relay run --timeout 30000 # custom timeout
+  twd-relay run --test "login"           # run tests matching "login"
+  twd-relay run --test "login" --test "signup"  # run multiple
+  twd-relay run --max-test-duration 30000         # raise abort threshold to 30s
+  twd-relay run --max-test-duration 0             # disable abort detection`);
 }
 if (args.includes("--help") || args.includes("-h")) {
-  printHelp();
-  process.exit(0);
+	printHelp();
+	process.exit(0);
 }
 if (subcommand === "run") {
-  const portStr = parseFlag("--port");
-  const timeoutStr = parseFlag("--timeout");
-  const pathFlag = parseFlag("--path") ?? "/__twd/ws";
-  const hostFlag = parseFlag("--host") ?? "localhost";
-  const port = portStr ? parseInt(portStr, 10) : 5173;
-  if (isNaN(port)) {
-    console.error("Invalid port number:", portStr);
-    process.exit(1);
-  }
-  const timeout = timeoutStr ? parseInt(timeoutStr, 10) : 18e4;
-  if (isNaN(timeout)) {
-    console.error("Invalid timeout value:", timeoutStr);
-    process.exit(1);
-  }
-  run({ port, timeout, path: pathFlag, host: hostFlag });
+	const portStr = parseFlag("--port");
+	const timeoutStr = parseFlag("--timeout");
+	const pathFlag = parseFlag("--path") ?? "/__twd/ws";
+	const hostFlag = parseFlag("--host") ?? "localhost";
+	const port = portStr ? parseInt(portStr, 10) : 5173;
+	if (isNaN(port)) {
+		console.error("Invalid port number:", portStr);
+		process.exit(1);
+	}
+	const timeout = timeoutStr ? parseInt(timeoutStr, 10) : 18e4;
+	if (isNaN(timeout)) {
+		console.error("Invalid timeout value:", timeoutStr);
+		process.exit(1);
+	}
+	const testNames = parseFlagAll("--test");
+	const maxDurationStr = parseFlag("--max-test-duration");
+	let maxTestDurationMs;
+	if (maxDurationStr !== void 0) {
+		maxTestDurationMs = parseInt(maxDurationStr, 10);
+		if (isNaN(maxTestDurationMs)) {
+			console.error("Invalid --max-test-duration value:", maxDurationStr);
+			process.exit(1);
+		}
+	}
+	run({
+		port,
+		timeout,
+		path: pathFlag,
+		host: hostFlag,
+		testNames: testNames.length > 0 ? testNames : void 0,
+		maxTestDurationMs
+	});
 } else if (!subcommand || subcommand === "serve") {
-  let shutdown = function() {
-    console.log("\nShutting down...");
-    relay.close();
-    server.close(() => {
-      process.exit(0);
-    });
-  };
-  const portStr = parseFlag("--port");
-  const pathFlag = parseFlag("--path") ?? "/__twd/ws";
-  let port = 9876;
-  if (portStr) {
-    port = parseInt(portStr, 10);
-    if (isNaN(port)) {
-      console.error("Invalid port number:", portStr);
-      process.exit(1);
-    }
-  }
-  const server = createServer();
-  const relay = createTwdRelay(server, {
-    path: pathFlag,
-    onError(err) {
-      console.error("[twd-relay] Error:", err.message);
-    }
-  });
-  server.listen(port, () => {
-    console.log(`TWD Relay running on ws://localhost:${port}${pathFlag}`);
-    console.log("Waiting for connections...");
-  });
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+	const portStr = parseFlag("--port");
+	const pathFlag = parseFlag("--path") ?? "/__twd/ws";
+	let port = 9876;
+	if (portStr) {
+		port = parseInt(portStr, 10);
+		if (isNaN(port)) {
+			console.error("Invalid port number:", portStr);
+			process.exit(1);
+		}
+	}
+	const server = createServer();
+	const relay = createTwdRelay(server, {
+		path: pathFlag,
+		onError(err) {
+			console.error("[twd-relay] Error:", err.message);
+		}
+	});
+	server.listen(port, () => {
+		console.log(`TWD Relay running on ws://localhost:${port}${pathFlag}`);
+		console.log("Waiting for connections...");
+	});
+	function shutdown() {
+		console.log("\nShutting down...");
+		relay.close();
+		server.close(() => {
+			process.exit(0);
+		});
+	}
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
 } else {
-  console.error(`Unknown command: ${subcommand}`);
-  printHelp();
-  process.exit(1);
+	console.error(`Unknown command: ${subcommand}`);
+	printHelp();
+	process.exit(1);
 }
+//#endregion