nixamp 0.1.0 → 0.3.0

package/dist/directory.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The public directory.
+ *
+ * A nixamp that agrees to be listed announces itself to nixamp.com every so
+ * often and is forgotten when it stops. There is no database behind it: an
+ * entry lives for a few minutes and a heartbeat renews it, so a restart of the
+ * directory costs one heartbeat rather than a migration, and a stream that
+ * dies falls out of the list without anyone having to notice.
+ *
+ * What is published is the *listen* link. The control key never leaves the
+ * machine it was minted on.
+ */
+/** How long an entry survives without a heartbeat. */
+export declare const TTL_MS: number;
+/** How often a publisher renews. Comfortably inside the TTL. */
+export declare const HEARTBEAT_MS: number;
+export declare const DEFAULT_DIRECTORY = "https://nixamp.com";
+export interface Listing {
+    /** Assigned by the directory, so a publisher cannot claim someone else's. */
+    id: string;
+    name: string;
+    /** The listen link, which is what a browser opens. */
+    url: string;
+    tracks: number;
+    nowPlaying: string;
+    /** Set by the directory from the request, never by the publisher. */
+    updatedAt: number;
+}
+/** What a publisher sends. Everything else about a listing is ours to decide. */
+export interface Announcement {
+    id?: string;
+    name: string;
+    url: string;
+    tracks: number;
+    nowPlaying: string;
+}
+/** Trim and flatten, so one publisher cannot draw a box in someone's terminal. */
+export declare function clean(value: unknown, max: number): string;
+/**
+ * A URL we are willing to list. It has to be somewhere a browser can go, and
+ * it must not be a loopback or link-local address: those are only reachable
+ * from the machine that published them, so listing one is an entry nobody but
+ * the publisher can ever open.
+ */
+export declare function publishable(raw: string): URL | null;
+export declare function parseAnnouncement(input: unknown): Announcement | null;
+/**
+ * The registry. In memory on purpose: see the note at the top of the file.
+ * One entry per URL, so a publisher restarting does not leave a ghost of
+ * itself behind next to the entry that replaced it.
+ */
+export declare class Directory {
+    private readonly ttl;
+    private readonly now;
+    private readonly items;
+    private sequence;
+    constructor(ttl?: number, now?: () => number);
+    announce(announcement: Announcement): Listing;
+    withdraw(id: string): void;
+    list(): Listing[];
+    /** Forget anything that stopped renewing. */
+    private sweep;
+}

package/dist/directory.js

