nixamp 0.5.2 → 0.5.4

package/dist/daemon.d.ts

@@ -8,6 +8,25 @@ export interface DaemonState {
     startedAt: number;
     /** Where its output went, for when it died and you want to know why. */
     log: string;
+    /**
+     * The labelled addresses the server itself worked out, share key not applied.
+     *
+     * Recorded rather than recomputed because only the server knows them: a
+     * daemon bound to every interface has no single host to print, and the
+     * public one may be a tunnel it was told about rather than an interface
+     * anybody here can see. Absent on a state file written by an older nixamp.
+     */
+    urls?: {
+        label: string;
+        url: string;
+    }[];
+    /** The firewall standing between this port and the rest of the network. */
+    firewall?: string | null;
+    /**
+     * The public address was asked of an outside service rather than found on an
+     * interface, so it names the router and not this port.
+     */
+    guessedPublic?: boolean;
 }
 /** XDG, with the usual fallback. One daemon per user, which is one too few for nobody. */
 export declare function stateDir(): string;
@@ -29,6 +48,17 @@ export declare function status(): {
 };
 /** The URL an admin client should talk to. */
 export declare function daemonUrl(state: DaemonState): string;
+/**
+ * What `nixamp daemon start` prints, as lines, so it can be tested without
+ * starting a daemon.
+ *
+ * Every address the server found, not one loopback link: the point of a daemon
+ * is the phone in the other room, and 127.0.0.1 is the single address that
+ * cannot be handed to anybody. The firewall warning comes with it because the
+ * server writes that into a log file nobody reads, not to the person who just
+ * typed the command.
+ */
+export declare function daemonLines(state: DaemonState): string[];
 /**
  * Start one, detached, and wait until it is actually answering before saying
  * it started. Reporting success and leaving the user to discover a crash in a

package/dist/daemon.js

@@ -10,6 +10,7 @@ import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { portCommands } from "./share.js";
 /** XDG, with the usual fallback. One daemon per user, which is one too few for nobody. */
 export function stateDir() {
     const base = process.env["XDG_STATE_HOME"] || join(homedir(), ".local", "state");
@@ -63,6 +64,39 @@ export function daemonUrl(state) {
     const host = state.host === "0.0.0.0" || state.host === "::" ? "127.0.0.1" : state.host;
     return `http://${host.includes(":") ? `[${host}]` : host}:${state.port}`;
 }
+/**
+ * What `nixamp daemon start` prints, as lines, so it can be tested without
+ * starting a daemon.
+ *
+ * Every address the server found, not one loopback link: the point of a daemon
+ * is the phone in the other room, and 127.0.0.1 is the single address that
+ * cannot be handed to anybody. The firewall warning comes with it because the
+ * server writes that into a log file nobody reads, not to the person who just
+ * typed the command.
+ */
+export function daemonLines(state) {
+    const link = (url) => (state.key ? `${url}/s/${state.key}` : url);
+    // A state file written by an older nixamp has no list, so host and port
+    // still stand in rather than printing nothing at all.
+    const addresses = state.urls ?? [{ label: "here", url: daemonUrl(state) }];
+    const width = Math.max(...addresses.map((a) => a.label.length), "source".length);
+    const lines = [`nixamp daemon running (pid ${state.pid})`];
+    for (const { label, url } of addresses)
+        lines.push(`  ${label.padEnd(width)}  ${link(url)}`);
+    lines.push(`  ${"source".padEnd(width)}  ${state.source}`);
+    if (state.guessedPublic) {
+        lines.push("", "  That internet address is this machine's router, not this port.", `  Nothing outside reaches it until ${state.port} is forwarded here.`);
+    }
+    if (state.firewall) {
+        const { open } = portCommands(state.firewall, state.port);
+        lines.push("", `  ${state.firewall} is running, so nothing else can reach port ${state.port} yet:`, `    sudo ${open.join(" ")}`, "  or `nixamp daemon stop` and start again with --open-port.");
+    }
+    if (!addresses.some((a) => a.label === "on the internet")) {
+        lines.push("", "  None of those work from outside this network. If it should:", "    nixamp daemon start ... --public-url https://your-tunnel.example.com");
+    }
+    lines.push("", "  nixamp attach       the player, in front of it", "  nixamp admin        who is connected", "  nixamp daemon stop  when you are done");
+    return lines;
+}
 /**
  * Start one, detached, and wait until it is actually answering before saying
  * it started. Reporting success and leaving the user to discover a crash in a
@@ -119,11 +153,15 @@ async function waitForAnnounce(log, timeoutMs) {
             try {
                 const parsed = JSON.parse(line);
                 if (parsed["nixamp"] === "listening") {
+                    const urls = parsed["urls"];
                     return {
                         host: String(parsed["host"]),
                         port: Number(parsed["port"]),
                         key: parsed["key"] ?? null,
                         source: String(parsed["source"]),
+                        ...(Array.isArray(urls) ? { urls: urls } : {}),
+                        ...(typeof parsed["firewall"] === "string" ? { firewall: parsed["firewall"] } : {}),
+                        ...(parsed["guessedPublic"] === true ? { guessedPublic: true } : {}),
                     };
                 }
             }

package/dist/main.js

@@ -70,6 +70,8 @@ Options for serve:
       --public-url URL  the address this server is reachable at from outside,
                    when that is a tunnel or a forwarded port rather than one of
                    its own interfaces. Also NIXAMP_PUBLIC_URL
+      --no-lookup  do not ask ipinfo.io what this machine's public address is
+                   when nothing local looks public
       --ingest     accept a live stream in at POST /api/ingest
       --rtmp-in N  also listen for RTMP publishers (OBS, Larix) from port N
       --rtmp-streams N  how many may publish at once (default 3, a port each)
@@ -195,13 +197,8 @@ async function runDaemon(argv) {
     if (action === "start") {
         try {
             const state = await d.start(rest, entry);
-            console.log(`nixamp daemon running (pid ${state.pid})`);
-            const url = d.daemonUrl(state);
-            console.log(`  ${state.key ? `${url}/s/${state.key}` : url}`);
-            console.log(`  ${state.source}`);
-            console.log("");
-            console.log("  nixamp admin        who is connected");
-            console.log("  nixamp daemon stop  when you are done");
+            for (const line of d.daemonLines(state))
+                console.log(line);
             return 0;
         }
         catch (error) {

package/dist/server.d.ts

@@ -56,6 +56,12 @@ export interface ServeOptions {
      * listing is skipped and the printed links only work inside the house.
      */
     publicUrl: string;
+    /**
+     * Ask an outside service what this machine's public address is, when no
+     * interface holds one and none was given. Behind NAT that is the only way to
+     * learn it, and it is one short request at startup.
+     */
+    lookup: boolean;
     /**
      * Charge for listening once the stream is busy. Off unless asked for, and
      * useless without somewhere to pay: see NIXAMP_PAY_TO.

package/dist/server.js

@@ -34,7 +34,7 @@ import { notifyAll, resendEmail, webPush } from "./notify.js";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.js";
 import { applyRemoteConfig, createPaywall, FREE_LISTENERS, paywallFromEnv, } from "./paywall.js";
 import { isRemote, playsInBrowser } from "./sources.js";
-import { allowedForListening, elevate, firewallInUse, keyCookie, keyFrom, newKey, portCommands, reachableAddresses, scopeOf, shareLink, audioLink, } from "./share.js";
+import { allowedForListening, elevate, firewallInUse, keyCookie, keyFrom, lookupPublicIp, newKey, portCommands, reachableAddresses, scopeOf, shareLink, audioLink, } from "./share.js";
 import { extname, join, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { detectTools, peaks, RATE, Stream, toMono, } from "./audio.js";
@@ -67,6 +67,7 @@ export function parseServeArgs(argv) {
         publish: "ask",
         name: "",
         publicUrl: process.env["NIXAMP_PUBLIC_URL"] ?? "",
+        lookup: true,
         x402: false,
         owner: "",
         ingest: false,
@@ -127,6 +128,9 @@ export function parseServeArgs(argv) {
             }
             options.publicUrl = given.replace(/\/+$/, "");
         }
+        else if (arg === "--no-lookup") {
+            options.lookup = false;
+        }
         else if (arg === "--name") {
             options.name = value();
         }
@@ -2085,8 +2089,42 @@ export async function serve(argv, version = "0.1.0") {
             return { status: done.status, stdout: done.stdout ?? "" };
         },
     };
+    // The link, not the address. Without the key the address is a 401, so
+    // printing a bare host:port would be printing something that does not work.
+    //
+    // Behind NAT no interface holds the public address, so if nobody said what it
+    // is and nothing local looks public, ask. What comes back is a fact about the
+    // router and not about this port -- the port still has to be forwarded -- so
+    // it is marked as a guess and everything that prints it says so.
+    const localAddresses = reachableAddresses(options.host, port, options.publicUrl);
+    const guessedPublic = options.lookup && !options.publicUrl && !localAddresses.some((a) => a.label === "on the internet")
+        ? await lookupPublicIp()
+        : "";
+    const addresses = guessedPublic
+        ? reachableAddresses(options.host, port, `http://${guessedPublic.includes(":") ? `[${guessedPublic}]` : guessedPublic}:${port}`)
+        : localAddresses;
+    // Listening on every interface proves the socket is open here and nothing
+    // about the path between here and the phone.
+    const listening = options.host === "0.0.0.0" || options.host === "::";
+    const firewall = listening ? firewallInUse(io) : null;
     if (options.announce) {
-        console.log(JSON.stringify({ nixamp: "listening", host: options.host, port, key, source: root }));
+        // Everything `nixamp daemon start` needs to print what this would have
+        // printed. Without the addresses it could only reconstruct host and port,
+        // which for a server bound to every interface means it printed 127.0.0.1 --
+        // an address that works on exactly the machine you are already sitting at.
+        // The firewall matters for the same reason: the warning was going into a
+        // log file nobody reads instead of to the person who just typed the
+        // command.
+        console.log(JSON.stringify({
+            nixamp: "listening",
+            host: options.host,
+            port,
+            key,
+            source: root,
+            urls: addresses,
+            firewall,
+            guessedPublic: guessedPublic !== "",
+        }));
     }
     // The other half of "names now, tags later". It runs while the banner is
     // printed and while the publish prompt waits, and it is deliberately not
@@ -2102,13 +2140,15 @@ export async function serve(argv, version = "0.1.0") {
     }
     console.log(`nixamp serve — ${tracks.length} tracks under ${root}`);
     console.log("");
-    // The link, not the address. Without the key the address is a 401, so
-    // printing a bare host:port would be printing something that does not work.
-    const addresses = reachableAddresses(options.host, port, options.publicUrl);
     const width = Math.max(...addresses.map((a) => a.label.length));
     for (const { label, url } of addresses) {
         console.log(`  ${label.padEnd(width)}  ${shareLink(url, key)}`);
     }
+    if (guessedPublic) {
+        console.log("");
+        console.log(`  That internet address is this machine's router, not this port.`);
+        console.log(`  Nothing outside reaches it until ${port} is forwarded here.`);
+    }
     console.log("");
     if (key === null) {
         console.log("  No key: anyone who can reach this port can drive it and hear it.");
@@ -2161,10 +2201,6 @@ export async function serve(argv, version = "0.1.0") {
     }
     if (web === null)
         console.log("  No built PWA found, so / has nothing to serve: run `bun run web:build`.");
-    // Listening on every interface proves the socket is open here and nothing
-    // about the path between here and the phone.
-    const listening = options.host === "0.0.0.0" || options.host === "::";
-    const firewall = listening ? firewallInUse(io) : null;
     let closePort = null;
     if (firewall !== null) {
         const { open, close } = portCommands(firewall, port);

package/dist/share.d.ts

@@ -25,6 +25,20 @@ export declare function keyFrom(request: IncomingMessage, url: URL): string | nu
 export declare function keyCookie(key: string): string;
 /** Where an address actually goes, which is not always where you would like. */
 export declare function classify(address: string): "private" | "cgnat" | "public";
+/** Looks like an address, rather than an error page or a rate-limit notice. */
+export declare function isIpAddress(value: string): boolean;
+/**
+ * The address the rest of the world sees this machine as, by asking.
+ *
+ * Behind NAT no interface holds it, so there is nobody to ask but somebody
+ * outside. It is a claim about the router, not about this port: an address
+ * discovered this way is only reachable once the router forwards the port to
+ * this machine, which is why what prints it says so.
+ *
+ * Empty string for every failure. A player must not spend its startup waiting
+ * on somebody else's web service.
+ */
+export declare function lookupPublicIp(send?: typeof fetch, timeoutMs?: number): Promise<string>;
 /**
  * The addresses another device could actually reach this machine on, nearest
  * first. On a server the public one is the point: it is the address a phone

package/dist/share.js

@@ -74,6 +74,41 @@ export function classify(address) {
         return "cgnat";
     return "public";
 }
+/** Looks like an address, rather than an error page or a rate-limit notice. */
+export function isIpAddress(value) {
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(value)) {
+        return value.split(".").every((part) => Number(part) <= 255);
+    }
+    // Enough of v6 to reject prose: hex groups and colons, nothing else. This is
+    // not a validator, it is a guard against printing an error page as an address.
+    return value.includes(":") && /^[0-9a-f:]+$/i.test(value);
+}
+/**
+ * The address the rest of the world sees this machine as, by asking.
+ *
+ * Behind NAT no interface holds it, so there is nobody to ask but somebody
+ * outside. It is a claim about the router, not about this port: an address
+ * discovered this way is only reachable once the router forwards the port to
+ * this machine, which is why what prints it says so.
+ *
+ * Empty string for every failure. A player must not spend its startup waiting
+ * on somebody else's web service.
+ */
+export async function lookupPublicIp(send = fetch, timeoutMs = 2500) {
+    try {
+        const answer = await send("https://ipinfo.io/ip", {
+            signal: AbortSignal.timeout(timeoutMs),
+            headers: { accept: "text/plain", "user-agent": "nixamp" },
+        });
+        if (!answer.ok)
+            return "";
+        const found = (await answer.text()).trim();
+        return isIpAddress(found) ? found : "";
+    }
+    catch {
+        return "";
+    }
+}
 /**
  * The addresses another device could actually reach this machine on, nearest
  * first. On a server the public one is the point: it is the address a phone

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",

package/src/daemon.ts

@@ -10,6 +10,7 @@ import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { type Firewall, portCommands } from "./share.ts";
 
 export interface DaemonState {
   pid: number;
@@ -21,6 +22,22 @@ export interface DaemonState {
   startedAt: number;
   /** Where its output went, for when it died and you want to know why. */
   log: string;
