nixamp 0.5.6 → 0.5.8

package/dist/admin.d.ts

@@ -28,6 +28,19 @@ interface Snapshot {
 export interface AdminOptions {
     url: string;
     key: string | null;
+    /**
+     * Every address the server found, labelled, share key not yet applied.
+     *
+     * `url` is the one this process talks to, which for a local daemon is
+     * loopback -- correct for asking it questions and useless for handing to
+     * anybody. These are the ones worth reading off the screen.
+     */
+    links: {
+        label: string;
+        url: string;
+    }[];
+    /** What it is serving, so the admin view says so without being asked. */
+    source: string;
 }
 /** Where to point, from the flags or from the daemon that is running. */
 export declare function resolveTarget(argv: string[]): AdminOptions;
@@ -42,6 +55,13 @@ export interface View {
     error: string;
     typing: boolean;
     restreaming: string;
+    /** Labelled addresses, and the key that makes them work. */
+    links: {
+        label: string;
+        url: string;
+    }[];
+    key: string | null;
+    source: string;
 }
 export declare function draw(ui: Container, theme: Theme, view: View): void;
 export {};

package/dist/admin.js

@@ -14,13 +14,22 @@ export function resolveTarget(argv) {
     const keyAt = argv.findIndex((a) => a === "--key");
     const url = at === -1 ? null : argv[at + 1];
     const key = keyAt === -1 ? null : (argv[keyAt + 1] ?? null);
-    if (url)
-        return { url: url.replace(/\/+$/, ""), key };
+    // Pointed somewhere by hand, that address is the only one known.
+    if (url) {
+        const bare = url.replace(/\/+$/, "");
+        return { url: bare, key, links: [{ label: "there", url: bare }], source: "" };
+    }
     const state = readState();
     if (state === null) {
         throw new Error("nixamp: no daemon is running. Start one with `nixamp daemon start`, or pass --url.");
     }
-    return { url: daemonUrl(state), key: key ?? state.key };
+    return {
+        url: daemonUrl(state),
+        key: key ?? state.key,
+        // A state file written before 0.5.3 has no list; loopback stands in.
+        links: state.urls ?? [{ label: "here", url: daemonUrl(state) }],
+        source: state.source,
+    };
 }
 /** Seconds as something a person reads at a glance. */
 export function since(ms) {
@@ -118,6 +127,7 @@ export async function admin(argv) {
     app.on("exit", () => clearInterval(timer));
     app.render(({ ui, theme }) => draw(ui, theme, {
         url: target.url, report, snapshot, error, typing, restreaming,
+        links: target.links, key: target.key, source: target.source,
     }));
     await app.start();
     clearInterval(timer);
@@ -159,6 +169,22 @@ export function draw(ui, theme, view) {
             ]);
         });
     });
