so-called-expert 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "so-called-expert",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A multiplayer terminal trivia game where everyone claims to be an expert. Hosted by Claude.",
   "type": "module",
   "bin": {

package/src/client.js

@@ -1,11 +1,31 @@
 // The player's side: one WebSocket to the host plus a full-screen terminal UI.
 import crypto from 'node:crypto';
+import dns from 'node:dns';
 import readline from 'node:readline';
 import WebSocket from 'ws';
 import { renderFrame } from './ui.js';
 
 const INPUT_LIMITS = { pick: 80, question: 120 };
 
+/**
+ * Hostname lookup that falls back to public resolvers. A tunnel hostname that
+ * was looked up before it existed can be stuck as "not found" in the local
+ * DNS cache; asking a public resolver directly gets around that.
+ */
+function lookup(hostname, options, callback) {
+  if (typeof options === 'function') [options, callback] = [{}, options];
+  dns.lookup(hostname, options, (err, address, family) => {
+    if (!err) return callback(null, address, family);
+    const resolver = new dns.Resolver({ timeout: 3000, tries: 1 });
+    resolver.setServers(['1.1.1.1', '8.8.8.8']);
+    resolver.resolve4(hostname, (err2, addresses) => {
+      if (err2 || !addresses?.length) return callback(err);
+      if (options?.all) callback(null, addresses.map((a) => ({ address: a, family: 4 })));
+      else callback(null, addresses[0], 4);
+    });
+  });
+}
+
 /**
  * Runs until the player quits. Resolves with an exit message (or null).
  */
@@ -69,7 +89,7 @@ export function runClient({ url, name, hostKey, onExit }) {
     };
 
     const connect = () => {
-      ws = new WebSocket(url, { handshakeTimeout: 10_000 });
+      ws = new WebSocket(url, { handshakeTimeout: 10_000, lookup });
       ws.on('open', () => {
         attempts = 0;
         everConnected = true;

package/src/tunnel.js

@@ -2,6 +2,7 @@
 // machine over the internet without any port forwarding or account.
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
+import dns from 'node:dns/promises';
 
 const URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
 
@@ -46,5 +47,33 @@ export async function startTunnel(port, { timeoutMs = 30_000 } = {}) {
     throw err;
   });
 
+  await waitForDns(new URL(url).hostname);
   return { url, stop };
 }
+
+/**
+ * A quick tunnel's hostname takes a few seconds to appear in DNS. If a guest
+ * looks it up too early, their resolver remembers "no such host" and the join
+ * keeps failing. So before the code is shown, poll the domain's authoritative
+ * nameservers directly (they do not cache misses) until the name exists.
+ */
+async function waitForDns(hostname, maxMs = 30_000) {
+  const started = Date.now();
+  const pause = (ms) => new Promise((r) => setTimeout(r, ms));
+  try {
+    const zone = hostname.split('.').slice(-2).join('.');
+    const nameservers = await dns.resolveNs(zone);
+    const addresses = (await Promise.all(nameservers.slice(0, 2).map((ns) => dns.resolve4(ns)))).flat();
+    while (Date.now() - started < maxMs) {
+      // A new resolver each time: a reused one caches the "not found" answer itself.
+      const resolver = new dns.Resolver({ timeout: 2000, tries: 1 });
+      resolver.setServers(addresses);
+      const found = await resolver.resolve4(hostname).then((a) => a.length > 0, () => false);
+      if (found) return;
+      await pause(1000);
+    }
+  } catch {
+    // Direct DNS is blocked on this network: fall back to a fixed wait.
+    await pause(Math.max(0, 8000 - (Date.now() - started)));
+  }
+}