Use @hongminhee/localtunnel in startTunnel

Author: 2chanhaeng

examples/rfc-9421-test/deno.json

@@ -1,5 +1,6 @@
 {
   "imports": {
+    "@hongminhee/localtunnel": "jsr:@hongminhee/localtunnel@^0.3.0",
     "hono": "jsr:@hono/hono@^4.7.1"
   },
   "tasks": {

examples/rfc-9421-test/dev.ts

@@ -14,29 +14,29 @@ const logger = getLogger(["fedify", "examples", "rfc-9421-test", "dev"]);
 const port = parseInt(Deno.env.get("PORT") ?? "8000", 10);
 
 // 1. Start the tunnel (owned by this process, not the watched child).
-const tunnel = await startTunnel(port, 30_000);
+const tunnel = await startTunnel(port);
 if (!tunnel) {
   logger.error("Tunnel failed. Aborting dev mode.");
   Deno.exit(1);
 }
-logger.info("Tunnel ready: {url}", { url: tunnel.url });
+logger.info("Tunnel ready: {url}", { url: tunnel.url.href });
 
 // 2. Spawn the server in --watch mode, passing the tunnel URL via ORIGIN.
 const child = new Deno.Command("deno", {
   args: ["run", "-A", "--watch", "main.ts"],
   cwd: import.meta.dirname!,
-  env: { ...Deno.env.toObject(), ORIGIN: tunnel.url },
+  env: { ...Deno.env.toObject(), ORIGIN: tunnel.url.href },
   stdin: "inherit",
   stdout: "inherit",
   stderr: "inherit",
 }).spawn();
 
 // 3. Clean up on SIGINT: kill server, then tunnel.
-Deno.addSignalListener("SIGINT", () => {
+Deno.addSignalListener("SIGINT", async () => {
   child.kill("SIGTERM");
-  tunnel.child.kill("SIGTERM");
+  await tunnel.close();
   Deno.exit(0);
 });
 
 await child.status;
-tunnel.child.kill("SIGTERM");
+await tunnel.close();

examples/rfc-9421-test/main.ts

@@ -69,19 +69,18 @@ if (import.meta.main) {
   const origin = Deno.env.get("ORIGIN");
   if (origin) {
     logger.info("Public URL (external tunnel): {url}", { url: origin });
-    logger.info("Actor: @{id}@{host}", {
-      id: ACTOR_ID,
-      host: new URL(origin).hostname,
+    logger.info("Actor: {actor}", {
+      actor: `@${ACTOR_ID}@${new URL(origin).hostname}`,
     });
   } else {
-    const tunnel = await startTunnel(port, 30_000);
+    const tunnel = await startTunnel(port);
     if (tunnel) {
-      logger.info("Public URL: {url}", { url: tunnel.url });
+      logger.info("Public URL: {url}", { url: tunnel.url.href });
       logger.info("Actor: {actor}", {
-        actor: `@${ACTOR_ID}@${new URL(tunnel.url).hostname}`,
+        actor: `@${ACTOR_ID}@${tunnel.url.hostname}`,
       });
-      Deno.addSignalListener("SIGINT", () => {
-        tunnel.child.kill("SIGTERM");
+      Deno.addSignalListener("SIGINT", async () => {
+        await tunnel.close();
         Deno.exit(0);
       });
     } else {

examples/rfc-9421-test/tunnel.ts

@@ -1,85 +1,23 @@
-import $, { type CommandChild } from "@david/dax";
+import { openTunnel, type Tunnel } from "@hongminhee/localtunnel";
 import { getLogger } from "@logtape/logtape";
 
+const logger = getLogger(["fedify", "examples", "tunnel"]);
+
 /**
- * Starts `fedify tunnel -s pinggy.io <port>` and waits up to `timeoutMs`
- * for the tunnel URL to appear in its output.  The tunnel process is kept
- * alive and returned to the caller; it must be killed when no longer needed.
- *
- * Returns `null` if the URL was not found before the timeout.
+ * Opens a tunnel to expose a local port using `@hongminhee/localtunnel`.
+ * Returns the {@link Tunnel} object (with `.url` and `.close()`), or `null`
+ * if it fails.
  */
 export default async function startTunnel(
   port: number,
-  timeoutMs: number,
-): Promise<{ child: CommandChild; url: string } | null> {
-  const tunnelLogger = getLogger(["fedify", "examples", "tunnel"]);
-  tunnelLogger.info("Opening localhost.run tunnel on port {port}", { port });
-
-  const child = $`mise cli tunnel -s pinggy.io ${String(port)}`
-    .stdout("piped")
-    .stderr("piped")
-    .noThrow()
-    .spawn();
-
-  // Accumulate text from both streams while logging each chunk at DEBUG.
-  const textChunks: string[] = [];
-  const decoder = new TextDecoder();
-
-  const readStream = (stream: ReadableStream<Uint8Array>) => {
-    (async () => {
-      const reader = stream.getReader();
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          const text = decoder.decode(value, { stream: true });
-          textChunks.push(text);
-          const trimmed = text.trim();
-          if (trimmed) tunnelLogger.debug("{output}", { output: trimmed });
-        }
-      } catch {
-        // Stream may error when the process is killed.
-      }
-    })();
-  };
-
-  readStream(child.stdout());
-  readStream(child.stderr());
-
-  // Poll until we find an https URL in the accumulated output.
-  // The `message` template tag from @optique/run may wrap the URL in double
-  // quotes in non-TTY output, so we stop matching at whitespace or quotes.
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const match = textChunks.join("").match(/https:\/\/[^\s"']+/);
-    if (match) {
-      tunnelLogger.info("Tunnel established at {url}", { url: match[0] });
-      return { child, url: match[0] };
-    }
-    await new Promise((r) => setTimeout(r, 200));
-  }
-
-  tunnelLogger.error(
-    "Tunnel did not produce a URL within {timeout} ms",
-    { timeout: timeoutMs },
-  );
-  forceKillChild(child);
-  return null;
-}
-
-/**
- * Sends SIGKILL to `child` immediately.  A rejection handler is attached to
- * the CommandChild promise (which extends Promise<CommandResult>) so that the
- * eventual rejection from the killed process does not surface as an unhandled
- * promise rejection.  We intentionally do **not** await the promise because
- * dax keeps it pending until all piped streams are fully consumed, which may
- * never happen once the process is forcibly killed.
- */
-function forceKillChild(child: CommandChild): void {
-  child.catch(() => {});
+): Promise<Tunnel | null> {
+  logger.info("Opening tunnel on port {port}…", { port });
   try {
-    child.kill("SIGKILL");
-  } catch {
-    // Process already exited.
+    const tunnel = await openTunnel({ port, service: "pinggy.io" });
+    logger.info("Tunnel established at {url}", { url: tunnel.url.href });
+    return tunnel;
+  } catch (error) {
+    logger.error("Failed to open tunnel: {error}", { error });
+    return null;
   }
 }