+  /**
+   * The labelled addresses the server itself worked out, share key not applied.
+   *
+   * Recorded rather than recomputed because only the server knows them: a
+   * daemon bound to every interface has no single host to print, and the
+   * public one may be a tunnel it was told about rather than an interface
+   * anybody here can see. Absent on a state file written by an older nixamp.
+   */
+  urls?: { label: string; url: string }[];
+  /** The firewall standing between this port and the rest of the network. */
+  firewall?: string | null;
+  /**
+   * The public address was asked of an outside service rather than found on an
+   * interface, so it names the router and not this port.
+   */
+  guessedPublic?: boolean;
 }
 
 /** XDG, with the usual fallback. One daemon per user, which is one too few for nobody. */
@@ -82,6 +99,60 @@ export function daemonUrl(state: DaemonState): string {
   return `http://${host.includes(":") ? `[${host}]` : host}:${state.port}`;
 }
 
+/**
+ * What `nixamp daemon start` prints, as lines, so it can be tested without
+ * starting a daemon.
+ *
+ * Every address the server found, not one loopback link: the point of a daemon
+ * is the phone in the other room, and 127.0.0.1 is the single address that
+ * cannot be handed to anybody. The firewall warning comes with it because the
+ * server writes that into a log file nobody reads, not to the person who just
+ * typed the command.
+ */
+export function daemonLines(state: DaemonState): string[] {
+  const link = (url: string): string => (state.key ? `${url}/s/${state.key}` : url);
+  // A state file written by an older nixamp has no list, so host and port
+  // still stand in rather than printing nothing at all.
+  const addresses = state.urls ?? [{ label: "here", url: daemonUrl(state) }];
+  const width = Math.max(...addresses.map((a) => a.label.length), "source".length);
+
+  const lines = [`nixamp daemon running (pid ${state.pid})`];
+  for (const { label, url } of addresses) lines.push(`  ${label.padEnd(width)}  ${link(url)}`);
+  lines.push(`  ${"source".padEnd(width)}  ${state.source}`);
+
+  if (state.guessedPublic) {
+    lines.push(
+      "",
+      "  That internet address is this machine's router, not this port.",
+      `  Nothing outside reaches it until ${state.port} is forwarded here.`,
+    );
+  }
+  if (state.firewall) {
+    const { open } = portCommands(state.firewall as Firewall, state.port);
+    lines.push(
+      "",
+      `  ${state.firewall} is running, so nothing else can reach port ${state.port} yet:`,
+      `    sudo ${open.join(" ")}`,
+      "  or `nixamp daemon stop` and start again with --open-port.",
+    );
+  }
+  if (!addresses.some((a) => a.label === "on the internet")) {
+    lines.push(
+      "",
+      "  None of those work from outside this network. If it should:",
+      "    nixamp daemon start ... --public-url https://your-tunnel.example.com",
+    );
+  }
+
+  lines.push(
+    "",
+    "  nixamp attach       the player, in front of it",
+    "  nixamp admin        who is connected",
+    "  nixamp daemon stop  when you are done",
+  );
+  return lines;
+}
+
 /**
  * Start one, detached, and wait until it is actually answering before saying
  * it started. Reporting success and leaving the user to discover a crash in a
@@ -142,11 +213,15 @@ async function waitForAnnounce(
       try {
         const parsed = JSON.parse(line) as { nixamp?: string } & Record<string, unknown>;
         if (parsed["nixamp"] === "listening") {
+          const urls = parsed["urls"];
           return {
             host: String(parsed["host"]),
             port: Number(parsed["port"]),
             key: (parsed["key"] as string | null) ?? null,
             source: String(parsed["source"]),
+            ...(Array.isArray(urls) ? { urls: urls as { label: string; url: string }[] } : {}),
+            ...(typeof parsed["firewall"] === "string" ? { firewall: parsed["firewall"] } : {}),
+            ...(parsed["guessedPublic"] === true ? { guessedPublic: true } : {}),
           };
         }
       } catch {

package/src/main.ts

@@ -94,6 +94,8 @@ Options for serve:
       --public-url URL  the address this server is reachable at from outside,
                    when that is a tunnel or a forwarded port rather than one of
                    its own interfaces. Also NIXAMP_PUBLIC_URL
+      --no-lookup  do not ask ipinfo.io what this machine's public address is
+                   when nothing local looks public
       --ingest     accept a live stream in at POST /api/ingest
       --rtmp-in N  also listen for RTMP publishers (OBS, Larix) from port N
       --rtmp-streams N  how many may publish at once (default 3, a port each)
@@ -224,13 +226,7 @@ async function runDaemon(argv: string[]): Promise<number> {
   if (action === "start") {
     try {
       const state = await d.start(rest, entry);
-      console.log(`nixamp daemon running (pid ${state.pid})`);
-      const url = d.daemonUrl(state);
-      console.log(`  ${state.key ? `${url}/s/${state.key}` : url}`);
-      console.log(`  ${state.source}`);
-      console.log("");
-      console.log("  nixamp admin        who is connected");
-      console.log("  nixamp daemon stop  when you are done");
+      for (const line of d.daemonLines(state)) console.log(line);
       return 0;
     } catch (error) {
       console.error((error as Error).message);

package/src/server.ts

@@ -61,6 +61,7 @@ import {
   keyCookie,
   keyFrom,
   keysMatch,
+  lookupPublicIp,
   newKey,
   portCommands,
   reachableAddresses,
@@ -128,6 +129,12 @@ export interface ServeOptions {
    * listing is skipped and the printed links only work inside the house.
    */
   publicUrl: string;
