nixamp 0.1.0 → 0.2.0

package/src/daemon.ts

@@ -0,0 +1,193 @@
+/**
+ * Daemon mode.
+ *
+ * `nixamp serve` holds a terminal. A server you leave running should not, and
+ * you should be able to walk away and come back to it, which means something on
+ * disk has to remember where it is and what key it minted. That file is the
+ * whole of the daemon: a pid to signal and enough to reconnect.
+ */
+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";
+
+export interface DaemonState {
+  pid: number;
+  host: string;
+  port: number;
+  /** The share key, so `nixamp admin` can talk to it without being told. */
+  key: string | null;
+  source: string;
+  startedAt: number;
+  /** Where its output went, for when it died and you want to know why. */
+  log: string;
+}
+
+/** XDG, with the usual fallback. One daemon per user, which is one too few for nobody. */
+export function stateDir(): string {
+  const base = process.env["XDG_STATE_HOME"] || join(homedir(), ".local", "state");
+  return join(base, "nixamp");
+}
+
+export function statePath(): string {
+  return join(stateDir(), "daemon.json");
+}
+
+export function logPath(): string {
+  return join(stateDir(), "daemon.log");
+}
+
+export function readState(): DaemonState | null {
+  try {
+    return JSON.parse(readFileSync(statePath(), "utf8")) as DaemonState;
+  } catch {
+    return null;
+  }
+}
+
+export function writeState(state: DaemonState): void {
+  mkdirSync(dirname(statePath()), { recursive: true });
+  writeFileSync(statePath(), `${JSON.stringify(state, null, 2)}\n`);
+}
+
+export function clearState(): void {
+  rmSync(statePath(), { force: true });
+}
+
+/**
+ * Signal 0 asks "could I signal this?" without sending anything. A pid file
+ * outlives the process that wrote it often enough that trusting one is how you
+ * end up reporting a daemon that has been dead since Tuesday.
+ */
+export function alive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM means it exists and belongs to someone else, which is still alive.
+    return (error as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+/** The daemon as far as anyone asking is concerned. */
+export function status(): { running: boolean; state: DaemonState | null } {
+  const state = readState();
+  if (state === null) return { running: false, state: null };
+  return { running: alive(state.pid), state };
+}
+
+/** The URL an admin client should talk to. */
+export function daemonUrl(state: DaemonState): string {
+  const host = state.host === "0.0.0.0" || state.host === "::" ? "127.0.0.1" : state.host;
+  return `http://${host.includes(":") ? `[${host}]` : host}:${state.port}`;
+}
+
+/**
+ * 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
+ * log file is the thing this is meant to avoid.
+ */
+export async function start(argv: string[], entry: string): Promise<DaemonState> {
+  const existing = status();
+  if (existing.running && existing.state) {
+    throw new Error(`nixamp: a daemon is already running (pid ${existing.state.pid}). Stop it first.`);
+  }
+
+  mkdirSync(stateDir(), { recursive: true });
+  const log = logPath();
+  const out = openSync(log, "a");
+
+  const child = spawn(process.execPath, [entry, "serve", ...argv, "--announce"], {
+    detached: true,
+    stdio: ["ignore", out, out],
+    env: { ...process.env, NIXAMP_DAEMON: "1" },
+  });
+  child.unref();
+  if (child.pid === undefined) throw new Error("nixamp: could not start the daemon");
+
+  // The server prints one JSON line when it is listening, because guessing how
+  // long a start takes is how a flaky `daemon start` is written.
+  const announced = await waitForAnnounce(log, 15_000);
+  if (announced === null) {
+    try {
+      process.kill(child.pid, "SIGTERM");
+    } catch {
+      // Already gone, which is the more likely reason we are here.
+    }
+    throw new Error(`nixamp: the daemon did not start. See ${log}`);
+  }
+
+  const state: DaemonState = { ...announced, pid: child.pid, startedAt: Date.now(), log };
+  writeState(state);
+  return state;
+}
+
+/** Poll the log for the announce line. */
+async function waitForAnnounce(
+  log: string,
+  timeoutMs: number,
+): Promise<Omit<DaemonState, "pid" | "startedAt" | "log"> | null> {
+  const deadline = Date.now() + timeoutMs;
+  const from = existsSync(log) ? readFileSync(log, "utf8").length : 0;
+  while (Date.now() < deadline) {
+    await new Promise((done) => setTimeout(done, 100));
+    let text: string;
+    try {
+      text = readFileSync(log, "utf8").slice(from);
+    } catch {
+      continue;
+    }
+    for (const line of text.split("\n")) {
+      if (!line.startsWith("{")) continue;
+      try {
+        const parsed = JSON.parse(line) as { nixamp?: string } & Record<string, unknown>;
+        if (parsed["nixamp"] === "listening") {
+          return {
+            host: String(parsed["host"]),
+            port: Number(parsed["port"]),
+            key: (parsed["key"] as string | null) ?? null,
+            source: String(parsed["source"]),
+          };
+        }
+      } catch {
+        // A partial line: it will be complete on the next pass.
+      }
+    }
+  }
+  return null;
+}
+
+/** Stop it, and wait for it to actually be gone. */
+export async function stop(timeoutMs = 5000): Promise<boolean> {
+  const { running, state } = status();
+  if (!state) return false;
+  if (!running) {
+    clearState();
+    return false;
+  }
+
+  try {
+    process.kill(state.pid, "SIGTERM");
+  } catch {
+    clearState();
+    return false;
+  }
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!alive(state.pid)) {
+      clearState();
+      return true;
+    }
+    await new Promise((done) => setTimeout(done, 100));
+  }
+
+  // It ignored SIGTERM. ffmpeg children make that more likely than it sounds.
+  try {
+    process.kill(state.pid, "SIGKILL");
+  } catch {
+    // Gone between the check and the signal.
+  }
+  clearState();
+  return true;
+}