@@ -0,0 +1,111 @@
+/**
+ * The public directory.
+ *
+ * A nixamp that agrees to be listed announces itself to nixamp.com every so
+ * often and is forgotten when it stops. There is no database behind it: an
+ * entry lives for a few minutes and a heartbeat renews it, so a restart of the
+ * directory costs one heartbeat rather than a migration, and a stream that
+ * dies falls out of the list without anyone having to notice.
+ *
+ * What is published is the *listen* link. The control key never leaves the
+ * machine it was minted on.
+ */
+/** How long an entry survives without a heartbeat. */
+export const TTL_MS = 4 * 60 * 1000;
+/** How often a publisher renews. Comfortably inside the TTL. */
+export const HEARTBEAT_MS = 90 * 1000;
+export const DEFAULT_DIRECTORY = "https://nixamp.com";
+const MAX_NAME = 60;
+const MAX_TRACK = 120;
+/** Trim and flatten, so one publisher cannot draw a box in someone's terminal. */
+export function clean(value, max) {
+    if (typeof value !== "string")
+        return "";
+    // Control characters include the escape that starts an ANSI sequence, and
+    // this text is rendered in a terminal as well as a browser.
+    return value.replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, max);
+}
+/**
+ * A URL we are willing to list. It has to be somewhere a browser can go, and
+ * it must not be a loopback or link-local address: those are only reachable
+ * from the machine that published them, so listing one is an entry nobody but
+ * the publisher can ever open.
+ */
+export function publishable(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        return null;
+    const host = url.hostname.replace(/^\[|\]$/g, "");
+    if (host === "localhost" || host === "::1" || host.endsWith(".localhost"))
+        return null;
+    if (/^127\./.test(host) || /^169\.254\./.test(host))
+        return null;
+    return url;
+}
+export function parseAnnouncement(input) {
+    if (typeof input !== "object" || input === null)
+        return null;
+    const record = input;
+    const url = typeof record["url"] === "string" ? record["url"] : "";
+    if (publishable(url) === null)
+        return null;
+    const name = clean(record["name"], MAX_NAME);
+    const tracks = Number(record["tracks"]);
+    return {
+        ...(typeof record["id"] === "string" ? { id: clean(record["id"], 40) } : {}),
+        name: name || "a nixamp",
+        url,
+        tracks: Number.isFinite(tracks) && tracks >= 0 ? Math.min(1_000_000, Math.floor(tracks)) : 0,
+        nowPlaying: clean(record["nowPlaying"], MAX_TRACK),
+    };
+}
+/**
+ * The registry. In memory on purpose: see the note at the top of the file.
+ * One entry per URL, so a publisher restarting does not leave a ghost of
+ * itself behind next to the entry that replaced it.
+ */
+export class Directory {
+    ttl;
+    now;
+    items = new Map();
+    sequence = 0;
+    constructor(ttl = TTL_MS, now = Date.now) {
+        this.ttl = ttl;
+        this.now = now;
+    }
+    announce(announcement) {
+        this.sweep();
+        const existing = [...this.items.values()].find((item) => item.url === announcement.url);
+        const id = existing?.id ?? `s${++this.sequence}${this.now().toString(36)}`;
+        const listing = {
+            id,
+            name: announcement.name,
+            url: announcement.url,
+            tracks: announcement.tracks,
+            nowPlaying: announcement.nowPlaying,
+            updatedAt: this.now(),
+        };
+        this.items.set(id, listing);
+        return listing;
+    }
+    withdraw(id) {
+        this.items.delete(id);
+    }
+    list() {
+        this.sweep();
+        return [...this.items.values()].sort((a, b) => b.updatedAt - a.updatedAt || a.id.localeCompare(b.id));
+    }
+    /** Forget anything that stopped renewing. */
+    sweep() {
+        const cutoff = this.now() - this.ttl;
+        for (const [id, item] of this.items)
+            if (item.updatedAt < cutoff)
+                this.items.delete(id);
+    }
+}

package/dist/ingest.d.ts

@@ -0,0 +1,80 @@
+import type { Readable } from "node:stream";
+/** A live source is one session at a time: two would be two songs at once. */
+export interface IngestSession {
+    id: string;
+    /** What the sender called itself. */
+    name: string;
+    /** The container the sender is producing, e.g. webm from MediaRecorder. */
+    format: string;
+    startedAt: number;
+    bytes: number;
+}
+export interface IngestStatus {
+    live: boolean;
+    session: IngestSession | null;
+    /** Where a native broadcaster should publish, when one is being listened for. */
+    rtmp: {
+        port: number;
+        path: string;
+    } | null;
+}
+/**
+ * ffmpeg's `-f` is a demuxer name, and passing an unknown one is how a stream
+ * dies four seconds in with a message nobody sees. An unrecognised container is
+ * refused up front instead.
+ */
+export declare function normaliseFormat(value: unknown): string | null;
+export interface IngestOptions {
+    ffmpeg: string[];
+    /** Where the decoded audio should go: a file ffmpeg writes, or a pipe. */
+    sink: string;
+    /** Called when a session starts, so the player can switch to it. */
+    onStart: (session: IngestSession) => void;
+    /** Called when it ends, cleanly or otherwise. */
+    onEnd: (session: IngestSession, error: string) => void;
+    /** Encoded audio, as it arrives from a live publisher. */
+    onAudio?: (chunk: Buffer) => void;
+}
+/**
+ * The live input.
+ *
+ * One session at a time: a second sender is refused rather than mixed, because
+ * mixing two uninvited streams is never what anybody meant.
+ */
+export declare class Ingest {
+    private readonly options;
+    private child;
+    private session;
+    private closing;
+    /** The RTMP listener, which outlives any one publisher. */
+    private rtmpChild;
+    private rtmpPort;
+    private rtmpKey;
+    constructor(options: IngestOptions);
+    status(): IngestStatus;
+    get live(): boolean;
+    /**
+     * Open a session. Returns the session, or null when one is already running:
+     * the caller answers 409, because "somebody else is already broadcasting" is
+     * a different problem from "your request was wrong".
+     */
+    open(name: string, format: string): IngestSession | null;
+    /** Feed it. Returns false once the session is over. */
+    write(chunk: Buffer): boolean;
+    /** Pipe a whole request body in, for a sender that can stream one. */
+    pump(body: Readable): Promise<void>;
+    /**
+     * Wait for an RTMP publisher, and keep waiting after each one leaves.
+     *
+     * ffmpeg is the RTMP server here: `-rtmp_listen 1` binds the port and blocks
+     * until somebody publishes. It serves one publisher and exits, so the
+     * listener is started again afterwards -- otherwise a broadcaster who
+     * reconnects finds nothing listening.
+     */
+    listenRtmp(port: number, key: string): void;
+    /** Stop waiting for publishers. */
+    stopRtmp(): void;
+    private armRtmp;
+    /** End the session, whoever ended it. */
+    close(error?: string): void;
+}