+  /**
+   * Ask an outside service what this machine's public address is, when no
+   * interface holds one and none was given. Behind NAT that is the only way to
+   * learn it, and it is one short request at startup.
+   */
+  lookup: boolean;
   /**
    * Charge for listening once the stream is busy. Off unless asked for, and
    * useless without somewhere to pay: see NIXAMP_PAY_TO.
@@ -178,6 +185,7 @@ export function parseServeArgs(argv: string[]): ServeOptions {
     publish: "ask",
     name: "",
     publicUrl: process.env["NIXAMP_PUBLIC_URL"] ?? "",
+    lookup: true,
     x402: false,
     owner: "",
     ingest: false,
@@ -226,6 +234,8 @@ export function parseServeArgs(argv: string[]): ServeOptions {
         throw new Error("nixamp serve: --public-url must be a URL, e.g. https://nixamp.example.com");
       }
       options.publicUrl = given.replace(/\/+$/, "");
+    } else if (arg === "--no-lookup") {
+      options.lookup = false;
     } else if (arg === "--name") {
       options.name = value();
     } else if (arg === "--owner") {
@@ -2390,8 +2400,47 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     },
   };
 
+  // The link, not the address. Without the key the address is a 401, so
+  // printing a bare host:port would be printing something that does not work.
+  //
+  // Behind NAT no interface holds the public address, so if nobody said what it
+  // is and nothing local looks public, ask. What comes back is a fact about the
+  // router and not about this port -- the port still has to be forwarded -- so
+  // it is marked as a guess and everything that prints it says so.
+  const localAddresses = reachableAddresses(options.host, port, options.publicUrl);
+  const guessedPublic =
+    options.lookup && !options.publicUrl && !localAddresses.some((a) => a.label === "on the internet")
+      ? await lookupPublicIp()
+      : "";
+  const addresses = guessedPublic
+    ? reachableAddresses(options.host, port, `http://${guessedPublic.includes(":") ? `[${guessedPublic}]` : guessedPublic}:${port}`)
+    : localAddresses;
+
+  // Listening on every interface proves the socket is open here and nothing
+  // about the path between here and the phone.
+  const listening = options.host === "0.0.0.0" || options.host === "::";
+  const firewall = listening ? firewallInUse(io) : null;
+
   if (options.announce) {
-    console.log(JSON.stringify({ nixamp: "listening", host: options.host, port, key, source: root }));
+    // Everything `nixamp daemon start` needs to print what this would have
+    // printed. Without the addresses it could only reconstruct host and port,
+    // which for a server bound to every interface means it printed 127.0.0.1 --
+    // an address that works on exactly the machine you are already sitting at.
+    // The firewall matters for the same reason: the warning was going into a
+    // log file nobody reads instead of to the person who just typed the
+    // command.
+    console.log(
+      JSON.stringify({
+        nixamp: "listening",
+        host: options.host,
+        port,
+        key,
+        source: root,
+        urls: addresses,
+        firewall,
+        guessedPublic: guessedPublic !== "",
+      }),
+    );
   }
 
   // The other half of "names now, tags later". It runs while the banner is
@@ -2410,14 +2459,17 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
   console.log(`nixamp serve — ${tracks.length} tracks under ${root}`);
   console.log("");
 
-  // The link, not the address. Without the key the address is a 401, so
-  // printing a bare host:port would be printing something that does not work.
-  const addresses = reachableAddresses(options.host, port, options.publicUrl);
   const width = Math.max(...addresses.map((a) => a.label.length));
   for (const { label, url } of addresses) {
     console.log(`  ${label.padEnd(width)}  ${shareLink(url, key)}`);
   }
 
+  if (guessedPublic) {
+    console.log("");
+    console.log(`  That internet address is this machine's router, not this port.`);
+    console.log(`  Nothing outside reaches it until ${port} is forwarded here.`);
+  }
+
   console.log("");
   if (key === null) {
     console.log("  No key: anyone who can reach this port can drive it and hear it.");
@@ -2469,10 +2521,6 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
   }
   if (web === null) console.log("  No built PWA found, so / has nothing to serve: run `bun run web:build`.");
 
-  // Listening on every interface proves the socket is open here and nothing
-  // about the path between here and the phone.
-  const listening = options.host === "0.0.0.0" || options.host === "::";
-  const firewall = listening ? firewallInUse(io) : null;
   let closePort: (() => void) | null = null;
 
   if (firewall !== null) {

package/src/share.ts

@@ -87,6 +87,41 @@ export function classify(address: string): "private" | "cgnat" | "public" {
   return "public";
 }
 
+/** Looks like an address, rather than an error page or a rate-limit notice. */
+export function isIpAddress(value: string): boolean {
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(value)) {
+    return value.split(".").every((part) => Number(part) <= 255);
+  }
+  // Enough of v6 to reject prose: hex groups and colons, nothing else. This is
+  // not a validator, it is a guard against printing an error page as an address.
+  return value.includes(":") && /^[0-9a-f:]+$/i.test(value);
+}
+
+/**
+ * The address the rest of the world sees this machine as, by asking.
+ *
+ * Behind NAT no interface holds it, so there is nobody to ask but somebody
+ * outside. It is a claim about the router, not about this port: an address
+ * discovered this way is only reachable once the router forwards the port to
+ * this machine, which is why what prints it says so.
+ *
+ * Empty string for every failure. A player must not spend its startup waiting
+ * on somebody else's web service.
+ */
+export async function lookupPublicIp(send: typeof fetch = fetch, timeoutMs = 2500): Promise<string> {
+  try {
+    const answer = await send("https://ipinfo.io/ip", {
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: { accept: "text/plain", "user-agent": "nixamp" },
+    });
+    if (!answer.ok) return "";
+    const found = (await answer.text()).trim();
+    return isIpAddress(found) ? found : "";
+  } catch {
+    return "";
+  }
+}
+
 /**
  * The addresses another device could actually reach this machine on, nearest
  * first. On a server the public one is the point: it is the address a phone

package/web/dist/sw.js

@@ -1,5 +1,5 @@
 /* nixamp service worker — generated, do not edit */
-const CACHE = "nixamp-1788936569431";
+const CACHE = "nixamp-1788937565929";
 const PRECACHE = [
   "/",
   "/apple-touch-icon.png",