nixamp 0.5.2 → 0.5.3

package/dist/daemon.d.ts

@@ -8,6 +8,20 @@ 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;
 }
 /** XDG, with the usual fallback. One daemon per user, which is one too few for nobody. */
 export declare function stateDir(): string;
@@ -29,6 +43,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,36 @@ 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.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 +150,14 @@ 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"] } : {}),
                     };
                 }
             }

package/dist/main.js

@@ -195,13 +195,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.js

@@ -2085,8 +2085,30 @@ 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.
+    const addresses = reachableAddresses(options.host, port, options.publicUrl);
+    // 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,
+        }));
     }
     // 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,9 +2124,6 @@ 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)}`);
@@ -2161,10 +2180,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "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,17 @@ 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;
 }
 
 /** XDG, with the usual fallback. One daemon per user, which is one too few for nobody. */
@@ -82,6 +94,53 @@ 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.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 +201,14 @@ 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"] } : {}),
           };
         }
       } catch {

package/src/main.ts

@@ -224,13 +224,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

@@ -2390,8 +2390,34 @@ 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);
+
+  // 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,
+      }),
+    );
   }
 
   // The other half of "names now, tags later". It runs while the banner is
@@ -2410,9 +2436,6 @@ 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)}`);
@@ -2469,10 +2492,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/web/dist/sw.js

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