package/dist/ingest.js

@@ -0,0 +1,252 @@
+/**
+ * Streaming into a nixamp, rather than out of one.
+ *
+ * A phone or a laptop sends live audio to the server, and the server plays it,
+ * serves it to listeners, and broadcasts it onward. Two ways in, because one is
+ * not enough:
+ *
+ * - A single long POST whose body is the stream. ffmpeg, OBS, curl and the
+ *   desktop app can all do this, and it is the efficient one.
+ * - A sequence of small POSTs, for browsers. Chrome only allows a streaming
+ *   request body over HTTP/2, and a nixamp on your own network is plain
+ *   HTTP/1.1, so a phone that wants to broadcast has to send chunks.
+ *
+ * Both end up writing into the same ffmpeg stdin, which is what makes the two
+ * paths interchangeable to everything downstream.
+ *
+ * And a third, which is the one anything native should use: RTMP. Point OBS,
+ * Larix or another ffmpeg at rtmp://this-machine/live/<key> and it publishes,
+ * with no nixamp-shaped client in the middle. ffmpeg listens for it (-rtmp_listen),
+ * so this costs no dependency and no protocol implementation. The HTTP paths
+ * above are not a workaround for that: they are what a *browser* has, since a
+ * web page cannot speak RTMP at all.
+ */
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+/** Containers a browser or a desktop encoder actually produces. */
+const FORMATS = new Set(["webm", "ogg", "mp4", "matroska", "mp3", "wav", "flv"]);
+/**
+ * ffmpeg's `-f` is a demuxer name, and passing an unknown one is how a stream
+ * dies four seconds in with a message nobody sees. An unrecognised container is
+ * refused up front instead.
+ */
+export function normaliseFormat(value) {
+    if (typeof value !== "string")
+        return null;
+    const format = value.trim().toLowerCase();
+    if (format === "")
+        return null;
+    // A MediaRecorder mime type: audio/webm;codecs=opus.
+    // The subtype may carry a hyphen: audio/x-matroska is what some browsers
+    // hand out, and stopping at the hyphen turned it into "x".
+    const fromMime = /^(?:audio|video)\/([a-z0-9-]+)/.exec(format)?.[1];
+    const candidate = fromMime ?? format;
+    const mapped = candidate === "x-matroska" ? "matroska" : candidate;
+    return FORMATS.has(mapped) ? mapped : null;
+}
+/**
+ * The live input.
+ *
+ * One session at a time: a second sender is refused rather than mixed, because
+ * mixing two uninvited streams is never what anybody meant.
+ */
+export class Ingest {
+    options;
+    child = null;
+    session = null;
+    closing = false;
+    /** The RTMP listener, which outlives any one publisher. */
+    rtmpChild = null;
+    rtmpPort = null;
+    rtmpKey = "";
+    constructor(options) {
+        this.options = options;
+    }
+    status() {
+        return {
+            live: this.session !== null,
+            session: this.session,
+            rtmp: this.rtmpPort === null ? null : { port: this.rtmpPort, path: `/live/${this.rtmpKey}` },
+        };
+    }
+    get live() {
+        return this.session !== null;
+    }
+    /**
+     * Open a session. Returns the session, or null when one is already running:
+     * the caller answers 409, because "somebody else is already broadcasting" is
+     * a different problem from "your request was wrong".
+     */
+    open(name, format) {
+        if (this.session !== null)
+            return null;
+        const session = {
+            id: randomBytes(8).toString("hex"),
+            name: name || "a device",
+            format,
+            startedAt: Date.now(),
+            bytes: 0,
+        };
+        const [command, ...prefix] = this.options.ffmpeg;
+        const child = spawn(command, [
+            ...prefix,
+            "-hide_banner",
+            "-loglevel", "error",
+            // The demuxer is stated because ffmpeg mis-probes a live, unseekable
+            // pipe: it reads a few kilobytes, guesses, and guesses wrong.
+            "-f", format,
+            "-i", "pipe:0",
+            "-vn",
+            "-c:a", "libmp3lame",
+            "-b:a", "192k",
+            "-y",
+            "-f", "mp3",
+            this.options.sink,
+        ], { stdio: ["pipe", "ignore", "pipe"] });
+        let tail = "";
+        child.stderr?.on("data", (chunk) => {
+            tail = (tail + chunk.toString()).slice(-2000);
+        });
+        // A sender that hangs up mid-write breaks the pipe, and an unhandled EPIPE
+        // takes the whole server down with it.
+        child.stdin?.on("error", () => this.close(""));
+        child.on("error", (error) => this.close(error.message));
+        child.on("close", (code) => this.close(code === 0 ? "" : tail.trim().split("\n").pop() ?? ""));
+        this.child = child;
+        this.session = session;
+        this.closing = false;
+        this.options.onStart(session);
+        return session;
+    }
+    /** Feed it. Returns false once the session is over. */
+    write(chunk) {
+        const child = this.child;
+        const session = this.session;
+        if (child === null || session === null || child.stdin === null)
+            return false;
+        session.bytes += chunk.byteLength;
+        return child.stdin.write(chunk);
+    }
+    /** Pipe a whole request body in, for a sender that can stream one. */
+    async pump(body) {
+        for await (const chunk of body) {
+            if (!this.write(chunk)) {
+                // Backpressure: wait for the drain rather than growing a buffer that
+                // is really the network's problem.
+                await new Promise((done) => this.child?.stdin?.once("drain", done) ?? done(null));
+            }
+            if (this.session === null)
+                return;
+        }
+    }
+    /**
+     * Wait for an RTMP publisher, and keep waiting after each one leaves.
+     *
+     * ffmpeg is the RTMP server here: `-rtmp_listen 1` binds the port and blocks
+     * until somebody publishes. It serves one publisher and exits, so the
+     * listener is started again afterwards -- otherwise a broadcaster who
+     * reconnects finds nothing listening.
+     */
+    listenRtmp(port, key) {
+        this.rtmpPort = port;
+        this.rtmpKey = key;
+        this.armRtmp();
+    }
+    /** Stop waiting for publishers. */
+    stopRtmp() {
+        this.rtmpPort = null;
+        const listener = this.rtmpChild;
+        this.rtmpChild = null;
+        listener?.kill("SIGKILL");
+    }
+    armRtmp() {
+        const port = this.rtmpPort;
+        if (port === null || this.rtmpChild !== null)
+            return;
+        const [command, ...prefix] = this.options.ffmpeg;
+        const child = spawn(command, [
+            ...prefix,
+            "-hide_banner",
+            "-loglevel", "error",
+            "-rtmp_listen", "1",
+            // Wait indefinitely: a stream that starts tomorrow is still the stream.
+            "-timeout", "-1",
+            "-f", "flv",
+            "-i", `rtmp://0.0.0.0:${port}/live/${this.rtmpKey}`,
+            "-vn",
+            "-c:a", "libmp3lame",
+            "-b:a", "192k",
+            "-y",
+            "-f", "mp3",
+            this.options.sink,
+        ], 
+        // stdout is watched rather than ignored: the encoded bytes are the only
+        // honest signal that a publisher turned up. ffmpeg does not announce a
+        // connect, a healthy stream says nothing at -loglevel error, and
+        // -progress only reports at the end in this build. Audio existing means
+        // audio arrived.
+        { stdio: ["ignore", "pipe", "pipe"] });
+        const session = {
+            id: randomBytes(8).toString("hex"),
+            name: "an RTMP publisher",
+            format: "flv",
+            startedAt: Date.now(),
+            bytes: 0,
+        };
+        let tail = "";
+        child.stderr?.on("data", (chunk) => {
+            tail = (tail + chunk.toString()).slice(-2000);
+        });
+        child.stdout?.on("data", (chunk) => {
+            if (this.rtmpChild !== child)
+                return;
+            if (this.session === null) {
+                this.session = session;
+                this.options.onStart(session);
+            }
+            if (this.session === session)
+                session.bytes += chunk.byteLength;
+            // Consumed and dropped for now. The pipe has to be read either way --
+            // an unread one fills and stalls the encoder -- and handing these bytes
+            // to the listeners is the next piece of work, not a missing one here.
+            this.options.onAudio?.(chunk);
+        });
+        child.on("error", () => {
+            if (this.rtmpChild === child)
+                this.rtmpChild = null;
+        });
+        child.on("close", () => {
+            if (this.rtmpChild !== child)
+                return;
+            this.rtmpChild = null;
+            if (this.session === session) {
+                this.session = null;
+                // A publisher disconnecting is how a broadcast ends, not an error.
+                this.options.onEnd(session, "");
+            }
+            // Listen again for the next one.
+            if (this.rtmpPort !== null)
+                this.armRtmp();
+        });
+        this.rtmpChild = child;
+    }
+    /** End the session, whoever ended it. */
+    close(error = "") {
+        if (this.closing)
+            return;
+        this.closing = true;
+        const session = this.session;
+        const child = this.child;
+        this.session = null;
+        this.child = null;
+        try {
+            child?.stdin?.end();
+        }
+        catch {
+            // Already broken, which is usually why we are here.
+        }
+        child?.kill("SIGKILL");
+        if (session)
+            this.options.onEnd(session, error);
+    }
+}