package/src/main.ts

@@ -7,6 +7,7 @@
  * ffmpeg decodes; we read every sample on its way to the speakers and draw it.
  */
 import { createApp, themes, type BrailleCanvas, type Container, type KeyEvent, type Theme } from "@profullstack/hqtui";
+import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
 import {
   detectTools, formatTime, peaks, RATE, Stream, toMono,
@@ -14,7 +15,8 @@ import {
 } from "./audio.ts";
 import { Analyser, bandEdges, bands, decay } from "./fft.ts";
 import { version } from "./meta.ts";
-import { displayName, loadPlaylist } from "./playlist.ts";
+import { displayName, loadSource } from "./playlist.ts";
+import { isRemote } from "./sources.ts";
 import { DEFAULT_PORT } from "./server.ts";
 
 const FFT_SIZE = 2048;
@@ -64,21 +66,87 @@ export function barGlyph(value: number): string {
 
 const HELP = `nixamp — it really whips the terminal's ass.
 
-  nixamp [path]                  play a directory or a file in the terminal
-  nixamp serve [path] [options]  play here, and hand out a browser remote
+  nixamp [source]                play it in the terminal
+  nixamp serve [source] [options]  play here, and hand out a browser remote
+  nixamp daemon start|stop|status  serve in the background, and let go of it
+  nixamp admin [--url U] [--key K] who is connected, and re-stream to them
   nixamp update [version]        re-run the installer, keeping your choices
   nixamp uninstall [--yes]       remove everything the installer created
 
+A source is a directory, a file, an .m3u, an .m3u8, a .pls, or a URL to any
+of those.
+
 Options for serve:
   -p, --port N     port to listen on (default ${DEFAULT_PORT})
-  -h, --host HOST  address to bind (default 127.0.0.1; 0.0.0.0 for the LAN)
+  -h, --host HOST  address to bind (default 0.0.0.0, every interface)
       --web DIR    directory of built PWA files to serve at /
       --no-media   do not stream the library's bytes to remotes
+      --no-key     serve to anyone who can reach the port, with no share link
+      --open-port  let the port through the local firewall, and close it on exit
 
   -v, --version    print the version
       --help       print this
 `;
 
+/**
+ * `nixamp daemon <start|stop|status>`.
+ *
+ * The daemon is `nixamp serve` with nobody holding its terminal, so this is
+ * mostly bookkeeping: start it detached, remember where it went, and be able
+ * to answer whether it is still there.
+ */
+async function runDaemon(argv: string[]): Promise<number> {
+  const d = await import("./daemon.ts");
+  const [action = "status", ...rest] = argv;
+  const entry = fileURLToPath(new URL("./main.js", import.meta.url));
+
+  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");
+      return 0;
+    } catch (error) {
+      console.error((error as Error).message);
+      return 1;
+    }
+  }
+
+  if (action === "stop") {
+    const stopped = await d.stop();
+    console.log(stopped ? "nixamp daemon stopped" : "nixamp: no daemon was running");
+    return 0;
+  }
+
+  if (action === "status") {
+    const { running, state } = d.status();
+    if (!state) {
+      console.log("nixamp: no daemon. Start one with `nixamp daemon start`.");
+      return 1;
+    }
+    // A pid file outlives its process often enough that saying "running"
+    // without checking is how you report a daemon that died on Tuesday.
+    if (!running) {
+      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`);
+    return 0;
+  }
+
+  console.error(`nixamp daemon: unknown action ${action}. Try start, stop or status.`);
+  return 64;
+}
+
 /**
  * The whole CLI, as a function. `bin/nixamp.mjs` imports and calls it: relying
  * on `import.meta.main` there would leave the installed binary doing nothing,
@@ -92,6 +160,15 @@ export async function main(): Promise<void> {
     await serve(rest, version());
     return;
   }
+  if (first === "daemon") {
+    process.exitCode = await runDaemon(rest);
+    return;
+  }
+  if (first === "admin") {
+    const { admin } = await import("./admin.ts");
+    await admin(rest);
+    return;
+  }
   if (first === "update" || first === "uninstall") {
     const manage = await import("./manage.ts");
     process.exitCode = first === "update" ? manage.update(rest) : manage.uninstall(rest);
@@ -100,9 +177,12 @@ export async function main(): Promise<void> {
   if (first === "--version" || first === "-v") { console.log(version()); return; }
   if (first === "--help") { console.log(HELP); return; }
 
-  const target = resolve(first ?? ".");
+  // resolve() would turn https://host/x into /cwd/https:/host/x, so a URL is
+  // left exactly as it was typed.
+  const asked = first ?? ".";
+  const target = isRemote(asked) ? asked : resolve(asked);
   const tools = detectTools();
-  const tracks = loadPlaylist(tools, target);
+  const tracks = await loadSource(tools, target);
   if (tracks.length === 0) {
     console.error(`nixamp: no audio files under ${target}`);
     process.exit(1);

package/src/manage.ts

@@ -23,6 +23,9 @@ export interface Manifest {
 
 const SITE = "https://nixamp.com";
 
+/** Windows has its own installer, its own shim and its own removal script. */
+const windows = process.platform === "win32";
+
 /**
  * Where the installer put things. `NIXAMP_HOME` is exported by the shim it
  * wrote, which is the only thing that knows for certain; the walk up from this
@@ -64,7 +67,11 @@ function notInstalled(what: string): number {
   console.error("");
   console.error("  Installed with npm or bun:  npm uninstall -g nixamp");
   console.error("  Running from a checkout:    delete the checkout");
-  console.error(`  Wanted the installed one:   curl -fsSL ${SITE}/install.sh | sh`);
+  console.error(
+    windows
+      ? `  Wanted the installed one:   irm ${SITE}/install.ps1 | iex`
+      : `  Wanted the installed one:   curl -fsSL ${SITE}/install.sh | sh`,
+  );
   return 69;
 }
 
@@ -78,13 +85,26 @@ export function update(argv: string[]): number {
   const manifest = root ? readManifest(root) : null;
   if (!root || !manifest) return notInstalled("update");
 
-  const installer = manifest.installer || `${SITE}/install.sh`;
-  const args = ["-s", "--", manifest.desktop ? "--desktop" : "--cli-only", "--prefix", manifest.prefix];
+  const installer = manifest.installer || `${SITE}/${windows ? "install.ps1" : "install.sh"}`;
   const wanted = argv.find((a) => !a.startsWith("-"));
-  if (wanted) args.push("--version", wanted);
 
   console.log(`nixamp ${manifest.version} is installed. Fetching the installer...`);
 
+  if (windows) {
+    // PowerShell fetches and runs it in one expression, which is also the
+    // documented install line, so an update takes a fresh install's path.
+    const flags = [manifest.desktop ? "" : "-CliOnly", "-Prefix", quote(manifest.prefix)];
+    if (wanted) flags.push("-Version", quote(wanted));
+    const expression = `& ([scriptblock]::Create((irm ${installer}))) ${flags.filter(Boolean).join(" ")}`;
+    const run = spawnSync("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", expression], {
+      stdio: "inherit",
+    });
+    return run.status ?? 1;
+  }
+
+  const args = ["-s", "--", manifest.desktop ? "--desktop" : "--cli-only", "--prefix", manifest.prefix];
+  if (wanted) args.push("--version", wanted);
+
   const fetcher = which("curl") ? ["curl", "-fsSL", installer] : which("wget") ? ["wget", "-qO-", installer] : null;
   if (!fetcher) {
     console.error("nixamp: curl or wget is required to update.");
@@ -118,17 +138,24 @@ export function uninstall(argv: string[]): number {
     return 0;
   }
 
-  const script = join(root, "uninstall.sh");
+  const script = join(root, windows ? "uninstall.ps1" : "uninstall.sh");
   if (!existsSync(script)) {
     console.error(`nixamp: ${script} is missing, so removal cannot be exact.`);
     console.error(`  The manifest lists: ${manifest.paths.join(", ")}`);
     return 1;
   }
 
-  const run = spawnSync("sh", [script], { stdio: "inherit" });
+  const run = windows
+    ? spawnSync("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", script], { stdio: "inherit" })
+    : spawnSync("sh", [script], { stdio: "inherit" });
   return run.status ?? 1;
 }
 
+/** A PowerShell single-quoted string: the only escape inside one is a doubled quote. */
+function quote(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
 function which(command: string): boolean {
   return spawnSync("sh", ["-c", `command -v ${command}`], { stdio: "ignore" }).status === 0;
 }

package/src/playlist.ts

@@ -1,7 +1,16 @@
-/** The playlist: audio files found on disk, in a stable order. */
-import { readdirSync, statSync } from "node:fs";
+/** The playlist: audio found on disk or named by a playlist, in a stable order. */
+import { readFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { probe, type Tools, type Track } from "./audio.ts";
+import {
+  type Entry,
+  isHls,
+  isPlaylistFile,
+  isRemote,
+  nameOf,
+  parseM3u,
+  parsePls,
+} from "./sources.ts";
 
 export const AUDIO_EXTENSIONS = new Set([
   ".mp3", ".flac", ".ogg", ".oga", ".opus", ".m4a", ".aac",
@@ -48,6 +57,63 @@ export function findAudio(root: string): string[] {
   return out;
 }
 
+/** An entry that was never probed: playable, just not described. */
+function bare(entry: Entry): Track {
+  return { path: entry.source, title: entry.title, artist: "", album: "", duration: entry.duration };
+}
+
+/**
+ * Read a playlist, from disk or over the network. An HLS playlist is not a list
+ * of tracks but one stream in segments, so it comes back as a single entry and
+ * ffmpeg is left to do what it is good at.
+ */
+export async function readPlaylist(source: string): Promise<Entry[]> {
+  let text: string;
+  if (isRemote(source)) {
+    const response = await fetch(source, { redirect: "follow" });
+    if (!response.ok) throw new Error(`nixamp: ${source} answered ${response.status}`);
+    text = await response.text();
+  } else {
+    text = readFileSync(source, "utf8");
+  }
+
+  if (isHls(text)) return [{ source, title: nameOf(source), duration: 0 }];
+  const entries = /\.pls$/i.test(source) ? parsePls(text, source) : parseM3u(text, source);
+  return entries;
+}
+
+/**
+ * Everything `nixamp <thing>` can be handed: a directory, a file, a playlist,
+ * or a URL to any of those.
+ *
+ * Reading tags means an ffprobe per file, which is slow for a large library and
+ * slower still over the network, so it is only done for local files the caller
+ * asked about.
+ */
+export async function loadSource(tools: Tools, source: string, probeTags = true): Promise<Track[]> {
+  if (isPlaylistFile(source)) {
+    let entries: Entry[];
+    try {
+      entries = await readPlaylist(source);
+    } catch (error) {
+      // The playlist is the whole argument, so failing to read it is fatal --
+      // but it is fatal with a sentence, not a stack.
+      throw new Error(`nixamp: could not read ${source}: ${(error as Error).message.replace(/^nixamp: /, "")}`);
+    }
+    return entries.map((entry) =>
+      probeTags && !isRemote(entry.source) && entry.duration === 0
+        ? { ...probe(tools, entry.source), title: entry.title || probe(tools, entry.source).title }
+        : bare(entry),
+    );
+  }
+
+  // A bare URL is one remote thing to play. Whether it is a song or a live
+  // stream is ffmpeg's problem, and it is good at it.
+  if (isRemote(source)) return [bare({ source, title: nameOf(source), duration: 0 })];
+
+  return loadPlaylist(tools, source, probeTags);
+}
+
 /**
  * Reading tags means an ffprobe per file, which is slow for a large library, so
  * the caller decides when to pay for it. Untagged entries still play.