refactor: improve tunnel stability

Author: pi0

src/cloudflared/tunnel.ts

@@ -3,7 +3,8 @@
  *
  * Check main license for more information
  */
-import { spawn, ChildProcess } from "node:child_process";
+import { spawn, type ChildProcess } from "node:child_process";
+import { once } from "node:events";
 import type { Connection } from "./types.ts";
 import { cloudflaredBinPath, connRegex, ipRegex, locationRegex, indexRegex } from "./constants.ts";
 
@@ -22,8 +23,8 @@ export function startCloudflaredTunnel(
   connections: Promise<Connection>[];
   /** Spwaned cloudflared process */
   child: ChildProcess;
-  /** Stop the cloudflared process */
-  stop: ChildProcess["kill"];
+  /** Stop the cloudflared process and wait for it to exit */
+  stop: () => Promise<void>;
 } {
   const args: string[] = ["tunnel"];
   for (const [key, value] of Object.entries(options)) {
@@ -56,6 +57,8 @@ export function startCloudflaredTunnel(
   let urlResolver: (value: string | PromiseLike<string>) => void = () => undefined;
   let urlRejector: (reason: unknown) => void = () => undefined;
   const url = new Promise<string>((...pair) => ([urlResolver, urlRejector] = pair));
+  // Avoid unhandled-rejection warnings if no consumer awaits before child fails.
+  url.catch(() => undefined);
 
   const connectionResolvers: ((value: Connection | PromiseLike<Connection>) => void)[] = [];
   const connectionRejectors: ((reason: unknown) => void)[] = [];
@@ -90,8 +93,28 @@ export function startCloudflaredTunnel(
   };
   child.stdout.on("data", parser).on("error", urlRejector);
   child.stderr.on("data", parser).on("error", urlRejector);
+  child.on("error", urlRejector);
+  child.on("exit", (code, signal) => {
+    const reason = new Error(
+      `cloudflared exited (code=${code}, signal=${signal}) before URL was ready`,
+    );
+    urlRejector(reason);
+    for (const reject of connectionRejectors) reject?.(reason);
+  });
 
-  const stop = () => child.kill("SIGINT");
+  const stop = async (): Promise<void> => {
+    if (child.exitCode !== null || child.signalCode !== null) return;
+    const exited = once(child, "exit");
+    child.kill("SIGINT");
+    const killTimer = setTimeout(() => {
+      if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+    }, 5000);
+    try {
+      await exited;
+    } finally {
+      clearTimeout(killTimer);
+    }
+  };
 
   return { url, connections, child, stop };
 }

src/tunnel.ts

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { constants as osConstants } from "node:os";
 import { log, prompt } from "./log.ts";
 
 export interface TunnelOptions {
@@ -95,23 +96,37 @@ export async function startTunnel(opts: TunnelOptions): Promise<undefined | Tunn
     await installCloudflared();
   }
 
-  const args = [["--url", url], opts.verifyTLS ? undefined : ["--no-tls-verify", ""]].filter(
+  const args = [["--url", url], opts.verifyTLS ? undefined : ["--no-tls-verify", null]].filter(
     Boolean,
-  ) as [string, string][];
+  ) as [string, string | null][];
 
-  const tunnel = await startCloudflaredTunnel(Object.fromEntries(args), opts.extraArgs);
+  const tunnel = startCloudflaredTunnel(Object.fromEntries(args), opts.extraArgs);
 
-  const cleanup = async () => {
+  let closed = false;
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP"] as const;
+  const handlers = new Map<NodeJS.Signals, () => void>();
+
+  const cleanup = async (): Promise<void> => {
+    if (closed) return;
+    closed = true;
+    for (const [sig, handler] of handlers) process.off(sig, handler);
+    handlers.clear();
     await tunnel.stop();
   };
-  for (const signal of ["SIGINT", "SIGUSR1", "SIGUSR2"] as const) {
-    process.once(signal, cleanup);
+
+  for (const signal of signals) {
+    const handler = () => {
+      cleanup().finally(() => {
+        const signo = osConstants.signals[signal] ?? 0;
+        process.exit(128 + signo);
+      });
+    };
+    handlers.set(signal, handler);
+    process.once(signal, handler);
   }
 
   return {
-    getURL: async () => await tunnel.url,
-    close: async () => {
-      await cleanup();
-    },
+    getURL: () => tunnel.url,
+    close: cleanup,
   };
 }