nixamp 0.5.3 → 0.5.4

package/dist/daemon.d.ts

@@ -22,6 +22,11 @@ export interface DaemonState {
     }[];
     /** 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;

package/dist/daemon.js

@@ -84,6 +84,9 @@ export function daemonLines(state) {
     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.");
@@ -158,6 +161,7 @@ async function waitForAnnounce(log, timeoutMs) {
                         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)

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();
         }
@@ -2087,7 +2091,18 @@ export async function serve(argv, version = "0.1.0") {
     };
     // 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);
+    //
+    // 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 === "::";
@@ -2108,6 +2123,7 @@ export async function serve(argv, version = "0.1.0") {
             source: root,
             urls: addresses,
             firewall,
+            guessedPublic: guessedPublic !== "",
         }));
     }
     // The other half of "names now, tags later". It runs while the banner is
@@ -2128,6 +2144,11 @@ export async function serve(argv, version = "0.1.0") {
     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.");

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.3",
+  "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

@@ -33,6 +33,11 @@ export interface DaemonState {
   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. */
@@ -115,6 +120,13 @@ export function daemonLines(state: DaemonState): string[] {
   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(
@@ -209,6 +221,7 @@ async function waitForAnnounce(
             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)

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") {
@@ -2392,7 +2402,19 @@ 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.
-  const addresses = reachableAddresses(options.host, port, options.publicUrl);
+  //
+  // 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.
@@ -2416,6 +2438,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
         source: root,
         urls: addresses,
         firewall,
+        guessedPublic: guessedPublic !== "",
       }),
     );
   }
@@ -2441,6 +2464,12 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     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.");

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-1788937268228";
+const CACHE = "nixamp-1788937565929";
 const PRECACHE = [
   "/",
   "/apple-touch-icon.png",