nixamp 0.1.0

package/src/manage.ts

@@ -0,0 +1,134 @@
+/**
+ * `nixamp update` and `nixamp uninstall`.
+ *
+ * Both belong on the CLI rather than in a second script the user has to find.
+ * Removal reads the manifest the installer wrote, so it is exact and works
+ * offline: a tool that needs the network to uninstall itself is one you cannot
+ * remove on a plane.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+/** What the installer recorded about this install. */
+export interface Manifest {
+  version: string;
+  method: string;
+  installer: string;
+  installedAt: string;
+  prefix: string;
+  desktop: boolean;
+  paths: string[];
+}
+
+const SITE = "https://nixamp.com";
+
+/**
+ * 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
+ * file covers a shim from an older install that did not set it.
+ */
+export function installRoot(from = new URL(".", import.meta.url).pathname): string | null {
+  const declared = process.env["NIXAMP_HOME"];
+  if (declared && existsSync(join(declared, "manifest.json"))) return declared;
+
+  // dist/ -> the CLI directory -> share/nixamp for a CLI-only install, or the
+  // app bundle's resources for a desktop one.
+  let dir = resolve(from);
+  for (let i = 0; i < 6; i++) {
+    if (existsSync(join(dir, "manifest.json"))) return dir;
+    const share = join(dir, "share", "nixamp");
+    if (existsSync(join(share, "manifest.json"))) return share;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+export function readManifest(root: string): Manifest | null {
+  try {
+    return JSON.parse(readFileSync(join(root, "manifest.json"), "utf8")) as Manifest;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The message for a copy that no installer put here: a checkout, an npx run, or
+ * a package manager's own install. Telling someone to run `rm -rf` on a
+ * directory we did not create would be worse than saying so.
+ */
+function notInstalled(what: string): number {
+  console.error(`nixamp: this copy was not put here by the installer, so there is nothing to ${what}.`);
+  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`);
+  return 69;
+}
+
+/**
+ * Update by re-running the installer with the same choices. It is the one
+ * place that knows how to lay an install out, so an update gets every fix the
+ * installer has had since, rather than only a newer tarball.
+ */
+export function update(argv: string[]): number {
+  const root = installRoot();
+  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 wanted = argv.find((a) => !a.startsWith("-"));
+  if (wanted) args.push("--version", wanted);
+
+  console.log(`nixamp ${manifest.version} is installed. Fetching the installer...`);
+
+  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.");
+    return 69;
+  }
+
+  // Piping the script into sh is what the documented install line does, so an
+  // update takes exactly the path a fresh install takes.
+  const script = spawnSync(fetcher[0] as string, fetcher.slice(1), { encoding: "utf8" });
+  if (script.status !== 0 || !script.stdout) {
+    console.error(`nixamp: could not fetch ${installer}`);
+    return 1;
+  }
+  const run = spawnSync("sh", args, { input: script.stdout, stdio: ["pipe", "inherit", "inherit"] });
+  return run.status ?? 1;
+}
+
+/** Run the uninstall script the installer left beside the manifest. */
+export function uninstall(argv: string[]): number {
+  const root = installRoot();
+  const manifest = root ? readManifest(root) : null;
+  if (!root || !manifest) return notInstalled("uninstall");
+
+  // Saying what would go needs only the manifest, so it comes first: a missing
+  // script is a problem for removing, not for describing.
+  if (!argv.includes("--yes") && !argv.includes("-y")) {
+    console.log(`This removes nixamp ${manifest.version} and everything the installer created:`);
+    for (const path of manifest.paths) console.log(`  ${path}`);
+    console.log("");
+    console.log("Your music is not touched. Run `nixamp uninstall --yes` to go ahead.");
+    return 0;
+  }
+
+  const script = join(root, "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" });
+  return run.status ?? 1;
+}
+
+function which(command: string): boolean {
+  return spawnSync("sh", ["-c", `command -v ${command}`], { stdio: "ignore" }).status === 0;
+}

package/src/meta.ts

@@ -0,0 +1,12 @@
+/** Facts about this install that both the terminal app and the server want. */
+import { readFileSync } from "node:fs";
+
+/** The version we were installed as, or 0.0.0 when the manifest is missing. */
+export function version(): string {
+  try {
+    const raw = readFileSync(new URL("../package.json", import.meta.url), "utf8");
+    return (JSON.parse(raw) as { version?: string }).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}

package/src/playlist.ts

@@ -0,0 +1,66 @@
+/** The playlist: audio files found on disk, in a stable order. */
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { probe, type Tools, type Track } from "./audio.ts";
+
+export const AUDIO_EXTENSIONS = new Set([
+  ".mp3", ".flac", ".ogg", ".oga", ".opus", ".m4a", ".aac",
+  ".wav", ".wma", ".aiff", ".aif", ".alac", ".mp4", ".webm",
+]);
+
+export function isAudio(path: string): boolean {
+  const dot = path.lastIndexOf(".");
+  return dot > 0 && AUDIO_EXTENSIONS.has(path.slice(dot).toLowerCase());
+}
+
+/** Every audio file under `root`, depth first. A single file is a playlist of one. */
+export function findAudio(root: string): string[] {
+  const out: string[] = [];
+  let stats;
+  try {
+    stats = statSync(root);
+  } catch {
+    return out;
+  }
+  if (stats.isFile()) return isAudio(root) ? [root] : out;
+
+  const walk = (dir: string): void => {
+    let entries: string[];
+    try {
+      entries = readdirSync(dir).sort();
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.startsWith(".")) continue;
+      const full = join(dir, entry);
+      let s;
+      try {
+        s = statSync(full);
+      } catch {
+        continue;
+      }
+      if (s.isDirectory()) walk(full);
+      else if (isAudio(full)) out.push(full);
+    }
+  };
+  walk(root);
+  return out;
+}
+
+/**
+ * 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.
+ */
+export function loadPlaylist(tools: Tools, root: string, probeTags = true): Track[] {
+  return findAudio(root).map((path) =>
+    probeTags ? probe(tools, path) : {
+      path,
+      title: path.split("/").pop() ?? path,
+      artist: "", album: "", duration: 0,
+    });
+}
+
+export function displayName(track: Track): string {
+  return track.artist ? `${track.artist} — ${track.title}` : track.title;
+}

package/src/protocol.ts

@@ -0,0 +1,91 @@
+/**
+ * The wire format between a running nixamp and any remote that drives it.
+ *
+ * Kept free of node imports on purpose: the browser client type-checks against
+ * this same file, so a change to the protocol breaks both sides at once rather
+ * than one of them at runtime.
+ */
+
+/** A track as a remote sees it — no filesystem path leaves the machine. */
+export interface RemoteTrack {
+  title: string;
+  artist: string;
+  album: string;
+  /** Seconds; 0 when ffprobe could not tell us. */
+  duration: number;
+}
+
+/** Everything a remote needs to draw the player. */
+export interface Snapshot {
+  /** Bumped on every push so a client can drop an out-of-order frame. */
+  revision: number;
+  tracks: RemoteTrack[];
+  index: number;
+  playing: boolean;
+  position: number;
+  /** Analyser bands, 0..1, one per bar. */
+  bars: number[];
+  /** Left and right peak levels, 0..1. */
+  levels: [number, number];
+  /** Whether this machine can actually make sound. */
+  silent: boolean;
+  note: string;
+  root: string;
+}
+
+export type Command =
+  | { type: "play"; index?: number }
+  | { type: "toggle" }
+  | { type: "stop" }
+  | { type: "next" }
+  | { type: "prev" }
+  | { type: "select"; index: number };
+
+export const COMMAND_TYPES = ["play", "toggle", "stop", "next", "prev", "select"] as const;
+
+/**
+ * Commands arrive as untrusted JSON from a browser on the LAN, so nothing is
+ * assumed: an unknown type or a non-integer index is a null, not a throw.
+ */
+export function parseCommand(input: unknown): Command | null {
+  if (typeof input !== "object" || input === null) return null;
+  const record = input as Record<string, unknown>;
+  const type = record.type;
+  if (typeof type !== "string") return null;
+  const index = record.index;
+  const validIndex = typeof index === "number" && Number.isInteger(index) && index >= 0;
+
+  switch (type) {
+    case "toggle":
+    case "stop":
+    case "next":
+    case "prev":
+      return { type };
+    case "play":
+      return validIndex ? { type: "play", index: index as number } : { type: "play" };
+    case "select":
+      return validIndex ? { type: "select", index: index as number } : null;
+    default:
+      return null;
+  }
+}
+
+/** The name a remote shows for a track. */
+export function remoteName(track: RemoteTrack): string {
+  return track.artist ? `${track.artist} — ${track.title}` : track.title;
+}
+
+export function emptySnapshot(): Snapshot {
+  return {
+    revision: 0,
+    tracks: [],
+    index: 0,
+    playing: false,
+    position: 0,
+    bars: [],
+    levels: [0, 0],
+    silent: true,
+    note: "",
+    root: "",
+  };
+}

package/src/serve.ts

@@ -0,0 +1,11 @@
+/**
+ * The server on its own, with no terminal UI attached.
+ *
+ * `nixamp serve` reaches the same code through main.ts, but the desktop app
+ * spawns this file directly: it pulls in no TUI, so what it has to load is the
+ * four modules that decode and serve and nothing else.
+ */
+import { version } from "./meta.ts";
+import { serve } from "./server.ts";
+
+await serve(process.argv.slice(2), version());