+    // The links, because the point of a daemon is the phone in the other room
+    // and the address this process happens to talk to is the one that will not
+    // reach it. The key is on them: without it every address is a 401.
+    if (view.links.length > 0) {
+        const width = Math.max(...view.links.map((link) => link.label.length));
+        ui.panel({ title: "Share links", size: view.links.length + (view.source ? 3 : 2) }, (p) => {
+            for (const link of view.links) {
+                const full = view.key === null ? link.url : `${link.url}/s/${view.key}`;
+                p.text(`${link.label.padEnd(width)}  ${full}`, {
+                    fg: link.label === "on the internet" ? theme.accent : theme.foreground,
+                });
+            }
+            if (view.source)
+                p.label(view.source);
+        });
+    }
     ui.panel({ title: `Connections (${report?.active ?? 0} live)` }, (p) => {
         if (view.error) {
             p.text(view.error, { fg: theme.danger });

package/dist/daemon.d.ts

@@ -49,8 +49,8 @@ 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.
+ * What `nixamp daemon start` and `nixamp daemon status` print, 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
@@ -58,7 +58,7 @@ export declare function daemonUrl(state: DaemonState): string;
  * 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[];
+export declare function daemonLines(state: DaemonState, uptimeMs?: number): 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

@@ -65,8 +65,25 @@ export function daemonUrl(state) {
     return `http://${host.includes(":") ? `[${host}]` : host}:${state.port}`;
 }
 /**
- * What `nixamp daemon start` prints, as lines, so it can be tested without
- * starting a daemon.
+ * How long it has been up, as a person would say it. Written here rather than
+ * borrowed from admin.ts, which would drag the whole terminal UI into a code
+ * path that only prints four lines.
+ */
+function spell(ms) {
+    const seconds = Math.max(0, Math.round(ms / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${seconds % 60}s`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ${minutes % 60}m`;
+    return `${Math.floor(hours / 24)}d ${hours % 24}h`;
+}
+/**
+ * What `nixamp daemon start` and `nixamp daemon status` print, 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
@@ -74,7 +91,7 @@ export function daemonUrl(state) {
  * server writes that into a log file nobody reads, not to the person who just
  * typed the command.
  */
-export function daemonLines(state) {
+export function daemonLines(state, uptimeMs) {
     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.
@@ -84,6 +101,8 @@ 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 (uptimeMs !== undefined)
+        lines.push(`  ${"up".padEnd(width)}  ${spell(uptimeMs)}`);
     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.`);
     }

package/dist/main.js

@@ -223,11 +223,11 @@ async function runDaemon(argv) {
             console.log(`nixamp: the daemon (pid ${state.pid}) is gone. See ${state.log}`);
             return 1;
         }
-        const url = d.daemonUrl(state);
-        console.log(`nixamp daemon running (pid ${state.pid})`);
-        console.log(`  ${state.key ? `${url}/s/${state.key}` : url}`);
-        console.log(`  ${state.source}`);
-        console.log(`  up ${Math.round((Date.now() - state.startedAt) / 1000)}s`);
+        // The same lines start prints, because the question "where is it" has the
+        // same answer however you ask it -- and printing loopback alone was the
+        // one address that cannot be handed to anybody.
+        for (const line of d.daemonLines(state, Date.now() - state.startedAt))
+            console.log(line);
         return 0;
     }
     // `nixamp daemon attach` is what people try before `nixamp attach`, so it is

package/package.json

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

package/src/admin.ts

@@ -30,6 +30,16 @@ interface Snapshot {
 export interface AdminOptions {
   url: string;
   key: string | null;
+  /**
+   * Every address the server found, labelled, share key not yet applied.
+   *
+   * `url` is the one this process talks to, which for a local daemon is
+   * loopback -- correct for asking it questions and useless for handing to
+   * anybody. These are the ones worth reading off the screen.
+   */
+  links: { label: string; url: string }[];
+  /** What it is serving, so the admin view says so without being asked. */
+  source: string;
 }
 
 /** Where to point, from the flags or from the daemon that is running. */
@@ -39,13 +49,23 @@ export function resolveTarget(argv: string[]): AdminOptions {
   const url = at === -1 ? null : argv[at + 1];
   const key = keyAt === -1 ? null : (argv[keyAt + 1] ?? null);
 
-  if (url) return { url: url.replace(/\/+$/, ""), key };
+  // Pointed somewhere by hand, that address is the only one known.
+  if (url) {
+    const bare = url.replace(/\/+$/, "");
+    return { url: bare, key, links: [{ label: "there", url: bare }], source: "" };
+  }
 
   const state = readState();
   if (state === null) {
     throw new Error("nixamp: no daemon is running. Start one with `nixamp daemon start`, or pass --url.");
   }
-  return { url: daemonUrl(state), key: key ?? state.key };
+  return {
+    url: daemonUrl(state),
+    key: key ?? state.key,
+    // A state file written before 0.5.3 has no list; loopback stands in.
+    links: state.urls ?? [{ label: "here", url: daemonUrl(state) }],
+    source: state.source,
+  };
 }
 
 /** Seconds as something a person reads at a glance. */
@@ -134,6 +154,7 @@ export async function admin(argv: string[]): Promise<void> {
   app.on("exit", () => clearInterval(timer));
   app.render(({ ui, theme }) => draw(ui, theme, {
     url: target.url, report, snapshot, error, typing, restreaming,
+    links: target.links, key: target.key, source: target.source,
   }));
 
   await app.start();
@@ -161,6 +182,10 @@ export interface View {
   error: string;
   typing: boolean;
   restreaming: string;
+  /** Labelled addresses, and the key that makes them work. */
+  links: { label: string; url: string }[];
+  key: string | null;
+  source: string;
 }
 
 export function draw(ui: Container, theme: Theme, view: View): void {
@@ -189,6 +214,22 @@ export function draw(ui: Container, theme: Theme, view: View): void {
     });
   });
 
+  // The links, because the point of a daemon is the phone in the other room
+  // and the address this process happens to talk to is the one that will not
+  // reach it. The key is on them: without it every address is a 401.
+  if (view.links.length > 0) {
+    const width = Math.max(...view.links.map((link) => link.label.length));
+    ui.panel({ title: "Share links", size: view.links.length + (view.source ? 3 : 2) }, (p) => {
+      for (const link of view.links) {
+        const full = view.key === null ? link.url : `${link.url}/s/${view.key}`;
+        p.text(`${link.label.padEnd(width)}  ${full}`, {
+          fg: link.label === "on the internet" ? theme.accent : theme.foreground,
+        });
+      }
+      if (view.source) p.label(view.source);
+    });
+  }
+
   ui.panel({ title: `Connections (${report?.active ?? 0} live)` }, (p) => {
     if (view.error) {
       p.text(view.error, { fg: theme.danger });

package/src/daemon.ts

@@ -100,8 +100,23 @@ export function daemonUrl(state: DaemonState): string {
 }
 
 /**
- * What `nixamp daemon start` prints, as lines, so it can be tested without
- * starting a daemon.
+ * How long it has been up, as a person would say it. Written here rather than
+ * borrowed from admin.ts, which would drag the whole terminal UI into a code
+ * path that only prints four lines.
+ */
+function spell(ms: number): string {
+  const seconds = Math.max(0, Math.round(ms / 1000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ${minutes % 60}m`;
+  return `${Math.floor(hours / 24)}d ${hours % 24}h`;
+}
+
+/**
+ * What `nixamp daemon start` and `nixamp daemon status` print, 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
@@ -109,7 +124,7 @@ export function daemonUrl(state: DaemonState): string {
  * server writes that into a log file nobody reads, not to the person who just
  * typed the command.
  */
-export function daemonLines(state: DaemonState): string[] {
+export function daemonLines(state: DaemonState, uptimeMs?: number): 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.
@@ -119,6 +134,7 @@ export function daemonLines(state: DaemonState): string[] {
   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 (uptimeMs !== undefined) lines.push(`  ${"up".padEnd(width)}  ${spell(uptimeMs)}`);
 
   if (state.guessedPublic) {
     lines.push(

package/src/main.ts

@@ -252,11 +252,10 @@ async function runDaemon(argv: string[]): Promise<number> {
       console.log(`nixamp: the daemon (pid ${state.pid}) is gone. See ${state.log}`);
       return 1;
     }
-    const url = d.daemonUrl(state);
-    console.log(`nixamp daemon running (pid ${state.pid})`);
-    console.log(`  ${state.key ? `${url}/s/${state.key}` : url}`);
-    console.log(`  ${state.source}`);
-    console.log(`  up ${Math.round((Date.now() - state.startedAt) / 1000)}s`);
+    // The same lines start prints, because the question "where is it" has the
+    // same answer however you ask it -- and printing loopback alone was the
+    // one address that cannot be handed to anybody.
+    for (const line of d.daemonLines(state, Date.now() - state.startedAt)) console.log(line);
     return 0;
   }
 

package/web/dist/sw.js

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