package/dist/main.js

@@ -7,11 +7,13 @@
  * ffmpeg decodes; we read every sample on its way to the speakers and draw it.
  */
 import { createApp, themes } from "@profullstack/hqtui";
+import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
 import { detectTools, formatTime, peaks, RATE, Stream, toMono, } from "./audio.js";
 import { Analyser, bandEdges, bands, decay } from "./fft.js";
 import { version } from "./meta.js";
-import { displayName, loadPlaylist } from "./playlist.js";
+import { displayName, loadSource } from "./playlist.js";
+import { isRemote } from "./sources.js";
 import { DEFAULT_PORT } from "./server.js";
 const FFT_SIZE = 2048;
 export const BAND_COUNT = 24;
@@ -41,20 +43,93 @@ export function barGlyph(value) {
 }
 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 login [--signup]        sign in to nixamp.com
+  nixamp logout / whoami        forget it, or check it
   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
+      --publish    list it at nixamp.com/directory without asking first
+      --no-publish never list it, and do not ask
+      --name NAME  what to call it in the directory (default: this hostname)
+      --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)
+      --rtmp D     broadcast out, e.g. --rtmp youtube=<key>. Repeatable
+      --x402       charge for listening once more than 5 people are listening
+      --no-x402    never charge
 
   -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) {
+    const d = await import("./daemon.js");
+    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.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,
@@ -67,6 +142,25 @@ export async function main() {
         await serve(rest, version());
         return;
     }
+    if (first === "daemon") {
+        process.exitCode = await runDaemon(rest);
+        return;
+    }
+    if (first === "admin") {
+        const { admin } = await import("./admin.js");
+        await admin(rest);
+        return;
+    }
+    if (first === "login" || first === "signup") {
+        const { login } = await import("./session.js");
+        process.exitCode = await login(first === "signup" ? [...rest, "--signup"] : rest);
+        return;
+    }
+    if (first === "logout" || first === "whoami") {
+        const session = await import("./session.js");
+        process.exitCode = first === "logout" ? session.logout() : await session.whoami();
+        return;
+    }
     if (first === "update" || first === "uninstall") {
         const manage = await import("./manage.js");
         process.exitCode = first === "update" ? manage.update(rest) : manage.uninstall(rest);
@@ -80,9 +174,12 @@ export async function main() {
         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);